In
programming languages, name binding is the association of entities (data and/or code) with
identifiers.
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.
Binding time
* ''Static binding'' (or ''early binding'') is name binding performed before the program is run.
* ''Dynamic binding'' (or ''late binding'' or ''virtual binding'') is name binding performed as the program is running.
An example of a static binding is a direct
C function call: the function referenced by the identifier cannot change at runtime.
But 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 list)
List
is an
interface, so
list
must refer to a
subtype of it. Is it a reference to a
LinkedList
, an
ArrayList
, or some other
subtype of
List
? The actual method referenced by
add
is not known until runtime. In C, such an instance of dynamic binding may be a call to a function pointed to by a variable or expression of a function pointer type whose value is unknown until it actually gets evaluated at run-time.
Rebinding and mutation
Rebinding should not be confused with mutation.
* ''Rebinding'' is a change to the ''referencing'' identifier.
* ''Mutation'' is a change to the ''referenced'' entity.
Consider the following
Java code:
LinkedList list;
list = new LinkedList();
list.add("foo");
list = null;
The identifier
list
initially references nothing (it is
uninitialized); it is then rebound to reference an object (a linked list of strings). The linked list referenced by
list
is then mutated, adding a string to the list. Lastly,
list
is rebound to
null
.
Late static
Late static binding is a variant of binding somewhere between static and dynamic binding. Consider the following
PHP example:
class A
class B extends A
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.
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
class B extends A
B::hello();
See also
*
Late binding
*
Branch table method of applying name binding via branch table or function pointers
*
Dynamic dispatch
*
Higher-order abstract syntax (HOAS)
References
{{reflist
Category:Programming language concepts
Category:Articles with example Java code
Category:Definition
ja:束縛 (情報工学)
pt:Vinculação de nomes (computação)