Namespace
Incomputing,anamespaceis a set of signs (names) that are used to identify and refer to objects of various kinds. A namespace ensures that all of a given set of objects have unique names so that they can be easilyidentified.
Namespaces are commonly structured as hierarchies to allow reuse of names in different contexts. As an analogy, consider a system ofnaming of peoplewhere each person has a given name, as well as a family name shared with their relatives. If the first names of family members are unique only within each family, then each person can be uniquely identified by the combination of first name and family name; there is only one Jane Doe, though there may be many Janes. Within the namespace of the Doe family, just "Jane" suffices to unambiguously designate this person, while within the "global" namespace of all people, the full name must be used.
Prominent examples for namespaces includefile systems,which assign names to files.[1] Someprogramming languagesorganize theirvariablesandsubroutinesin namespaces.[2][3][4] Computer networksanddistributed systemsassign names to resources, such ascomputers,printers,websites,and remote files.Operating systemscan partitionkernelresources by isolated namespaces to support virtualizationcontainers.
Similarly,hierarchical file systemsorganize files in directories. Each directory is a separate namespace, so that the directories "letters" and "invoices" may both contain a file "to_jane".
Incomputer programming,namespaces are typically employed for the purpose of grouping symbols and identifiers around a particular functionality and to avoidname collisionsbetween multiple identifiers that share the same name.
Innetworking,theDomain Name Systemorganizes websites (and other resources) intohierarchical namespaces.
Name conflicts
[edit]Element names are defined by the developer. This often results in a conflict when trying to mix XML documents from different XML applications.
This XML carriesHTML tableinformation:
<table>
<tr>
<td>Apples</td>
<td>Oranges</td>
</tr>
</table>
This XML carries information about atable(i.e. a piece of furniture):
<table>
<name>MahoganyCoffeeTable</name>
<width>80</width>
<length>120</length>
</table>
If these XML fragments were added together, there would be a name conflict. Both contain a<table>...</table>
element, but the elements have different content and meaning.
An XML parser will not know how to handle these differences.
Solution via prefix
[edit]Name conflicts in XML can easily be avoided using a name prefix.
The following XML distinguishes between information about the HTML table and furniture by prefi xing "h" and "f" at the beginning of the elements.
<h:table>
<h:tr>
<h:td>Apples</h:td>
<h:td>Oranges</h:td>
</h:tr>
</h:table>
<f:table>
<f:name>MahoganyCoffeeTable</f:name>
<f:width>80</f:width>
<f:length>120</f:length>
</f:table>
Naming system
[edit]A name in a namespace consists of a namespace name and a local name.[5][6]The namespace name is usually applied as aprefixto the local name.
name=<namespacename>separator<localname>
When local names are used by themselves,name resolutionis used to decide which (if any) particular name is alluded to by some particular local name.
Examples
[edit]Context | Name | Namespace name | Local name |
---|---|---|---|
Path | /home/user/readme.txt | /home/user (directory) | readme.txt (file name) |
Domain name | example | example (domain name) | www (leaf domain name) |
C++ | std::array | std (C++ namespace) | array (struct) |
UN/LOCODE | US NYC | US (country or territory) | NYC (locality) |
XML | xmlns:xhtml= "http:// w3.org/1999/xhtml" <xhtml:body> |
xhtml (previously declared XML namespace xhtml= "http:// w3.org/1999/xhtml") | body (element) |
Perl | $DBI::errstr | $DBI (Perl module) | errstr (variable) |
Java | java.util.Date | java.util (Java namespace) | Date (class) |
Uniform Resource Name(URN) | urn:nbn:fi-fe19991055 | urn:nbn(National Bibliography Numbers) | fi-fe19991055 |
Handle System | 10.1000/182 | 10 (handle naming authority) | 1000/182 (handle local name) |
Digital object identifier | 10.1000/182 | 10.1000 (publisher) | 182 (publication) |
MAC address | 01-23-45-67-89-ab | 01-23-45 (organizationally unique identifier) | 67-89-ab (NIC specific) |
PCI ID | 1234 abcd | 1234 (vendor ID) | abcd (device ID) |
USB VID/PID | 2341 003f[7] | 2341 (vendor ID) | 003f (product ID) |
SPARQL | dbr:Sydney | dbr (previously declared ontology, e.g. by specifying @prefix dbr: <http://dbpedia.org/resource/>) | Sydney |
Delegation
[edit]Delegation of responsibilities between parties is important in real-world applications, such as the structure of the World Wide Web. Namespaces allow delegation of identifier assignment to multiple name issuing organisations whilst retaining global uniqueness.[8]A centralRegistration authorityregisters theassigned namespace names allocated.Each namespace name is allocated to an organisation which is subsequently responsible for the assignment of names in their allocated namespace. This organisation may be a name issuing organisation thatassign the namesthemselves, or anotherRegistration authoritywhich further delegates parts of their namespace to different organisations.
Hierarchy
[edit]A naming scheme that allows subdelegation of namespaces to third parties is ahierarchical namespace.
A hierarchy is recursive if the syntax for the namespace names is the same for each subdelegation. An example of a recursive hierarchy is theDomain name system.
An example of a non-recursive hierarchy areUniform Resource Namerepresenting anInternet Assigned Numbers Authority(IANA) number.
Registry | Registrar | Example Identifier | Namespace name | Namespace |
---|---|---|---|---|
Uniform Resource Name(URN) | Internet Assigned Numbers Authority | urn:isbn:978-3-16-148410-0 | urn | Formal URN namespace |
Formal URN namespace | Internet Assigned Numbers Authority | urn:isbn:978-3-16-148410-0 | ISBN | International Standard Book Numbers as Uniform Resource Names |
International Article Number (EAN) | GS1 | 978-3-16-148410-0 | 978 | Bookland |
International Standard Book Number(ISBN) | International ISBN Agency | 3-16-148410-X | 3 | German-speaking countries |
German publisher code | Agentur für Buchmarktstandards | 3-16-148410-X | 16 | Mohr Siebeck |
Namespace versus scope
[edit]A namespace name may provide context (scopein computer science) to a name, and the terms are sometimes used interchangeably. However, the context of a name may also be provided by other factors, such as the location where it occurs or the syntax of the name.
Without a namespace | With a namespace | |
---|---|---|
Local scope | Vehicle registration plate | Filesystem Hierarchy Standard |
Global scope | Universally unique identifier | Domain Name System |
In programming languages
[edit]For many programming languages, namespace is a context for theiridentifiers.In an operating system, an example of namespace is a directory. Each name in a directory uniquely identifies one file or subdirectory.[9]
As a rule, names in a namespace cannot have more than one meaning; that is, different meanings cannot share the same name in the same namespace. A namespace is also called acontext,because the same name in different namespaces can have different meanings, each one appropriate for its namespace.
Following are other characteristics of namespaces:
- Names in the namespace can represent objects as well asconcepts,be the namespace anatural or ethnic language,aconstructed language,thetechnical terminologyof a profession, adialect,asociolect,or an artificial language (e.g., aprogramming language).
- In theJava programming language,identifiers that appear in namespaces have a short (local) name and a unique long "qualified" name for use outside the namespace.
- Some compilers (for languages such asC++) combine namespaces and names for internal use in the compiler in a process calledname mangling.
As well as its abstract language technical usage as described above, some languages have a specific keyword used for explicit namespace control, amongst other uses. Below is an example of a namespace in C++:
#include<iostream>
// This is how one brings a name into the current scope. In this case, it's
// bringing them into global scope.
usingstd::cout;
usingstd::endl;
namespacebox1{
intbox_side=4;
}
namespacebox2{
intbox_side=12;
}
intmain(){
intbox_side=42;
cout<<box1::box_side<<endl;// Outputs 4.
cout<<box2::box_side<<endl;// Outputs 12.
cout<<box_side<<endl;// Outputs 42.
}
Computer-science considerations
[edit]A namespace in computer science (sometimes also called aname scope) is an abstract container or environment created to hold a logical grouping of uniqueidentifiersorsymbols(i.e. names). An identifier defined in a namespace is associated only with that namespace. The same identifier can be independently defined in multiple namespaces. That is, an identifier defined in one namespace may or may not have the same meaning as the same identifier defined in another namespace. Languages that support namespaces specify the rules that determine to which namespace an identifier (not its definition) belongs.[10]
This concept can be illustrated with an analogy. Imagine that two companies, X and Y, each assign ID numbers to their employees. X should not have two employees with the same ID number, and likewise for Y; but it is not a problem for the same ID number to be used at both companies. For example, if Bill works for company X and Jane works for company Y, then it is not a problem for each of them to be employee #123. In this analogy, the ID number is the identifier, and the company serves as the namespace. It does not cause problems for the same identifier to identify a different person in each namespace.
In largecomputer programsor documents it is common to have hundreds or thousands of identifiers. Namespaces (or a similar technique, seeEmulating namespaces) provide a mechanism for hiding local identifiers. They provide a means of grouping logically related identifiers into corresponding namespaces, thereby making the system moremodular.
Data storage devicesand many modernprogramming languagessupport namespaces. Storage devices use directories (or folders) as namespaces. This allows two files with the same name to be stored on the device so long as they are stored in different directories. In some programming languages (e.g.C++,Python), the identifiers naming namespaces are themselves associated with an enclosing namespace. Thus, in these languages namespaces can nest, forming a namespacetree.At the root of this tree is the unnamedglobal namespace.
Use in common languages
[edit]C
[edit]It is possible to use anonymous structs as namespaces inCsinceC99.
// helper.c
staticint_add(inta,intb){
returna+b;
}
conststruct{
doublepi;
int(*add)(int,int);
}helper={3.14,_add};
// helper.h
conststruct{
doublepi;
int(*add)(int,int);
}helper;
// main.c
#include<stdio.h>
#include"helper.h"
intmain(){
printf("3 + 2 = %d\n",helper.add(3,2));
printf("pi is %f\n",helper.pi);
}
C++
[edit]InC++,a namespace is defined with a namespace block.[11]
namespaceabc{
intbar;
}
Within this block, identifiers can be used exactly as they are declared. Outside of this block, the namespace specifier must be prefixed. For example, outside ofnamespace abc
,bar
must be writtenabc::bar
to be accessed. C++ includes another construct that makes this verbosity unnecessary. By adding the line
usingnamespaceabc;
to a piece of code, the prefixabc::
is no longer needed.
Identifiers that are not explicitly declared within a namespace are considered to be in the global namespace.
intfoo;
These identifiers can be used exactly as they are declared, or, since the global namespace is unnamed, the namespace specifier::
can be prefixed. For example,foo
can also be written::foo
.
Namespace resolution in C++ is hierarchical. This means that within the hypothetical namespacefood::soup
,the identifierchicken
refers tofood::soup::chicken
.Iffood::soup::chicken
doesn't exist, it then refers tofood::chicken
.If neitherfood::soup::chicken
norfood::chicken
exist,chicken
refers to::chicken
,an identifier in the global namespace.
Namespaces in C++ are most often used to avoidnaming collisions.Although namespaces are used extensively in recent C++ code, most older code does not use this facility because it did not exist in early versions of the language. For example, the entireC++ Standard Libraryis defined withinnamespace std
,but before standardization many components were originally in the global namespace. A programmer can insert theusing
directive to bypass namespace resolution requirements and obtain backwards compatibility with older code that expects all identifiers to be in the global namespace. However the use of theusing
directive for reasons other than backwards compatibility (e.g., convenience) is considered to be against good code practices.
Java
[edit]InJava,the idea of a namespace is embodied inJava packages.All code belongs to a package, although that package need not be explicitly named. Code from other packages is accessed by prefi xing the package name before the appropriate identifier, for exampleclass String
inpackagejava.lang
can be referred to asjava.lang.String
(this is known as thefully qualified class name). Like C++, Java offers a construct that makes it unnecessary to type the package name (import
). However, certain features (such asreflection) require the programmer to use the fully qualified name.
Unlike C++, namespaces in Java are not hierarchical as far as the syntax of the language is concerned. However, packages are named in a hierarchical manner. For example, all packages beginning withjava
are a part of theJava platform—the packagejava.lang
contains classes core to the language, andjava.lang.reflect
contains core classes specifically relating to reflection.
In Java (andAda,C#,and others), namespaces/packages express semantic categories of code. For example, in C#,namespace System
contains code provided by the system (the.NET Framework). How specific these categories are and how deep the hierarchies go differ from language to language.
Functionandclassscopescan be viewed as implicit namespaces that are inextricably linked with visibility, accessibility, andobject lifetime.
C#
[edit]Namespaces are heavily used in C# language. All.NET Framework classes are organized in namespaces, to be used more clearly and to avoid chaos. Furthermore, custom namespaces are extensively used by programmers, both to organize their work and to avoidnaming collisions. When referencing a class, one should specify either its fully qualified name, which means namespace followed by the class name,
System.Console.WriteLine("Hello World!");
inti=System.Convert.ToInt32("123");
or add ausingstatement. This, eliminates the need to mention the complete name of all classes in that namespace.
usingSystem;
Console.WriteLine("Hello World!");
inti=Convert.ToInt32("123");
In the above examples,Systemis a namespace, andConsoleandConvertare classes defined withinSystem.
Python
[edit]InPython,namespaces are defined by the individual modules, and since modules can be contained in hierarchical packages, then namespaces are hierarchical too.[12][13] In general when a module is imported then the names defined in the module are defined via that module's namespace, and are accessed in from the calling modules by using the fully qualified name.
# assume modulea defines two functions: func1() and func2() and one class: Class1
importModulea
Modulea.func1()
Modulea.func2()
a=Modulea.Class1()
Thefrom... import...
statement can be used to insert the relevant names directly into the calling module's namespace, and those names can be accessed from the calling module without the qualified name:
# assume Modulea defines two functions: func1() and func2() and one class: Class1
fromModuleaimportfunc1
func1()
func2()# this will fail as an undefined name, as will the full name Modulea.func2()
a=Class1()# this will fail as an undefined name, as will the full name Modulea.Class1()
Since this directly imports names (without qualification) it can overwrite existing names with no warnings.
A special form of the statement isfrom... import *
which imports all names defined in the named package directly in the calling module's namespace. Use of this form of import, although supported within the language, is generally discouraged as it pollutes the namespace of the calling module and will cause already defined names to be overwritten in the case of name clashes.[14]
Python also supportsimport x as y
as a way of providing an alias or alternative name for use by the calling module:
importnumpyasnp
a=np.arange(1000)
XML namespace
[edit]InXML,the XML namespace specification enables the names of elements and attributes in an XML document to be unique, similar to the role of namespaces in programming languages. Using XML namespaces, XML documents may contain element or attribute names from more than one XML vocabulary.
PHP
[edit]Namespaces were introduced intoPHPfrom version 5.3 onwards. Naming collision of classes, functions and variables can be avoided. InPHP,a namespace is defined with a namespace block.
# File phpstar/foobar.php
namespacephpstar;
classFooBar
{
publicfunctionfoo():void
{
echo'Hello world, from function foo';
}
publicfunctionbar():void
{
echo'Hello world, from function bar';
}
}
We can reference a PHP namespace with the following different ways:
# File index.php
# Include the file
include"phpstar/foobar.php";
# Option 1: directly prefix the class name with the namespace
$obj_foobar=new\phpstar\FooBar();
# Option 2: import the namespace
usephpstar\FooBar;
$obj_foobar=newFooBar();
# Option 2a: import & alias the namespace
usephpstar\FooBarasFB;
$obj_foobar=newFB();
# Access the properties and methods with regular way
$obj_foobar->foo();
$obj_foobar->bar();
Emulating namespaces
[edit]In programming languages lacking language support for namespaces, namespaces can be emulated to some extent by using anidentifier naming convention.For example,Clibraries such aslibpngoften use a fixed prefix for all functions and variables that are part of their exposed interface. Libpng exposes identifiers such as:
png_create_write_struct png_get_signature png_read_row png_set_invalid
Thisnaming conventionprovides reasonable assurance that theidentifiersare unique and can therefore be used in larger programs withoutnaming collisions.[15]Likewise, many packages originally written inFortran(e.g.,BLAS,LAPACK) reserve the first few letters of a function's name to indicate which group it belongs to.
This technique has several drawbacks:
- It doesn't scale well to nested namespaces; identifiers become excessively long since all uses of the identifiers must befully namespace-qualified.
- Individuals or organizations may use inconsistent naming conventions, potentially introducing unwanted obfuscation.
- Compound or "query-based" operations on groups of identifiers, based on the namespaces in which they are declared, are rendered unwieldy or unfeasible.
- In languages with restricted identifier length, the use of prefixes limits the number of characters that can be used to identify what the function does. This is a particular problem for packages originally written inFORTRAN 77,which offered only 6 characters per identifier. For example, the name of theBLASfunction
DGEMM
function indicates that it operates on double-precision numbers ( "D" ) and general matrices ( "GE" ), and only the last two characters show what it actually does: matrix-matrix multiplication (the "MM" ).
There are several advantages:
- No special software tools are required to locate names in source-code files. A simple program likegrepsuffices.
- There are no namespace name conflicts.
- There is no need for name-mangling, and thus no potential incompatibility problems.
See also
[edit]![](https://upload.wikimedia.org/wikipedia/commons/thumb/9/99/Wiktionary-logo-en-v2.svg/40px-Wiktionary-logo-en-v2.svg.png)
- 11-digitdelivery pointZIP code
- Binomial nomenclature(genus-species inbiology)
- Chemical nomenclature
- Dewey Decimal Classification
- Digital object identifier
- Domain Name System
- Fourth wall
- Identity (object-oriented programming)
- Library of Congress Classification
- Star cataloguesandastronomical naming conventions
- Violation of abstraction level
- XML namespace
- Argument-dependent name lookup
References
[edit]- ^Adya, Atul; Bolosky, William; Castro, Miguel; Cermak, Gerald; Chaiken, Ronnie; Douceur, John; Howell, Jon; Lorch, Jacob; Theimer, Marvin; Wattenhofer, Roger (2002).FARSITE: Federated, Available, and Reliable Storage for an Incompletely Trusted Environment(PDF).Proc.USENIXSymp. on Operating Systems Design and Implementation. Archived fromthe original(PDF)on 2010-07-28.
The primary construct established by a file system is a hierarchical directory namespace, which is the logical repository for files.
- ^"C# FAQ: What is a namespace".C# Online Net. Archived fromthe originalon 2013-10-20.Retrieved2010-02-23.
A namespace is nothing but a group of assemblies, classes, or types. A namespace acts as a container—like a disk folder—for classes organized into groups usually based on functionality. C# namespacesyntaxallows namespaces to be nested.
- ^"An overview of namespaces in PHP".PHP Manual.
What are namespaces? In the broadest definition, namespaces are a way of encapsulating items. This can be seen as an abstract concept in many places. For example, in any operating system directories serve to group related files, and act as a namespace for the files within them.
- ^"Creating and Using Packages".Java Documentation.Oracle.
A package is a grouping of related types providing access protection and name space management. Note that types refers toclasses,interfaces,enumerations,and annotation types. Enumerations and annotation types are special kinds of classes and interfaces, respectively, so types are often referred to in this lesson simply as classes and interfaces.
[better source needed] - ^XML Core Working Group (8 December 2009)."Namespaces in XML 1.0 (Third Edition)".W3C.Retrieved2012-03-30.
- ^Moats, Ryan (May 1997)."Syntax".URN Syntax.IETF.p. 1. sec. 2.doi:10.17487/RFC2141.RFC2141.Retrieved2012-03-30.
- ^ Stephen J. Gowdy. "List of USB ID's". 2013.
- ^Sollins & Masinter (December 1994)."Requirements for functional capabilities".Functional Requirements for Uniform Resource Names.IETF.p. 3. sec. 2.doi:10.17487/RFC1731.RFC1731.Retrieved2012-03-30.
- ^"C# FAQ: What is a namespace".C# Online Net.Archived fromthe originalon October 20, 2013.Retrieved2010-02-23.
For instance, [underWindows], to access the built-in input-output (I/O) classes and members, use the System.IO namespace. Or, to access Web-related classes and members, use the System.Web namespace.
- ^"A namespace is" a logical grouping of the names used within a program. "".Webopedia. 10 April 2002.Retrieved2011-07-26.
- ^"Namespaces allow to group entities like classes, objects and functions under a name".Cplusplus.Retrieved2011-07-26.
- ^"6. Modules".The Python Tutorial.Python Software Foundation.Retrieved25 October2010.
- ^"Python Scopes and Namespaces".Docs. Python.org.Retrieved2011-07-26.
- ^https://docs. Python.org/3/tutorial/modules.html"in general the practice of importing * from a module or package is frowned upon"
- ^Danny Kalev."Why I Hate Namespaces".Archived from the original on 2016-07-09.
{{cite web}}
:CS1 maint: bot: original URL status unknown (link)