Mga halimbawa ng paggamit ng namespace sa php. Mga namespace sa PHP, ipinaliwanag. Mga namespace: Maramihang saklaw ng paglalarawan

Kamakailan ay inilagay ko ang aking proyekto sa isang namespace at napunta sa problema ng kakulangan ng wastong dokumentasyon. Lahat ng nahanap namin ay nagmula noong humigit-kumulang 2009, at ito ay halos 2012... Sa materyal na natagpuan, mayroong maraming mga hindi gumaganang lugar na gumagamit ng isang bagay na wala sa kasalukuyang bersyon ng php. Kaugnay nito, nais kong magbigay ng kaunting liwanag sa isyung ito.
Kaya, ano ang isang Namespace o namespace? Tinukoy sila ng mahusay na wikipedia tulad nito:

Ang namespace ay isang set, na nangangahulugang isang modelo, abstract na storage o environment na ginawa para sa lohikal na pagpapangkat ng mga natatanging identifier (iyon ay, mga pangalan). Ang isang identifier na tinukoy sa isang namespace ay nauugnay sa namespace na iyon. Ang parehong identifier ay maaaring independiyenteng tukuyin sa maraming espasyo. Kaya, ang isang value na nauugnay sa isang identifier na tinukoy sa isang namespace ay maaaring (o maaaring hindi) magkaroon ng pareho (o sa halip ay naiiba) na kahulugan bilang parehong identifier na tinukoy sa isa pang namespace. Tinutukoy ng mga wikang may kaalaman sa namespace ang mga panuntunan na nagsasaad kung saang namespace kabilang ang isang identifier (iyon ay, kahulugan nito).wiki

Malinaw ang lahat? Ito ay talagang simple. Bago ang bersyon 5.3, mayroon lamang dalawang puwang sa php - global (kung saan ang iyong pangunahing code ay naisakatuparan) at lokal (kung saan tinukoy ang mga variable ng function).

Mula noong bersyon 5.3 lahat ay nagbago. Ngayon ay maaari mong tukuyin ang iyong namespace kung saan iiral ang iyong mga klase, pamamaraan, atbp.


Sana naging mas malinaw ito ng kaunti.

Pareho kong pinangalanan ang mga klase. Dahil ang mga ito ay tinukoy sa magkaibang mga puwang, sila ay dalawang magkaibang klase, sa kabila ng parehong mga pangalan. Ang pangunahing script ay gumagana pa rin sa pandaigdigang espasyo, walang nagbago dito at ang mga klase at pag-andar ay maaari pa ring tukuyin dito. Kaya para saan ang mga puwang? Una sa lahat, para matiyak na kapag nagsama ka ng file na may ilang framework o library, hindi i-override ng iyong mga klase ang mga klase ng framework o vice versa.

Upang magamit ang mga klase na tinukoy sa iyong namespace, kailangan mong i-import ang puwang na iyong tinukoy sa pandaigdigang isa sa tamang lugar (karaniwang mas gusto kong gawin ito sa simula ng file). Upang gawin ito, gamitin ang use keyword

Pansin: sa ilang kadahilanan ay hindi pinapayagan ng php ang paggamit ng keyword gamitin sa kondisyon ng mga bloke at mga loop

Kunin natin ang halimbawa mula sa mga larawan at ipatupad ito sa code:

Pansin: ang keyword ng namespace ay dapat na matatagpuan sa pinakadulo simula ng file, kaagad pagkatapos
file A.php
B.php file
Posible ang isang alternatibong syntax:
Inirerekomenda na ideklara ang bawat namespace sa isang hiwalay na file. Kahit na ito ay posible sa isa, ito ay mahigpit na hindi inirerekomenda!
Ngayon ay lumipat tayo sa ikatlong file, kung saan gagana ang aming pangunahing script
index.php
Mukhang ito ay isang kalamangan, mas maraming code ang idinagdag, ngunit hindi ito ganap na totoo, kaunti pa ay magbibigay ako ng isang halimbawa ng isang klase ng autoload, kung saan ang mga linya na nagkokonekta sa mga file sa mga klase ay hindi na kailangan.
Ngayon tingnan natin ang ating mga klase.

Pansin: gamit ang scope resolution operator (::) sa php namespaces hindi pwede! Ang tanging bagay na angkop para sa ay ang pag-access sa mga static na pamamaraan ng klase at constants. Noong una ay gusto nilang gamitin ito para sa namespace, ngunit pagkatapos ay nagpasya silang laban dito dahil sa mga problemang lumitaw. Samakatuwid, isang konstruksiyon tulad ng A::A::say(); ay hindi wasto at magreresulta sa isang error.

Para sa mga namespace, dapat mong gamitin ang backslash na character na "\"

Pansin: Upang maiwasan ang mga hindi pagkakaunawaan, kailangang takasan ang karakter na ito kapag ginamit sa mga string: "\\"

Maaaring ilagay ang mga namespace sa loob ng bawat isa, idagdag natin sa aming A.php file:
at sa index ay isusulat namin ang sumusunod:

Ang isang mahalagang punto ay ang paggamit ng mga alias para sa mga na-import na espasyo. Maaari kang sumulat ng A\subA::say(); Sasang-ayon ka na mahirap magsulat ng buong mga landas sa mga espasyo sa bawat oras; upang maiwasan ito, ipinakilala ang mga alias. Kapag nag-compile, ang mga sumusunod ay mangyayari: sa halip na ang alias sub, A\subA ang papalitan, kaya makukuha natin ang tawag na A\subA::say();

Ano ang mangyayari kapag tumatawag sa mga function na tinukoy sa pandaigdigang espasyo? Hinahanap muna ng PHP ang isang function sa loob ng espasyo kung saan ka kasalukuyang nagtatrabaho, at kung hindi ito mahanap, mapupunta ito sa pandaigdigang saklaw. Upang agad na maipahiwatig na gumagamit ka ng isang pandaigdigang function, dapat mo itong unahan ng isang backslash.

Upang maiwasan ang mga problema sa autoloading ng mga klase mula sa mga espasyo, ang file system ay dapat na organisado nang katulad ng samahan ng mga espasyo. Halimbawa, mayroon kaming root folder na mga klase, kung saan ang aming mga klase ay maiimbak, pagkatapos ang aming mga puwang ay maaaring isaayos tulad ng sumusunod
classes\A\A.php
classes\A\sub\A.php (ilalagay ang sub subspace sa isang hiwalay na file)
classes\B\B.php

Ang PHP ay may magic constant na __NAMESPACE__ na naglalaman ng pangalan ng kasalukuyang espasyo.

At ngayon tungkol sa autoloading.

Ang klase sa ibaba ay hindi akin, ginawa ko lang ito at pinagbuti ito ng kaunti, kinuha mula dito.

Pansin: Upang ma-load ang iyong mga klase, dapat tumugma ang pangalan ng klase sa pangalan ng file!

" .$file ." sa " .$filepath)); if (file_exists ($filepath)) ( if(Autoloader::debug) Autoloader::StPutFile(("connected " .$filepath)); $flag = FALSE; require_once($filepath); break; ) Autoloader::recursive_autoload($file, $path2, &$flag); ) ) closedir($handle); ) ) pribadong static function na StPutFile($data) ($dir = $_SERVER["DOCUMENT_ROOT"] ." /Log/Log.html"; $file = fopen($dir, "a"); flock($file, LOCK_EX); fwrite($file, ("║" .$data ."=>" .date(" d.m.Y H:i:s") ."
║
" .PHP_EOL)); kawan($file, LOCK_UN); fclose ($file); ) ) \spl_autoload_register("yourNameSpace\Autoloader::autoload"); )
Kung titingnan mo ang mga pangalan ng mga klase na papasok para sa paglo-load, makikita mo na ang bawat klase ay nauuna sa isang prefix mula sa namespace na tinukoy sa paggamit. Ito ang dahilan kung bakit inirerekomenda ko ang paggamit ng lokasyon ng mga file sa mga direktoryo na katulad ng namespace; pinapabilis nito ang paghahanap sa isa o dalawang pag-ulit.

Ngayon ang aming index ay maaaring isulat tulad nito:
Ngayon ang lahat ng mga klase at interface na iyong gagamitin ay awtomatikong mailo-load.

Upang ipakita ang ilan sa mga dynamic na kakayahan ng wika na may mga puwang, magdeklara tayo ng isa pang klase:
pagsubok.php

Index.php
sayName("test"); //o maaari mong gawin ang pagsubok na ito\sayName("test2"); //o tulad nito $obj::sayName("test"); //o maaari mong gawin ang pagsubok na ito::sayName("test2");

Umaasa ako na ang aking artikulo ay magiging kapaki-pakinabang sa isang tao.

Ang PHP, simula sa bersyon 5.3, ay nagbigay sa amin ng mga namespace. Simula noon, nagkaroon ng ilang tamad at ilang mainit na talakayan tungkol sa kung paano gamitin ang namespace na ito?
Ang ilang mga balangkas, tulad ng Symphony, Laravel, at, siyempre, Zend, ay nagpatibay ng teknolohiyang ito.
Ang lahat ng ito ay higit pa o mas kaunti magkasya sa MVC scheme. May nananatiling isa, malamang na walang hanggan, debate: ano ang dapat na pangunahing pares ng kasal ng aplikasyon - Modelo at Controller?
Ang ilan ay nagsasabi sa amin na ang Modelo ay dapat na mataba at mataba at kasama niya ang isang payat at payat na Controller. Sa isang salita - matriarchy.
Ang iba, sa kabaligtaran, ay naniniwala na ang Kontroler ay dapat pangasiwaan at utusan ang lahat, kaya siya ay lumalabas na solid at busog. At kasama niya ang isang manipis, payat na Modelo, na ang gawain ay bumubuhos upang magbigay at dalhin. Ito ay patriarchy.
Kaya alin ang mas mahusay sa MVC scheme? Patriarchy o matriarchy?
Tingnan natin ito mula sa pananaw ng pagbuo ng unit ng pamilya batay sa demokrasya. At hayaan ang Namespace na tulungan kami dito.

Hindi namin gusto ang makapal, makulit na Controller na, tulad ng isang toro sa isang china shop, ay maaaring durugin ang buong application kung ikaw ay pabaya.
Hindi rin kami mahilig sa matatabang Modelo. Well, sino ang may gusto sa kanila? Dapat silang maging karapat-dapat sa podium!
Subukan natin, sa tulong ng Namespace, tulad ng isang mahusay na matchmaker, upang lumikha ng isang maayos na pamilya.

Una, gawin natin ang framework ng application. Kahit na karaniwan, hayaan itong maging isang blog.

Gumawa kami ng isang pangunahing istraktura kung saan:

• Ang blog ay imbakan ng aming application;
• Mga View at Template - imbakan ng mga view at template;
• Utility - imbakan ng mga shared library;
• index.php - bootstrap script;
• Post - dito dapat maganap ang idyll ng pamilya ng Controller at ng Modelo.

Sa index.php ang lahat ay simple:

tumakbo(); /* * dulo ng index.php */

Tinutukoy namin ang mga kinakailangang landas at lumikha ng isang autoloader.
Nilo-load ng autoloader ang mga kinakailangang klase, na matatagpuan sa isang hierarchy ng folder ayon sa namespace ng klase. Halimbawa, ang klase ng BlogPostServicesView ay hahanapin sa Blog/Post/Services.
At narito ang unang pagpupulong sa Namespace.
Kapag sinimulan namin ang index.php, lumikha kami ng isang halimbawa ng application ng Blog, na ang klase ay na-load mula sa Blog/Blog.php.
Tingnan natin siya.

post = bagong Post(); ) public function run() ( $this->post->view->all(); ) )//end class Blog

Kapag gumagawa ng Blog class, nag-iinject kami ng Post class dito gamit ang Namespace BlogPost at nilo-load ito ng autoloader mula sa Blog/Post/Post.php.
Marahil ang klase na ito ay matatawag na Controller,

view = bagong View(); ) )//end class Post

Kasama sa Post entity ang:
- ang istraktura ng mismong talaan ng data - BlogPostEntitiesPostEntity.php

Mga serbisyong naghahatid ng mga kahilingan ng Controller - BlogPostServicesView.php (isa sa mga serbisyo, halimbawa)

db = bagong 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",)); ) )//end class PostView

Ang database interaction system - BlogPostRepositoriesDB.php - narito, ang aming manipis, eleganteng Modelo,
Ibigay mo lang, dalhin mo, at wala nang iba pa!

dbh = bagong PDO("mysql:host=localhost;dbname=test", $user, $pass, array(PDO::ATTR_PERSISTENT => true)); ) catch (PDOException $e) ( echo "Error!: " . $e->getMessage() ."
"; die(); ) )//end __construct public function survey() ($query_view = $this->dbh->prepare("SELECT * from posts"); $query_view->execute(); return $query_view- >fetchAll(PDO::FETCH_CLASS, "BlogPostEntitiesPostEntity"); )//end survey )//end class Db

Bilang resulta, nakagawa kami ng isang istraktura ng aplikasyon kung saan ang lahat ng mga bahagi ay mahusay na konektado, habang nakamit namin ang isang malinaw na paghihiwalay ng mga klase, kung saan ang bawat klase ay gumaganap ng sarili nitong gawain. Ang aming controller ay manipis at sa parehong oras ay malakas. Ang modelo ay tugma sa kanya. Perpektong pamilya!
At lahat salamat sa Namespace.

Hindi ako nakikipagtalo, sa maraming mga kaso ang balangkas ay maginhawa. Ngunit tingnan mo, ang Namespace ay hindi nagpapaalala sa iyo ng anuman?
Ang isang malinaw na dibisyon sa mga klase, isang mahigpit at sa parehong oras nababaluktot hierarchy ng mga direktoryo at mga klase, ganap na subordinate sa developer.
Minsan walang ganoong makabuluhang add-on sa anyo ng daan-daang mga file at klase sa anyo ng isang balangkas.
Ang kawalan ng isang Procrustean bed ng mga patakaran para sa pakikipag-ugnayan ng mga klase at mga bahagi.

Ang artikulo ay inspirasyon ng mga saloobin sa paksang ito ni Taylor Otwell, ang may-akda ng Laravel framework, kung saan maraming salamat sa kanya.
Address ng halimbawang source code sa GitHub.

Kamusta. Sa artikulo ngayon ay titingnan natin, ano ang mga namespace sa PHP.

Kung matagal mo na itong ginagamit OOP, pagkatapos ay malamang na nakatagpo ka ng sitwasyon kung saan, kapag kumokonekta sa isang third-party na library, nakaranas ka ng pagkabigo dahil sa katotohanan na ginagamit mo na ang parehong mga pangalan ng klase sa iyong code tulad ng sa library. Ito ay maaaring mangyari lalo na kung gumagamit ka ng mga karaniwang pangalan tulad ng "modelo", "db" at iba pa. Sasabihin ko sa iyo ngayon kung paano ayusin ito.

Namespace- ito ay ilang uri ng storage na nilikha para sa abstract na pagpapangkat ng mga natatanging identifier (pangalan).

Yung. kung gagamit ka mga namespace, pagkatapos ay maaari mong ligtas na ikonekta ang mga aklatan ng third-party at huwag matakot na magkakaroon sila ng parehong mga pangalan tulad ng sa iyong code. Tapusin natin ang teorya at magpatuloy tayo sa pagsasanay.

Gumawa tayo ng file myclass.php kasama ang nilalamang ito

namespace my\oneProject;
klase MyClass ( )
?>

Dito nakagawa kami ng klase sa namespace my\oneProject. Sa pamamagitan ng paraan, kailangan mong isulat nang eksakto ang backslash. Huwag malito!

Ngayon nasa file index.php isulat natin ang sumusunod

require_once("myclass.php");
$mc = bagong MyClass(); // Error: hindi nahanap ang klase
$mc = new my\oneProject\MyClass(); // lahat ay gumagana
?>

Tulad ng nakikita mo, ngayon ay hindi posible na lumikha ng isang klase na ganoon lang, dapat mong tukuyin kung saan namespace nakahiga siya.

Maaari naming tukuyin ang ilan nang sabay-sabay mga namespace sa isang file

Namespace Project;

Const CONNECT_OK = 1;
Koneksyon ng klase ( )
function connect() ( )

NamespaceAnotherProject;

Const CONNECT_OK = 1;
Koneksyon ng klase ( )
function connect() ( )
?>

Sa kabila ng katotohanan na mayroon kaming ganap na magkaparehong mga pangalan ng mga klase, pag-andar at mga pare-pareho, hindi kami magkakaroon ng salungatan sa pangalan, dahil nakahiga sila sa iba't ibang espasyo.

Maaari din nating gamitin ang bracket syntax.

Namespace Project (

Const CONNECT_OK = 1;
Koneksyon ng klase ( )
function connect() ( )
}

Namespace AnotherProject (

Const CONNECT_OK = 1;
Koneksyon ng klase ( )
function connect() ( )
}
?>

Kung pagsasamahin mo ang code sa pandaigdigang namespace na may code sa iba pang mga puwang, pagkatapos ay ang syntax na may mga bracket lamang ang ginagamit.

Namespace Project (

Const CONNECT_OK = 1;
Koneksyon ng klase ( )
function connect() ( )
}

Namespace ( // global code
session_start();
$a = Project\connect();
echo Project\Connection::start();
}
?>

Gayundin, huwag kalimutan na ang pagtukoy sa isang namespace ay dapat palaging ang unang linya ng code. Kung magsulat ka ng ganito magkakaroon ng error

Upang malaman kung saang namespace ka kasalukuyang naroroon, maaari mong gamitin ang constant __NAMESPACE__

Namespace Project;
echo """, __NAMESPACE__, """; // ay magpi-print ng "Proyekto"
?>

Gamit ang pare-parehong ito maaari mong, halimbawa, dynamic na bumuo ng mga pangalan

Namespace Project;

Function incl($classname) (
$a = __NAMESPACE__ . "\\" . $classname;
ibalik ang bagong $a;
}
?>

Kaya iyon lang para sa araw na ito. Makakakuha ka ng higit pang impormasyon at praktikal na kaalaman sa pamamagitan ng pagkuha ng kurso

Kamakailan ay inilagay ko ang aking proyekto sa isang namespace at napunta sa problema ng kakulangan ng wastong dokumentasyon. Lahat ng nahanap namin ay nagmula noong humigit-kumulang 2009, at ito ay halos 2012... Sa materyal na natagpuan, mayroong maraming mga hindi gumaganang lugar na gumagamit ng isang bagay na wala sa kasalukuyang bersyon ng php. Kaugnay nito, nais kong magbigay ng kaunting liwanag sa isyung ito.
Kaya, ano ang isang Namespace o namespace? Tinukoy sila ng mahusay na wikipedia tulad nito:

Ang namespace ay isang set, na nangangahulugang isang modelo, abstract na storage o environment na ginawa para sa lohikal na pagpapangkat ng mga natatanging identifier (iyon ay, mga pangalan). Ang isang identifier na tinukoy sa isang namespace ay nauugnay sa namespace na iyon. Ang parehong identifier ay maaaring independiyenteng tukuyin sa maraming espasyo. Kaya, ang isang value na nauugnay sa isang identifier na tinukoy sa isang namespace ay maaaring (o maaaring hindi) magkaroon ng pareho (o sa halip ay naiiba) na kahulugan bilang parehong identifier na tinukoy sa isa pang namespace. Tinutukoy ng mga wikang may kaalaman sa namespace ang mga panuntunan na nagsasaad kung saang namespace kabilang ang isang identifier (iyon ay, kahulugan nito).wiki

Malinaw ang lahat? Ito ay talagang simple. Bago ang bersyon 5.3, mayroon lamang dalawang puwang sa php - global (kung saan ang iyong pangunahing code ay naisakatuparan) at lokal (kung saan tinukoy ang mga variable ng function).

Mula noong bersyon 5.3 lahat ay nagbago. Ngayon ay maaari mong tukuyin ang iyong namespace kung saan iiral ang iyong mga klase, pamamaraan, atbp.


Sana naging mas malinaw ito ng kaunti.

Pareho kong pinangalanan ang mga klase. Dahil ang mga ito ay tinukoy sa magkaibang mga puwang, sila ay dalawang magkaibang klase, sa kabila ng parehong mga pangalan. Ang pangunahing script ay gumagana pa rin sa pandaigdigang espasyo, walang nagbago dito at ang mga klase at pag-andar ay maaari pa ring tukuyin dito. Kaya para saan ang mga puwang? Una sa lahat, para matiyak na kapag nagsama ka ng file na may ilang framework o library, hindi i-override ng iyong mga klase ang mga klase ng framework o vice versa.

Upang magamit ang mga klase na tinukoy sa iyong namespace, kailangan mong i-import ang puwang na iyong tinukoy sa pandaigdigang isa sa tamang lugar (karaniwang mas gusto kong gawin ito sa simula ng file). Upang gawin ito, gamitin ang use keyword

Pansin: sa ilang kadahilanan ay hindi pinapayagan ng php ang paggamit ng keyword gamitin sa kondisyon ng mga bloke at mga loop

Kunin natin ang halimbawa mula sa mga larawan at ipatupad ito sa code:

Pansin: ang keyword ng namespace ay dapat na matatagpuan sa pinakadulo simula ng file, kaagad pagkatapos
file A.php
B.php file
Posible ang isang alternatibong syntax:
Inirerekomenda na ideklara ang bawat namespace sa isang hiwalay na file. Kahit na ito ay posible sa isa, ito ay mahigpit na hindi inirerekomenda!
Ngayon ay lumipat tayo sa ikatlong file, kung saan gagana ang aming pangunahing script
index.php
Mukhang ito ay isang kalamangan, mas maraming code ang idinagdag, ngunit hindi ito ganap na totoo, kaunti pa ay magbibigay ako ng isang halimbawa ng isang klase ng autoload, kung saan ang mga linya na nagkokonekta sa mga file sa mga klase ay hindi na kailangan.
Ngayon tingnan natin ang ating mga klase.

Pansin: gamit ang scope resolution operator (::) sa php namespaces hindi pwede! Ang tanging bagay na angkop para sa ay ang pag-access sa mga static na pamamaraan ng klase at constants. Noong una ay gusto nilang gamitin ito para sa namespace, ngunit pagkatapos ay nagpasya silang laban dito dahil sa mga problemang lumitaw. Samakatuwid, isang konstruksiyon tulad ng A::A::say(); ay hindi wasto at magreresulta sa isang error.

Para sa mga namespace, dapat mong gamitin ang backslash na character na "\"

Pansin: Upang maiwasan ang mga hindi pagkakaunawaan, kailangang takasan ang karakter na ito kapag ginamit sa mga string: "\\"

Maaaring ilagay ang mga namespace sa loob ng bawat isa, idagdag natin sa aming A.php file:
at sa index ay isusulat namin ang sumusunod:

Ang isang mahalagang punto ay ang paggamit ng mga alias para sa mga na-import na espasyo. Maaari kang sumulat ng A\subA::say(); Sasang-ayon ka na mahirap magsulat ng buong mga landas sa mga espasyo sa bawat oras; upang maiwasan ito, ipinakilala ang mga alias. Kapag nag-compile, ang mga sumusunod ay mangyayari: sa halip na ang alias sub, A\subA ang papalitan, kaya makukuha natin ang tawag na A\subA::say();

Ano ang mangyayari kapag tumatawag sa mga function na tinukoy sa pandaigdigang espasyo? Hinahanap muna ng PHP ang isang function sa loob ng espasyo kung saan ka kasalukuyang nagtatrabaho, at kung hindi ito mahanap, mapupunta ito sa pandaigdigang saklaw. Upang agad na maipahiwatig na gumagamit ka ng isang pandaigdigang function, dapat mo itong unahan ng isang backslash.

Upang maiwasan ang mga problema sa autoloading ng mga klase mula sa mga espasyo, ang file system ay dapat na organisado nang katulad ng samahan ng mga espasyo. Halimbawa, mayroon kaming root folder na mga klase, kung saan ang aming mga klase ay maiimbak, pagkatapos ang aming mga puwang ay maaaring isaayos tulad ng sumusunod
classes\A\A.php
classes\A\sub\A.php (ilalagay ang sub subspace sa isang hiwalay na file)
classes\B\B.php

Ang PHP ay may magic constant na __NAMESPACE__ na naglalaman ng pangalan ng kasalukuyang espasyo.

At ngayon tungkol sa autoloading.

Ang klase sa ibaba ay hindi akin, ginawa ko lang ito at pinagbuti ito ng kaunti, kinuha mula dito.

Pansin: Upang ma-load ang iyong mga klase, dapat tumugma ang pangalan ng klase sa pangalan ng file!

" .$file ." sa " .$filepath)); if (file_exists ($filepath)) ( if(Autoloader::debug) Autoloader::StPutFile(("connected " .$filepath)); $flag = FALSE; require_once($filepath); break; ) Autoloader::recursive_autoload($file, $path2, &$flag); ) ) closedir($handle); ) ) pribadong static function na StPutFile($data) ($dir = $_SERVER["DOCUMENT_ROOT"] ." /Log/Log.html"; $file = fopen($dir, "a"); flock($file, LOCK_EX); fwrite($file, ("║" .$data ."=>" .date(" d.m.Y H:i:s") ."
║
" .PHP_EOL)); kawan($file, LOCK_UN); fclose ($file); ) ) \spl_autoload_register("yourNameSpace\Autoloader::autoload"); )
Kung titingnan mo ang mga pangalan ng mga klase na papasok para sa paglo-load, makikita mo na ang bawat klase ay nauuna sa isang prefix mula sa namespace na tinukoy sa paggamit. Ito ang dahilan kung bakit inirerekomenda ko ang paggamit ng lokasyon ng mga file sa mga direktoryo na katulad ng namespace; pinapabilis nito ang paghahanap sa isa o dalawang pag-ulit.

Ngayon ang aming index ay maaaring isulat tulad nito:
Ngayon ang lahat ng mga klase at interface na iyong gagamitin ay awtomatikong mailo-load.

Upang ipakita ang ilan sa mga dynamic na kakayahan ng wika na may mga puwang, magdeklara tayo ng isa pang klase:
pagsubok.php

Index.php
sayName("test"); //o maaari mong gawin ang pagsubok na ito\sayName("test2"); //o tulad nito $obj::sayName("test"); //o maaari mong gawin ang pagsubok na ito::sayName("test2");

Umaasa ako na ang aking artikulo ay magiging kapaki-pakinabang sa isang tao.

(PHP 5 >= 5.3.0, PHP 7)

Bago talakayin ang paggamit ng mga namespace, mahalagang maunawaan kung paano alam ng PHP kung aling namespaced na elemento ang hinihiling ng iyong code. Ang isang simpleng pagkakatulad ay maaaring gawin sa pagitan ng mga namespace ng PHP at isang filesystem. May tatlong paraan upang ma-access ang isang file sa isang file system:

1. Kamag-anak na pangalan ng file tulad ng foo.txt. Ito ay nagpapasya sa kasalukuyangdirectory/foo.txt kung saan ang kasalukuyangdirectory ay ang direktoryo na kasalukuyang inookupahan. Kaya kung ang kasalukuyang direktoryo ay /home/foo, ang pangalan ay nagreresulta sa /home/foo/foo.txt.
2. Kamag-anak na pangalan ng path tulad ng subdirectory/foo.txt. Ito ay nagpapasya sa kasalukuyangdirectory/subdirectory/foo.txt.
3. Ganap na pangalan ng landas tulad ng /main/foo.txt. Ito ay nagpapasya sa /main/foo.txt.

Ang parehong prinsipyo ay maaaring ilapat sa mga namespaced na elemento sa PHP. Halimbawa, maaaring tukuyin ang isang pangalan ng klase sa tatlong paraan:

1. Hindi kwalipikadong pangalan, o isang unprefix na pangalan ng klase tulad ng $a = bagong foo(); o foo::staticmethod(); kasalukuyang namespace, ito ay nagpapasya sa currentnamespace\foo foo. Isang caveat: ang mga hindi kwalipikadong pangalan para sa mga function at constant ay magre-resolve sa mga global function at constants kung hindi tinukoy ang namespaced function o constant. Tingnan ang Paggamit ng mga namespace: fallback sa global function/constant para sa mga detalye.
2. Kwalipikadong pangalan, o isang prefix na pangalan ng klase tulad ng $a = bagong subnamespace\foo(); o subnamespace\foo::staticmethod();. Kung ang kasalukuyang namespace ay kasalukuyang namespace, ito ay nagpapasya sa currentnamespace\subnamespace\foo. Kung ang code ay pandaigdigan, hindi naka-namespace na code, ito ay lutasin sa subnamespace\foo.
3. Ganap na kwalipikadong pangalan, o isang prefix na pangalan na may global prefix operator tulad ng $a = bagong \currentnamespace\foo(); o \currentnamespace\foo::staticmethod();. Palagi itong nireresolba sa literal na pangalan na tinukoy sa code, currentnamespace\foo.

Narito ang isang halimbawa ng tatlong uri ng syntax sa aktwal na code:

namespace Foo\Bar\subnamespace;

const FOO = 1 ;
function na foo()()
klase foo
{
}
?>

namespace Foo\Bar;
isama ang "file1.php" ;

const FOO = 2;
function na foo()()
klase foo
{
static function staticmethod()()
}

/* Hindi kwalipikadong pangalan */
foo(); foo::staticmethod(); echo FOO ;

/* Kwalipikadong pangalan */
subnamespace\foo(); // ay nagpasya na gumana ang Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // lumutas sa klase Foo\Bar\subnamespace\foo,
// paraan ng static na pamamaraan
echo subnamespace\FOO; // lumutas sa pare-parehong Foo\Bar\subnamespace\FOO

/* Ganap na kwalipikadong pangalan */
\foo\bar\foo(); // nagpasya na gumana ang Foo\Bar\foo
\foo\bar\foo::staticmethod(); // lumutas sa klase Foo\Bar\foo, method staticmethod
echo\Foo\Bar\FOO; // lumulutas sa pare-parehong Foo\Bar\FOO
?>

Tandaan na para ma-access ang anumang pandaigdigang klase, function o pare-pareho, maaaring gumamit ng ganap na kwalipikadong pangalan, gaya ng \strlen() o \Exception o \INI_ALL. ?>