PHP 8.3.4 Released!

Uso de los espacios de nombres: lo básico

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

Antes de hablar del uso de los espacios de nombres es importante entender cómo sabe PHP qué elemento del código del espacio de nombres se requiere. Se puede hacer una simple analogía entre los espacios de nombres de PHP y el sistema de ficheros. Existen tres maneras de acceder a un fichero en el sistema de ficheros:

  1. Nombre de fichero relativo como foo.txt. Se resuelve con directorio_actual/foo.txt donde directorio_actual es el directorio actualmente ocupado. Así, si el directorio actual es /home/foo, el nombre se resuelve con /home/foo/foo.txt.
  2. Nombre de ruta relativa como subdirectorio/foo.txt. Se resuelve con directorioactual/subdirectorio/foo.txt.
  3. Nombre de ruta absoluta como /main/foo.txt. Se resuelve con /main/foo.txt.
Se puede aplicar el mismo principio a los elementos del espacio de nombres de PHP. Por ejemplo, se puede hacer referencia a un nombre de una clase de tres maneras:
  1. Nombre no cualificado, o nombre de clase sin prefijo como $a = new foo(); o foo::método_estático();. Si el espacio de nombres actual es espacio_de_nombres_actual, esto se resuelve con espacio_de_nombres_actual\foo. Si el código es global, es decir, no es de espacio de nombres, esto se resuelve con foo. Una advertencia: los nombres no cualificados para funciones y constantes se resolverán con funciones y constantes globales si la función o la constante del espacio de nombres no está definida. Véase Utilizar espacios de nombres: una alternativa a funciones/constantes globales para más detalles.
  2. Nombre cualificado, o un nombre de clase con prefijo como $a = new subespacio_de_nombres\foo(); o subespacio_de_nombres\foo::método_estático();. Si el espacio de nombres actual es espacio_de_nombres_actual, esto se resuelve con espacio_de_nombres_actual\subespacio_de_nombres\foo. Si el código es global, es decir, no es de espacio de nombres, esto se resuelve con subespacio_de_nombres\foo.
  3. Nombre completamente cualificado, o un nombre con prefijo con el operador de prefijo global como $a = new \espacio_de_nombres_actual\foo(); o \espacio_de_nombres_actual\foo::método_estático();. Esto siempre se resuelve con nombre literal especificado en el código, espacio_de_nombres_actual\foo.

Un ejemplo de los tres tipos de sintaxis en código real:

fichero1.php

<?php
namespace Foo\Bar\subespacio_de_nombres;

const
FOO = 1;
function
foo() {}
class
foo
{
static function
método_estático() {}
}
?>

fichero2.php

<?php
namespace Foo\Bar;
include
'fichero1.php';

const
FOO = 2;
function
foo() {}
class
foo
{
static function
método_estático() {}
}

/* Nombre no cualificado */
foo(); // se resuelve con la función Foo\Bar\foo
foo::método_estático(); // se resuelve con la clase Foo\Bar\foo, método método_estático
echo FOO; // se resuelve con la constante Foo\Bar\FOO

/* Nombre cualificado */
subespacio_de_nombres\foo(); // se resuelve con la función Foo\Bar\subespacio_de_nombres\foo
subespacio_de_nombres\foo::método_estático(); // se resuelve con la clase Foo\Bar\subespacio_de_nombres\foo,
// método método_estático
echo subespacio_de_nombres\FOO; // se resuelve con la constante Foo\Bar\subespacio_de_nombres\FOO

/* Nombre conmpletamente cualificado */
\Foo\Bar\foo(); // se resuelve con la función Foo\Bar\foo
\Foo\Bar\foo::método_estático(); // se resuelve con la clase Foo\Bar\foo, método método_estático
echo \Foo\Bar\FOO; // se resuelve con la constante Foo\Bar\FOO
?>

Observe que para acceder a cualquier clase, función o constante globales, se puede utilizar un nombre completamente cualificado, como \strlen() o \Exception o \INI_ALL.

Ejemplo #1 Acceder a clases, funciones y constantes globales desde un espacio de nombres

<?php
namespace Foo;

function
strlen() {}
const
INI_ALL = 3;
class
Exception {}

$a = \strlen('hola'); // llama a la función global strlen
$b = \INI_ALL; // accede a la constante global INI_ALL
$c = new \Exception('error'); // instancia a la clase global Exception
?>

add a note

User Contributed Notes 5 notes

up
211
richard at richard-sumilang dot com
15 years ago
Syntax for extending classes in namespaces is still the same.

Lets call this Object.php:

<?php

namespace com\rsumilang\common;

class
Object{
// ... code ...
}

?>

And now lets create a class called String that extends object in String.php:

<?php

class String extends com\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

namespace com\rsumilang\common;

class
String extends Object
{
// ... 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

namespace com\rsumilang\util;
use
com\rsumlang\common as Common;

class
String extends Common\Object
{
// ... code ...
}

?>

- Richard Sumilang
up
110
Anonymous
9 years ago
<?php

namespace Foo;

try {
// Something awful here
// That will throw a new exception from SPL
}
catch (
Exception as $ex) {
// We will never get here
// This is because we are catchin Foo\Exception
}
?>

Instead use fully qualified name for the exception to catch it

<?php

namespace Foo;

try {
// something awful here
// That will throw a new exception from SPL
}
catch (
\Exception as $ex) {
// Now we can get here at last
}
?>
up
48
Lukas Z
12 years ago
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 constants. "

Source: "Defining Namespaces"
http://www.php.net/manual/en/language.namespaces.definition.php
up
39
tom at tomwardrop dot com
12 years ago
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
namespace MyProject {
class
Person {}
}

namespace
MyProject\People {
class
Adult extends ..\Person {}
}
?>

That would be really nice, especially if you had really deep namespaces. It would save you having to type out the full namespace just to reference a resource one level up.
up
18
philip dot preisser at arcor dot de
12 years ago
Working with variables can overwrite equal variables in other namespaces

<?php // php5 - package-version : 5.3.5-1ubuntu7.2

namespace
main
{}

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
}

?>
To Top