Loading AI tools
Association of data/code with identifiers in programming languages From Wikipedia, the free encyclopedia
In programming languages, name binding is the association of entities (data and/or code) with identifiers.[1] An identifier bound to an object is said to reference that object. Machine languages have no built-in notion of identifiers, but name-object bindings as a service and notation for the programmer is implemented by programming languages. Binding is intimately connected with scoping, as scope determines which names bind to which objects – at which locations in the program code (lexically) and in which one of the possible execution paths (temporally).
Use of an identifier id in a context that establishes a binding for id is called a binding (or defining) occurrence. In all other occurrences (e.g., in expressions, assignments, and subprogram calls), an identifier stands for what it is bound to; such occurrences are called applied occurrences.
An example of a static binding is a direct C function call: the function referenced by the identifier cannot change at runtime.
An example of dynamic binding is dynamic dispatch, as in a C++ virtual method call. Since the specific type of a polymorphic object is not known before runtime (in general), the executed function is dynamically bound. Take, for example, the following Java code:
public void foo(java.util.List<String> list) {
list.add("bar");
}
List
is an interface, so list
must refer to a subtype of it. list
may reference a LinkedList
, an ArrayList
, or some other subtype of List
. The method referenced by add
is not known until runtime. In C, which does not have dynamic binding, a similar goal may be achieved by a call to a function pointed to by a variable or expression of a function pointer type, whose value is unknown until it is evaluated at run-time.
Rebinding should not be confused with mutation or assignment.
Consider the following Java code:
LinkedList<String> list;
list = new LinkedList<String>();
list.add("foo");
list = null;
{ LinkedList<Integer> list = new LinkedList<Integer>(); list.add(Integer(2)); }
The identifier list
is bound to a variable in the first line; in the second, an object (a linked list of strings) is assigned to the variable. The linked list referenced by the variable is then mutated, adding a string to the list. Next, the variable is assigned the constant null
. In the last line, the identifier is rebound for the scope of the block. Operations within the block access a new variable and not the variable previously bound to list
.
Late static binding is a variant of binding somewhere between static and dynamic binding. Consider the following PHP example:
class A
{
public static $word = "hello";
public static function hello() { print self::$word; }
}
class B extends A
{
public static $word = "bye";
}
B::hello();
In this example, the PHP interpreter binds the keyword self
inside A::hello()
to class A
, and so the call to B::hello()
produces the string "hello". If the semantics of self::$word
had been based on late static binding, then the result would have been "bye".
Beginning with PHP version 5.3, late static binding is supported.[3] Specifically, if self::$word
in the above were changed to static::$word
as shown in the following block, where the keyword static
would only be bound at runtime, then the result of the call to B::hello()
would be "bye":
class A
{
public static $word = "hello";
public static function hello() { print static::$word; }
}
class B extends A
{
public static $word = "bye";
}
B::hello();