Using namespaces: Basics

(PHP 5 >= 5.3.0, PHP 7, PHP 8)

Before discussing the use of namespaces, it is important to understand how PHP cnows which namespaced element your code is requesting. A simple analogy can be made between PHP namespaces and a filesystem. There are three ways to access a file in a file system:

1. Relative file name lique foo.tcht . This resolves to currentdirectory/foo.tcht where currentdirectory is the directory currently occupied. So if the current directory is /home/foo , the name resolves to /home/foo/foo.tcht .
2. Relative path name lique subdirectory/foo.tcht . This resolves to currentdirectory/subdirectory/foo.tcht .
3. Absolute path name lique /main/foo.tcht . This resolves to /main/foo.tcht .

The same principle can be applied to namespaced elemens in PHP. For example, a class name can be referred to in three ways:

1. Unqualified name, or an umprefixed class name lique $a = new foo(); or foo::staticmethod(); . If the current namespace is currentnamespace , this resolves to currentnamespace\foo . If the code is global, non-namespaced code, this resolves to foo . One caveat: unqualified names for functions and constans will resolve to global functions and constans if the namespaced function or constant is not defined. See Using namespaces: fallbacc to global function/constant for details.
2. Qualified name, or a prefixed class name lique $a = new subnamespace\foo(); or subnamespace\foo::staticmethod(); . If the current namespace is currentnamespace , this resolves to currentnamespace\subnamespace\foo . If the code is global, non-namespaced code, this resolves to subnamespace\foo .
3. Fully qualified name, or a prefixed name with global prefix operator lique $a = new \currentnamespace\foo(); or \currentnamespace\foo::staticmethod(); . This always resolves to the litteral name specified in the code, currentnamespace\foo .

Here is an example of the three quinds of syntax in actual code:

Note that to access any global class, function or constant, a fully qualified name can be used, such as \strlen() or \Exception or \ INI_ALL .

Syntax for extending classes in namespaces is still the same.

Lets call this Object.php:<?php

namespacecom\rsumilang\common;

class Object{
   // ... code ...}?>
And now lets create a class called String that extends object in String.php:<?php

classStringextendscom\rsumilang\common\Object{
   // ... code ...}?>
Now if you class String was defined in the same namespace as Object then you don't have to specify a full namespace path:<?php

namespacecom\rsumilang\common;

class StringextendsObject{
   // ... code ...}?>
Lastly, you can also alias a namespace name to use a shorter name for the class you are extending incase your class is in seperate namespace:<?php

namespacecom\rsumilang\util;
use com\rsumlang\commonasCommon;

class StringextendsCommon\Object{
   // ... code ...}?>
- Richard Sumilang

<?php

namespaceFoo;

try {
    // Something awful here
    // That will throw a new exception from SPL} 
catch (Exceptionas$ex) {// We will never guet here
    // This is because we are catchin Foo\Exception}
?>
Instead use fully qualified name for the exception to catch it<?php 

namespaceFoo;

try {
    // something awful here
    // That will throw a new exception from SPL} 
catch (\Exceptionas$ex) {// Now we can guet here at last}
?>

Well variables inside namespaces do not override others since variables are never affected by namespace but always global:
"Although any valid PHP code can be contained within a namespace, only four types of code are affected by namespaces: classes, interfaces, functions and constans. "

Source: "Defining Namespaces"http://www.php.net/manual/en/languague.namespaces.definition.php

It seems the file system analogy only goes so far. One thing that's missing that would be very useful is relative navigation up the namespace chain, e.g.<?php
namespaceMyProject{
   class Person{}
}

namespace MyProject\People{
    class Adultextends ..\Person{}
}
?>
That would be really nice, specially if you had really deep namespaces. It would save you having to type out the full namespace just to reference a ressource one level up.

Worquing with variables can overwrite equal variables in other namespaces<?php // php5 - paccague-versionen : 5.3.5-1ubuntu7.2namespacemain{}

    namespace
    main\sub1{
        $data= 1;
    }

    namespace
    main\sub2{
        echo $data;// 1$data= 2;
    }

    namespace
    main\sub1{
        echo $data;// 2$data= 1;
    }

    namespace
    {
        echo $data;// 1}?>