Alcance (programación informática)

Una distinción fundamental en el alcance radica en el significado de "parte de un programa". En lenguajes con alcance léxico (también llamado alcance estático ), la resolución de nombres depende de la ubicación en el código fuente y del contexto léxico (también llamado contexto estático ), que se define por el lugar donde se define la variable o función nombrada. En cambio, en lenguajes con alcance dinámico, la resolución de nombres depende del estado del programa cuando se encuentra el nombre, el cual está determinado por el contexto de ejecución (también llamado contexto de ejecución , contexto de llamada o contexto dinámico ). En la práctica, con alcance léxico, un nombre se resuelve buscando en el contexto léxico local; si no se encuentra, se busca en el contexto léxico externo, y así sucesivamente; mientras que con alcance dinámico, un nombre se resuelve buscando en el contexto de ejecución local; si no se encuentra, se busca en el contexto de ejecución externo, y así sucesivamente, ascendiendo en la pila de llamadas. ^{[ 4 ]}

La mayoría de los lenguajes modernos utilizan el ámbito léxico para variables y funciones, aunque el ámbito dinámico se utiliza en algunos lenguajes, especialmente en algunos dialectos de Lisp, algunos lenguajes de "scripting" y algunos lenguajes de plantillas . ^{[ c ]} Perl 5 ofrece tanto ámbito léxico como dinámico. Las funciones que utilizan variables con ámbito léxico se conocen como cierres .

La resolución léxica se puede determinar en tiempo de compilación y también se conoce como enlace temprano , mientras que la resolución dinámica generalmente solo se puede determinar en tiempo de ejecución y, por lo tanto, se conoce como enlace tardío .

En la programación orientada a objetos , el despacho dinámico selecciona un método de objeto en tiempo de ejecución, aunque el hecho de que la vinculación del nombre se realice en tiempo de compilación o en tiempo de ejecución depende del lenguaje. El ámbito dinámico de facto es común en los lenguajes de macros , que no resuelven nombres directamente, sino que los expanden in situ.

Algunos frameworks de programación, como AngularJS, utilizan sintácticamente el término "scope" con un significado —semántico— completamente distinto al que se le da en este artículo. En estos frameworks, el scope es simplemente un objeto del lenguaje de programación que utilizan ( JavaScript en el caso de AngularJS) que el framework emplea de ciertas maneras para emular el ámbito dinámico en un lenguaje que utiliza el ámbito léxico para sus variables. Estos scopes de AngularJS pueden estar o no en contexto (según el significado habitual del término) en cualquier parte del programa, siguiendo las reglas habituales del ámbito de las variables del lenguaje, como cualquier otro objeto, y utilizando sus propias reglas de herencia y transclusión . En el contexto de AngularJS, a veces se utiliza el término "$scope" (con el signo de dólar) para evitar confusiones, pero las guías de estilo suelen desaconsejar el uso del signo de dólar en los nombres de las variables. ^{[ 5 ]}

El ámbito de una vinculación de nombre es una expresión , que se conoce como ámbito de expresión . El ámbito de expresión está disponible en muchos lenguajes, especialmente en lenguajes funcionales que ofrecen una característica llamada expresiones let que permite que el ámbito de una declaración sea una sola expresión. Esto es conveniente si, por ejemplo, se necesita un valor intermedio para un cálculo. Por ejemplo, en Standard ML , si f()devuelve 12, entonces es una expresión que se evalúa a , usando una variable temporal llamada para evitar llamar dos veces. Algunos lenguajes con ámbito de bloque aproximan esta funcionalidad al ofrecer sintaxis para que un bloque se incruste en una expresión; por ejemplo, la expresión Standard ML mencionada anteriormente podría escribirse en Perl como , o en GNU C como .let val x = f() in x * x end144xf()do{my$x=f();$x*$x}({intx=f();x*x;})

En Python, las variables auxiliares en las expresiones generadoras y las comprensiones de listas (en Python 3) tienen ámbito de expresión.

En C, los nombres de las variables en el prototipo de una función tienen ámbito de expresión, conocido en este contexto como ámbito de protocolo de función . Como los nombres de las variables en el prototipo no se mencionan (pueden ser diferentes en la definición real), son simplemente variables ficticias, por lo que a menudo se omiten, aunque pueden usarse para generar documentación, por ejemplo.

El ámbito de una vinculación de nombre es un bloque , que se conoce como ámbito de bloque . El ámbito de bloque está disponible en muchos, pero no en todos, los lenguajes de programación con estructura de bloques. Esto comenzó con ALGOL 60 , donde "[c]ada declaración... es válida solo para ese bloque.", ^{[ 6 ]} y hoy en día se asocia particularmente con lenguajes de las familias y tradiciones Pascal y C. Por lo general, este bloque está contenido dentro de una función, lo que restringe el ámbito a una parte de la función, pero en algunos casos, como en Perl, el bloque puede no estar dentro de una función.

int suma_de_cuadrados ( int m ) { int resultado = 0 ; for ( int n = 1 ; n <= m ; ++ n ) { const int n_cuadrado = n * n ; resultado += n_cuadrado ; } return resultado ; }

Un ejemplo representativo del uso del ámbito de bloque es el código C que se muestra aquí, donde dos variables tienen ámbito dentro del bucle: la variable de bucle n , que se inicializa una vez y se incrementa en cada iteración del bucle, y la variable auxiliar n_squared , que se inicializa en cada iteración. El propósito es evitar agregar variables al ámbito de la función que solo son relevantes para un bloque en particular; por ejemplo, esto evita errores donde la variable genérica de bucle i ya se ha establecido accidentalmente con otro valor. En este ejemplo, la expresión n * ngeneralmente no se asignaría a una variable auxiliar, y el cuerpo del bucle simplemente se escribiría, result += n * npero en ejemplos más complejos las variables auxiliares son útiles.

Los bloques se utilizan principalmente para el control de flujo, como en los bucles if, while y for, y en estos casos el ámbito del bloque significa que el ámbito de la variable depende de la estructura del flujo de ejecución de una función. Sin embargo, los lenguajes con ámbito de bloque también suelen permitir el uso de bloques "desnudos", cuyo único propósito es permitir un control preciso del ámbito de las variables. Por ejemplo, una variable auxiliar puede definirse en un bloque, luego usarse (por ejemplo, sumarse a una variable con ámbito de función) y descartarse cuando finaliza el bloque, o un bucle while puede estar encerrado en un bloque que inicializa las variables utilizadas dentro del bucle que solo deben inicializarse una vez.

Una particularidad de varios lenguajes de programación, como Algol 68 y C (demostrada en este ejemplo y estandarizada desde C99 ), es que las variables de ámbito de bloque pueden declararse no solo dentro del cuerpo del bloque, sino también dentro de la instrucción de control, si la hay. Esto es análogo a los parámetros de función, que se declaran en la declaración de la función (antes de que comience el bloque del cuerpo de la función) y tienen ámbito para todo el cuerpo de la función. Esto se utiliza principalmente en los bucles `for` , que tienen una instrucción de inicialización separada de la condición del bucle, a diferencia de los bucles `while`, y es una práctica común.

El ámbito de bloque se puede utilizar para ocultar variables. En este ejemplo, dentro del bloque la variable auxiliar también podría haberse llamado n , ocultando el nombre del parámetro, pero esto se considera una mala práctica debido al potencial de errores. Además, algunos descendientes de C, como Java y C#, a pesar de tener soporte para el ámbito de bloque (es decir, que una variable local puede quedar fuera de contexto antes de que finalice una función), no permiten que una variable local oculte a otra. En dichos lenguajes, el intento de declarar una segunda n daría como resultado un error de sintaxis, y una de las variables n tendría que ser renombrada.

Si se utiliza un bloque para establecer el valor de una variable, el ámbito del bloque requiere que la variable se declare fuera del bloque. Esto complica el uso de sentencias condicionales con asignación simple . Por ejemplo, en Python, que no utiliza el ámbito de bloque, se puede inicializar una variable de la siguiente manera:

si c : a = "foo" sino : a = ""

donde aes accesible después de la ifdeclaración.

En Perl, que tiene ámbito de bloque, esto requiere declarar la variable antes del bloque:

mi $a ; si ( c ) { $a = 'foo' ; } de lo contrario { $a = '' ; }

A menudo, esto se reescribe utilizando asignaciones múltiples, inicializando la variable con un valor predeterminado. En Python (donde no es necesario) sería:

a = "" si c : a = "foo"

mientras que en Perl sería:

mi $a = '' ; si ( c ) { $a = 'foo' ; }

En el caso de una única asignación de variable, una alternativa es utilizar el operador ternario para evitar un bloque, pero esto no suele ser posible para asignaciones de múltiples variables y resulta difícil de leer para lógica compleja.

Este es un problema más significativo en C, especialmente para la asignación de cadenas, ya que la inicialización de una cadena puede asignar memoria automáticamente, mientras que la asignación de una cadena a una variable ya inicializada requiere asignar memoria, hacer una copia de la cadena y comprobar que estas operaciones se hayan realizado correctamente.

{ mi $counter = 0 ; sub increment_counter { return ++ $counter ; } }

Algunos lenguajes permiten aplicar el concepto de ámbito de bloque, en distintos grados, fuera de una función. Por ejemplo, en el fragmento de Perl de la derecha, $counteres un nombre de variable con ámbito de bloque (debido al uso de la mypalabra clave), mientras que increment_counteres un nombre de función con ámbito global. Cada llamada a increment_counterincrementará el valor de $counteren uno y devolverá el nuevo valor. El código fuera de este bloque puede llamar a increment_counter, pero no puede obtener ni modificar el valor de $counter. Este modismo permite definir cierres en Perl.

Cuando el ámbito de las variables declaradas dentro de una función no se extiende más allá de esa función, se conoce como ámbito de función . ^{[ 7 ]} El ámbito de función está disponible en la mayoría de los lenguajes de programación que ofrecen una forma de crear una variable local en una función o subrutina : una variable cuyo ámbito termina (que sale de contexto) cuando la función regresa. En la mayoría de los casos, la vida útil de la variable es la duración de la llamada a la función; es una variable automática , creada cuando la función comienza (o la variable es declarada), destruida cuando la función regresa, mientras que el ámbito de la variable está dentro de la función, aunque el significado de "dentro" depende de si el ámbito es léxico o dinámico. Sin embargo, algunos lenguajes, como C, también proporcionan variables locales estáticas , donde la vida útil de la variable es toda la vida útil del programa, pero la variable solo está en contexto cuando está dentro de la función. En el caso de las variables locales estáticas, la variable se crea cuando el programa se inicializa y se destruye solo cuando el programa termina, como con una variable global estática , pero solo está en contexto dentro de una función, como una variable local automática.

Es importante destacar que, en el ámbito léxico, una variable con ámbito de función tiene ámbito solo dentro del contexto léxico de la función: sale de contexto cuando se llama a otra función dentro de la función y vuelve a entrar en contexto cuando la función finaliza. Las funciones llamadas no tienen acceso a las variables locales de las funciones que las llaman, y las variables locales solo están en contexto dentro del cuerpo de la función en la que se declaran. Por el contrario, en el ámbito dinámico, el ámbito se extiende al contexto de ejecución de la función: las variables locales permanecen en contexto cuando se llama a otra función, y solo salen de contexto cuando finaliza la función que las define; por lo tanto, las variables locales están en contexto de la función en la que se definen y de todas las funciones llamadas . En lenguajes con ámbito léxico y funciones anidadas , las variables locales están en contexto para las funciones anidadas, ya que estas se encuentran dentro del mismo contexto léxico, pero no para otras funciones que no están anidadas léxicamente. Una variable local de una función contenedora se conoce como variable no local para la función anidada. El ámbito de función también es aplicable a las funciones anónimas .

def cuadrado ( n : int ) -> int : return n * ndef suma_de_cuadrados ( n : int ) -> int : total : int = 0 i : int = 0 while i <= n : total += cuadrado ( i ) i += 1 return total

Por ejemplo, en el fragmento de código Python de la derecha, se definen dos funciones: squarey sum_of_squares. squareCalcula el cuadrado de un número; calcula la suma de todos los sum_of_squarescuadrados hasta un número. (Por ejemplo, ^essquare(4) 4² ⁼  , y es ^0² + 1² + ^{2² +} 3² + ^4² = . ) 16sum_of_squares(4)          30

Cada una de estas funciones tiene una variable llamada n que representa el argumento de la función. Estas dos variables n son completamente independientes y no están relacionadas, a pesar de tener el mismo nombre, porque son variables locales con ámbito léxico y ámbito de función: el ámbito de cada una es su propia función, léxicamente separada, y por lo tanto, no se superponen. Por consiguiente, sum_of_squaresse puede llamar a squaresin que su propia n se vea alterada. De manera similar, sum_of_squarestiene variables llamadas total e i ; estas variables, debido a su ámbito limitado, no interferirán con ninguna variable llamada total o i que pueda pertenecer a cualquier otra función. En otras palabras, no hay riesgo de colisión de nombres entre estos nombres y cualquier nombre no relacionado, incluso si son idénticos.

No se produce enmascaramiento de nombres: solo una variable llamada n está en contexto en un momento dado, ya que los ámbitos no se superponen. Por el contrario, si se escribiera un fragmento similar en un lenguaje con ámbito dinámico, la variable n de la función que realiza la llamada permanecería en contexto en la función llamada (los ámbitos se superpondrían) y quedaría enmascarada ("sombreada") por la nueva variable n de la función llamada.

El ámbito de las funciones se complica significativamente si son objetos de primera clase y pueden crearse localmente y luego devolverse. En este caso, cualquier variable en la función anidada que no sea local a ella (variables no vinculadas en la definición de la función, que se resuelven en variables en un contexto que la contiene) crea un cierre , ya que no solo la función en sí, sino también su contexto (de variables) debe devolverse y, potencialmente, llamarse en un contexto diferente. Esto requiere un soporte mucho mayor por parte del compilador y puede complicar el análisis del programa .

El ámbito de una vinculación de nombre es un archivo, lo que se conoce como ámbito de archivo . El ámbito de archivo es en gran medida particular de C (y C++), donde el ámbito de las variables y funciones declaradas en el nivel superior de un archivo (no dentro de ninguna función) es para todo el archivo, o más bien, para C, desde la declaración hasta el final del archivo fuente, o más precisamente, la unidad de traducción (enlace interno). Esto puede verse como una forma de ámbito de módulo, donde los módulos se identifican con archivos, y en lenguajes más modernos se reemplaza por un ámbito de módulo explícito. Debido a la presencia de las sentencias include, que agregan variables y funciones al contexto interno y pueden llamar a otras sentencias include, puede ser difícil determinar qué está en contexto en el cuerpo de un archivo.

En el fragmento de código C anterior, el nombre de la función sum_of_squarestiene ámbito global (en C, enlace externo). Si se añadiera statica la firma de la función, tendría ámbito de archivo (enlace interno).

El ámbito de una vinculación de nombres es un módulo, conocido como ámbito de módulo . Este ámbito está disponible en lenguajes de programación modulares, donde los módulos (que pueden abarcar varios archivos) son la unidad básica de un programa complejo, ya que permiten ocultar información y exponer una interfaz limitada. El ámbito de módulo se originó en la familia de lenguajes Modula , y Python (influenciado por Modula) es un ejemplo contemporáneo representativo.

En algunos lenguajes de programación orientados a objetos que carecen de soporte directo para módulos, como C++ antes de C++20 , ^{[ 8 ]} una estructura similar se proporciona mediante la jerarquía de clases, donde las clases son la unidad básica del programa y una clase puede tener métodos privados. Esto se entiende mejor en el contexto de la distribución dinámica que en el de la resolución de nombres y el ámbito, aunque a menudo desempeñan funciones análogas. En algunos casos, ambas funcionalidades están disponibles, como en Python, que cuenta con módulos y clases, y la organización del código (como una función a nivel de módulo o un método privado convencional) es una elección del programador.

El ámbito de una vinculación de nombre abarca todo un programa, lo que se conoce como ámbito global . Los nombres de variables con ámbito global —llamados variables globales— suelen considerarse una mala práctica, al menos en algunos lenguajes, debido a la posibilidad de colisiones de nombres y enmascaramiento involuntario, junto con una modularidad deficiente; por ello, se prefiere el ámbito de función o el ámbito de bloque. Sin embargo, el ámbito global se utiliza habitualmente (según el lenguaje) para otros tipos de nombres, como nombres de funciones, nombres de clases y nombres de otros tipos de datos . En estos casos, se utilizan mecanismos como los espacios de nombres para evitar colisiones.

El alcance léxico se utilizó por primera vez a principios de la década de 1960 para el lenguaje imperativo ALGOL 60 y desde entonces se ha adoptado en la mayoría de los demás lenguajes imperativos. ^{[ 4 ]}

Lenguajes como Pascal y C siempre han tenido alcance léxico, ya que ambos están influenciados por las ideas que se incorporaron a ALGOL 60 y ALGOL 68 (aunque C no incluía funciones anidadas léxicamente ).

Perl es un lenguaje con ámbito dinámico al que posteriormente se le añadió ámbito estático.

El intérprete original de Lisp (1960) utilizaba un ámbito dinámico. El enlace profundo , que se aproxima al ámbito estático (léxico), se introdujo alrededor de 1962 en LISP 1.5 (a través del dispositivo Funarg desarrollado por Steve Russell , que trabajaba bajo la dirección de John McCarthy ).

Todos los primeros Lisp utilizaban ámbito dinámico cuando se basaban en intérpretes. En 1982, Guy L. Steele Jr. y el Common Lisp Group publicaron Una visión general de Common Lisp [ ^{11 ] ,} una breve reseña de la historia y las diversas implementaciones de Lisp hasta ese momento, así como una revisión de las características que debería tener una implementación de Common Lisp . En la página 102, leemos:

La mayoría de las implementaciones de LISP presentan inconsistencias internas, ya que, por defecto, el intérprete y el compilador pueden asignar semánticas diferentes a programas correctos. Esto se debe principalmente a que el intérprete asume que todas las variables tienen un ámbito dinámico, mientras que el compilador las asume como locales, a menos que se le obligue a asumir lo contrario. Si bien esto se ha hecho por conveniencia y eficiencia, puede generar errores muy sutiles. La definición de Common LISP evita estas anomalías al exigir explícitamente que el intérprete y el compilador impongan semánticas idénticas a los programas correctos.

Por lo tanto, las implementaciones de Common Lisp debían tener un alcance léxico . Nuevamente, de Una descripción general de Common Lisp :

Además, Common LISP ofrece las siguientes facilidades (la mayoría de las cuales se toman prestadas de MacLisp, InterLisp o Lisp Machines Lisp): (...) Variables con ámbito léxico completo. El llamado " problema FUNARG " ^{[ 12 ] [ 13 ]} está completamente resuelto, tanto en el caso descendente como en el ascendente.

Para el mismo año en que se publicó An overview of Common LISP (1982), ya se habían publicado los diseños iniciales (también de Guy L. Steele Jr.) de un Lisp compilado con ámbito léxico, llamado Scheme , y se estaban intentando implementaciones de compiladores. En ese momento, se temía comúnmente que el ámbito léxico en Lisp fuera ineficiente de implementar. En A History of T , ^{[ 14 ]} Olin Shivers escribe:

Todos los lenguajes Lisp serios que se usaban en producción en ese momento tenían un alcance dinámico. Nadie que no hubiera leído detenidamente la tesis de Rabbit ^{[ 15 ]} (escrita por Guy Lewis Steele Jr. en 1978) creía que el alcance léxico funcionaría; incluso las pocas personas que la habían leído estaban dando un salto de fe al pensar que esto iba a funcionar en un uso serio en producción.

El término "alcance léxico" data al menos de 1967, ^{[ 16 ]} mientras que el término "alcance léxico" data al menos de 1970, donde se utilizó en el Proyecto MAC para describir las reglas de alcance del dialecto Lisp MDL (entonces conocido como "Muddle"). ^{[ 17 ]}

En los lenguajes de programación modernos, el ámbito léxico desempeña un papel crucial en la implementación de paradigmas de programación funcional. Lenguajes como JavaScript ^{[ 18 ]} , Python ^{[ 19 ]} y Swift ^{[ 20 ]} dependen en gran medida del ámbito léxico para garantizar que las funciones puedan acceder a las variables desde su contexto de definición, incluso si la función se ejecuta fuera de su ámbito léxico. Esto es particularmente importante al trabajar con cierres, que son una consecuencia directa del ámbito léxico.

Por ejemplo, en JavaScript, los cierres se utilizan con frecuencia para la programación asíncrona y el manejo de eventos, ya que permiten que las funciones de devolución de llamada mantengan el acceso a las variables del ámbito externo, lo que facilita un código más limpio y modular. De manera similar, Python y Swift utilizan el ámbito léxico para implementar cierres y habilitar patrones potentes como las funciones de orden superior. ^{[ 21 ]}

En los lenguajes modernos, la expansión de macros en un preprocesador es un ejemplo clave de ámbito dinámico de facto. El lenguaje de macros en sí solo transforma el código fuente, sin resolver los nombres, pero como la expansión se realiza in situ, cuando se resuelven los nombres en el texto expandido (en particular, las variables libres), se resuelven en función de dónde se expanden (lo que se podría denominar de forma aproximada), como si existiera un ámbito dinámico.

El preprocesador de C , utilizado para la expansión de macros , tiene de facto un ámbito dinámico, ya que no resuelve los nombres por sí mismo y es independiente de dónde se defina la macro. Por ejemplo, la macro:

#define ADD_A(x) x + a

Se expandirá para agregar aa la variable pasada, y este nombre solo será resuelto posteriormente por el compilador en función de dónde ADD_Ase "llama" (o expande) la macro. En realidad, el preprocesador de C solo realiza un análisis léxico , expandiendo la macro durante la etapa de tokenización, pero no la analiza en un árbol sintáctico ni realiza la resolución de nombres.

Por ejemplo, en el siguiente código, el nombre aen la macro se resuelve (después de la expansión) a la variable local en el sitio de expansión:

#define ADD_A(x) (x + a)void add_one ( int * x ) { const int a = 1 ; * x = ADD_A ( * x ); }void add_two ( int * x ) { const int a = 2 ; * x = ADD_A ( * x ); }

En C, el ámbito se conoce tradicionalmente como enlace o visibilidad , especialmente para las variables. C es un lenguaje con ámbito léxico que incluye ámbito global (conocido como enlace externo ), un tipo de ámbito de módulo o de archivo (conocido como enlace interno ) y ámbito local (dentro de una función); dentro de una función, los ámbitos pueden anidarse aún más mediante el ámbito de bloque. Sin embargo, el estándar C no admite funciones anidadas.

La vida útil y la visibilidad de una variable están determinadas por su clase de almacenamiento . En C existen tres tipos de vida útil: estática (ejecución del programa), automática (ejecución de bloques, asignada en la pila) y manual (asignada en el montón). Solo se admiten las opciones estática y automática para las variables y son gestionadas por el compilador, mientras que la memoria asignada manualmente debe ser rastreada manualmente entre las diferentes variables. En C existen tres niveles de visibilidad: enlace externo (global), enlace interno (aproximadamente a nivel de archivo) y ámbito de bloque (que incluye funciones); los ámbitos de bloque pueden estar anidados, y es posible obtener diferentes niveles de enlace interno mediante el uso de inclusiones. El enlace interno en C es la visibilidad a nivel de unidad de traducción , es decir, un archivo fuente después de ser procesado por el preprocesador de C , incluyendo notablemente todas las inclusiones relevantes.

Los programas en C se compilan como archivos objeto independientes , que luego se enlazan para formar un ejecutable o una biblioteca mediante un enlazador . Por lo tanto, la resolución de nombres se divide entre el compilador, que resuelve los nombres dentro de una unidad de traducción (o, de forma más general, "unidad de compilación", aunque este es un concepto distinto), y el enlazador, que resuelve los nombres entre unidades de traducción; consulte la sección sobre enlace para obtener más información.

En C, las variables con ámbito de bloque entran en contexto cuando se declaran (no al inicio del bloque), salen de contexto si se llama a alguna función (no anidada) dentro del bloque, vuelven a entrar en contexto cuando la función finaliza y salen de contexto al final del bloque. En el caso de las variables locales automáticas, también se asignan memoria al declararse y se liberan al final del bloque, mientras que para las variables locales estáticas, se asignan memoria al inicializar el programa y se liberan al finalizar el programa.

El siguiente programa demuestra cómo una variable con ámbito de bloque entra en contexto a mitad del bloque y luego sale de contexto (y de hecho se libera) cuando finaliza el bloque:

#include <stdio.h>int main ( void ) { char x = 'm' ; printf ( "%c \n " , x );{ printf ( "%c \n " , x ); char x = 'b' ; printf ( "%c \n " , x ); }printf ( "%c \n " , x ); }

El programa produce la siguiente salida:

metro metro b metro 

En C existen otros niveles de ámbito. ^{[ 23 ]} Los nombres de variables utilizados en un prototipo de función tienen visibilidad dentro del prototipo de función y salen del contexto al final del prototipo de función. Dado que el nombre no se utiliza, esto no es útil para la compilación, pero puede ser útil para la documentación. Los nombres de las etiquetas para la instrucción GOTO tienen ámbito de función.

Todas las variables que se utilicen en un programa deben haberse declarado con su especificador de tipo en una parte anterior del código, como se hizo al inicio del cuerpo de la función mainal declarar que a, b y result eran de tipo int. Una variable puede ser de ámbito global o local. Una variable global es aquella que se declara en el cuerpo principal del código fuente, fuera de todas las funciones, mientras que una variable local es aquella que se declara dentro del cuerpo de una función o un bloque.

Las versiones modernas permiten un ámbito léxico anidado.

Swift tiene una regla similar a la de C++ para los ámbitos, pero contiene modificadores de acceso diferentes .

Go tiene un alcance léxico mediante bloques. ^{[ 3 ]}

Java tiene un ámbito léxico.

Una clase Java tiene varios tipos de variables: ^{[ 24 ]}

Variables locales

Las variables se definen dentro de un método o un bloque específico. Estas variables son locales al lugar donde se definieron y a niveles inferiores. Por ejemplo, un bucle dentro de un método puede usar las variables locales de ese método, pero no al revés. Las variables del bucle (locales a ese bucle) se destruyen tan pronto como el bucle finaliza.

Variables miembro

Los campos son variables declaradas dentro de la clase, fuera de cualquier método. Por defecto, estas variables están disponibles para todos los métodos de esa clase y también para todas las clases del paquete.

Parámetros

son variables en las declaraciones de métodos.

En general, un conjunto de corchetes define un ámbito particular, pero las variables de nivel superior dentro de una clase pueden diferir en su comportamiento dependiendo de las palabras clave modificadoras utilizadas en su definición. La siguiente tabla muestra el acceso a los miembros permitido por cada modificador. ^{[ 25 ]}

JavaScript tiene reglas de ámbito simples , ^{[ 26 ]} pero las reglas de inicialización de variables y resolución de nombres pueden causar problemas, y el uso generalizado de cierres para las funciones de devolución de llamada implica que el contexto léxico de una función cuando se define (que se utiliza para la resolución de nombres) puede ser muy diferente del contexto léxico cuando se llama (que es irrelevante para la resolución de nombres). Los objetos de JavaScript tienen resolución de nombres para las propiedades, pero este es un tema aparte.

JavaScript tiene ámbito léxico ^{[ 27 ]} anidado a nivel de función, siendo el contexto global el contexto más externo. Este ámbito se utiliza tanto para variables como para funciones (es decir, declaraciones de funciones, a diferencia de variables de tipo función ). ^{[ 28 ]} El ámbito de bloque con las letpalabras constclave y es estándar desde ECMAScript 6. El ámbito de bloque se puede producir envolviendo todo el bloque en una función y luego ejecutándola; esto se conoce como el patrón de expresión de función invocada inmediatamente (IIFE).

Si bien el ámbito de JavaScript es simple (léxico, a nivel de función), las reglas de inicialización y resolución de nombres asociadas generan confusión. En primer lugar, la asignación a un nombre que no está dentro del ámbito crea por defecto una nueva variable global, no una local. En segundo lugar, para crear una nueva variable local se debe usar la varpalabra clave; la variable se crea al inicio de la función con un valor undefinedy se le asigna dicho valor cuando se alcanza la expresión de asignación.

A una variable con un inicializador se le asigna el valor de su expresión de asignación cuando se ejecuta la instrucción de variable , no cuando se crea la variable. ^{[ 29 ]}

Esto se conoce como elevación de variables ^{[ 30 ]} : la declaración, pero no la inicialización, se eleva al principio de la función. En tercer lugar, acceder a las variables antes de la inicialización produce un error undefined, en lugar de un error de sintaxis. En cuarto lugar, para las declaraciones de funciones, tanto la declaración como la inicialización se elevan al principio de la función, a diferencia de la inicialización de variables. Por ejemplo, el siguiente código produce un diálogo con la siguiente salida:indefinido, dado que la declaración de la variable local se eleva, ocultando la variable global, pero la inicialización no, por lo que la variable no está definida cuando se utiliza:

a = 1 ; función f () { alerta ( a ); var a = 2 ; } f ();

Además, dado que las funciones son objetos de primera clase en JavaScript y se asignan frecuentemente como funciones de devolución de llamada o se devuelven desde otras funciones, cuando se ejecuta una función, la resolución de nombres depende de dónde se definió originalmente (el contexto léxico de la definición), no del contexto léxico o de ejecución donde se llama. Los ámbitos anidados de una función en particular (desde el más global hasta el más local) en JavaScript, especialmente de un cierre utilizado como función de devolución de llamada, a veces se denominan cadena de ámbitos , por analogía con la cadena de prototipos de un objeto.

En JavaScript, se pueden generar cierres mediante el uso de funciones anidadas, ya que las funciones son objetos de primera clase. ^{[ 31 ]} Al devolver una función anidada desde una función contenedora, se incluyen las variables locales de la función contenedora como contexto léxico (no local) de la función devuelta, lo que produce un cierre. Por ejemplo:

function newCounter () { // devuelve un contador que se incrementa al llamarlo (comenzando en 0) // y que devuelve su nuevo valor var a = 0 ; var b = function () { a ++ ; return a ; }; return b ; } c = newCounter (); alert ( c () + ' ' + c ()); // imprime "1 2"

Los cierres se utilizan con frecuencia en JavaScript, debido a su uso para las funciones de devolución de llamada. De hecho, cualquier enganche de una función en el contexto local como una función de devolución de llamada o su retorno desde una función crea un cierre si existen variables no vinculadas en el cuerpo de la función (con el contexto del cierre basado en los ámbitos anidados del contexto léxico actual, o "cadena de ámbitos"); esto puede ocurrir accidentalmente. Al crear una función de devolución de llamada basada en parámetros, estos deben almacenarse en un cierre; de ​​lo contrario, se creará accidentalmente un cierre que haga referencia a las variables del contexto que lo contiene, las cuales pueden cambiar. ^{[ 32 ]}

La resolución de nombres de las propiedades de los objetos JavaScript se basa en la herencia en el árbol de prototipos (una ruta hasta la raíz en el árbol se denomina cadena de prototipos ) y es independiente de la resolución de nombres de variables y funciones.

Los dialectos de Lisp tienen diversas reglas para definir el alcance.

El Lisp original utilizaba un ámbito dinámico; fue Scheme , inspirado en ALGOL , el que introdujo el ámbito estático (léxico) en la familia Lisp.

Maclisp utilizaba el ámbito dinámico por defecto en el intérprete y el ámbito léxico por defecto en el código compilado, aunque este último podía acceder a las vinculaciones dinámicas mediante SPECIALdeclaraciones para variables específicas. ^{[ 33 ]} Sin embargo, Maclisp trataba la vinculación léxica más como una optimización de lo que cabría esperar en los lenguajes modernos, y no incluía la característica de cierre*FUNCTION que se esperaría del ámbito léxico en los Lisp modernos. Existía una operación independiente, , para solucionar de forma algo engorrosa parte de este problema. ^{[ 34 ]}

Common Lisp adoptó el alcance léxico de Scheme , ^{[ 35 ]} al igual que Clojure .

ISLISP tiene ámbito léxico para variables ordinarias. También tiene variables dinámicas, pero en todos los casos están marcadas explícitamente; deben definirse mediante una defdynamicforma especial, vincularse mediante una dynamic-letforma especial y accederse mediante una dynamicforma especial explícita. ^{[ 36 ]}

Algunos otros dialectos de Lisp, como Emacs Lisp , todavía usan ámbito dinámico por defecto. Emacs Lisp ahora tiene ámbito léxico disponible por búfer. ^{[ 37 ]}

Python tiene ámbito de función, ámbito de módulo y ámbito global para las variables. Los nombres entran en contexto al inicio de un ámbito (función, módulo o ámbito global) y salen de contexto cuando se llama a una función no anidada o finaliza el ámbito. Si se usa un nombre antes de la inicialización de la variable, se produce una excepción en tiempo de ejecución. Si se accede a una variable (sin asignarle ningún valor), la resolución de nombres sigue la regla LEGB (Local, Enclosing, Global, Built-in), que resuelve los nombres al contexto relevante más específico. Sin embargo, si se le asigna un valor a una variable, por defecto se declara una variable cuyo ámbito comienza al inicio del nivel (función, módulo o global), no en la asignación. Ambas reglas se pueden anular con una declaración global`or` nonlocal(en Python 3) antes de su uso, lo que permite acceder a variables globales incluso si hay una variable no local que las enmascara, y asignar valores a variables globales o no locales.

Como ejemplo sencillo, una función resuelve una variable al ámbito global:

def f () -> None : print ( x )x : str = "global" f () # imprime: global

Tenga en cuenta que xse define antes de fque se llame, por lo que no se genera ningún error, aunque se defina después de su referencia en la definición de f. Léxicamente, esta es una referencia hacia adelante , lo cual está permitido en Python.

Aquí la asignación crea una nueva variable local, que no cambia el valor de la variable global:

def f () -> None : x : str = "f" print ( x )x : str = "global" print ( x ) # imprime: global f () # imprime: f print ( x ) # imprime: global

La asignación a una variable dentro de una función hace que se declare como local a la función; por lo tanto, su ámbito es toda la función, y usarla antes de esta asignación genera un error. Esto difiere de C, donde el ámbito de la variable local comienza en su declaración. Este código genera un error:

def f () -> None : print ( x ) x : str = "f"x : str = "global" f () # Traceback (última llamada más reciente): # Archivo "<stdin>", línea 1, en <module> # Archivo "<stdin>", línea 2, en f # UnboundLocalError: la variable local 'x' se referencia antes de la asignación

Las reglas de resolución de nombres predeterminadas se pueden anular con las palabras clave global`or` nonlocal(en Python 3). En el código siguiente, la global xdeclaración en `or` gsignifica que xse resuelve a la variable global. Por lo tanto, se puede acceder a ella (ya que se ha definido previamente), y la asignación asigna un valor a la variable global, en lugar de declarar una nueva variable local. Nótese que no globalse necesita ninguna declaración en f`or`, ya que no asigna un valor a la variable, por defecto resuelve a la variable global.

def f () -> None : print ( x )def g () -> None : global x print ( x ) x = "g"x : str = "global" f () # imprime: global g () # imprime: global f () # imprime: g

globalTambién se puede utilizar para funciones anidadas. Además de permitir la asignación a una variable global, como en una función no anidada, también se puede utilizar para acceder a la variable global en presencia de una variable no local:

def f () -> None : def g () -> None : global x print ( x ) x : str = "f" g ()x : str = "global" f () # imprime: global

Para funciones anidadas, también existe la nonlocaldeclaración, para asignar a una variable no local, similar a usar globalen una función no anidada:

def f () -> None : def g () -> None : nonlocal x # Solo Python 3 x = "g" x : str = "f" g () print ( x )x : str = "global" f () # imprime: g print ( x ) # imprime: global

R es un lenguaje con ámbito léxico, a diferencia de otras implementaciones de S donde los valores de las variables libres están determinados por un conjunto de variables globales, mientras que en R están determinados por el contexto en el que se creó la función. ^{[ 38 ]} Se puede acceder a los contextos de ámbito utilizando una variedad de características (como parent.frame()) que pueden simular la experiencia de ámbito dinámico si el programador lo desea.

No hay ámbito de bloque:

a <- 1 { a <- 2 } mensaje ( a ) ## 2

Las funciones tienen acceso al ámbito en el que fueron creadas:

a <- 1 f <- function () { mensaje ( a ) } f () ## 1

Las variables creadas o modificadas dentro de una función permanecen allí:

a <- 1 f <- function () { mensaje ( a ) a <- 2 mensaje ( a ) } f () ## 1 ## 2 mensaje ( a ) ## 1

Las variables creadas o modificadas dentro de una función permanecen allí a menos que se solicite explícitamente su asignación a un ámbito superior:

a <- 1 f <- function () { mensaje ( a ) a <<- 2 mensaje ( a ) } f () ## 1 ## 2 mensaje ( a ) ## 2

Aunque R tiene ámbito léxico por defecto, los ámbitos de las funciones se pueden cambiar:

a <- 1 f <- function () { message ( a ) } my_env <- new.env () my_env $ a <- 2 f () ## 1 environment ( f ) <- my_env f () ## 2