Spații de nume
Spațiile de nume permit evitarea conflictelor de nume și gruparea funcționalității. În interiorul unui spațiu de nume pot fi plasate clase, interfețe, funcții și constante.
Dacă o construcție (de exemplu, o clasă sau o funcție) este definită în afara oricărui spațiu de nume, se consideră că este localizată în spațiul de nume global.
Definirea spațiilor de nume
Pentru a crea un spațiu de nume se folosește directiva namespace, urmată de numele spațiului de nume:
namespace base;
class Person
{
private $name;
function __construct($name) { $this->name = $name; }
}În acest caz, este definit spațiul de nume "base". De obicei, numele spațiilor de nume sunt indicate cu litere mici. Tot ce este situat sub această directivă aparține spațiului de nume "base". Astfel, clasa Person aparține spațiului de nume base.
Trebuie menționat că definiția spațiului de nume trebuie să fie plasată deasupra oricărui alt cod sau markup HTML. De exemplu:
<?php
namespace base;
class Person
{
public $name;
function __construct($name) { $this->name = $name; }
}
?>
<!DOCTYPE html>
<html>
<head>
<title>FDC.COM</title>
<meta charset="utf-8" />
</head>
<body>
<?php
$tom = new Person("Tom");
echo $tom->name;
?>
</body>
</html>Accesarea spațiului de nume
Pentru a accesa construcțiile dintr-un spațiu de nume, înaintea numelui construcției, se specifică spațiul de nume folosind o bară oblică inversă (backslash). De exemplu, avem un fișier Person.php:
<?php
namespace base;
class Person
{
public $name;
function __construct($name) { $this->name = $name; }
}
?>Acum, într-un alt fișier, includem acest fișier și accesăm clasa Person:
<?php
namespace work;
include "Person.php";
$tom = new \base\Person("Tom");
echo $tom->name;
?>Aici este definit un alt spațiu de nume - "work". Mai întâi, în acesta se include fișierul Person.php. Apoi, creăm un obiect al clasei Person.
Dacă construcțiile unui spațiu de nume sunt utilizate în alt spațiu de nume (inclusiv în spațiul de nume global), atunci înaintea numelui construcției se specifică spațiul de nume complet:
$tom = new \base\Person("Tom");Observați că mai întâi vine o bară oblică inversă, apoi numele spațiului de nume și apoi, prin bară oblică inversă, numele clasei (\base\Person).
Fără specificarea spațiului de nume, putem folosi construcția doar în același spațiu de nume în care este definită.
Spații de nume imbricate
Unele spații de nume pot conține altele. De exemplu:
<?php
namespace base\classes;
class Person
{
public $name;
function __construct($name) { $this->name = $name; }
}
?>Aici, clasa Person este definită în spațiul de nume base\classes. Astfel, pentru a accesa clasa Person dintr-un alt spațiu de nume, trebuie să specificăm \base\classes\Person:
<?php
namespace work;
include "Person.php";
$tom = new \base\classes\Person("Tom");
echo $tom->name;
?>Pseudonime
Dacă într-un spațiu de nume este utilizată o clasă din alt spațiu de nume, scrierea fiecărei referințe la clasa respectivă cu spațiul de nume complet poate deveni obositoare și supraîncarcă codul. De exemplu:
<?php
namespace work;
include "Person.php";
$tom = new \base\classes\Person("Tom");
echo $tom->name . "<br>";
$bob = new \base\classes\Person("Bob");
echo $bob->name;
?>În acest caz, putem folosi pseudonime, care sunt stabilite în forma:
use nume_complet_clasă as pseudonim;Construcția use importă clasa din alt spațiu de nume, iar operatorul as stabilește un pseudonim pentru aceasta.
Astfel, putem simplifica codul anterior folosind pseudonime:
<?php
namespace work;
include "Person.php";
// stabilirea unui pseudonim
use \base\classes\Person as User;
$tom = new User("Tom");
echo $tom->name . "<br>";
$bob = new User("Bob");
echo $bob->name;
?>În acest caz, pentru clasa \base\classes\Person este stabilit pseudonimul User, astfel încât acum putem folosi pseudonimul User pentru a ne referi la clasa Person. Rezultatul este același, dar codul este mai scurt.
Putem folosi doar construcția use fără a specifica un pseudonim. În acest caz, clasa poate fi utilizată cu numele său direct:
<?php
namespace work;
include "Person.php";
use \base\classes\Person;
$tom = new Person("Tom");
echo $tom->name . "<br>";
$bob = new Person("Bob");
echo $bob->name;
?>Includerea mai multor clase
În mod similar, putem include mai multe clase deodată. De exemplu, să presupunem că în fișierul Person.php avem următoarele clase:
<?php
namespace base\classes;
class Person
{
public $name;
function __construct($name) { $this->name = $name; }
}
class Employee extends Person { }
?>Includerea claselor Person și Employee:
<?php
namespace work;
include "Person.php";
use \base\classes\Person as User, \base\classes\Employee as Employee;
$tom = new User("Tom");
echo $tom->name . "<br>";
$sam = new Employee("Sam");
echo $sam->name;
?>Definirea pseudonimelor poate fi scurtată:
use \base\classes\{Person as User, Employee as Employee};Includerea constantelor și funcțiilor
Pentru a include constante, se folosește instrucțiunea use const, iar pentru a include funcții, se folosește use function.
De exemplu, definiția fișierului Person.php:
<?php
namespace base\classes;
const adminName = "Odmen";
function printPerson($person){
echo $person->name . "<br>";
}
class Person
{
public $name;
function __construct($name) { $this->name = $name; }
}
?>Includem clasa Person împreună cu constanta adminName și funcția printPerson:
<?php
namespace work;
include "Person.php";
use \base\classes\Person;
use const \base\classes\adminName;
use function \base\classes\printPerson;
$tom = new Person(adminName);
printPerson($tom); // Odmen
?>