php-ში სახელთა სივრცის გამოყენების მაგალითები. სახელთა სივრცეები PHP-ში, განმარტა. გლობალური სახელების სივრცე

• თარგმანი
• სახელმძღვანელო

შენიშვნა: მე ვიცი, რომ თარგმანის დროს PHP-ის ამჟამინდელი ვერსია არის 5.5 და ასევე არსებობს ბრძნული სახელმძღვანელო წიგნი. მაგრამ ჩემთვის საინტერესო იყო, თუ როგორ წარმოგვიდგენს ავტორი სახელთა სივრცის ფუნქციონირებას, შესაძლოა, სტატია დაეხმარება ზოგიერთ მათგანს, ვინც ახლახან სწავლობს საფუძვლებს (და არა მხოლოდ სხვებს, არის მრავალი წვერიანი დეველოპერი, რომლებიც დასახლდნენ PHP 5.2-ზე). ჰოდორი.

PHP-ში, 5.3 ვერსიიდან დაწყებული, გამოჩნდა სახელთა სივრცეები. თანამედროვე ენების უმეტესობას დიდი ხანია აქვს ეს ფუნქციონირება, მაგრამ PHP ცოტა დაგვიანდა. თუმცა, ყოველ ახალ ფუნქციას აქვს თავისი მიზანი, მოდით გავარკვიოთ, თუ როგორ შეგვიძლია ვისარგებლოთ სახელთა სივრცის გამოყენებით.

PHP-ში არ შეიძლება ორი კლასის ერთი დასახელება, ისინი ყველა უნიკალური უნდა იყოს. ამ შეზღუდვის პრობლემა ის არის, რომ თუ იყენებთ სხვის მესამე მხარის ბიბლიოთეკას, რომელიც უზრუნველყოფს კლასს სახელად მომხმარებელი, მაშინ ვერ შექმნით საკუთარ კლასს, რომელსაც ასევე დაასახელებთ მომხმარებელი. ეს ნამდვილად ცუდია, რადგან User არის ძალიან მოსახერხებელი სახელი კლასისთვის, არა?

სახელთა სივრცეები გვაძლევს საშუალებას მოვიშოროთ ეს პრობლემა და ჩვენ შეგვიძლია შევქმნათ იმდენი მომხმარებლის კლასი, რამდენიც გვჭირდება.

მოდით შევხედოთ ძალიან გავრცელებულ კლასს. დიახ... ვიცი, რომ თქვენ უკვე გამოიყენეთ ისინი, რა შუაშია სახელთა სივრცეები? უბრალოდ დამიჯერე ამაში, კარგი?

გლობალური სახელების სივრცე

აქ არის ძალიან მარტივი კლასი:
არაფერი განსაკუთრებული, როგორც ხედავთ, და თუ გსურთ მისი გამოყენება, უბრალოდ გააკეთეთ ეს:

დეილ, მე ვიცი PHP...

კარგი, კარგი, ბოდიში. საქმე იმაშია, რომ ჩვენ შეგვიძლია ვიფიქროთ, რომ ეს კლასი გლობალურ სახელთა სივრცეშია. სინამდვილეში, ეს ნიშნავს, რომ კლასი არ ეკუთვნის რომელიმე პაკეტს, უბრალოდ ჩვეულებრივ კლასს.

სახელთა სივრცის მარტივი გამოყენება

შევქმნათ კიდევ ერთი ედარდი, გლობალურის გვერდით.
აქ ჩვენ გვაქვს ძალიან მსგავსი კლასი ერთი მცირე ცვლილებით, სახელთა სივრცის დირექტივის დამატებით. სიმებიანი სახელების სივრცე Stark; ეუბნება PHP-ს, რომ ჩვენ ვმუშაობთ Stark სახელების სივრცეში და ნებისმიერი კოდი (კლასების, ფუნქციების, ცვლადების და ა.შ. დეკლარირება) ეხება მას.

ასე რომ, ჩვენ უნდა შევქმნათ ახალი Edd, თუ გადაწყვეტთ, რომ ეს ასე უნდა გაკეთდეს:
ასე რომ არა, ეს არ არის სიმართლე. აქ ჩვენ ვიღებთ კლასის მაგალითს ადრე შექმნილი პირველი მაგალითიდან. არა ის სტარკის სახელთა სივრცეში. შევეცადოთ შევქმნათ ედდარ სტარკის მაგალითი.
კლასის ეგზემპლარის შესაქმნელად, ჩვენ უნდა დავაყენოთ კლასის სახელი პრეფიქსით იმ სახელთა სივრციდან, რომელსაც კლასი მიეკუთვნება და გამოვიყენოთ როგორც დელიმიტერი. უკანა ხაზი. შედეგად, ჩვენ გვაქვს ზუსტად იმ კლასის მაგალითი, რომელიც გვჭირდება. ჯადოსნური არაა?

სხვათა შორის, სახელთა სივრცეებს ​​შეუძლიათ შექმნან თვითნებურად რთული იერარქია, იმდენი დონის გამოყენებით, რამდენიც საჭიროა. Მაგალითად:
ეს\სახელთა სივრცე\და\კლასი\კომბინაცია\სულელურია\მაგრამ მუშაობს

Ფარდობითობის თეორია

დაიმახსოვრე, როგორ გითხარი, რომ PHP ყოველთვის მუშაობს მიმდინარე სახელთა სივრცესთან შედარებით. მოდით შევხედოთ ამას მოქმედებაში:
სახელთა სივრცის დირექტივის დამატებით, ჩვენ ვაცნობებთ PHP-ს, რომ ვართ Stark სახელთა სივრცეში. ვინაიდან სწორედ მასში განვსაზღვრეთ Eddard კლასი, სწორედ ამას მივიღებთ. ნახეთ - ყველაფერი შედარებითია.

ახლა, როცა სახელთა სივრცე შევცვალეთ, ერთი პატარა პრობლემა გვაქვს. წარმოდგენა გაქვთ რაზე ვსაუბრობ? ახლა როგორ მივიღოთ ჩვენი ორიგინალური Eddard კლასი? ისე, ერთი გლობალურ სივრცეში?

საბედნიეროდ, PHP-ს აქვს ხრიკი, რომელიც ამ პრობლემის გადაჭრის საშუალებას გვაძლევს - უბრალოდ \\ კლასის სახელს დავამატებთ.
წამყვანი ხაზის დანახვისას, PHP ესმის, რომ ჩვენ უნდა გავიხედოთ მიმდინარე სახელთა სივრცის მიღმა და ქმნის ჩვენთვის საჭირო კლასის მაგალითს.

ახლა გამოიყენეთ თქვენი ფანტაზია. წარმოიდგინეთ, რომ გვაქვს კლასი სხვა სახელების სივრციდან, სახელწოდებით Tully\Edmure. ახლა ჩვენ უნდა გამოვიყენოთ იგი Stark სივრცეში. და როგორ გავაკეთოთ ეს?

კიდევ ერთხელ, ჩვენ უნდა გამოგვეყენებინა უკანა ხაზი გლობალური გადასასვლელად, სანამ კლასის ინსტანციირებას მოვახდენდით Tully-ის სივრცეში.

ზოგადად, მსგავსი სხვა სახელების სივრცის კლასებზე მითითება, სახელის სრული იერარქიის გამოყენება, შეიძლება საკმაოდ დამღლელი იყოს. მაგრამ საბედნიეროდ, არსებობს მალსახმობის გაკეთების ვარიანტი, მოდით შევხედოთ:

გამოყენების დირექტივის გამოყენებით, ჩვენ შეგვიძლია მივიღოთ კლასი სხვადასხვა სახელების სივრციდან. უბრალოდ გთხოვთ, არ მკითხოთ "რატომ არ დავაყენეთ აქ წამყვანი ხაზი, რადგან უბრალოდ არ ვიცი?" როგორც ვიცი, ეს ერთადერთი გამონაკლისია. არა, აქ შეგიძლიათ გამოიყენოთ წინ დახრილი. მაგრამ ამაში აზრი არ იქნება.

ოჰ, კიდევ ერთი პატარა ხრიკი! ჩვენ შეგვიძლია მივცეთ ჩვენს იმპორტირებულ კლასებს მეტსახელები:
როგორც საკვანძო სიტყვის გამოყენებით, ჩვენ Tully/Brynden კლასს მივეცით მეტსახელი Blackfish, რაც საშუალებას გვაძლევს გამოვიყენოთ ახალი მეტსახელი მის იდენტიფიცირებისთვის მიმდინარე სახელთა სივრცეში. ჭკვიანი, არა? ეს ასევე ძალიან მოსახერხებელია, თუ თქვენ გჭირდებათ ორი კლასის გამოყენება, სახელწოდებით იგივე სახელების სივრცეში:

Dothraki სივრციდან Daenerys-ს მეტსახელის Khaleesi-ს მინიჭებით, ჩვენ შეგვიძლია გამოვიყენოთ დაენერისის ორივე კლასი. საკმაოდ მოსახერხებელია, იქ ჩვენ შეგვიძლია გამოვიყენოთ ყველა საჭირო კლასი ჩვენს აპლიკაციაში.

სტრუქტურა

სახელთა სივრცე ასევე დაგვეხმარება ჩვენი კოდის ორგანიზებაში. ნება მომეცით ვაჩვენო.

ვთქვათ, მინდა შევქმნა ღია კოდის ბიბლიოთეკა. მოხარული ვიქნები, თუ სხვებმა გამოიყენონ ჩემი კოდი, ეს შესანიშნავი იქნება! პრობლემა ის არის, რომ ჩემს კოდში კლასების სახელები ეწინააღმდეგებოდა მომხმარებლის მიერ ჩემს ბიბლიოთეკის აპლიკაციას. საშინლად მოუხერხებელი იქნებოდა. აი, როგორ მოვაგვარებდი ამ პრობლემას:
Dayle\Blog\Content\Post Dayle\Blog\Content\Page Dayle\Blog\Tag
აქ მე გამოვიყენე ჩემი სახელი, რათა მეჩვენებინა, რომ კოდი ჩემია და გამოვყო ჩემი კოდი ჩემი ბიბლიოთეკის მომხმარებლის კოდისგან. ბაზის სახელთა სივრცის ფარგლებში მე შევქმენი კლასის სტრუქტურა მათი იერარქიის მიხედვით.

კომპოზიტორის გამოყენების დაწყების შემდეგ, თქვენ შეისწავლით როგორ გამოიყენოთ სახელთა სივრცეები, რათა გაადვილოთ კოდის ავტომატური ჩატვირთვა. გირჩევთ, გადახედოთ ამ სასარგებლო მექანიზმს.

ხარვეზები

სიმართლე გითხრათ, ცოტა დამნაშავედ ვგრძნობ თავს, რომ ამ ქვესათაურს „მინუსები“ ვუწოდე. რაზეც მე ვისაუბრებ, სინამდვილეში შეცდომა არ არის.

ფაქტია, რომ სხვა ენებში სახელთა სივრცის ფუნქციონირება ხორციელდება ანალოგიურად და ამავდროულად ენები უზრუნველყოფენ დამატებით ფუნქციონირებას სახელთა სივრცეებთან ურთიერთობისთვის.

ჯავაში, მაგალითად, შეგიძლიათ მრავალი კლასის იმპორტი მიმდინარე სახელთა სივრცეში იმპორტის განცხადების გამოყენებით. ჯავაში იმპორტი ანალოგიურია გამოსაყენებლად და ის იყენებს წერტილებს ჩადგმული სახელების სივრცის (ან პაკეტების) გამოსაყოფად. აი მაგალითი:
იმპორტი dayle.blog.*;
ეს გადაიტანს ყველა კლასს 'dayle.blog' პაკეტში.

თქვენ არ შეგიძლიათ ამის გაკეთება PHP-ში. თქვენ უნდა შემოიტანოთ თითოეული კლასი ცალ-ცალკე. Ბოდიში. სინამდვილეში, რატომ ვიხდი ბოდიშს? წადით და უჩივით PHP განვითარების გუნდს, მაგრამ გთხოვ, იყოთ თავაზიანი. ბოლო დროს მათ ბევრი საინტერესო რამ გააკეთეს.

აქ არის სწორი ხრიკი, რომ ოდნავ შეამსუბუქოთ საკითხი. წარმოიდგინეთ, რომ გვაქვს კლასის სტრუქტურა წინა მაგალითიდან. ჩვენ შეგვიძლია ავიღოთ ქვესივრცის ნაწილი და მივცეთ მას მეტსახელი.
ეს შეიძლება სასარგებლო იყოს კლასების დიდი რაოდენობის გამოყენებისას. კარგია ყველასთვის!

სიამოვნებით მივიღებ ყველა სურვილსა და წინადადებას პირად შეტყობინებაში, მადლობა.

ცვლადი განსაზღვრავს მნიშვნელობას, მაგრამ შეიძლება იყოს მითითება სხვა ცვლადზე და ჰქონდეს თავისი მნიშვნელობა. ალგორითმის შესრულებისას ცვლადი ჩვეულებრივ იღებს ბევრ განსხვავებულ მნიშვნელობას. მუდმივი ინახავს მხოლოდ ერთ მნიშვნელობას. ობიექტი არაპროგნოზირებადია: მას აქვს სტრუქტურა, შინაარსი და მრავალი მახასიათებელი.

სახელთა სივრცე არის დეველოპერის მიერ შექმნილი ცვლადების, მუდმივების, ობიექტების, ფუნქციების და სხვა კონსტრუქციების კოლექცია, რომელთა მითითებაც შესაძლებელია ამ სახელთა სივრცის სახელით.

სახელები: მონაცემთა აღწერის სფერო და ალგორითმები

ელემენტების სახელები (ცვლადები, მუდმივები, ობიექტები, ფუნქციები და სხვა დეველოპერის კონსტრუქტები) არასოდეს იკვეთება. PHP ნებისმიერი სახელის შესატყვისს განმარტავს, როგორც სერიოზულ შეცდომას და იმ შემთხვევებში, როდესაც მას არ შეუძლია პრობლემის ნათლად იდენტიფიცირება, დეველოპერი იღებს კოდს, რომელიც არ მუშაობს ისე, როგორც დაგეგმილი იყო, ან ბრაუზერში თეთრ ველს.

ყველა მონაცემის ყველა სახელი უნდა იყოს უნიკალური, რადგან სივრცე გლობალურია. ობიექტებისა და ფუნქციების სახელები ასევე არ უნდა განმეორდეს, მაგრამ გლობალური ხილვადობის ფარგლები წყდება ობიექტებისა და ფუნქციების მეთოდურ ორგანოებში. მას აქვს საკუთარი ლოკალური სახელების სივრცე და არაფერი გიშლით ხელს, დაარქვათ რაიმე შინაგანად ისე, როგორც გარედან არის მითითებული.

ზემოთ მოყვანილი მაგალითი კლასიკურია, თუ ყურადღებას არ მიაქცევთ სახელთა სივრცის საკვანძო სიტყვას: ყველაფერი ისეა, როგორც ყოველთვის. მეორე მოიცავს ნამუშევრებს. NameSpaceTwo\ პრეფიქსი ფუნქციის სახელების წინ მიუთითებს რომელი ჩასმული კოდიდან არის აღებული.

თუ გლობალურ საკვანძო სიტყვას და ოპერაციას მოვაშორებთ პირველი ფუნქციიდან $iExt = 1; გადავიდეთ ზემოთ მოცემულ ხაზში, მაშინ არც პირველმა და არც მეორე ფუნქციამ არ იცის ცვლადის 100 მნიშვნელობის შესახებ.

სახელთა სივრცეები: აღწერის მრავალი სფერო

ნაჩვენებ მაგალითს აქვს გაზიარებული ფაილი, რომელიც იყენებს ორ ჩანართს. თითოეულ ჩანართს აქვს იგივე scCheckName() ფუნქცია. რომელი აირჩიოს, გადაწყვეტს პროგრამისტი იმ სივრცის დასახელების გამოყენებით, რომელიც შესაბამისია საჭირო დროს კოდის სწორ ადგილას.

ის ფაქტი, რომ ერთი და იგივე სახელი არის საერთო კოდში (ჩანართების გაერთიანების შემდეგ) არ იწვევს შეცდომას იმ მარტივი მიზეზის გამო, რომ თითოეული ჩასმული ფაილი მონიშნულია თავისი უნიკალური სახელით.

პირველ ფაილში ყველაფერი, რაც მასში იქნება აღწერილი, ასოცირდება სახელთან NameSpaceOne. მეორე ფაილში ყველა აღწერა ასოცირდება სახელთან NameSpaceTwo.

ორივე ფაილში დაშვებულია სახელების ნებისმიერი დუბლირება, მაგრამ თითოეულ მათგანში ნებისმიერი ელემენტის სახელი (ცვლადი, მუდმივი, ობიექტი, ფუნქცია) უნდა იყოს უნიკალური.

ამ მაგალითში, scCheckName() ფუნქციის გამოძახებაში სახელთა სივრცის სახელის შეცვლამ ხელი შეუშალა მეორე სახელთა სივრცის $iExt ცვლადის შეცვლას. ამიტომ მაგალითში სიტყვა „შეცვლილი“ სპეციალურად არის ხაზგასმული - ცვლილება რეალურად არ მომხდარა. ცვლადის მნიშვნელობა იგივე რჩება.

ტესტირება და მრავალჯერადი დიზაინი

ეს მარტივი მაგალითები აჩვენებს, რომ თქვენ შეგიძლიათ მარტივად გაამარტივოთ რთული პროექტების განვითარება, გაზარდოთ ეფექტურობა, პროდუქტიულობა და დააჩქაროთ მუშაობა. რა თქმა უნდა, მაშინვე გაჩნდა პირველი იდეები სახელთა სივრცის გამოყენების შესახებ:

• სკრიპტების უსაფრთხო ტესტირება - „სამუშაო“ სივრცეების სატესტო ანალოგებით ჩანაცვლებით;
• უსაფრთხო დიზაინი დეველოპერების დიდი გუნდების მიერ - მათთვის ელემენტების აღწერისთვის „ინდივიდუალური“ სივრცეების მიწოდებით.

სინამდვილეში, სახელთა სივრცე ბევრად უფრო მნიშვნელოვანია. PHP ენა, სახელთა სივრცე და აღწერის თითოეული ელემენტი (ცვლადი, მუდმივი, ობიექტი...) დიდი ხანია აძლევს დეველოპერს სინტაქსისა და სემანტიკის დამოუკიდებლად მანიპულირების შესაძლებლობას.

ენობრივი კონსტრუქციები და თანამედროვე პროგრამირების ზოგადი წესი: „გაიგეს“ - შესრულებულია - არსებობს წინააღმდეგობა - „თეთრი ეკრანი“ არ მოქმედებს პროფესიონალ დეველოპერზე.

ბევრმა პროგრამისტმა არც კი იცის სად უნდა მოძებნოს PHP შეცდომის შეტყობინება, როდესაც ბრაუზერში არაფერია (ცარიელი თეთრი ყუთი). მისი განვითარების გარკვეულ ეტაპზე პროგრამისტი ფიქრობს PHP სინტაქსისა და სემანტიკაში, ავტომატურად „მუშაობს“ და შედეგი: საკუთარი სინტაქსი და საკუთარი სემანტიკა, ნებადართულის ფარგლებში.

თეთრი ეკრანი არის პროფესიონალი პროგრამისტის დაუყოვნებელი ცალსახა რეაქცია და შეცდომა აღმოიფხვრება. რატომ კარგავთ დროს გამართვას და შეცდომების ჟურნალის ნახვას?

ობიექტები, მასივები და სახელების სივრცეები

შეიძლება ითქვას, რომ ცვლადები, მუდმივები და ფუნქციები წარსულის საგანია, მაგრამ ისინი გამოიყენება ობიექტების დიზაინში. კარგი კოდია, როდესაც ალგორითმი წარმოდგენილია ურთიერთქმედების ობიექტებით და არა სწორი კონსტრუქციების თანმიმდევრობით.

თუ იყენებთ ობიექტების მასივებს, მანიპულირებთ სტეკის იდეით და მასივის ბოლო (პირველი) ელემენტით, შეგიძლიათ მიიღოთ დინამიკა: თავად ობიექტები „წყვეტენ“ როგორ უნდა იმუშაოს საიტის ფუნქციონირება არსებული სიტუაციიდან გამომდინარე. .

PHP-ში სახელთა სივრცე არის სპეციალური სახის ცვლადი, რომელიც წარმოდგენილია თავისი უნიკალური სახელით, ხშირად რთული. კოდში გამოყენებულია სახელთა სივრცის სახელი. თუ ეს არის სტრიქონი, მაშინ შეგიძლიათ შეცვალოთ ერთი სივრცე მეორეთი სკრიპტის შესრულებისას.

თუ PHP იყენებს სახელთა სივრცის სახელებს, როგორც ცვლადის მნიშვნელობებს, მაშინ ეს კიდევ უფრო სემანტიკურად დატვირთული სინტაქსია, უფრო ძლიერი ვიდრე ობიექტების მასივები.

ობიექტი არის სტრუქტურა და შინაარსი, რომელიც ხასიათდება ერთიანობით. სახელთა სივრცე არის ობიექტების, ელემენტების და მათ შორის ურთიერთობების ერთობლიობა.

შეუძლებელია ექსპერიმენტების ჩატარება გაშვებულ სისტემაზე, მაგრამ სახელთა სივრცის წყალობით, PHP იძლევა შესაძლებლობას მოახდინოს რეალური გაშვებული სისტემის სიმულაცია განსხვავებულ სივრცეში მიზნებისთვის:

• შემდგომი განვითარება;
• ტესტირება;
• მოვლა და ა.შ.

თუ PHP-ის დეველოპერების მიერ შემოთავაზებული სინტაქსის აბსტრაციას შევუდგებით და წარმოვიდგენთ სახელთა სივრცეებს, როგორც ობიექტების გლობალურ კომპლექსურ სისტემებს, მაშინ შესაძლებლობების ჰორიზონტები მრავალჯერ ფართოვდება.

სახელთა სივრცის სინტაქსი და გამოყენება

PHP იღებს მხოლოდ სიტყვას სახელთა სივრცეში კოდის პირველ სტრიქონში თითოეულ ფაილში. ყველა აღწერილობა უნდა დაიცვას მხოლოდ მას. სინტაქსი მოიცავს მხოლოდ სახელს, რომელიც აღინიშნება სახელის ჩვეულებრივი გაგებით.

მნიშვნელოვანია გამოიყენოთ სწორი სიტყვები, რომლებიც გადმოსცემენ მნიშვნელობას. უმჯობესია, როდესაც სახელი გრძელია, მაგრამ შეიცავს რაღაცას, რაც ნათლად აცნობიერებს რა სივრცეზე ვსაუბრობთ, რას აკეთებს, რას აღწერს, რას იღებს ან რისთვის შეიქმნა.

სივრცეები შეიძლება განუსაზღვრელი ვადით იყოს ბუდებული, მაგრამ ეს არ უნდა იყოს ზედმეტი. სახელი უნდა იყოს მკაფიო, ბუდე უნდა იყოს გამართლებული და სივრცის სახელების თანმიმდევრობას უნდა ჰქონდეს ლოგიკა.

გამოყენებისა და სახელების სივრცის აპლიკაციებში, PHP იძლევა კომპლექსური კოდირების საშუალებას, მაგრამ როდესაც ეს შესაძლებელია, უმჯობესია გამოიყენოთ მარტივი ვარიანტი.

ზოგადი წესია: სახელთა სივრცე არის აღწერა და ეს არის ერთი ფაილი, გამოყენება არის სივრცის იმპორტი გამოყენების სკრიპტში და მასზე მეტსახელის (მოკლე ბმული) მინიჭება.

კლასების (ობიექტების) ავტომატური ჩატვირთვის მარტივი მაგალითი

ამოცანა შეიცავს ობიექტს სტრიქონების მანიპულირებისთვის, გვერდის ელემენტების სტილებით (CSS აღწერილობები), თარიღის ობიექტს, ფაილური სისტემის ობიექტს და მონაცემთა ბაზის ობიექტს. განხორციელების მიზანია ამ ხუთი პოზიციისთვის მარტივი ინტერფეისების შექმნა, რათა გამოიყენოს საჭირო შესაძლებლობები მხოლოდ ამ ობიექტების მეთოდებით.

დაუშვებელია ენობრივი ფუნქციებისა და კონსტრუქციების პირდაპირი გამოყენება. ეს ამოცანა იყენებს PHP კლასის ავტომატურ ჩატვირთვას. სახელთა სივრცე განიხილება, როგორც ფაილური სისტემის კონკრეტულ ადგილას მდებარე ობიექტების კოლექცია. როგორც წესი, ყველა ობიექტი განლაგებულია ფაილურ სისტემაში მათი მნიშვნელობის მიხედვით, საქაღალდეებში და ფაილებში კონკრეტული სახელით.

მარცხნივ კოდი მიუთითებს საჭირო ხუთი ობიექტის შექმნაზე, მაგრამ ზუსტად სად მდებარეობს ისინი არ არის მითითებული. კოდი მარჯვნივ გვიჩვენებს ავტოჩამტვირთველის (მთავარი სკრიპტის) ტექსტს, რომელიც კლასების (ობიექტების) ჩატვირთვისას ავტომატურად ანაცვლებს საჭირო გზას ობიექტის ადგილმდებარეობისა და .php ფაილის გაფართოებისკენ.

მრავალი სახელთა სივრცის მაგალითი

PhpOffice/PhpWord ბიბლიოთეკა კარგი მაგალითია მრავალი სახელთა სივრცის რთული იერარქიის გამოყენებისათვის. ელემენტების საქაღალდე შეიცავს ელემენტების თითქმის მთელ დიაპაზონს, რომელიც ხელმისაწვდომია *.docx დოკუმენტის (MS Word) შექმნისას, სხვა საქაღალდეები შეიცავს ელემენტებთან, აბზაცებთან და ცხრილებთან მუშაობის აუცილებელ ინსტრუმენტებს.

სინამდვილეში, ბიბლიოთეკა განთავსდა პროექტის საქაღალდეში იმ მიზეზით, რომ PhpOffice / PhpWord ფუნქციონალური სივრცის დამატება სჭირდებოდა კონკრეტული ხელსაწყოებით და საბოლოოდ შექმნათ მსგავსი პროდუქტის საკუთარი ვერსია.

იტვირთება სხვადასხვა სახელების სივრცის მრავალი კლასი

PHP სახელთა სივრცის ავტომატური დატვირთვის გამოყენება, როდესაც საჭიროა მრავალი კლასის ჩატვირთვა, ხოლო ობიექტების განვითარებული სისტემის იერარქია საკმაოდ რთული და ძნელი წარმოსადგენია, იწვევს ხისტი სტრუქტურების შექმნის აუცილებლობას.

დეველოპერის ორიენტაცია (რომელიც იყენებს პროდუქტს მუშაობის გასაგრძელებლად) შესაძლებელია მხოლოდ სემანტიკის კონტექსტში (პროექტის გაგება), რომელიც წარმოდგენილია სიტყვების შესაბამისი კომბინაციებით, რომლებიც ასახავს ობიექტების რეალურ მნიშვნელობას და ურთიერთობებს.

ბიბლიოთეკის ინდივიდუალურ პროექტში გამოყენების აუცილებლობა იწვევს პრობლემის გადაჭრას, თუ როგორ გავაერთიანოთ დეველოპერი და PhpOffice / PhpWord ავტორის სახელების სივრცეები. საუკეთესო გზაა ამ პროდუქტის (მისი სივრცეები და ობიექტები) განთავსება საკუთარ საპროექტო სივრცეში.

მნიშვნელოვანია აღინიშნოს, რომ შეუძლებელი იქნება ამ პროდუქტის სახელთა სივრცის შეცვლის გარეშე მისი აბსტრაქტული ელემენტებისა და კლასის დატვირთვის დონეზე. ეს მიუთითებს იმაზე, რომ PHP სახელთა სივრცეში შიდა სახელთა სივრცის გამოყენება შეიძლება არ იყოს საკმარისად აბსტრაქტული და უნივერსალური.

ფაილური სისტემა და სივრცის ლოკალიზაცია

არსებითად, სახელთა სივრცეები წარმოადგენს ფაილურ სისტემაში გზის „მოხაზულობას“ სასურველ ობიექტამდე. ფაილის სახელების გამოყენება ობიექტების სახელებად ბუნებრივი და გავრცელებულია. საქაღალდის სახელების გამოყენება სახელთა სივრცის დასახელებისთვის ობიექტურია.

ინფორმაციის "ხის" ორგანიზაცია საკმაოდ შრომატევადია გამოსაყენებლად და ართულებს განვითარებას, მაგრამ ეს არის ბუნებრივი წარმოდგენა ობიექტების სისტემებისთვის.

პრობლემა ის არის, რომ განვითარების ეტაპი წარმოდგენილია სპეციფიკური კოდის რედაქტორით, რომელიც აერთიანებს როგორც საქაღალდეების ხილულ წარმოდგენას, ასევე კონკრეტული საქაღალდის შიგთავსს, მაგრამ ჯერ არ არსებობს რედაქტორი, რომელიც უზრუნველყოფს ბოლომდე გადაადგილებას ობიექტების და მეშვეობით. საქაღალდეები.

აბსტრაქტულობის და უნივერსალურობის პრობლემა

მიღებულია დეველოპერის ცნობიერებისა და მიზნის მიერ რეალურად:

• უზრუნველყოფს აბსტრაქციას და ინფორმაციის მანიპულირების უნარს მისი რეალური სემანტიკის მიხედვით;
• სახელთა სივრცეები ასახავს სკრიპტების, ობიექტების პოზიციას და ნაწილობრივ პროექტის მნიშვნელობას ფაილურ სისტემაში

სინამდვილეში, OOP აბსტრაქციის მიერ ობიექტების სახელებთან (ფაილებთან) დაკავშირებით და ფაილურ სისტემაზე (საქაღალდეებზე) გადაფარვით სახელთა სივრცის ადეკვატური ფორმირებით (ბილიკები + სახელები), შეგიძლიათ აკონტროლოთ სახელთა სივრცის ფორმირება სკრიპტის შესრულების დროს.

პროგრამირებამ უკვე შეიძინა განვითარების მძლავრი დინამიკა, მაგრამ თუ გადავიტანთ განვითარების ეტაპის პროცესს და დატვირთვას ტექსტის რედაქტორიდან (რომელშიც იქმნება სკრიპტები და მოთავსებულია საქაღალდეების ხეებში) კოდის გენერირების იდეაზე. საშუალებას აძლევს საკუთარ თავს გაუმჯობესდეს და განთავსდეს ფაილურ სისტემაში სწორ ადგილას - პროგრამირება ახალ სიმაღლეებზე აიწევს.

მე ცოტა ხნის წინ ჩავყარე ჩემი პროექტი სახელთა სივრცეში და წავაწყდი სათანადო დოკუმენტაციის არარსებობის პრობლემას. ყველაფერი, რისი პოვნაც მოვახერხეთ, თარიღდება დაახლოებით 2009 წლით, და ეს თითქმის 2012 წლითაა... ნაპოვნი მასალაში არის უამრავი არასამუშაო ადგილი, რომელიც იყენებს იმას, რაც არ არის php-ის მიმდინარე ვერსიაში. ამასთან დაკავშირებით, მსურს ამ საკითხს გარკვეული სინათლე მოჰფინოს.
მაშ, რა არის სახელთა სივრცე ან სახელთა სივრცე? დიდი ვიკიპედია მათ ასე განსაზღვრავს:

სახელთა სივრცე არის ნაკრები, რაც ნიშნავს მოდელს, აბსტრაქტულ საცავს ან გარემოს, რომელიც შექმნილ იქნა უნიკალური იდენტიფიკატორების (ანუ სახელების) ლოგიკური დაჯგუფებისთვის. სახელთა სივრცეში განსაზღვრული იდენტიფიკატორი ასოცირდება ამ სახელთა სივრცესთან. ერთი და იგივე იდენტიფიკატორი შეიძლება დამოუკიდებლად განისაზღვროს მრავალ სივრცეში. ამრიგად, ერთ სახელთა სივრცეში განსაზღვრულ იდენტიფიკატორთან ასოცირებულ მნიშვნელობას შეიძლება (ან შეიძლება არ ჰქონდეს) იგივე (ან უფრო სწორად განსხვავებული) მნიშვნელობა, რაც იგივე იდენტიფიკატორს, რომელიც განსაზღვრულია სხვა სახელთა სივრცეში. სახელთა სივრცის მცოდნე ენები განსაზღვრავენ წესებს, რომლებიც მიუთითებენ რომელ სახელთა სივრცეს ეკუთვნის იდენტიფიკატორი (ანუ მისი განმარტება).wiki

Ყველაფერი გასაგებია? სინამდვილეში მარტივია. 5.3 ვერსიამდე php-ში მხოლოდ ორი სივრცე იყო - გლობალური (რომელშიც თქვენი მთავარი კოდი იყო შესრულებული) და ლოკალური (რომელშიც იყო განსაზღვრული ფუნქციის ცვლადები).

5.3 ვერსიის შემდეგ ყველაფერი შეიცვალა. ახლა თქვენ შეგიძლიათ განსაზღვროთ თქვენი სახელების სივრცე, რომელშიც იარსებებს თქვენი კლასები, მეთოდები და ა.შ.


იმედია ცოტა უფრო ნათელი გახდა.

მე კონკრეტულად იგივე დავასახელე კლასები. ვინაიდან ისინი განსაზღვრულია სხვადასხვა სივრცეში, ისინი ორი განსხვავებული კლასია, მიუხედავად ერთი და იგივე სახელებისა. მთავარი სკრიპტი კვლავ ფუნქციონირებს გლობალურ სივრცეში, აქ არაფერი შეცვლილა და მასში კლასები და ფუნქციები ჯერ კიდევ შეიძლება განისაზღვროს. მაშინ რისთვის არის სივრცეები? უპირველეს ყოვლისა, დარწმუნდით, რომ როდესაც თქვენ აერთიანებთ ფაილს რაიმე ჩარჩოს ან ბიბლიოთეკაში, თქვენი კლასები არ გადალახავს ჩარჩოს კლასებს ან პირიქით.

იმისათვის, რომ გამოიყენოთ კლასები, რომლებიც განსაზღვრულია თქვენს სახელთა სივრცეში, თქვენ უნდა შემოიტანოთ თქვენს მიერ განსაზღვრული სივრცე გლობალურ სივრცეში სწორ ადგილას (მე ჩვეულებრივ მირჩევნია ამის გაკეთება ფაილის დასაწყისში, ამისათვის გამოიყენეთ საკვანძო სიტყვა).

ყურადღება:რატომღაც php არ იძლევა საკვანძო სიტყვის გამოყენებას გამოყენებამდგომარეობაში ბლოკები და მარყუჟები

ავიღოთ მაგალითი სურათებიდან და განვახორციელოთ კოდით:

ყურადღება:სახელთა სივრცის საკვანძო სიტყვა უნდა განთავსდეს ფაილის დასაწყისშივე, ამის შემდეგ
ფაილი A.php
B.php ფაილი
შესაძლებელია ალტერნატიული სინტაქსი:
რეკომენდირებულია თითოეული სახელთა სივრცის ცალკე ფაილში გამოცხადება. მიუხედავად იმისა, რომ ეს შესაძლებელია ერთში, მკაცრად არ არის რეკომენდებული!
ახლა გადავიდეთ მესამე ფაილზე, რომელშიც ჩვენი მთავარი სკრიპტი იმუშავებს
index.php
როგორც ჩანს, ეს უპირატესობაა, მხოლოდ მეტი კოდია დამატებული, მაგრამ ეს მთლად ასე არ არის, ცოტა შემდგომ მე მივცემ ავტოჩატვირთვის კლასის მაგალითს, რომლითაც კლასებთან ფაილების დამაკავშირებელი ხაზები ზედმეტი იქნება.
ახლა მოდით გადავხედოთ ჩვენს კლასებს.

ყურადღება:მასშტაბის გარჩევადობის ოპერატორის (::) გამოყენებით php სახელთა სივრცეებში არაა ნებადართული! ერთადერთი, რისთვისაც ის შესაფერისია, არის სტატიკური კლასის მეთოდებსა და მუდმივებზე წვდომა. თავიდან მათ სურდათ მისი გამოყენება სახელთა სივრცისთვის, მაგრამ შემდეგ მათ წინააღმდეგობა გადაწყვიტეს წარმოქმნილი პრობლემების გამო. მაშასადამე, ისეთი კონსტრუქცია, როგორიცაა A::A::say(); არასწორია და გამოიწვევს შეცდომას.

სახელთა სივრცისთვის, თქვენ უნდა გამოიყენოთ უკანა ხაზის სიმბოლო "\"

ყურადღება:გაუგებრობების თავიდან ასაცილებლად, აუცილებელია ამ სიმბოლოს გაქცევა სტრიქონებში გამოყენებისას: "\\"

სახელთა სივრცეები შეიძლება იყოს ჩასმული ერთმანეთში, მოდით დავამატოთ ჩვენს A.php ფაილს:
და ინდექსში ჩავწერთ შემდეგს:

მნიშვნელოვანი პუნქტია იმპორტირებული ფართებისთვის მეტსახელების გამოყენება. შეგიძლიათ დაწეროთ A\subA::say(); დამეთანხმებით, რომ ძნელია ყოველ ჯერზე სივრცის სრული ბილიკების დაწერა ამის თავიდან ასაცილებლად, შემოღებულ იქნა მეტსახელები. კომპილაციისას მოხდება შემდეგი: მეტსახელის sub-ის ნაცვლად შეიცვლება A\subA, ამიტომ მივიღებთ გამოძახებას A\subA::say();

რა ხდება მაშინ გლობალურ სივრცეში განსაზღვრული ფუნქციების გამოძახებისას? PHP ჯერ ეძებს ფუნქციას იმ სივრცეში, სადაც ამჟამად მუშაობთ და თუ ვერ პოულობს, გადადის გლობალურ ასპექტში. იმისათვის, რომ დაუყოვნებლივ მიუთითოთ, რომ იყენებთ გლობალურ ფუნქციას, წინ უნდა უძღოდეთ მას უკანა ხაზით.

იმისათვის, რომ თავიდან ავიცილოთ პრობლემები სივრცეებიდან კლასების ავტომატური ჩატვირთვასთან დაკავშირებით, ფაილური სისტემა უნდა იყოს ორგანიზებული სივრცეების ორგანიზების მსგავსად. მაგალითად, ჩვენ გვაქვს root საქაღალდის კლასები, სადაც შეინახება ჩვენი კლასები, შემდეგ ჩვენი სივრცეები შეიძლება დალაგდეს შემდეგნაირად.
კლასები\A\A.php
classes\A\sub\A.php (ქვესივრცე განთავსდება ცალკე ფაილში)
კლასები\B\B.php

PHP-ს აქვს ჯადოსნური მუდმივი __NAMESPACE__, რომელიც შეიცავს მიმდინარე სივრცის სახელს.

ახლა კი ავტომატური ჩატვირთვის შესახებ.

ქვემოთ მოყვანილი კლასი ჩემი არ არის, უბრალოდ დავამუშავე და ცოტა გავაუმჯობესე, აქედან აღებული.

ყურადღება:იმისათვის, რომ თქვენი კლასები ჩაიტვირთოს, კლასის სახელი უნდა შეესაბამებოდეს ფაილის სახელს!

" .$ფაილი." in " .$filepath)); if (file_exists($filepath)) (if(Autoloader::debug) Autoloader::StPutFile(("დაკავშირებული" .$filepath)); $flag = FALSE; require_once($filepath); break ) Autoloader::recursive_autoload($file, $path2, &$flag ) ) closeir($handle ) private static ფუნქცია 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)); flock ($file, LOCK_UN); fclose ($file); ) ) \spl_autoload_register("yourNameSpace\Autoloader::autoload"); )
თუ გადახედავთ იმ კლასების სახელებს, რომლებიც შემოდის ჩატვირთვისთვის, ნახავთ, რომ თითოეულ კლასს წინ უძღვის პრეფიქსი სახელთა სივრციდან, რომელიც მითითებულია გამოყენებაში. ამიტომ გირჩევთ გამოიყენოთ ფაილების ადგილმდებარეობა სახელთა სივრცის მსგავს კატალოგებში, რაც აჩქარებს ძიებას ერთ ან ორ გამეორებამდე.

ახლა ჩვენი ინდექსი შეიძლება დაიწეროს ასე:
ახლა ყველა კლასი და ინტერფეისი, რომელსაც გამოიყენებთ, ავტომატურად იტვირთება.

ენის ზოგიერთი დინამიური შესაძლებლობების საჩვენებლად სივრცეებით, მოდით გამოვაცხადოთ სხვა კლასი:
test.php

ინდექსი.php
sayName ("ტესტი"); //ან შეგიძლიათ გააკეთოთ ეს ტესტი\sayName("test2"); //ან ასე $obj::sayName("ტესტი"); //ან შეგიძლიათ გააკეთოთ ეს ტესტი::sayName("test2");

იმედი მაქვს, რომ ჩემი სტატია ვინმესთვის სასარგებლო იქნება.

გამარჯობა. დღევანდელ სტატიაში განვიხილავთ, რა არის სახელთა სივრცეები PHP-ში.

თუ დიდი ხანია იყენებთ OOP, მაშინ თქვენ ალბათ შეგხვედრიათ სიტუაცია, როდესაც მესამე მხარის ბიბლიოთეკის დაკავშირებისას თქვენ განიცადეთ წარუმატებლობა იმის გამო, რომ თქვენ უკვე იყენებთ იმავე კლასის სახელებს თქვენს კოდში, როგორც ბიბლიოთეკაში. ეს განსაკუთრებით შეიძლება მოხდეს, თუ იყენებთ ჩვეულებრივ სახელებს, როგორიცაა "მოდელი", "დბ"და ასე შემდეგ. მე გეტყვით ახლა როგორ გამოვასწოროთ ეს.

სახელთა სივრცე- ეს არის ერთგვარი საცავი, რომელიც შექმნილია უნიკალური იდენტიფიკატორების (სახელების) აბსტრაქტული დაჯგუფებისთვის.

იმათ. თუ იყენებთ სახელთა სივრცეები, მაშინ შეგიძლიათ უსაფრთხოდ დააკავშიროთ მესამე მხარის ბიბლიოთეკები და არ შეგეშინდეთ, რომ მათ ექნებათ იგივე სახელები, როგორც თქვენს კოდში. დავასრულოთ თეორია და გადავიდეთ პრაქტიკაზე.

მოდით შევქმნათ ფაილი myclass.phpამ შინაარსით

სახელთა სივრცე my\oneProject;
კლასი MyClass ( )
?>

აქ ჩვენ შევქმენით კლასი სახელთა სივრცეში ჩემი\ერთიპროექტი. სხვათა შორის, თქვენ უნდა დაწეროთ ზუსტად უკანა ხაზი. არ დაიბნეთ!

ახლა ფაილში index.phpდავწეროთ შემდეგი

require_once ("myclass.php");
$mc = new MyClass(); // შეცდომა: კლასი ვერ მოიძებნა
$mc = new my\oneProject\MyClass(); // ყველაფერი მუშაობს
?>

როგორც ხედავთ, ახლა შეუძლებელია კლასის შექმნა ასე, თქვენ უნდა მიუთითოთ რომელში სახელთა სივრცეის წევს.

შეგვიძლია ერთდროულად რამდენიმე დავასახელოთ სახელთა სივრცეებიერთ ფაილში

სახელთა სივრცის პროექტი;

Const CONNECT_OK = 1;
კლასის კავშირი ( )
ფუნქცია Connect() ()

NamespaceAnotherProject;

Const CONNECT_OK = 1;
კლასის კავშირი ( )
ფუნქცია Connect() ()
?>

მიუხედავად იმისა, რომ ჩვენ გვაქვს კლასების, ფუნქციების და მუდმივების აბსოლუტურად იდენტური სახელები, სახელების კონფლიქტი არ გვექნება, რადგან ისინი სხვადასხვა სივრცეში წევენ.

ჩვენ ასევე შეგვიძლია გამოვიყენოთ ბრეკეტის სინტაქსი.

სახელთა სივრცის პროექტი (

Const CONNECT_OK = 1;
კლასის კავშირი ( )
ფუნქცია Connect() ()
}

სახელთა სივრცე AnotherProject (

Const CONNECT_OK = 1;
კლასის კავშირი ( )
ფუნქცია Connect() ()
}
?>

თუ კოდს აერთიანებთ გლობალური სახელების სივრცეკოდით სხვა სივრცეებში, მაშინ გამოიყენება მხოლოდ სინტაქსი ფრჩხილებით.

სახელთა სივრცის პროექტი (

Const CONNECT_OK = 1;
კლასის კავშირი ( )
ფუნქცია Connect() ()
}

სახელთა სივრცე (// გლობალური კოდი
session_start();
$a = პროექტი\დაკავშირება();
echo Project\Connection::start();
}
?>

ასევე, არ დაგავიწყდეთ, რომ სახელთა სივრცის განსაზღვრა ყოველთვის უნდა იყოს კოდის პირველი ხაზი. თუ ასე დაწერ, შეცდომა იქნება

იმის გასარკვევად, რომელ სახელთა სივრცეში იმყოფებით ამჟამად, შეგიძლიათ გამოიყენოთ მუდმივი __NAMESPACE__

სახელთა სივრცის პროექტი;
ექო """, __NAMESPACE__, """; // დაბეჭდავს "პროექტს"
?>

ამ მუდმივის გამოყენებით, შეგიძლიათ, მაგალითად, დინამიურად ააწყოთ სახელები

სახელთა სივრცის პროექტი;

ფუნქცია incl($classname) (
$a = __NAMESPACE__ . "\\". $classname;
დააბრუნეთ ახალი $a;
}
?>

ასე რომ დღეისთვის სულ ესაა. კურსის გავლისას შეგიძლიათ მიიღოთ მეტი ინფორმაცია და პრაქტიკული ცოდნა