Espacio de nombres

En C , aunque el lenguaje no tiene formalmente espacios de nombres (aunque se emulan con frecuencia ), se puede pensar que los identificadores habitan diferentes espacios de nombres; estos son los identificadores ordinarios, las etiquetas ( struct/ union/ enum), los nombres de miembros y las etiquetas. Por ejemplo, el nombre Foopuede reutilizarse en estos cuatro contextos:

#include <stdio.h>// en el espacio de nombres de etiquetas struct Foo { int Foo ; // en el espacio de nombres de miembros };// nombre de la función y parámetro (identificadores ordinarios) struct Foo Foo ( int Foo ) { struct Foo result = { . Foo = Foo }; if ( Foo < 0 ) { goto Foo ; // en el espacio de nombres de la etiqueta }devolver resultado ; Foo : resultado.Foo = 0 ; devolver resultado ; }​​int main () { // crea una estructura Foo, llamada Foo, // usando la función Foo() struct Foo Foo = Foo ( 42 ); printf ( "%d \n " , Foo . Foo ); }

Además, es posible utilizar estructuras anónimas como espacios de nombres en C desde C99 .

Matemáticas.h :

#pragma una vezconst struct { double PI ; double ( * sin )( double ); } Math ;

Matemáticas.c :

#include <math.h>static double _sin ( double arg ) { return sin ( arg ); }const struct { double PI ; double ( * sin )( double ); } Math = { M_PI , _sin };

Main.c :

#include <stdio.h> #include "Math.h"int main () { printf ( "sin(0) = %d \n " , Math . sin ( 0 )); printf ( "pi es %f \n " , Math . PI ); }

En C++ , un espacio de nombres se define con un bloque de espacio de nombres. ^{[ 11 ]}

espacio de nombres abc { int bar ; }

Dentro de este bloque, los identificadores se pueden usar exactamente como se declaran. Fuera de este bloque, se debe anteponer el especificador de espacio de nombres. Por ejemplo, fuera de , se debe escribir para poder acceder a . C++ incluye otra construcción que hace innecesaria esta verbosidad. Al agregar la líneanamespaceabcbarabc::bar

usando el espacio de nombres abc ;

En un fragmento de código, el prefijo abc::ya no es necesario.

Los identificadores que no se declaran explícitamente dentro de un espacio de nombres se consideran pertenecientes al espacio de nombres global.

entero foo ;

Estos identificadores se pueden usar exactamente como se declaran o, dado que el espacio de nombres global no tiene nombre, ::se puede anteponer el especificador del espacio de nombres. Por ejemplo, footambién se puede escribir ::foo.

La resolución de espacios de nombres en C++ es jerárquica. Esto significa que dentro del hipotético espacio de nombres food::soup, el identificador Chickense refiere a food::soup::Chicken. Si food::soup::Chickenno existe, se refiere a food::Chicken. Si no existen food::soup::Chickenni ni , se refiere a , un identificador en el espacio de nombres global.food::ChickenChicken::Chicken

Los espacios de nombres en C++ se utilizan principalmente para evitar conflictos de nombres . Aunque se usan ampliamente en el código C++ reciente, la mayoría del código antiguo no utiliza esta funcionalidad porque no existía en las primeras versiones del lenguaje. Por ejemplo, toda la biblioteca estándar de C++ se define dentro de , pero antes de la estandarización muchos componentes estaban originalmente en el espacio de nombres global. La instrucción se puede usar para importar un símbolo al ámbito actual.namespacestdusing

El uso de las usingdeclaraciones en los encabezados por razones distintas a la retrocompatibilidad (por ejemplo, conveniencia) se considera contrario a las buenas prácticas de codificación, ya que esas usingdeclaraciones se propagan a todas las unidades de traducción que incluyen el encabezado. Sin embargo, los módulos no exportan usingdeclaraciones a menos que estén marcadas explícitamente export, lo que hace que usinglas declaraciones sean más seguras de usar. Por ejemplo, se puede importar un módulo wikipedia.project.utilcon un espacio de nombres coincidente wikipedia::project::utily luego usar usingdeclaraciones en símbolos de ese espacio de nombres para simplificar espacios de nombres verbosos. A diferencia de otros lenguajes como Java o Rust, los módulos, los espacios de nombres y la estructura de archivos fuente de C++ no necesariamente coinciden, aunque es convención que coincidan para mayor claridad (por ejemplo, el módulo foo.bar.baz.Quxcoincide con la clase con espacio de nombres foo::bar::baz::Quxy reside en el archivo foo/bar/baz/Qux.cppm ).

usingDebe utilizarse para simplificar los espacios de nombres anidados y extensos cuando se utilizan unidades de traducción modulares.

exportar módulo wikipedia . proyecto . Aplicación ;importar std ;import wikipedia . project . fs ; import wikipedia . project . util ;using wikipedia :: project :: fs :: File ; using wikipedia :: project :: util :: ConfigLoader ; using wikipedia :: project :: util :: logging :: Logger ; using wikipedia :: project :: util :: logging :: LoggerFactory ;exportar espacio de nombres wikipedia :: proyecto {clase App { private : Logger logger ; // campos y métodos privados public : App () : logger { LoggerFactory :: getLogger ( "Main" ) } { ConfigLoader cl ( File ( "config/config_file.txt" )); logger.log ( "Iniciando la aplicación..." ); // resto del código } };}

C++11 introduce los espacios de nombres en línea , de modo que sus miembros se tratan como si también fueran miembros del espacio de nombres que los contiene. Se declara escribiendo . Es similar a una instrucción implícita, lo que significa que los símbolos de calificación son opcionales.inlinenamespaceusingnamespace

La propiedad inline es transitiva. Si un espacio de nombres acontiene un espacio de nombres inline b, que a su vez contiene otro espacio de nombres inline c, entonces cse puede acceder a los miembros de como si fueran miembros de ao b.

Un caso de uso principal para los espacios de nombres en línea es la compatibilidad ABI y el control de versiones. Al colocar diferentes versiones de una API dentro de espacios de nombres en línea distintos (por ejemplo, v1, v2), y luego convertir la versión deseada en línea, los desarrolladores de bibliotecas pueden gestionar la compatibilidad ABI. Cuando se lanza una nueva versión, la palabra clave inline se puede mover al espacio de nombres de la nueva versión, lo que permite a los usuarios enlazar automáticamente con la nueva versión y, al mismo tiempo, acceder a versiones anteriores mediante una calificación explícita.

espacio de nombres mylib :: utils { espacio de nombres v1 { [[ deprecated ( "Use mylib::utils::v2::func() instead" )]] void func () { // Implementación antigua } }// v2 es la versión actualmente activa inline namespace v2 { void func () { // Nueva implementación } } }int main () { // Llama implícitamente a mylib::utils::v2::func() mylib :: utils :: func ();// Llama explícitamente a mylib::utils::v2::func() mylib :: utils :: v2 :: func ();// Llama explícitamente a mylib::utils::v1::func() mylib :: utils :: v1 :: func ();devolver 0 ; }

Los espacios de nombres se utilizan ampliamente en el lenguaje C#. Todas las clases del framework .NET están organizadas en espacios de nombres para facilitar su uso y evitar el caos. Además, los programadores utilizan con frecuencia espacios de nombres personalizados para organizar su trabajo y evitar conflictos de nombres . Al hacer referencia a una clase, se puede especificar su nombre completo, es decir, su espacio de nombres seguido del nombre de la clase:

System.Console.WriteLine ( " ¡ Hola mundo! " ) ; int i = System.Convert.ToInt32 ( " 123 " ) ;

o bien, agregue una usingdeclaración. Esto elimina la necesidad de mencionar el nombre completo de todas las clases en ese espacio de nombres.

usando el sistema ;Console.WriteLine ( " ¡ Hola Mundo!" ) ; int i = Convert.ToInt32 ( " 123" ) ;

En los ejemplos anteriores, Systemes un espacio de nombres, y Consoley Convertson clases definidas dentro de System.

A diferencia de C++, usingsolo puede importar todos los símbolos de un espacio de nombres (al igual que en C++, Rust o Java). No se puede usar para importar símbolos y clases individuales como se hace en Java.usingnamespaceuse*import*

espacio de nombres Wikipedia.Proyecto ;using System ; using System.IO ;usando Microsoft.Extensions.Logging ;usando Wikipedia.Project.Utility ;clase App { private static ILogger < Program > registrador ;public App () { ConfigLoader cl = new ConfigLoader ( Path . Combine ( "config" , "config_file.txt" )); LoggerFactory loggerFactory = LoggerFactory . Create ( builder => { builder . AddConsole (); }); logger = loggerFactory . CreateLogger < Program > (); logger . LogInformation ( "Iniciando la aplicación..." ); // resto del código } }

A diferencia de C++, los espacios de nombres de C# no permiten referencias relativas a símbolos. Por ejemplo, Foo.Bar.Baz.Quxno se puede hacer referencia a la clase como Baz.Quxni siquiera si se hace referencia a ella desde dentro del espacio de nombres : o bien se debe importar Foo.Barel espacio de nombres para hacer referencia a la clase , o bien debe estar completamente cualificado.Foo.Bar.BazQuxFoo.Bar.Baz.Qux

En Java , el concepto de espacio de nombres se materializa en los paquetes Java . Todo el código pertenece a un paquete, aunque no es necesario nombrarlo explícitamente. Se accede al código de otros paquetes anteponiendo el nombre del paquete al identificador correspondiente; por ejemplo, en un paquete se puede hacer referencia a él como (esto se conoce como nombre de clase completo ). Al igual que C++, Java ofrece una construcción que hace innecesario escribir el nombre del paquete ( ). Sin embargo, ciertas características (como la reflexión ) requieren que el programador utilice el nombre completo.classStringjava.langjava.lang.Stringimport

A diferencia de C++, los espacios de nombres en Java no siguen una jerarquía con respecto a la sintaxis del lenguaje. Sin embargo, los paquetes sí se nombran de forma jerárquica. Por ejemplo, todos los paquetes que comienzan con javaforman parte de la plataforma Java : el paquete java.langcontiene clases fundamentales del lenguaje y java.lang.reflectcontiene clases esenciales relacionadas específicamente con la reflexión.

En Java (y Ada , C# y otros lenguajes), los espacios de nombres/paquetes expresan categorías semánticas de código. Por ejemplo, en C#, contiene código proporcionado por el sistema (el framework .NET ). El grado de especificidad de estas categorías y la profundidad de las jerarquías varían según el lenguaje.namespaceSystem

Los ámbitos de las funciones y las clases pueden considerarse como espacios de nombres implícitos que están inextricablemente vinculados con la visibilidad, la accesibilidad y el ciclo de vida de los objetos .

En Java, los paquetes no pueden calificarse parcialmente como en C++. Por ejemplo, no es posible importar el javaespacio de nombres y luego referirse a él java.util.ArrayListcomo util.ArrayList. Los símbolos deben estar completamente calificados o importados completamente al ámbito. importLas declaraciones no son transitivas ni pueden marcarse deliberadamente exportcomo en C++. Todas importlas declaraciones deben aparecer al principio del archivo y no pueden escribirse en ningún otro ámbito. Esto contrasta con C++, donde el stdespacio de nombres puede importarse escribiendo , y luego puede referirse a él como .usingnamespacestd;std::chrono::system_clockchrono::system_clock

paquete org.wikipedia.project ;import java.nio.file.Paths ; import java.util.logging.Level ; import java.util.logging.Logger ;import org.wikipdia.project.util.ConfigLoader ;public class App { private static final Logger logger = Logger . getLogger ( Main . class . getName ());public App () { ConfigLoader cl = new ConfigLoader ( Paths.get ( " config / config_file.txt" )); logger.log ( Level.INFO , " Iniciando la aplicación..." ) ; // resto del código } }

Debido a que Java no admite funciones independientes fuera de las clases, los métodos de clase estáticos y las llamadas "clases de utilidad" (clases con constructores privados y todos los métodos y campos estáticos) son el equivalente a los espacios de nombres al estilo C++. Algunos ejemplos son java.lang.Math, que contiene constantes como Math.PIy métodos como Math.sin().

importLas instrucciones se pueden usar para importar todos los símbolos de un paquete, lo que se denomina importación comodín, similar a la de C++. Por ejemplo, escribir importa todas las clases del paquete. Sin embargo, esto puede causar contaminación de símbolos dentro de un archivo. Además, usar instrucciones de importación glob en paquetes que tienen clases con el mismo nombre puede causar ambigüedad y provocará un error de compilación. No obstante, se importa implícitamente en todos los archivos fuente de Java por defecto.usingnamespaceimportjava.util.*;java.utiljava.lang.*

import java.sql.* ; // Importa todas las clases en java.sql, incluyendo java.sql.Date import java.util.* ; // Importa todas las clases en java.util, incluyendo java.util.DateDate d = new Date (); // Referencia de fecha ambigua que resulta en un error de compilación// En su lugar , deben usarse los nombres completos : java.sql.Date sqlDate = new java.sql.Date ( System.currentTimeMillis ( ) ) ; java.util.Date utilDate = new java.util.Date ( ) ;​​​

Los paquetes de Kotlin son muy similares a los paquetes de Java, pero a diferencia de Java, donde solo los objetos de tipo clase pueden residir directamente en un paquete, cualquier símbolo de nivel superior (como una variable, una clase, un alias de tipo, etc.) puede residir directamente dentro de un paquete.

paquete org.wikipedia.examplesimport kotlin.math.PIvar myPi = PIfun circleArea ( radio : Double ): Double { return myPi * radio * radio }

Sin embargo, aunque Kotlin permite que los objetos que no son de clase de nivel superior residan directamente en un paquete, esto se representa internamente en la Máquina Virtual de Java como si residieran dentro de una clase generada, parecida a algo como lo siguiente:

paquete org.wikipedia.examples ;clase pública final ExampleKt {privado estático doble myPi = Math.PI ;​​public static final double getMyPi () { return myPi ; }public static final void setMyPi ( double value ) { myPi = value ; }public static final double circleArea ( double radius ) { return myPi * radius * radius ; } }

Los espacios de nombres se introdujeron en PHP a partir de la versión 5.3. Esto permite evitar conflictos de nombres entre clases, funciones y variables. En PHP , un espacio de nombres se define mediante un bloque de espacio de nombres.

# Archivo phpstar/foobar.phpespacio de nombres phpstar ;clase FooBar { función pública foo () : void { echo 'Hola mundo, desde la función foo' ; }función pública bar () : void { echo 'Hola mundo, desde la función bar' ; } }

Podemos hacer referencia a un espacio de nombres PHP de las siguientes maneras diferentes:

# Archivo index.php# Incluir el archivo include "phpstar/foobar.php" ;# Opción 1: anteponer directamente el espacio de nombres al nombre de la clase $obj_foobar = new \phpstar\FooBar ();# Opción 2: importar el espacio de nombres use phpstar\FooBar ; $obj_foobar = new FooBar ();# Opción 2a: importar y crear un alias para el espacio de nombres use phpstar\FooBar as FB ; $obj_foobar = new FB ();# Acceda a las propiedades y métodos de forma habitual $obj_foobar -> foo (); $obj_foobar -> bar ();

En Python , los espacios de nombres se definen mediante los módulos individuales, y dado que los módulos pueden estar contenidos en paquetes jerárquicos, los espacios de nombres también son jerárquicos. ^{[ 12 ] [ 13 ]} En general, cuando se importa un módulo, los nombres definidos en él se definen a través del espacio de nombres de ese módulo, y se accede a ellos desde los módulos que lo llaman utilizando el nombre completo.

# Supongamos que mod_a define dos funciones: func1() y func2() y una clase: Class1 import mod_amod_a.func1 ( ) mod_a.func2 ( ) a : mod_a.Class1 = mod_a.Class1 ( )​​​​​

La instrucción se puede utilizar para insertar los nombres relevantes directamente en el espacio de nombres del módulo que realiza la llamada, y se puede acceder a esos nombres desde el módulo que realiza la llamada sin el nombre calificado:from...import...

# Supongamos que mod_a define dos funciones: func1() y func2() y una clase: Class1. from mod_a import func1func1 () func2 () # esto fallará como nombre indefinido, al igual que el nombre completo mod_a.func2() a : Class1 = Class1 () # esto fallará como nombre indefinido, al igual que el nombre completo mod_a.Class1()

Dado que esto importa nombres directamente (sin ninguna condición), puede sobrescribir los nombres existentes sin advertencias.

Una forma especial de la instrucción es que importa todos los nombres definidos en el paquete nombrado directamente en el espacio de nombres del módulo que realiza la llamada. El uso de esta forma de importación, aunque está soportada por el lenguaje, generalmente se desaconseja ya que contamina el espacio de nombres del módulo que realiza la llamada y hará que los nombres ya definidos se sobrescriban en caso de conflictos de nombres, ^{[ 14 ]} aunque su uso en Python puede simplificar espacios de nombres verbosos, como los espacios de nombres anidados.from...import*fromimport

from selenium.webdriver import Firefox from selenium.webdriver.common.action_chains import ActionChains from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys from selenium.webdriver.remote.webelement import WebElementif __name__ == " __main__ " : driver : Firefox = Firefox ( ) element : WebElement = driver.find_element ( By.ID , " myInputField " ) element.send_keys ( f " Hola Mundo { Keys.ENTER } " ) action : ActionChains = ActionChains ( driver ) action.key_down ( Keys.CONTROL ) .send_keys ( ' a ' ) . key_up ( Keys.CONTROL ) .perform ( )​​​​​​

Python también admite como una forma de proporcionar un alias o nombre alternativo para que lo utilice el módulo que realiza la llamada:importxasy

import numpy as np from numpy.typing import NDArray , float32a : NDArray [ float32 ] = np . organizar ( 1000 )

En Rust , un espacio de nombres se denomina "módulo" y se declara utilizando `<module>` mod. Los símbolos dentro del módulo son privados por defecto y no se puede acceder a ellos externamente, a menos que se declaren con la pubpalabra clave `private`, que los expone. Los módulos pueden contener submódulos, lo que permite la creación de espacios de nombres anidados.

De forma similar a la usingpalabra clave en C++, Rust tiene una usepalabra clave para importar símbolos al ámbito actual.

mod my_module { pub trait Greet { fn greet ( & self ); }pub struct Person { pub name : String , }impl Saludar para Persona { fn saludar ( & self ) { println! ( "Hola, {}!" , self . nombre ); } } }fn main () { use my_module ::{ Person , Greet };let person = Person { name : String :: from ( "Alice" ) }; person . greet (); }

Escribir indica al compilador que busque un archivo llamado o . en una instrucción se refiere a la raíz del "crate" (proyecto) actual, mientras que se puede usar para referirse al módulo padre.modutil;util.rsutil/mod.rscrateusesuper

mod util ;usar std :: fs :: File ;use crate :: util :: ConfigLoader ; use crate :: util :: logging ::{ Logger , LoggerFactory };pub struct App { config_loader : ConfigLoader ; }impl App { pub fn new () -> Self { config_loader = ConfigLoader :: new ( File :: open ( "config/config_file.txt" )); config_loader . load (); let logger : Logger = LoggerFactory :: get_logger ( "Main" ); logger . log ( "Iniciando la aplicación..." ); // resto del código } }

La usepalabra clave en Rust es más versátil que su equivalente usingen C++. Además de importar símbolos individuales, crear alias de símbolos ase importar comodines, usepuede importar varios símbolos en la misma línea usando llaves (que pueden estar anidadas), importar espacios de nombres individuales y realizar todo lo anterior en una sola instrucción. Este es un ejemplo de cómo usar todas estas funcionalidades:

use std ::{ alloc :: Layout , // importa std::alloc::Layout fmt :: * , // importa todos los símbolos en std::fmt fs ::{ File , Metadata }, // importa std::fs::File y std::fs::Metadata io ::{ prelude :: * , BufReader , BufWriter } // importa todos los símbolos en std::io::prelude::*, std::io::BufReader y std::io::BufWriter process , // importa el espacio de nombres std::process (por ejemplo, std::process::Command puede ser referido como process::Command) time ::{ self , Duration } // importa el espacio de nombres std::time y std::time::Duration };use std :: fmt :: Result as FmtResult ; // cambia el nombre de std::fmt::Result a FmtResult

En XML , la especificación de espacios de nombres XML permite que los nombres de los elementos y atributos en un documento XML sean únicos, de forma similar a la función de los espacios de nombres en los lenguajes de programación. Mediante los espacios de nombres XML, los documentos XML pueden contener nombres de elementos o atributos de más de un vocabulario XML.

En los sistemas SAP (especialmente en entornos ABAP), los espacios de nombres se utilizan para evitar conflictos de nombres entre objetos estándar proporcionados por SAP y desarrollos de clientes o socios. ^{[ 15 ]}

Un identificador de espacio de nombres está delimitado por “/” (por ejemplo, `/MYNS/`) y se reserva mediante el proceso de registro de espacios de nombres de SAP. Una vez reservados, los objetos creados bajo ese espacio de nombres son identificables de forma única y están protegidos contra sobrescrituras no deseadas por actualizaciones o importaciones de SAP. ^{[ 16 ]}

En los entornos SAP modernos (como ABAP en la nube y los contenedores HDI), los espacios de nombres también se utilizan para agrupar semánticamente artefactos o paquetes de desarrollo.