View source for Namespace

{{Short description|Container for a set of identifiers}}
{{Hatnote group|

{{About||a feature of the Linux kernel|Linux namespaces|the use of namespaces in Wikipedia|:Wikipedia:Namespace|and|selfref=yes}}
}}

In [[computing]], a '''namespace''' is a set of signs (''names'') that are used to identify and refer to [[Object (computer science)|objects]] of various kinds. A namespace ensures that all of a given set of objects have unique names so that they can be easily [[Identifier|identified]].

Namespaces are commonly structured as hierarchies to allow reuse of names in different contexts. As an analogy, consider a system of [[Anthroponymy|naming of people]] where 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 include [[file system]]s, which assign names to files.<ref>{{cite conference
 |first1=Siddharth 
 |last1=Aniket
 |first2=Anushka 
 |last2=Aditya
 |first3=Chaya
 |last3=Deepa
 |first4=Batman 
 |last4=Cermak 
 |first5=Ronnie 
 |last5=Chaiken 
 |first6=John 
 |last6=Douceur 
 |first7=Jon 
 |last7=Howell 
 |first8=Jacob 
 |last8=Lorch 
 |first9=Marvin 
 |last9=Theimer 
 |first10=Roger 
 |last10=Wattenhofer 
 |title=FARSITE: Federated, Available, and Reliable Storage for an Incompletely Trusted Environment 
 |conference=Proc. [[USENIX]] Symp. on Operating Systems Design and Implementation 
 |year=2002 
 |url=http://paul.rutgers.edu/cs545/S06/papers/adya-farsite-osdi-2002.pdf 
 |quote=The primary construct established by a file system is a hierarchical directory namespace, which is the logical repository for files. 
 |archive-url=https://web.archive.org/web/20100728202945/http://paul.rutgers.edu/cs545/S06/papers/adya-farsite-osdi-2002.pdf 
 |archive-date=2010-07-28 
}}</ref>
Some [[programming language]]s organize their [[variable (computer science)|variables]] and [[subroutine]]s in namespaces.<ref>{{cite web|url=http://en.csharp-online.net/CSharp_FAQ:_What_is_a_namespace |title=C# FAQ: What is a namespace |publisher=C# Online Net |quote=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# namespace [[Syntax (programming languages)|syntax]] allows namespaces to be nested. |access-date=2010-02-23 |archive-url=https://web.archive.org/web/20131020150529/http://tutorials.csharp-online.net/index.php?title=CSharp_FAQ%3A_What_is_a_namespace |archive-date=2013-10-20 }}</ref><ref>{{Cite web|url=http://php.net/manual/en/language.namespaces.rationale.php|title=An overview of namespaces in PHP|website=PHP Manual|quote=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.}}</ref><ref>{{Cite web|url=https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html|title=Creating and Using Packages|website=Java Documentation|publisher=Oracle|quote=A package is a grouping of related types providing access protection and name space management. Note that types refers to [[Class (programming)|classes]], [[Interface (computing)|interfaces]], [[Enumerated type|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|date=July 2015}}</ref>
[[Computer network]]s and [[distributed system]]s assign names to resources, such as [[computer]]s, [[Printer (computing)|printer]]s, [[website]]s, and remote files. [[Operating system]]s can partition [[Kernel (operating system)|kernel]] resources by isolated namespaces to support [[OS-level virtualisation|virtualization]] containers.

Similarly, [[Directory (computing)|hierarchical file systems]] organize files in directories. Each directory is a separate namespace, so that the directories "letters" and "invoices" may both contain a file "to_jane".

In [[computer programming]], namespaces are typically employed for the purpose of grouping symbols and identifiers around a particular functionality and to avoid [[name collision]]s between multiple identifiers that share the same name.

In [[Computer network|networking]], the [[Domain Name System]] organizes websites (and other resources) into [[hierarchical namespace]]s.

==Name conflicts==
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 carries [[HTML table]] information:
<syntaxhighlight lang="xml">
<table>
    <tr>
        <td>Apples</td>
        <td>Oranges</td>
    </tr>
</table>
</syntaxhighlight>
This XML carries information about a [[table (furniture)|table]] (i.e. a piece of furniture):
<syntaxhighlight lang="xml">
<table>
    <name>Mahogany Coffee Table</name>
    <width>80</width>
    <length>120</length>
</table>
</syntaxhighlight>

If these XML fragments were added together, there would be a name conflict. Both contain a {{tag|table}} element, but the elements have different content and meaning.

An XML parser will not know how to handle these differences.

===Solution via prefix===
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 prefixing "h" and "f" at the beginning of the elements.

<syntaxhighlight lang="xml">

<h:table>
    <h:tr>
        <h:td>Apples</h:td>
        <h:td>Oranges</h:td>
    </h:tr>
</h:table>

<f:table>
    <f:name>Mahogany Coffee Table</f:name>
    <f:width>80</f:width>
    <f:length>120</f:length>
</f:table>
</syntaxhighlight>

==Naming system==
A name in a namespace consists of a namespace name and a local name.<ref>{{cite web | url=http://www.w3.org/TR/REC-xml-names/ | title= Namespaces in XML 1.0 (Third Edition) | author=XML Core Working Group | work=W3C |date=8 December 2009 |access-date=2012-03-30}}</ref><ref>{{cite IETF  |title=URN Syntax |rfc=2141 |sectionname=Syntax |section=2 |page=1 |last= Moats |first= Ryan |date=May 1997 |publisher=[[Internet Engineering Task Force|IETF]] |access-date= 2012-03-30}}</ref> The namespace name is usually applied as a [[Prefix (computer science)|prefix]] to the local name.

In [[augmented Backus–Naur form]]:
<syntaxhighlight lang=abnf>
name = <namespace name> separator <local name>
</syntaxhighlight>
When local names are used by themselves, [[Name resolution (programming languages)|name resolution]] is used to decide which (if any) particular name is alluded to by some particular local name.

===Examples===
{| class=wikitable
|+ Examples of names in a namespace
|-
! Context !! Name !! Namespace name !! Local name
|-
| [[Domain name]] || {{mono|www.example.com}} || {{mono|example.com}} (domain name) || {{mono|www}} (subdomain name)
|-
| [[Wikipedia]] || {{mono|Talk:Mona Lisa}} || Talk || Mona Lisa
|-
| [[Path (computing)|Path]] ([[UNIX]]) || {{mono|/home/admin/Documents/readme.txt}} || {{mono|/home/admin/Documents}} (directory)|| {{mono|readme.txt}} (file name)
|-
| Path ([[Microsoft Windows|Windows]]) || {{mono|C:\Users\Admin\Documents\readme.txt}} || {{mono|C:\Users\Admin\Documents}} (directory)|| {{mono|readme.txt}} (file name)
|-
| [[C++ standard library|C++ standard library namespace]] || {{code|std::chrono::system_clock}} || {{code|std::chrono}} (C++ namespace)|| {{code|system_clock}} (class)
|-
| [[#C++|C++ namespace]] || {{code|Poco::Net::HTTPClientSession}} || {{code|Poco::Net}} (C++ namespace)|| {{code|HTTPClientSession}} (class)
|-
| [[C Sharp (programming language)|C#]] namespace || {{code|System.Collections.Generic.Dictionary}} || {{code|System.Collections.Generic}} (C# namespace)|| {{code|Dictionary}} (class)
|-
| [[Java Class Library|Java standard library package]] || {{code|java.util.Date}} || {{code|java.util}} (Java package)|| {{code|Date}} (class)
|-
| [[Java package]] || {{code|org.apache.commons.math3.special.Gamma}} || {{code|org.apache.commons.math3.special}} (Java package)|| {{code|Gamma}} (class)
|-
| [[UN/LOCODE]] || {{mono|US NYC}}  || {{mono|US}} (country or territory)|| {{mono|NYC}} (locality)
|-
| [[XML namespace|XML]] || <code>xmlns:xhtml="http://www.w3.org/1999/xhtml"</code> <br /> {{code|<xhtml:body>}} || {{code|xhtml}} (previously declared XML namespace <code>xhtml="http://www.w3.org/1999/xhtml"</code>)|| {{code|body}} (element)
|- 
| [[Perl module#Perl packages and namespaces|Perl]] || {{code|$DBI::errstr}} || {{code|$DBI}} (Perl module)|| {{code|errstr}} (variable)
|-
| [[Uniform Resource Name]] (URN) || {{mono|urn:nbn:fi-fe19991055}} || {{mono|urn:nbn}} (National Bibliography Numbers) || {{mono|fi-fe19991055}}
|-
| [[Handle System]] || {{mono|10.1000/182}}  || {{mono|10}} (handle naming authority) || {{mono|1000/182}} (handle local name)
|-
| [[Digital object identifier]] || {{mono|10.1000/182}} || {{mono|10.1000}} (publisher) || {{mono|182}} (publication)
|-
| [[MAC address]] || {{mono|01-23-45-67-89-ab}}  || {{mono|01-23-45}} ([[organizationally unique identifier]]) || {{mono|67-89-ab}} (NIC specific)
|-
| [[PCI ID]] || {{mono|1234 abcd}} || {{mono|1234}} (vendor ID) || {{mono|abcd}} (device ID)
|-
| [[USB Implementers Forum#Obtaining a vendor ID|USB VID/PID]] || {{mono|2341 003f}}<ref>
Stephen J. Gowdy.
[http://www.linux-usb.org/usb.ids "List of USB ID's"].
2013.
</ref> || {{mono|2341}} (vendor ID) || {{mono|003f}} (product ID)
|-
| [[SPARQL]] || {{code|dbr:Sydney}} || {{code|dbr}} (previously declared ontology, e.g. by specifying {{code|@prefix dbr: <http://dbpedia.org/resource/>}}) || {{code|Sydney}} 
|}

===Delegation===
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.<ref>{{cite IETF  |title= Functional Requirements for Uniform Resource Names |rfc=1731 |sectionname=Requirements for functional capabilities |section=2 |page=3 |last= Sollins & Masinter |date=December 1994 |publisher=[[Internet Engineering Task Force|IETF]] |access-date= 2012-03-30}}</ref> A central [[Registration authority]] registers the [[National Internet registry|assigned 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 that [[Metadata registry|assign the names]] themselves, or another [[Registration authority]] which further delegates parts of their namespace to different organisations.

===Hierarchy{{anchor|hierarchical namespace}}===
A naming scheme that allows subdelegation of namespaces to third parties is a '''hierarchical 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 the [[Domain name|Domain name system]].

An example of a non-recursive hierarchy are [[Uniform Resource Name]] representing an [[Internet Assigned Numbers Authority]] (IANA) number.

{| class=wikitable
|+ Hierarchical namespace breakdown for {{mono|urn:isbn:978-3-16-148410-0}}, an identifier for the book ''The Logic of Scientific Discovery'' by Karl Popper, 10th edition.
|-
! Registry !! Registrar !! Example Identifier !! Namespace name !! Namespace
|-
| [[Uniform Resource Name]] (URN) || [[Internet Assigned Numbers Authority]] || {{mono|urn:isbn:978-3-16-148410-0}} || {{mono|urn}} || [https://www.iana.org/assignments/urn-namespaces/urn-namespaces.xml Formal URN namespace]
|-
| [[Uniform resource name|Formal URN namespace]] || [[Internet Assigned Numbers Authority]] || {{mono|urn:isbn:978-3-16-148410-0}} || {{mono|ISBN}} || [http://tools.ietf.org/html/rfc3187 International Standard Book Numbers as Uniform Resource Names]
|-
| [[International Article Number (EAN)]] || [[GS1]] || {{mono|978-3-16-148410-0}} || {{mono|978}} || [[Bookland]]
|-
| [[International Standard Book Number]] (ISBN) || [[International ISBN Agency]] || {{mono|3-16-148410-X}} || {{mono|3}} || [[German-speaking countries]]
|-
| [[International Standard Book Number#Publisher code|German publisher code]] || [http://www.german-isbn.de/ Agentur für Buchmarktstandards] || {{mono|{{ISBNT|3-16-148410-X}}}} || {{mono|16}} || [[Mohr Siebeck]]
|}

===Namespace versus scope===
A namespace name may provide context ([[Scope (computer science)|scope]] in 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.

{| class=wikitable
|+Examples of naming systems with local and global scope, and with and without namespaces
!   !! 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== <!--Anchor for Redirect: [Namespace (computer science). -->

For many programming languages, namespace is a context for their [[Identifier (computer languages)|identifiers]]. In an operating system, an example of namespace is a directory. Each name in a directory uniquely identifies one file or subdirectory.<ref>{{cite web|url=http://tutorials.csharp-online.net/CSharp_FAQ:_What_is_a_namespace|title=C# FAQ: What is a namespace|website=C# Online Net|archive-url=https://web.archive.org/web/20131020153832/http://tutorials.csharp-online.net/CSharp_FAQ:_What_is_a_namespace|archive-date=October 20, 2013|access-date=2010-02-23|quote=For instance, [under [[Microsoft Windows|Windows]]], 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{{Not a typo|.}}Web namespace.}}</ref>

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 a [[context (computing)|context]], 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 as [[concept]]s, be the namespace a [[natural language|natural or ethnic language]], a [[constructed language]], the [[technical terminology]] of a profession, a [[dialect]], a [[sociolect]], or an artificial language (e.g., a [[programming language]]).
* In the [[Java (programming language)|Java 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 as [[C++]]) combine namespaces and names for internal use in the compiler in a process called ''[[name 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++:

<syntaxhighlight lang="cpp">
import std;

// This is how one brings a name into the current scope.  In this case, it's
// bringing them into global scope.
using std::println;

namespace box1 {
    constexpr int BOX_SIDE = 4;
}

namespace box2 {
    constexpr int BOX_SIDE = 12;
}

int main() {
    constexpr int BOX_SIDE = 42;
    println("{}", box1::BOX_SIDE);  // Outputs 4.
    println("{}", box2::BOX_SIDE);  // Outputs 12.
    println("{}", BOX_SIDE);  // Outputs 42.
}
</syntaxhighlight>

===Computer-science considerations===
A namespace in computer science (sometimes also called a '''name scope''') is an abstract container or environment created to hold a logical grouping of unique [[identifier]]s or [[symbol]]s (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.<ref>{{cite web |url=http://www.webopedia.com/TERM/N/namespace.html |title=A namespace is "a logical grouping of the names used within a program."|date=10 April 2002 | publisher=Webopedia.com| access-date=2011-07-26}}</ref>

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 large [[computer program]]s or documents it is common to have hundreds or thousands of identifiers. Namespaces (or a similar technique, see [[#Emulating namespaces|Emulating namespaces]]) provide a mechanism for hiding local identifiers. They provide a means of grouping logically related identifiers into corresponding namespaces, thereby making the system more [[modularity (programming)|modular]].

[[Data storage device]]s and many modern [[programming language]]s support 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 (programming language)|Python]]), the identifiers naming namespaces are themselves associated with an enclosing namespace. Thus, in these languages namespaces can nest, forming a namespace [[tree (data structure)|tree]]. At the root of this tree is the unnamed '''global namespace'''.

==== Use in common languages ====
===== C =====
It is possible to use anonymous structs as namespaces in [[C (programming language)|C]] since [[C99]].

{{mono|Math.h}}:
<syntaxhighlight lang="c">
#pragma once

const struct {
    double PI;
    double (*sin)(double);
} Math;
</syntaxhighlight>

{{mono|Math.c}}:
<syntaxhighlight lang="c">
#include <math.h>

static double _sin(double arg) {
    return sin(arg);
}

const struct {
    double PI;
    double (*sin)(double);
} Math = { M_PI, _sin };
</syntaxhighlight>

{{mono|Main.c}}:
<syntaxhighlight lang="c">
#include <stdio.h>
#include "Math.h"

int main() {
    printf("sin(0) = %d\n", Math.sin(0));
    printf("pi is %f\n", Math.PI);
}
</syntaxhighlight>

===== C++ =====
In [[C++]], a namespace is defined with a namespace block.<ref>{{cite web|url=http://www.cplusplus.com/doc/tutorial/namespaces/ |title=Namespaces allow to group entities like classes, objects and functions under a name. |publisher=Cplusplus.com |access-date=2011-07-26}}</ref>
<syntaxhighlight lang="cpp">
namespace abc {
    int bar;
}
</syntaxhighlight>
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 of <code>namespace abc</code>, <code>bar</code> must be written <code>abc::bar</code> to be accessed. C++ includes another construct that makes this verbosity unnecessary. By adding the line
<syntaxhighlight lang="cpp">
using namespace abc;
</syntaxhighlight>
to a piece of code, the prefix <code>abc::</code> is no longer needed.

Identifiers that are not explicitly declared within a namespace are considered to be in the global namespace.
<syntaxhighlight lang="cpp">
int foo;
</syntaxhighlight>
These identifiers can be used exactly as they are declared, or, since the global namespace is unnamed, the namespace specifier <code>::</code> can be prefixed. For example, <code>foo</code> can also be written <code>::foo</code>.

Namespace resolution in C++ is hierarchical. This means that within the hypothetical namespace <code>food::soup</code>, the identifier <code>Chicken</code> refers to <code>food::soup::Chicken</code>. If <code>food::soup::Chicken</code> doesn't exist, it then refers to <code>food::Chicken</code>. If neither <code>food::soup::Chicken</code> nor <code>food::Chicken</code> exist, <code>Chicken</code> refers to <code>::Chicken</code>, an identifier in the global namespace.

Namespaces in C++ are most often used to avoid [[naming collision]]s. 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 entire [[C++ Standard Library]] is defined within <code>namespace std</code>, but before standardization many components were originally in the global namespace. The <code>using</code> statement can be used to import a symbol into the current scope.

The use of the <code>using</code> statements in headers for reasons other than backwards compatibility (e.g., convenience) is considered to be against good code practices, as those <code>using</code> statements propagate into all translation units that include the header. However, [[Modules (C++)|modules]] do not export <code>using</code> statements unless explicitly marked <code>export</code>, making <code>using</code> statements safer to use. For instance, one can import a module <code>org.wikipedia.project.util</code> with matching namespace <code>org::wikipedia::project::util</code> and then use <code>using</code> statements on symbols from that namespace to simplify verbose namespaces. Note that unlike other languages like Java or Rust, C++ modules, namespaces and source file structure do not necessarily match, though it is convention to match them for clarity (for example, module <code>abc.def.uvw.XYZ</code> matches namespaced class <code>abc::def::uvw::XYZ</code> and resides in file <code>abc/def/uvw/XYZ.cppm</code>).

<code>using</code> should be used to simplify verbose nested namespaces when modular translation units are used.

<syntaxhighlight lang="cpp">
export module org.wikipedia.project.App;

import std;

import org.wikipedia.project.fs;
import org.wikipedia.project.util;

using org::wikipedia::project::fs::File;
using org::wikipedia::project::util::ConfigLoader;
using org::wikipedia::project::util::logging::Logger;
using org::wikipedia::project::util::logging::LoggerFactory;

export namespace org::wikipedia::project {

class App {
private:
    Logger logger;
    // private fields and methods
public:
    App():
        logger{LoggerFactory::getLogger("Main")} {
        ConfigLoader cl(File("config/config_file.txt"));
        logger.log("Application starting...");
        // rest of code
    }
};

}
</syntaxhighlight>

[[C++11]] introduces ''inline namespaces'', which is such that its members are treated as if they are also members of the enclosing namespace. It is declared by writing <code>inline namespace</code>. It is akin to an implicit <code>using namespace</code> statement, meaning qualifying symbols in it is optional.

The inline property is transitive. If a namespace <code>a</code> contains an inline namespace <code>b</code>, which in turn contains another inline namespace <code>c</code>, then members of <code>c</code> can be accessed as if they were members of <code>a</code> or <code>b</code>.

A primary use case for inline namespaces is [[Application binary interface|ABI]] compatibility and versioning. By placing different versions of an API within distinct inline namespaces (e.g., <code>v1</code>, <code>v2</code>), and then making the currently desired version inline, library developers can manage ABI compatibility. When a new version is released, the inline keyword can be moved to the new version's namespace, allowing users to automatically link against the new version while still enabling access to older versions through explicit qualification.

<syntaxhighlight lang="c++">
namespace mylib::utils {
    namespace v1 {
        void func() {
            // Old implementation
        }
    }

    // v2 is the currently active version
    inline namespace v2 {
        void func() {
            // New implementation
        }
    }
}

int main() {
    // Calls mylib::utils::v2::func() implicitly
    mylib::utils::func();

    // Calls mylib::utils::v2::func() explicitly
    mylib::utils::v2::func();

    // Calls mylib::utils::v1::func() explicitly
    mylib::utils::v1::func();

    return 0;
}
</syntaxhighlight>

===== C# =====
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 avoid [[naming collision]]s.
When referencing a class, one should specify either its fully qualified name, which means namespace followed by the class name:
<syntaxhighlight lang="c#">
System.Console.WriteLine("Hello World!");
int i = System.Convert.ToInt32("123");
</syntaxhighlight>

or add a <code>using</code> statement. This eliminates the need to mention the complete name of all classes in that namespace.

<syntaxhighlight lang="c#">
using System;

Console.WriteLine("Hello World!");
int i = Convert.ToInt32("123");
</syntaxhighlight>

In the above examples, <code>System</code> is a namespace, and <code>Console</code> and <code>Convert</code> are classes defined within <code>System</code>.

[[File:Dotnet-system-namespace-uml.svg|UML diagram with a <code>Console</code> and a <code>Convert</code> class.]]

Unlike C++, <code>using</code> can only import all symbols in a namespace (much like <code>using namespace</code> from C++, <code>use *</code> in Rust, or <code>import *</code> in Java). It cannot be used to import individual symbols and classes like it is used in Java.

<syntaxhighlight lang="c#">
namespace Wikipedia.Project;

using System;
using System.IO;

using Microsoft.Extensions.Logging;

using Wikipedia.Project.Utility;

class App
{
    private static ILogger<Program> logger;

    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("Application starting...");
        // rest of code
    }
}
</syntaxhighlight>

Unlike C++, C# namespaces do not allow relative referencing of symbols. For example, the class <code>Foo.Bar.Baz.Qux</code> cannot be referred to as <code>Baz.Qux</code> even if referred to from within namespace <code>Foo.Bar</code>: either the namespace <code>Foo.Bar.Baz</code> must be imported to refer to class <code>Qux</code>, or <code>Foo.Bar.Baz.Qux</code> must be fully qualified.

===== Java =====
In [[Java (programming language)|Java]], the idea of a namespace is embodied in [[Java package]]s. All code belongs to a package, although that package need not be explicitly named. Code from other packages is accessed by prefixing the package name before the appropriate identifier, for example <code>class String</code> in <code>package [[java.lang]]</code> can be referred to as <code>java.lang.String</code> (this is known as the [[fully qualified name|fully qualified class name]]). Like C++, Java offers a construct that makes it unnecessary to type the package name (<code>import</code>). However, certain features (such as [[reflection (computer science)|reflection]]) 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 with <code>java</code> are a part of the [[Java platform]]—the package {{Javadoc:SE|package=java.lang|java/lang}} contains classes core to the language, and {{Javadoc:SE|package=java.lang.reflect|java/lang/reflect}} contains core classes specifically relating to reflection.

In Java (and [[Ada (programming language)|Ada]], [[C Sharp (programming language)|C#]], and others), namespaces/packages express semantic categories of code. For example, in C#, <code>namespace System</code> 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.

[[function (programming)|Function]] and [[class (computer science)|class]] [[scope (programming)|scope]]s can be viewed as implicit namespaces that are inextricably linked with visibility, accessibility, and [[object lifetime]].

In Java, packages cannot be partially qualified like they can in C++. For instance, it is not possible to import the <code>java</code> namespace and then refer to <code>java.util.ArrayList</code> as <code>util.ArrayList</code>. Symbols must either be fully qualified or imported completely into scope. <code>import</code> statements are not transitive nor can they be deliberately marked <code>export</code> like in C++. All <code>import</code> statements must appear at the beginning of the file, and cannot be written at any other scope. This is in contrast to C++, where the <code>std</code> namespace can be imported by writing <syntaxhighlight lang="cpp" inline>using namespace std;</syntaxhighlight>, and then <code>std::chrono::system_clock</code> can be referred to as <code>chrono::system_clock</code>.

<syntaxhighlight lang="java">
package 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, "Application starting...");
        // rest of code
    }
}
</syntaxhighlight>

Because Java does not support independent functions outside of classes, static class methods and so-called "utility classes" (classes with private constructors and all methods and fields static) are the equivalent to C++-style namespaces. Some examples are <code>java.lang.Math</code>, which contains the constants like <code>Math.PI</code> and methods like <code>Math.sin()</code>.

<code>import</code> statements can be used to import all symbols in a package, called a glob import, which is similar to <code>using namespace</code> in C++. For instance, writing <syntaxhighlight lang="java" inline>import java.util.*;</syntaxhighlight> imports all classes in the <code>java.util</code> package. This however, can cause symbol pollution within a file. Furthermore, using glob import statements on packages that have classes with the same name can cause ambiguity, and will fail to compile. However, <code>java.lang.*</code> is implicitly imported into all Java source files by default.

<syntaxhighlight lang="java">
import java.sql.*; // Imports all classes in java.sql, including java.sql.Date
import java.util.*; // Imports all classes in java.util, including java.util.Date

Date d = new Date(); // Ambiguous Date reference resulting in compilation error

// Instead, the fully-qualified names must be used:
java.sql.Date sqlDate = new java.sql.Date(System.currentTimeMillis());
java.util.Date utilDate = new java.util.Date();
</syntaxhighlight>

===== PHP <!-- This section is linked from [[PHP]] --> =====
Namespaces were introduced into [[Php|PHP]] from version 5.3 onwards. Naming collision of classes, functions and variables can be avoided.
In [[PHP]], a namespace is defined with a namespace block.
<syntaxhighlight lang="php">
# File phpstar/foobar.php

namespace phpstar;

class FooBar
{
    public function foo(): void
    {
        echo 'Hello world, from function foo';
    }

    public function bar(): void
    {
        echo 'Hello world, from function bar';
    }
}
</syntaxhighlight>
We can reference a PHP namespace with the following different ways:
<syntaxhighlight lang="php">
# 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
use phpstar\FooBar;
$obj_foobar = new FooBar();

# Option 2a: import & alias the namespace
use phpstar\FooBar as FB;
$obj_foobar = new FB();

# Access the properties and methods with regular way
$obj_foobar->foo();
$obj_foobar->bar();
</syntaxhighlight>

[[File:UML phpstar package diagram.svg|UML diagram of the phpstar package with the class FooBar.]]

===== Python =====
In [[Python (programming language)|Python]], namespaces are defined by the individual modules, and since modules can be contained in hierarchical packages, then namespaces are hierarchical too.<ref>{{cite web|title=6. Modules|url=https://docs.python.org/tutorial/modules.html|work=The Python Tutorial|publisher=Python Software Foundation|access-date=25 October 2010}}</ref><ref>{{cite web|url=https://docs.python.org/tutorial/classes.html#python-scopes-and-namespaces |title=Python Scopes and Namespaces |publisher=Docs.python.org |access-date=2011-07-26}}</ref>
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.
<syntaxhighlight lang="python">
# assume ModuleA defines two functions : func1() and func2() and one class : Class1
import ModuleA

ModuleA.func1()
ModuleA.func2()
a: ModuleA.Class1 = Modulea.Class1()
</syntaxhighlight>

The <code>from ... import ...</code> 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:
<syntaxhighlight lang="python">
# assume ModuleA defines two functions : func1() and func2() and one class : Class1
from ModuleA import func1

func1()
func2() # this will fail as an undefined name, as will the full name ModuleA.func2()
a: Class1 = Class1() # this will fail as an undefined name, as will the full name ModuleA.Class1()
</syntaxhighlight>
Since this directly imports names (without qualification) it can overwrite existing names with no warnings.

A special form of the statement is <code>from ... import *</code> 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,<ref>https://docs.python.org/3/tutorial/modules.html "in general the practice of importing * from a module or package is frowned upon"</ref> though using <code>from import</code> in Python can simplify verbose namespaces, such as nested namespaces.

<syntaxhighlight lang="python">
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 WebElement

if __name__ == "__main__":
    driver: Firefox = Firefox()
    element: WebElement = driver.find_element(By.ID, "myInputField")
    element.send_keys(f"Hello World{Keys.ENTER}")
    action: ActionChains = ActionChains(driver)
    action.key_down(Keys.CONTROL).send_keys('a').key_up(Keys.CONTROL).perform()
</syntaxhighlight>

Python also supports <code>import x as y</code> as a way of providing an alias or alternative name for use by the calling module:

<syntaxhighlight lang="numpy">
import numpy as np
from numpy.typing import NDArray, float32

a: NDArray[float32] = np.arange(1000)
</syntaxhighlight>

===== Rust =====
In [[Rust (programming language)|Rust]], a namespace is called a "module" and declared using <code>mod</code>. Symbols inside the module are by default private, and cannot be accessed externally, unless declared with the <code>pub</code> keyword which exposes them. Modules can have sub-modules inside of them, allowing for nested namespaces.

Similar to the <code>using</code> keyword in C++, Rust has the <code>use</code> keyword to import symbols into the current scope.
<syntaxhighlight lang="rust">
mod my_module {
    pub trait Greet {
        fn greet(&self);
    }

    pub struct Person {
        pub name: String,
    }

    impl Greet for Person {
        fn greet(&self) {
            println!("Hello, {}!", self.name);
        }
    }
}

fn main() {
    use my_module::{Person, Greet};

    let person = Person { name: String::from("Alice") };
    person.greet();
}
</syntaxhighlight>

Writing <syntaxhighlight lang="rust" inline>mod util;</syntaxhighlight> indicates to the compiler to find either a file named <code>util.rs</code> or <code>util/mod.rs</code>. <code>crate</code> in a <code>use</code> statement refers to the root of the current "crate" (project), while <code>super</code> can be used to refer to the parent module.

<syntaxhighlight lang="rust">
mod util;

use 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("Application starting...");
        // rest of code
    }
}
</syntaxhighlight>

The <code>use</code> keyword in Rust is more versatile than its counterpart <code>using</code> in C++. In addition to importing single symbols, symbol aliasing with <code>as</code> and glob imports, <code>use</code> can import multiple symbols on the same line using braces (which may be nested), import individual namespaces, and do all of the above in a single statement. This is an example of using all of the above:

<syntaxhighlight lang="rust">
use std::{
    fmt::*, // imports all symbols in std::fmt
    fs::{File, Metadata}, // imports std::fs::File and std::fs::Metadata
    io::{prelude::*, BufReader, BufWriter} // imports all symbols in std::io::prelude::*, std::io::BufReader, and std::io::BufWriter
    process, // imports the std::process namespace (for example std::process::Command can be referred to as process::Command)
    time // imports the std::time namespace
};
</syntaxhighlight>

===== XML namespace <!-- This section is linked from [[XML]] --> =====
{{Main|XML namespace}}

In [[XML]], 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.

===== SAP Namespace =====

In [[SAP]] systems (especially ABAP environments), namespaces are used to prevent naming collisions between standard SAP-delivered objects and customer or partner developments.<ref>{{Cite web 
 |title=SAP Namespace Overview 
 |url=https://www.sapvista.com/sap-namespace 
 |website=SAPVista 
 |quote=SAP systems use namespaces to prevent naming conflicts between SAP standard objects and customer-specific developments. 
 |access-date=7 October 2025
}}</ref>

A namespace identifier is delimited with “/” (for example `/MYNS/`) and is reserved via SAP’s namespace registration process. Once reserved, objects created under that namespace are uniquely identifiable and protected from unintended overwrite by SAP upgrades or imports.<ref>{{Cite web 
 |title=SAP Help Portal – ABAP Connectivity and Namespace Documentation 
 |url=https://help.sap.com/docs/SUPPORT_CONTENT/abapconn/3354079474.html 
 |website=SAP Help Portal 
 |quote=In the SAP Application Interface Framework, namespaces are used for the logical structuring of objects and configurations. 
 |access-date=7 October 2025
}}</ref>

In modern SAP landscapes (such as ABAP in the cloud and HDI containers), namespaces are also used to semantically group development artifacts or bundles.

===Emulating namespaces===
In programming languages lacking language support for namespaces, namespaces can be emulated to some extent by using an [[identifier naming convention]]. For example, [[C (programming language)|C]] libraries such as [[libpng]] often 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

This [[naming conventions (programming)|naming convention]] provides reasonable assurance that the [[identifier]]s are unique and can therefore be used in larger programs without [[naming collision]]s.<ref>{{Cite web|url=http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=286 |title=Why I Hate Namespaces |author=Danny Kalev |url-status=bot: unknown |archive-url=https://web.archive.org/web/20160709115609/http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=286 |archive-date=2016-07-09 }}</ref> Likewise, many packages originally written in [[Fortran]] (e.g., [[BLAS]], [[LAPACK]]) reserve the first few letters of a function's name to indicate the group to which the function belongs.

This technique has several drawbacks:
* It doesn't scale well to nested namespaces; identifiers become excessively long since all uses of the identifiers must be [[fully qualified name|fully 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 in [[Fortran|FORTRAN 77]], which offered only 6 characters per identifier; for example, the name of the [[BLAS]] function <code>DGEMM</code> indicates that it operates on double-precision floating-point numbers (<code>D</code>) and general matrices (<code>GE</code>), with only the last two characters (<code>MM</code>) showing what it actually does: matrix–matrix multiplication.

It also has a few advantages:
* No special software tools are required to locate names in source-code files; a simple program like [[grep]] suffices;
* There are no namespace-related name conflicts;
* There is no need for name mangling, and thus no potential incompatibility problems.

==See also==
{{portal |Computer programming}}
* 11-digit [[delivery point]] [[ZIP code]]
* [[Binomial nomenclature]] (genus-species in [[biology]])
* [[Chemical nomenclature]]
* [[Dewey Decimal Classification]]
* [[Digital object identifier]]
* [[Domain Name System]]
* [[Fourth wall]]
* [[Identity (object-oriented programming)]]
* [[Library of Congress Classification]]
* [[Star catalogue]]s and [[astronomical naming conventions]]
* [[Violation of abstraction level]]
* [[XML namespace]]
* [[Argument-dependent name lookup]]

==References==
{{Reflist|30em}}

{{subject bar |wikt=namespace}}

{{DEFAULTSORT:Namespace}}
[[Category:Naming conventions]]