Name binding

Short description: Association of data/code with identifiers in programming languages

For bound variables in mathematics, see free variables and bound variables.

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.

## Contents

* 1 Binding time
* 2 Rebinding and mutation
* 3 Late static
* 4 See also
* 5 References

## Binding time

* Static binding (or early binding) is name binding performed before the program is run.[2]
* Dynamic binding (or late binding or virtual binding) is name binding performed as the program is running.[2]

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:

import java.util.List;

public void foo(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 and mutation

Rebinding should not be confused with mutation or assignment.

* Rebinding is a change to the referencing identifier.
* Assignment is a change to (the referenced) variable.
* Mutation is a change to an object in memory, possibly referenced by a variable or bound to an identifier.

Consider the following Java code:

import java.util.LinkedList;

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

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();

## See also

* Branch table - Method of transferring program control to another part of a program
* Higher-order abstract syntax

## References

1. ↑ Microsoft (May 11, 2007), Using early binding and late binding in Automation, Microsoft, http://support.microsoft.com/kb/245115, retrieved May 11, 2009
2. ↑ 2.0 2.1 Systems and software engineering — Vocabulary ISO/IEC/IEEE 24765:2010(E), IEEE, Dec 15, 2010
3. ↑ "Late Static Bindings". http://us2.php.net/manual/en/language.oop5.late-static-bindings.php.

ja:束縛 (情報工学) pt:Vinculação de nomes (computação)

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Name binding. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Name_binding&oldid=4172673"