Php7 - PHP: გლობალური ფუნქციის შიგნით არ აჩვენებს ცვლადს - Stack Overflow რუსულად. PHP ცვლადების ფარგლები. ყველაფერი, რაც გინდოდათ იცოდეთ, მაგრამ გეშინოდათ ფუნქციის გარეთ გლობალური php ცვლადის ამობეჭდვა

ბოლო განახლება: 11/1/2015

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

ლოკალური ცვლადები

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

ამ შემთხვევაში, get() ფუნქცია განსაზღვრავს ლოკალურ ცვლადს $result . და ზოგადი კონტექსტიდან მასზე წვდომა არ შეგვიძლია, ანუ დავწეროთ $a = $result; ეს შეუძლებელია, რადგან $result ცვლადის ფარგლები შემოიფარგლება get() ფუნქციით. ამ ფუნქციის გარეთ $result ცვლადი არ არსებობს.

იგივე ეხება ფუნქციის პარამეტრებს: ფუნქციის გარეთ, $lowlimit და $highlimit პარამეტრები ასევე არ არსებობს.

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

სტატიკური ცვლადები

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

იმის საჩვენებლად, რომ ცვლადი სტატიკური იქნება, მას ემატება საკვანძო სიტყვა static. სამი ზედიზედ სამი ზარით getCounter(), $counter ცვლადი გაიზრდება ერთით.

თუ $counter ცვლადი იყო ჩვეულებრივი არასტატიკური ცვლადი, მაშინ getCounter() დაბეჭდავს 1-ს ყოველ ჯერზე, როცა გამოიძახება.

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

გლობალური ცვლადები

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

"; ) getGlobal(); echo $gvar; ?>

getGlobal() ფუნქციის გამოძახების შემდეგ $gvar ცვლადის წვდომა შესაძლებელია პროგრამის ნებისმიერი ნაწილიდან.

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

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

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

პირობითი ფუნქციები

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

//ფუნქციას ეძახიან sayHi, მისი გამოძახება შესაძლებელია სადმე /*sayGoodbye ფუნქციის გამოძახება შეუძლებელია, რადგან ჩვენ ჯერ არ შეგვიმოწმებია მდგომარეობა და არ შევსულვართ if კონსტრუქციის შიგნით*/ if($apply)( ფუნქცია sayGoodbye())(echo "მშვიდობით ყველას!
"; } } /*ახლა შეგვიძლია ვუწოდოთ Say Goodbye*/
"; }

შედეგი:

და შეხედეთ ამ მაგალითს:

/*და აი რა მოხდება, თუ აქ დარეკე მშვიდობით*/თქვი ნახვამდის(); if($apply)( ფუნქცია sayGoodbye())(echo "მშვიდობით ყველას!
"; ) ) ფუნქცია sayHi())(echo "გამარჯობა ყველას!
"; }

შედეგი:

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

ჩადგმული ფუნქციები

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

/*აქ არ შეგიძლიათ დარეკოთ sayGoodbye, რადგან ის გამოჩნდება მხოლოდ sayHi ფუნქციის გამოძახების შემდეგ*/ sayHi(); /*გამოიძახეთ ფუნქცია sayHi, მისი გამოძახება შესაძლებელია სადმე*/ /*ახლა შეგვიძლია ვუწოდოთ Say Goodbye*/თქვი ნახვამდის(); ფუნქცია sayHi()) (echo "გამარჯობა ყველას!
"; ფუნქცია say Goodbye())(echo "მშვიდობით ყველას!
"; } }

ისევ, პირველ გადაკვეთაზე, PHP თარჯიმანი აღნიშნავს, რომ მან იპოვა sayHi ფუნქციის აღწერა, მაგრამ არ შედის მის სხეულში, ხედავს მხოლოდ სახელს, და რადგან თარჯიმანი არ შედის sayHi სხეულის შიგნით, მაშინ მას წარმოდგენა არ აქვს, რას განვსაზღვრავთ სხვა ფუნქციის შიგნით - say Goodbye.

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

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

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

ცვლადი ფარგლები

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

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

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

ძვირფასო ექსპერტებო, ყურადღება, შეკითხვა! რა გამოვა ბოლო ინსტრუქცია? ექო $სახელი; ?

როგორც თავად ნახე, ჩვენ გვქონდა 2 ცვლადი $name, ერთი ფუნქციის შიგნით (ლოკალური მასშტაბი), მეორე მხოლოდ კოდში (გლობალური მასშტაბი), ბოლო მინიჭება ცვლადზე $nameიყო $name = "რუდ სერგეი";მაგრამ რადგან ის ფუნქციის შიგნით იყო, იქ დარჩა. გლობალური მასშტაბით, ბოლო დავალება იყო $name = "ანდრეი";რასაც ჩვენ რეალურად ვხედავთ შედეგად.

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

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

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

გლობალურ ცვლადებზე წვდომა ადგილობრივი მასშტაბიდან

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

"; გლობალური $name; /*ამიერიდან ჩვენ ვგულისხმობთ გლობალურ ცვლადს $name*/$name = "რუდ სერგეი"; ) $name = "ანდრეი"; sayHi ($name); ექო $სახელი; //?

შედეგი:

მაგრამ ამ მეთოდს აქვს მინუსი, რადგან ჩვენ მივიღეთ გლობალური ცვლადი $nameჩვენ დავკარგეთ (გადაწერა) ლოკალური ცვლადი $name.

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

$name = "ანდრეი"; //Იგივე რაც$GLOBALS["name"] = "ანდრეი";

აქედან გამომდინარე:

"; $GLOBALS["name"] = "Rud Sergey"; ) $name = "ანდრეი"; sayHi($name); echo $name; // ?

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

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

არგუმენტების გადაცემა მითითებით

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

ასე რომ, არგუმენტის სწორი გადაცემა მითითებით PHP 5.3 და უფრო მაღალ ვერსიებში ხდება შემდეგნაირად:

ფუნქცია sayHi(& $name)(

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

და ბოლოს გვაქვს:

//მიიღეთ არა მნიშვნელობა, არამედ მითითება მნიშვნელობაზეექო "გამარჯობა, ".$name."!
"; $name = "რუდ სერგეი"; ) $name = "ანდრეი"; sayHi($name); echo $name; // ?

შედეგი:

სტატიკური ცვლადები

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

$c++; // მრიცხველის გაზრდა 1-ით

შედეგი:

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

// მრიცხველი, დამზადებულია სტატიკურიექო "გამარჯობა, ".$name."!
$c++; // მრიცხველის გაზრდა 1-ითექო "უბრალოდ გამარჯობა თქვა". $c. "ერთხელ.

"; ) sayHi ("რუდ სერგეი"); sayHi ("ანდრეი"); sayHi ("დიმიტრი");

შედეგი:

ღირებულებების დაბრუნება

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

შედეგი:

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

შედეგი:

ახლა ჩვენ შეგვიძლია გამოვიყენოთ ეს სხვადასხვა გზით:

//გამოიყვანს შედეგსექო"
"; $num = getSquare(5); echo $num;

შედეგი:

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

echo "PHP არასოდეს მომწვდება:(";) echo getSquare(5); //გამოიყვანს შედეგსექო"
$num = getSquare(5); // შედეგი მიანიჭა ცვლადსექო $num; // ცვლადის ჩვენება ეკრანზე

შედეგი:

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

რეკურსიული ფუნქცია

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

"; თუ ($number< 20){ // რათა რეკურსია გაუთავებელი არ გახდეს countPlease(++$number); // countPlease ფუნქციამ გამოიძახა თავი) ) count გთხოვთ(1);

შედეგი:

თუ იცით როგორ გააკეთოთ რეკურსიის გარეშე, მაშინ უმჯობესია ამის გაკეთება.

ძლიერი აკრეფა PHP-ში (ტიპის დახვეწა)

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

შედეგი:

საბედისწერო შეცდომა: არგუმენტი 1 გადაცემულია countPlease()-ში

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

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

მას უწოდებენ getEcho ფუნქციას

ცვლადი სიგრძის არგუმენტების გამოყენება

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

შედეგი:

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

func_num_args()- აბრუნებს ფუნქციაზე გადაცემული არგუმენტების რაოდენობას
func_get_arg (მიმდევრობის ნომერი)- აბრუნებს ელემენტს არგუმენტების სიიდან
func_get_args()- აბრუნებს მასივს, რომელიც შეიცავს ფუნქციის არგუმენტებს

"; echo func_get_arg(0) ;) $age = 22; getEcho("Rud Sergey", $age);

შედეგი:

დასკვნა

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

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

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

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

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

რა არის ფარგლები?

ცვლადების ფარგლები არის კონტექსტი, რომლის ფარგლებშიც განისაზღვრა ცვლადი და სადაც შესაძლებელია მასზე წვდომა. PHP-ს აქვს ორი ცვლადი სფერო:

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

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

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

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

"; ) sayHello(); echo "\$globalName-ის მნიშვნელობა: "$globalName"
"; echo "\$localName მნიშვნელობა: "$localName"
"; ?>

გამარჯობა ჰარი! $globalName ღირებულება: "Zoe" $localName ღირებულება: ""

ამ სკრიპტში ჩვენ შევქმენით ორი ცვლადი:

  • $globalName- ეს გლობალურიცვლადი
  • $localName- ეს ადგილობრივიცვლადი, რომელიც იქმნება sayHello() ფუნქციის შიგნით.

ცვლადის და ფუნქციის შექმნის შემდეგ სკრიპტი იძახებს sayHello(), რომელიც იბეჭდება "Hello Harry!" . შემდეგ სკრიპტი ცდილობს გამოიყვანოს ორი ცვლადის მნიშვნელობები ექოს ფუნქციის გამოყენებით. აი რა ხდება:

  • იმიტომ რომ $globalNameშეიქმნა ფუნქციის გარეთ, ის ხელმისაწვდომია სკრიპტის ნებისმიერ ადგილას, ამიტომ გამოდის "Zoe".
  • $localNameხელმისაწვდომი იქნება მხოლოდ sayHello() ფუნქციის შიგნით. ვინაიდან ექო გამონათქვამი ფუნქციის მიღმაა, PHP არ იძლევა ადგილობრივ ცვლადზე წვდომას. ამის ნაცვლად, PHP მოელის, რომ კოდი შექმნის ახალ ცვლადს სახელად $localName, რომელსაც ექნება ცარიელი სტრიქონის ნაგულისხმევი მნიშვნელობა. ამიტომ მეორე ზარი echo-ზე გამოაქვს მნიშვნელობა "" $localName ცვლადისთვის.

ფუნქციის შიგნით გლობალურ ცვლადებზე წვდომა

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

ფუნქცია myFunction() ( გლობალური $globalVariable; // გლობალური ცვლადის $globalVariable წვდომა)

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

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

"; გლობალური $globalName; echo "გამარჯობა $globalName!
";) sayHello(); ?>

როდესაც შესრულდება, სკრიპტი გამოვა:

გამარჯობა ჰარი! გამარჯობა ზოია!

sayHello() ფუნქცია იყენებს გლობალურ საკვანძო სიტყვას $globalName ცვლადის გლობალურად გამოსაცხადებლად. შემდეგ მას შეუძლია წვდომა ცვლადზე და გამოიტანოს მისი მნიშვნელობა (“Zoe”).

რა არის სუპერგლობალი?

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

აქ არის სუპერგლობალების სია, რომლებიც ხელმისაწვდომია PHP 5.3 ვერსიაში:

  • $GLOBALS - სკრიპტის ყველა გლობალური ცვლადის სია (სუპერგლობალურის გამოკლებით)
  • $_GET - შეიცავს ბრაუზერის მიერ წარდგენილი ფორმის ყველა ველის ჩამონათვალს GET მოთხოვნის გამოყენებით
  • $_POST - შეიცავს ბრაუზერის მიერ გაგზავნილი ყველა ფორმის ველის ჩამონათვალს POST მოთხოვნის გამოყენებით
  • $_COOKIE - შეიცავს ბრაუზერის მიერ გაგზავნილი ყველა ქუქიების ჩამონათვალს
  • $_REQUEST - შეიცავს ყველა გასაღების/მნიშვნელობის კომბინაციას, რომლებიც შეიცავს $_GET, $_POST, $_COOKIE მასივებს
  • $_FILES - შეიცავს ბრაუზერის მიერ გადმოწერილი ყველა ფაილის ჩამონათვალს
  • $_SESSION - გაძლევთ საშუალებას შეინახოთ და გამოიყენოთ სესიის ცვლადები მიმდინარე ბრაუზერისთვის
  • $_SERVER - შეიცავს ინფორმაციას სერვერის შესახებ, როგორიცაა შესრულებული სკრიპტის ფაილის სახელი და ბრაუზერის IP მისამართი.
  • $_ENV - შეიცავს PHP-ზე გადაცემული გარემოს ცვლადების სიას, როგორიცაა CGI ცვლადები.
მაგალითად, შეგიძლიათ გამოიყენოთ $_GET, რომ მიიღოთ სკრიპტის მოთხოვნის URL სტრიქონში ჩასმული ცვლადების მნიშვნელობები და აჩვენოთ ისინი გვერდზე:

თუ ზემოთ მოცემულ სკრიპტს გაუშვით URL-ის გამოყენებით http://www.example.com/script.php?yourName=Fred, ის გამოვა:

გამარჯობა ფრედ!

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

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

"; ) sayHello(); // ბეჭდავს "Hello, Zoya!" ?>

სტატიკური ცვლადები: ისინი სადღაც ირგვლივ არიან

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

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

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

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

ფუნქცია myFunction() ( სტატიკური $myVariable = 0; )

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


"; echo createWidget() ." ჩვენ უკვე შევქმენით.
"; echo createWidget() . " ჩვენ უკვე შევქმენით.>
"; ?>

მაგრამ, ვინაიდან $numWidgets ცვლადი იქმნება ყოველ ჯერზე ფუნქციის გამოძახებისას, მივიღებთ შემდეგ შედეგს:

ჩვენ ვქმნით რამდენიმე ვიჯეტს... ჩვენ უკვე შევქმენით 1. ჩვენ უკვე შევქმენით 1. ჩვენ უკვე შევქმენით 1.

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

"; echo createWidget() ." ჩვენ უკვე შევქმენით.
"; echo createWidget() ." ჩვენ უკვე შევქმენით.
"; echo createWidget() . " >ჩვენ უკვე შევქმენით.
"; ?>

ახლა სკრიპტი გამოიღებს მოსალოდნელ შედეგს:

ჩვენ ვქმნით რამდენიმე ვიჯეტს... ჩვენ უკვე შევქმენით 1. ჩვენ უკვე შევქმენით 2. ჩვენ უკვე შევქმენით 3.

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

Სულ ეს არის! გთხოვთ, ხშირად მიმართოთ თქვენს PHP დოკუმენტაციას.

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

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

მაშ რა პრობლემაა?

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

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

მაგალითი:

მოიცავს "file1.php"; ფუნქცია include2() (შეიცავს "file2.php"; )
  • file1.php განისაზღვრება გლობალური მასშტაბით.
  • file2.php განისაზღვრება include2 ფუნქციის ლოკალურ ასპექტში.

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

რატომ არის ცუდი მიდგომა გლობალური ცვლადებით?

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

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

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

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

იცით, რა არის საუკეთესო პრეფიქსი გლობალური ცვლადებისთვის?

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

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

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

ავხსნათ ეს ფაქტი კონკრეტული მაგალითით:

$a = 100 ;

ფუნქციის ფუნქცია() (
$a = 70;
ექო"

$a

" ;
}
ფუნქცია();
ექო"

$a

" ;
?>

სკრიპტი დაბეჭდავს ჯერ 70 და შემდეგ 100:

70
100

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

$a = 1;
$b = 2 ;

ფუნქცია ჯამი()
{
გლობალური $a, $b;

$b = $a + $b ;
}

ჯამი();
ექო $b ;
?>

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

გლობალური მასშტაბის ცვლადებზე წვდომის მეორე გზა არის სპეციალური PHP-ით განსაზღვრული მასივის გამოყენება $GLOBALS. წინა მაგალითი შეიძლება გადაიწეროს ასე:

გლობალურის ნაცვლად $GLOBALS-ის გამოყენება:

$a = 1;
$b = 2 ;

ფუნქცია ჯამი()
{
$GLOBALS [ "b" ] = $GLOBALS [ "a" ] + $GLOBALS [ "b" ];
}

ჯამი();
ექო $b ;
?>

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

ფუნქცია test_global()
{
// წინასწარ განსაზღვრული ცვლადების უმეტესობა არ არის
// "სუპერ" და ხელმისაწვდომი იყოს ადგილობრივ ტერიტორიაზე
// ფუნქციის ხილვადობა მოითხოვს "გლობალური" მითითებას.
გლობალური $HTTP_POST_VARS ;

ექო $HTTP_POST_VARS["სახელი"];

// სუპერგლობალი ხელმისაწვდომია ნებისმიერი მასშტაბით
// ხილვადობა და არ საჭიროებს "გლობალური" მითითებას.
// Superglobals ხელმისაწვდომია PHP 4.1.0-დან
echo $_POST ["სახელი"];
}
?>



დაკავშირებული პუბლიკაციები