En los lenguajes de programación , la resolución de nombres es la resolución de los tokens dentro de las expresiones del programa en los componentes del programa previstos.
Las expresiones en programas de computadora hacen referencia a variables, tipos de datos, funciones, clases, objetos, bibliotecas, paquetes y otras entidades por su nombre. En ese contexto, la resolución de nombres se refiere a la asociación de esos nombres no necesariamente únicos con las entidades del programa previstas. Los algoritmos que determinan a qué se refieren esos identificadores en contextos específicos son parte de la definición del lenguaje.
La complejidad de estos algoritmos está influenciada por la sofisticación del lenguaje. Por ejemplo, la resolución de nombres en lenguaje ensamblador generalmente implica solo una búsqueda de tabla simple , mientras que la resolución de nombres en C++ es extremadamente complicada ya que involucra:
En los lenguajes de programación , la resolución de nombres se puede realizar en tiempo de compilación o en tiempo de ejecución . La primera se llama resolución de nombres estática , la segunda se llama resolución de nombres dinámica .
Un error bastante común es que la escritura dinámica implica una resolución dinámica de nombres. Por ejemplo, Erlang se escribe dinámicamente pero tiene una resolución de nombre estática. Sin embargo, la escritura estática implica una resolución de nombres estática.
La resolución de nombres estáticos detecta, en tiempo de compilación, el uso de variables que no están dentro del alcance; evitando errores del programador. Los lenguajes con resolución de alcance dinámico sacrifican esta seguridad por una mayor flexibilidad; normalmente pueden establecer y obtener variables en el mismo ámbito en tiempo de ejecución.
Por ejemplo, en el REPL interactivo de Python :
>>> número = 99 >>> primer_nombre = "problemas" >>> segundo_nombre = "sabueso" >>> # Qué variables usar se deciden en tiempo de ejecución >>> print ( f "Obtuve { número } { primer_nombre } pero a { second_noun } no es uno." ) Tengo 99 problemas pero un perro no es uno. Sin embargo, la comunidad Python desaconseja confiar en la resolución dinámica de nombres en el código. [1] [2] La función también puede eliminarse en una versión posterior de Python. [3]
Ejemplos de lenguajes que utilizan resolución de nombres estática incluyen C , C++ , E , Erlang , Haskell , Java , Pascal , Scheme y Smalltalk . Ejemplos de lenguajes que utilizan resolución dinámica de nombres incluyen algunos dialectos Lisp , Perl , PHP , Python , Rebol y Tcl .
El enmascaramiento ocurre cuando se usa el mismo identificador para diferentes entidades en ámbitos léxicos superpuestos. A nivel de variables (más que de nombres), esto se conoce como sombreado de variables . Un identificador I' (para la variable X') enmascara un identificador I (para la variable X) cuando se cumplen dos condiciones
Se dice que la variable exterior X está sombreada por la variable interior X'.
Por ejemplo, el parámetro "foo" oculta la variable local "foo" en este patrón común:
privado int foo ; // El nombre "foo" se declara en el ámbito externo public void setFoo ( int foo ) { // El nombre "foo" se declara en el ámbito interno y es funcional local. este . foo = foo ; // Dado que "foo" se encontrará (y resolverá) primero en el alcance ''más interno'', // para sobrescribir con éxito el valor almacenado del atributo "foo" // con el nuevo valor del parámetro entrante " foo", se hace una distinción // entre "this.foo" (el atributo del objeto) y "foo" (el parámetro de función). } público int getFoo () { return foo ; } El enmascaramiento de nombres puede causar complicaciones en la sobrecarga de funciones , debido a que la sobrecarga no ocurre en todos los ámbitos en algunos lenguajes, en particular C++, lo que requiere que todas las funciones sobrecargadas se vuelvan a declarar o se importen explícitamente a un espacio de nombres determinado.
En lenguajes de programación con alcance léxico que no reflejan los nombres de las variables, se puede utilizar la conversión α (o el cambio de nombre α) para facilitar la resolución de nombres al encontrar una sustitución que asegure que ningún nombre de variable enmascare otro nombre en un alcance contenedor. El cambio de nombre alfa puede facilitar el análisis de código estático , ya que solo el renombrador alfa necesita comprender las reglas de alcance del lenguaje.
Por ejemplo, en este código:
punto de clase { privado : doble x , y ; público : Punto ( doble x , doble y ) { // x e y declarados aquí enmascaran los privados setX ( x ); establecerY ( y ); } void setX ( doble nuevox ) { x = nuevox ; } void setY ( doble nuevo ) { y = nuevo ; } } Dentro del constructor Point , las variables de instancia xey están sombreadas por variables locales del mismo nombre. Esto podría cambiarse alfa a:
punto de clase { privado : doble x , y ; público : Punto ( doble a , doble b ) { setX ( a ); establecerY ( b ); } void setX ( doble nuevox ) { x = nuevox ; } void setY ( doble nuevo ) { y = nuevo ; } } En la nueva versión no hay enmascaramiento, por lo que resulta inmediatamente obvio qué usos corresponden a qué declaraciones.
Es importante darse cuenta de que los alcances se determinan textualmente: el alcance global de una función definida en un módulo es el espacio de nombres de ese módulo, sin importar desde dónde o con qué alias se llame a la función. Por otro lado, la búsqueda real de nombres se realiza dinámicamente, en tiempo de ejecución; sin embargo, la definición del lenguaje está evolucionando hacia una resolución de nombres estática, en tiempo de "compilación", así que no confíe en la resolución de nombres dinámica. (De hecho, las variables locales ya están determinadas estáticamente).