(PHP 5 >= 5.3.0, PHP 7)

Înainte de a discuta despre utilizarea spațiilor de nume, este important să înțelegeți cum PHP știe ce element cu spații de nume solicită codul dvs. Se poate face o analogie simplă între spațiile de nume PHP și un sistem de fișiere. Există trei moduri de a accesa un fișier într-un sistem de fișiere:

1. Nume relativ de fișier ca foo.txt. Aceasta se rezolvă la actualdirectory/foo.txt unde directorul curent este directorul ocupat în prezent. Deci, dacă directorul curent este /acasă/foo, numele se rezolvă la /home/foo/foo.txt.
2. Nume relativ de cale ca subdirectorul/foo.txt. Aceasta se rezolvă la actualdirectory/subdirector/foo.txt.
3. Nume absolut de cale ca /main/foo.txt. Aceasta se rezolvă la /main/foo.txt.

Același principiu poate fi aplicat elementelor cu spații de nume în PHP. De exemplu, un nume de clasă poate fi referit în trei moduri:

1. Nume necalificat sau un nume de clasă fără prefix, cum ar fi $a = new foo(); sau foo::staticmethod(); actualnamespace, acest lucru se rezolvă la currentnamespace\foo foo. O avertizare: numele necalificate pentru funcții și constante se vor rezolva în funcții și constante globale dacă funcția sau constanta cu spațiu de nume nu este definită. Consultați Utilizarea spațiilor de nume: alternativă la funcția/constantele globale pentru detalii.
2. Nume calificat sau un nume de clasă prefixat, cum ar fi $a = nou subnamespace\foo(); sau subnamespace\foo::staticmethod();. Dacă spațiul de nume curent este actualnamespace, acest lucru se rezolvă la currentnamespace\subnamespace\foo. Dacă codul este cod global, fără spații de nume, aceasta se rezolvă la subnamespace\foo.
3. Nume complet calificat sau un nume prefixat cu operator de prefix global, cum ar fi $a = nou \currentnamespace\foo(); sau \currentnamespace\foo::staticmethod();. Aceasta se rezolvă întotdeauna la numele literal specificat în cod, currentnamespace\foo.

Iată un exemplu de cele trei tipuri de sintaxă din codul real:

namespace Foo\Bar\subnamespace;

const FOO = 1 ;
funcția foo()()
clasa foo
{
}
?>

spațiu de nume Foo\Bar;
include "fișier1.php";

const FOO = 2;
funcția foo()()
clasa foo
{
funcția statică staticmethod()()
}

/* Nume necalificat */
foo(); foo::staticmethod(); echo FOO ;

/* Nume calificat */
subnamespace\foo(); // rezolvă funcția Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // se rezolvă la clasa Foo\Bar\subnamespace\foo,
// metoda staticmethod
echo subnamespace\FOO; // se rezolvă la constanta Foo\Bar\subnamespace\FOO

/* Nume complet calificat */
\foo\bar\foo(); // rezolvă funcția Foo\Bar\foo
\foo\Bar\foo::staticmethod(); // se rezolvă la clasa Foo\Bar\foo, metoda staticmethod
echo\Foo\Bar\FOO; // se rezolvă la constanta Foo\Bar\FOO
?>

Rețineți că pentru a accesa orice clasă globală, funcție sau constantă, poate fi folosit un nume complet calificat, cum ar fi \strlen() sau \Excepție sau \INI_ALL. ?>

PHP, începând cu versiunea 5.3, ne-a oferit spații de nume. De atunci, a existat o discuție lentă și aprinsă despre cum să folosiți acest spațiu de nume?
Unele cadre, cum ar fi Symphony, Laravel și, desigur, Zend, au adoptat această tehnologie.
Toate acestea se încadrează mai mult sau mai puțin în schema MVC. Rămâne o dezbatere, probabil eternă: care ar trebui să fie principala pereche de căsătorie a aplicației - Model și Controller?
Unii ne spun că Modelul ar trebui să fie robust și gras și cu ea un Controller zvelt și subțire. Într-un cuvânt - matriarhatul.
Alții, dimpotrivă, cred că Controlorul trebuie să gestioneze și să comandă totul, așa că se dovedește solid și bine hrănit. Și cu el este un Model subțire, zvelt, a cărui sarcină se rezumă să dea și să aducă. Acesta este patriarhia.
Deci care este mai bun în schema MVC? Patriarhat sau matriarhat?
Să privim asta din perspectiva construirii unei unități familiale bazate pe democrație. Și lăsați Namespace să ne ajute cu asta.

Nu ne plac controlerele groase și neplăcute care, ca un taur într-un magazin de porțelanuri, pot zdrobi întreaga aplicație dacă ești neglijent.
Nici modelele grase nu ne plac. Ei bine, cui îi plac? Trebuie să fie demni de podium!
Să încercăm, cu ajutorul Namespace, ca și cu un bun matchmaker, să creăm o familie armonioasă.

Mai întâi, să creăm cadrul aplicației. Oricât de banal ar fi, să fie un blog.

Am creat o structură de bază în care:

• Blogul este stocarea aplicației noastre;
• Vizualizări și șabloane - stocarea vizualizărilor și a șabloanelor;
• Utility - depozit de biblioteci partajate;
• index.php - script bootstrap;
• Post - aici ar trebui să aibă loc idila familială a Controllerului și Modelului.

Cu index.php totul este simplu:

alerga(); /* * sfârșitul index.php */

Determinăm căile necesare și creăm un autoloader.
Încărcătorul automat încarcă clasele necesare, care sunt situate într-o ierarhie de foldere în funcție de spațiul de nume de clasă. De exemplu, clasa BlogPostServicesView ar fi căutată în Blog/Post/Services.
Și iată prima întâlnire cu Namespace.
Când pornim index.php, creăm o instanță a aplicației Blog, a cărei clasă este încărcată de pe Blog/Blog.php.
Să ne uităm la el.

post = post nou(); ) funcția publică run() ( $this->post->view->all(); ) )//end class Blog

Când creăm clasa Blog, injectăm o clasă Post în ea cu Namespace BlogPost și încărcătorul automat o încarcă din Blog/Post/Post.php.
Probabil această clasă poate fi numită Controller,

vizualizare = new View(); ) )//termină clasa Post

Entitatea Post include:
- structura înregistrării de date în sine - BlogPostEntitiesPostEntity.php

Servicii care deservesc solicitările Controllerului - BlogPostServicesView.php (unul dintre servicii, de exemplu)

db = nou DB(); )//end __construct public function all() ( $posts = $this->db->survey(); Contemplate::compose(array("header" => "header", "main" => "main", "footer" => "footer",), array("posts" => $posts, "title" => "Viper site",)); ) )//termină clasa PostView

Sistemul de interacțiune cu bazele de date - BlogPostRepositoriesDB.php - iată, modelul nostru subțire, elegant,
Doar dă-l, adu-l și nimic mai mult!

dbh = PDO nou ("mysql:host=localhost;dbname=test", $user, $pass, array(PDO::ATTR_PERSISTENT => true)); ) catch (PDOException $e) ( echo "Eroare!: " . $e->getMessage() ."
"; die(); ) )//end __construct public function survey() ( $query_view = $this->dbh->prepare("SELECT * din postari"); $query_view->execute(); return $query_view- >fetchAll(PDO::FETCH_CLASS, "BlogPostEntitiesPostEntity"); )//termină sondaj )//termină clasa Db

Drept urmare, am reușit să creăm o structură de aplicație în care toate componentele sunt bine conectate, în timp ce am realizat o separare clară a claselor, în care fiecare clasă își îndeplinește propria sarcină. Controlerul nostru este subțire și în același timp puternic. Modelul se potrivește cu el. Familia perfectă!
Și totul datorită Namespace.

Nu argumentez, în multe cazuri cadrul este convenabil. Dar uite, Namespace nu îți amintește de nimic?
O împărțire clară în clase, o ierarhie strictă și în același timp flexibilă a directoarelor și claselor, complet subordonată dezvoltatorului.
Uneori, nu există un astfel de add-on semnificativ sub formă de sute de fișiere și clase sub forma unui cadru.
Absența unui pat procustean de reguli pentru interacțiunea claselor și componentelor.

Articolul a fost inspirat de gândurile pe această temă ale lui Taylor Otwell, autorul framework-ului Laravel, pentru care îi mulțumesc mult.
Adresa exemplului de cod sursă pe GitHub.

Mi-am încapsulat recent proiectul într-un spațiu de nume și am întâlnit problema lipsei de documentație adecvată. Tot ceea ce am reușit să găsim datează din aproximativ 2009 și este aproape 2012... În materialul găsit, există o mulțime de locuri nefuncționale care folosesc ceva care nu este în versiunea curentă de php. În acest sens, aș dori să fac un pic de lumină asupra acestei probleme.
Deci, ce este un spațiu de nume sau un spațiu de nume? Marea wikipedia le definește astfel:

Spațiul de nume este un set, ceea ce înseamnă un model, un spațiu de stocare abstract sau un mediu creat pentru gruparea logică a identificatorilor unici (adică nume). Un identificator definit într-un spațiu de nume este asociat cu acel spațiu de nume. Același identificator poate fi definit independent în mai multe spații. Astfel, o valoare asociată cu un identificator definit într-un spațiu de nume poate (sau nu) să aibă același sens (sau mai degrabă diferit) ca același identificator definit într-un alt spațiu de nume. Limbile care știe spațiul de nume definesc reguli care indică spațiului de nume căruia îi aparține un identificator (adică definiția acestuia).wiki

Tot clar? Este de fapt simplu. Înainte de versiunea 5.3, în php existau doar două spații - global (în care era executat codul principal) și local (în care erau definite variabilele funcției).

De la versiunea 5.3 totul s-a schimbat. Acum vă puteți defini spațiul de nume în care vor exista clasele, metodele etc.


Sper că a devenit puțin mai clar.

Am numit în mod special clasele la fel. Deoarece sunt definite în spații diferite, sunt două clase diferite, în ciuda acelorași nume. Scriptul principal încă funcționează în spațiul global, nimic nu s-a schimbat aici și clasele și funcțiile pot fi încă definite în el. Atunci pentru ce sunt spațiile? În primul rând, pentru a vă asigura că atunci când includeți un fișier cu un cadru sau bibliotecă, clasele dvs. nu vor suprascrie clasele cadrului sau invers.

Pentru a utiliza clasele definite în spațiul dvs. de nume, trebuie să importați spațiul definit în cel global în locul potrivit (de obicei prefer să fac acest lucru la începutul fișierului). Pentru a face acest lucru, utilizați cuvântul cheie use

Atenţie: din anumite motive php nu permite utilizarea cuvântului cheie utilizareîn stare blocuri și bucle

Să luăm exemplul din imagini și să îl implementăm în cod:

Atenţie: cuvântul cheie namespace trebuie să fie situat chiar la începutul fișierului, imediat după
fisierul A.php
Fișierul B.php
Este posibilă o sintaxă alternativă:
Este recomandat să declarați fiecare spațiu de nume într-un fișier separat. Deși se poate într-unul, nu este strict recomandat!
Acum să trecem la al treilea fișier, în care va funcționa scriptul nostru principal
index.php
S-ar părea că acesta este un avantaj, se adaugă doar mai mult cod, dar acest lucru nu este în întregime adevărat, puțin mai departe voi da un exemplu de clasă de încărcare automată, cu care liniile care conectează fișierele cu clase vor fi inutile.
Acum să ne uităm la cursurile noastre.

Atenţie: folosind operatorul de rezoluție a domeniului (::) în spațiile de nume php nepermis! Singurul lucru pentru care este potrivit este accesarea metodelor și constantelor clasei statice. La început au vrut să-l folosească pentru spațiul de nume, dar apoi s-au decis să nu-l facă din cauza problemelor apărute. Prin urmare, o construcție ca A::A::say(); este invalid și va avea ca rezultat o eroare.

Pentru spațiile de nume, trebuie să utilizați caracterul bară oblică inversă „\”

Atenţie: Pentru a evita neînțelegerile, este necesar să evadați acest caracter atunci când este folosit în șiruri de caractere: „\\”

Spațiile de nume pot fi imbricate unul în celălalt, să adăugăm fișierului nostru A.php:
iar în index vom scrie următoarele:

Un punct important este utilizarea alias-urilor pentru spațiile importate. Ai putea scrie A\subA::say(); Veți fi de acord că este dificil să scrieți căi complete către spații de fiecare dată; pentru a evita acest lucru, au fost introduse aliasuri. La compilare se va întâmpla următoarele: în loc de sub alias, va fi înlocuit A\subA, deci vom obține apelul A\subA::say();

Ce se întâmplă atunci când apelăm funcții definite în spațiul global? PHP caută mai întâi o funcție în spațiul în care lucrați în prezent și, dacă nu o găsește, trece în domeniul global. Pentru a indica imediat că utilizați o funcție globală, trebuie să o precedați cu o bară oblică inversă.

Pentru a evita problemele cu încărcarea automată a claselor din spații, sistemul de fișiere trebuie să fie organizat similar cu organizarea spațiilor. De exemplu, avem un folder rădăcină clase, unde vor fi stocate clasele noastre, apoi spațiile noastre pot fi organizate după cum urmează
clase\A\A.php
clase\A\sub\A.php (subspațiul va fi plasat într-un fișier separat)
clase\B\B.php

PHP are o constantă magică __NAMESPACE__ care conține numele spațiului curent.

Și acum despre încărcarea automată.

Clasa de mai jos nu este a mea, doar am făcut-o să funcționeze și am îmbunătățit-o puțin, luată de aici.

Atenţie: Pentru ca clasele dvs. să fie încărcate, numele clasei trebuie să se potrivească cu numele fișierului!

" .$fișier ."în " .$filepath)); if (fișier_există($filepath)) ( if(Autoloader::debug) Autoloader::StPutFile(("conectat " .$filepath)); $flag = FALSE; require_once($filepath); break; ) Autoloader::recursive_autoload($file, $path2, &$flag); ) ) closedir($handle); ) ) funcție statică privată StPutFile($date) ( $dir = $_SERVER["DOCUMENT_ROOT"] ." /Log/Log.html"; $fișier = fopen($dir, "a"); flock($fișier, LOCK_EX); fwrite($fișier, ("║" .$date ."=>" .date(" d.m.Y H:i:s")."
║
" .PHP_EOL)); flock($fișier, LOCK_UN); fclose ($fișier); ) ) \spl_autoload_register("yourNameSpace\Autoloader::autoload"); )
Dacă vă uitați la numele claselor care vin pentru încărcare, veți vedea că fiecare clasă este precedată de un prefix din spațiul de nume care este specificat în uz. Acesta este motivul pentru care vă recomand să folosiți locația fișierelor în directoare similare cu spațiul de nume; acest lucru accelerează căutarea la una sau două iterații.

Acum indexul nostru poate fi scris astfel:
Acum toate clasele și interfețele pe care le veți folosi vor fi încărcate automat.

Pentru a demonstra unele dintre capacitățile dinamice ale limbajului cu spații, să declarăm o altă clasă:
test.php

Index.php
sayName("test"); //sau puteți face acest test\sayName("test2"); //sau ca asta $obj::sayName("test"); //sau puteți face acest test::sayName("test2");

Sper că articolul meu va fi de folos cuiva.

O variabilă definește o valoare, dar poate fi o referință la o altă variabilă și poate avea valoarea acesteia. În timpul execuției unui algoritm, o variabilă ia de obicei multe valori diferite. O constantă stochează o singură valoare. Un obiect este imprevizibil: tinde să aibă structură, conținut și multe caracteristici.

Un spațiu de nume este o colecție de variabile, constante, obiecte, funcții și alte constructe create de dezvoltator care pot fi referite prin numele acestui spațiu de nume.

Denumiri: sfera de descriere a datelor și a algoritmilor

Numele elementelor (variabile, constante, obiecte, funcții și alte constructe de dezvoltator) nu se intersectează niciodată. PHP interpretează orice potrivire de nume ca pe o eroare gravă, iar în cazurile în care nu poate identifica clar problema, dezvoltatorul primește cod care nu funcționează conform intenției, sau o casetă albă în browser.

Toate numele tuturor datelor trebuie să fie unice, deoarece spațiul este global. Numele obiectelor și funcțiilor nu trebuie, de asemenea, repetate, dar sfera vizibilității globale este întreruptă în corpurile de metode ale obiectelor și funcțiilor. Are propriul său spațiu de nume local și nimic nu vă împiedică să numiți ceva în interior, în același mod în care este desemnat extern.

Exemplul de mai sus este un clasic, dacă nu acordați atenție cuvântului cheie al spațiului de nume: totul este ca întotdeauna. Al doilea include lucrări. Prefixul NameSpaceTwo\ înainte de numele funcțiilor specifică din ce inserție este preluat codul.

Dacă eliminăm cuvântul cheie global și operația din prima funcție $iExt = 1; treceți la linia de mai sus, atunci nici prima, nici a doua funcție nu vor ști despre valoarea variabilei 100.

Spații de nume: mai multe domenii de descriere

Exemplul prezentat are un fișier partajat care utilizează două inserări. Fiecare inserare are aceeași funcție scCheckName(). Pe care să o alegeți este decis de programator folosind numele spațiului care este relevant la momentul potrivit în locul potrivit din cod.

Faptul că același nume este prezent în codul comun (după îmbinarea inserțiilor) nu provoacă o eroare din simplul motiv că fiecare fișier de inserare este marcat cu propriul nume unic.

În primul fișier, tot ceea ce va fi descris în el este asociat cu numele NameSpaceOne. În al doilea fișier, toate descrierile vor fi asociate cu numele NameSpaceTwo.

Este permisă orice duplicare a numelor în ambele fișiere, dar în fiecare dintre ele orice nume de element (variabilă, constantă, obiect, funcție) trebuie să fie unic.

În acest exemplu, schimbarea numelui spațiului de nume în apelul funcției scCheckName() a împiedicat modificarea variabilei $iExt a celui de-al doilea spațiu de nume. De aceea, în exemplu, cuvântul „schimbat” este evidențiat în mod special - schimbarea nu a avut loc de fapt. Valoarea variabilei rămâne aceeași.

Testare și proiectare multiplă

Aceste exemple simple arată că puteți simplifica cu ușurință dezvoltarea proiectelor complexe, crește eficiența, productivitatea și accelera munca. Cu siguranță, primele idei de utilizare a spațiilor de nume au apărut imediat:

• testarea sigură a scripturilor - prin înlocuirea spațiilor „de lucru” cu analogi de testare;
• design sigur de către echipe mari de dezvoltatori - oferindu-le spații „individuale” pentru descrierea elementelor.

De fapt, spațiul de nume este mult mai important. Limbajul PHP, spațiul de nume și fiecare element al descrierii (variabilă, constantă, obiect...) au oferit de mult dezvoltatorului capacitatea de a manipula independent sintaxa și semantica.

Construcțiile limbajului și regula generală a programării moderne: „înțeles” - executat - există o contradicție - un „ecran alb” nu are niciun efect asupra unui dezvoltator profesionist.

Mulți programatori nici măcar nu știu unde să caute un mesaj de eroare PHP când nu există nimic în browser (o casetă albă goală). La un anumit stadiu al dezvoltării sale, un programator gândește în sintaxa și semantica PHP, „funcționează” automat și rezultatul: propria sintaxă și propria sa semantică, în limitele a ceea ce este permis.

Un ecran alb este o reacție imediată fără ambiguitate a unui programator profesionist și eroarea este eliminată. De ce să pierzi timpul cu un depanator și să vizualizezi jurnalul de erori?

Obiecte, tablouri și spații de nume

Ați putea spune că variabilele, constantele și funcțiile sunt de domeniul trecutului, dar sunt folosite în proiectarea obiectelor. Codul bun este atunci când algoritmul este reprezentat prin obiecte care interacționează, și nu printr-o secvență de constructe corecte.

Dacă utilizați matrice de obiecte, manipulați ideea unei stive și ultimul (primul) element al matricei, puteți obține dinamică: obiectele în sine „decid” cum ar trebui să funcționeze funcționalitatea site-ului în funcție de situația actuală. .

În PHP, un spațiu de nume este un tip special de variabilă, reprezentată de propriul nume unic, adesea unul complex. Numele spațiului de nume este folosit în cod. Dacă acesta este un șir, atunci puteți înlocui un spațiu cu altul în timpul execuției scriptului.

Dacă PHP folosește numele spațiilor de nume ca valori variabile, atunci aceasta este o sintaxă încărcată și mai semantic, chiar mai puternică decât matricele de obiecte.

Un obiect este o structură și un conținut care sunt caracterizate de unitate. Un spațiu de nume este un set de obiecte, elemente și relații dintre ele.

Nu este posibil să se efectueze experimente pe un sistem care rulează, dar datorită spațiului de nume, PHP oferă posibilitatea de a simula un sistem real care rulează într-un spațiu diferit în scopul:

• dezvoltare ulterioară;
• testare;
• întreținere etc.

Dacă facem abstracție de sintaxa propusă de dezvoltatorii PHP și ne imaginăm spațiile de nume ca sisteme globale complexe de obiecte, atunci orizonturile posibilităților se extind de multe ori.

Sintaxa și utilizarea spațiului de nume

PHP acceptă doar spațiul de nume al cuvântului din prima linie de cod din fiecare fișier. Toate descrierile trebuie să o urmeze numai. Sintaxa include doar numele notat în sensul obișnuit al numelui.

Este important să folosiți cuvintele corecte care transmit sensul. Este mai bine când numele este lung, dar conține ceva care oferă o înțelegere clară despre ce spațiu vorbim, ce face, ce descrie, ce acceptă sau pentru ce a fost creat.

Spațiile pot fi imbricate pe termen nelimitat, dar acest lucru nu ar trebui să fie suprautilizat. Numele trebuie să fie clar, imbricarea trebuie să fie justificată, iar succesiunea numelor de spațiu trebuie să aibă logică.

În aplicațiile de utilizare și spații de nume, PHP permite codificare complexă, dar ori de câte ori este posibil, este mai bine să mergeți cu opțiunea simplă.

Regula generală este: spațiul de nume este o descriere și acesta este un fișier, utilizare este importarea spațiului în scriptul de utilizare și atribuirea unui alias (link scurt) acestuia.

Un exemplu simplu de încărcare automată a claselor (obiectelor)

Sarcina conține un obiect pentru manipularea șirurilor de caractere, stiluri de elemente de pagină (descrieri CSS), un obiect dată, un obiect sistem de fișiere și un obiect bază de date. Punctul de implementare este de a crea interfețe simple pentru aceste cinci poziții pentru a utiliza capabilitățile necesare doar prin metodele acestor obiecte.

Nu este permisă utilizarea directă a funcțiilor și constructelor limbajului. Această sarcină folosește încărcarea automată a clasei PHP. Spațiul de nume este considerat o colecție de obiecte situate într-o locație specifică din sistemul de fișiere. De obicei, toate obiectele sunt localizate în sistemul de fișiere în funcție de semnificația lor, în foldere și în fișiere cu un anumit nume.

Codul din stânga indică crearea celor cinci obiecte necesare, dar nu este indicat locul exact unde sunt amplasate. Codul din dreapta arată textul autoloader-ului (scriptul principal), care, la încărcarea claselor (obiectelor), înlocuiește automat calea necesară către locația obiectului și extensia de fișier .php.

Exemplu de spații de nume multiple

Biblioteca PhpOffice/PhpWord este un bun exemplu de utilizare a unei ierarhii complexe de spații de nume multiple. Folderul elemente conține aproape întreaga gamă de elemente disponibile la crearea unui document *.docx (MS Word), alte foldere conțin instrumentele necesare pentru lucrul cu elemente, paragrafe și tabele.

De fapt, biblioteca a fost plasată în folderul proiectului din motivul că spațiul de funcționalitate PhpOffice / PhpWord trebuia completat cu instrumente specifice și, în cele din urmă, să creați propria dvs. versiune a unui produs similar.

Se încarcă multe clase de spații de nume diferite

Folosirea autoîncărcării spațiului de nume PHP, când este necesară încărcarea multor clase, iar ierarhia sistemului de obiecte dezvoltat este destul de complexă și greu de imaginat, duce la necesitatea creării de structuri rigide.

Orientarea dezvoltatorului (care folosește produsul pentru a continua munca) este posibilă numai în contextul semanticii (înțelegerea proiectului), care este reprezentată de combinații adecvate de cuvinte care reflectă semnificația reală și relațiile obiectelor.

Necesitatea utilizării bibliotecii într-un proiect individual duce la rezolvarea problemei modului de combinare a spațiilor de nume ale dezvoltatorului și PhpOffice / PhpWord. Cel mai bun mod este să plasați acest produs (spațiile și obiectele sale) în propriul spațiu de proiect.

Este important de menționat că nu se va putea face fără modificarea spațiilor de nume ale acestui produs la nivelul elementelor sale abstracte și al încărcării clasei. Acest lucru indică faptul că în spațiul de nume PHP utilizarea spațiilor de nume interne poate să nu fie suficient de abstractă și universală.

Sistem de fișiere și localizare spațiu

În esență, spațiile de nume sunt „conturarea” căii din sistemul de fișiere către obiectul dorit. Utilizarea numelor de fișiere ca nume de obiecte este firească și comună. Utilizarea numelor de foldere ca denumire a spațiului de nume este obiectivă.

Organizarea „de lemn” a informațiilor este destul de greoaie de utilizat și complică dezvoltarea, dar este o reprezentare naturală pentru sistemele de obiecte.

Problema este că etapa de dezvoltare este reprezentată de un editor de cod specific, care combină atât reprezentarea vizibilă a folderelor, cât și conținutul unui folder anume, dar încă nu există un editor care să ofere mișcare end-to-end prin obiecte și prin foldere.

Problema abstracției și a universalității

Acceptat de conștiința dezvoltatorului și obiectivul în realitate:

• oferă abstractizare și capacitatea de a manipula informația conform semanticii sale reale;
• spațiile de nume reflectă poziția scripturilor, obiectelor și, parțial, semnificația proiectului în sistemul de fișiere

De fapt, conectând abstracția OOP la nume de obiecte (fișiere) și suprapunând-o pe sistemul de fișiere (foldere) cu formarea adecvată a spațiului de nume (căi + nume), puteți controla formarea spațiilor de nume în timpul execuției scriptului.

Programarea a dobândit deja o dinamică puternică de dezvoltare, dar dacă transferăm procesul și încărcarea etapei de dezvoltare de la un editor de text (în care scripturile sunt create și plasate în arbori de foldere) la ideea de a genera un cod care își permite să fie îmbunătățit și plasat la locul potrivit în sistemul de fișiere - programarea se va ridica la noi culmi.