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

როგორ შევქმნათ ცვლადი PHP– ში

თავდაპირველად, ცვლადები შეიცავს ნიშანს $ (დოლარი) - ცვლადის გამოყენების აღნიშვნა, შემდეგ ასოები ლათინური ანბანი(a– დან z– მდე და მცირე და დიდი), ბოლოს შეიძლება შეიცავდეს რიცხვები... ასევე, სახელს უფლება აქვს გამოიყენოს ხაზგასმა (არა ბოლომდე).

როგორ შეგიძლიათ დაასახელოთ ცვლადები:

$ var
$ ცვლადი
$ 1945 წელი
$ _ ცვალებადი
როგორ არ შეიძლება ცვლადების გამოძახება:

$ 1 - შედგება მხოლოდ ციფრისგან
$ 1 ვარი - თქვენ არ შეგიძლიათ დაიწყოთ ცვლადის სახელი ციფრებით
$ / var - დამატებითი ხაზების დაშვება შესაძლებელია მხოლოდ ქვედა ხაზზე _
$ ცვლადი - კირილიცას ნებადართულია php დოკუმენტაციით, მაგრამ არ არის რეკომენდებული
$ var iable - სივრცეების გამოყენება შეუძლებელია

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

$ city = "მოსკოვი"; // ცვლად $ ქალაქს მიენიჭა სიმებიანი (ბრჭყალებში) მნიშვნელობა მოსკოვი
$ წელი = 1147; // და $ year ცვლადს მიენიჭა რიცხვითი მნიშვნელობა 1147
?>

$ name = "ალექსანდრე";
$ Name = "ალექსეი";
ექო "$ name, $ Name"; // აჩვენებს "ალექსანდრე, ალექსეი"
?>

PHP ცვლადი გამომუშავება

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

// ასე ვანიჭებთ მნიშვნელობებს ცვლადებს
$ name1 = "ალექსეი";
$ name2 = "ალექსანდრე";

// ცვლადების ჩვენება
ექო $ name2; // გამომავალი: ალექსანდრე
ექო "name1 არის $ name1"; // სახელი 1 არის ალექსეი

// ერთჯერადი ბრჭყალების გამოყენებისას გამომავალი არის
// ცვლადის სახელი და არა მნიშვნელობა
ექო "name1 არის $ name1"; // ბეჭდავს: name1 არის $ name1

// თქვენ შეგიძლიათ უბრალოდ აჩვენოთ ცვლადების მნიშვნელობები
ექო $ name1; // ალექსეი
ექო $ name1, $ name2; // ალექსეი ალექსანდრე
ექო $ name1. "". $ name2; // ალექსეი ალექსანდრე
ექო "$ name1, $ name2"; // ალექსეი, ალექსანდრე

ექო<<ეს იყენებს სინტაქსს "აქ დოკუმენტი" გამოსასვლელად
მრავალი ხაზი $ ცვლადი ჩანაცვლებით.
ᲓᲐᲡᲐᲡᲠᲣᲚᲘ;

PHP ცვლადი ოპერაციები

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

- $ ა(უარყოფა) $ a ნიშნის შეცვლა.
$ a + $ b(დამატება) $ a და $ b თანხა.
$ a - $ b(გამოკლება) სხვაობა $ a და $ b შორის.
$ a * $ b(გამრავლება) $ a და $ b პროდუქტის.
$ a / $ b(გაყოფა) $ –ის კოეფიციენტი გაყოფილი $ b– ზე.
$ a% $ b(მოდული) მთელი $ დარჩენილი a a იყოფა $ b.
მოდით შევხედოთ მაგალითებს

$ a = 2; // შენიშვნა, რიცხვების შემთხვევაში ბრჭყალები არ გამოიყენება
$ b = 3; // შენიშვნა, რიცხვების შემთხვევაში ბრჭყალები არ გამოიყენება

$ შედეგი = $ a + $ b; // ცვლადების დამატება
ექო $ შედეგი; // დაბეჭდავს 5

$ შედეგი = $ b - $ a; // ცვლადების დამატება
ექო $ შედეგი; // გამოვა 1

გაზრდა და შემცირება ოპერაციები PHP– ში
ეს ოპერაციები სასარგებლო იქნება ძირითადად მარყუჟების აგებისას, რაზეც ცოტა მოგვიანებით ვისაუბრებთ.
პრეფიქსი- ოპერატორები დაწერილია ცვლადის წინ ( - $ ა; ++ $ ა). აბრუნებს ცვლადის მნიშვნელობას ცვლილებამდე.
პოსტიფიქსი- ცვლადის შემდეგ დაწერილი ოპერატორები ( $ a--; $ a--). აბრუნებს ცვლადის შეცვლილ მნიშვნელობას.
გაზრდა- ღირებულების გაზრდა.
შემცირება- ღირებულების შემცირება.

++ $ აპრეფიქსის გაზრდა. ზრდის $ a ერთს და აბრუნებს $ a.
$ a ++პოსტიფიქსის გაზრდა. აბრუნებს $ a მნიშვნელობას და შემდეგ ზრდის $ a ერთს.
- $ აპრეფიქსის შემცირება. ამცირებს $ a ერთს და აბრუნებს $ a ღირებულებას.
$ a-- Postfix შემცირება. აბრუნებს $ a მნიშვნელობას და შემდეგ მცირდება $ a ერთით.
ექო "

პოსტფიქსის გაზრდა

";
$ a = 5;
ექო "უნდა იყოს 5:". $ a ++. "\ n";

ექო "

პრეფიქსის გაზრდა

";
$ a = 5;
ექო "უნდა იყოს 6:". ++ $ ა "\ n";
ექო "უნდა იყოს 6:". $ ა "\ n";

ექო "

Postfix შემცირება

";
$ a = 5;
ექო "უნდა იყოს 5:". $ a--. "\ n";

ექო "

პრეფიქსის შემცირება

";
$ a = 5;
ექო "უნდა იყოს 4:". - $ ა "\ n";
ექო "უნდა იყოს 4:". $ ა "\ n";
?>

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

$ a = ($ b = 2) + 4; // შედეგი: $ a არის 6, $ b არის 2.

$ a = 2;
$ a + = 3; // ადგენს $ a– ს 5 – მდე, წერის მსგავსი: $ a = $ a + 3;
$ b = "გამარჯობა";
$ b. = "მსოფლიო!"; // ადგენს $ b- ს "გამარჯობა მსოფლიო!" ისევე როგორც $ b = $ b. "იქ!";

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

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

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

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

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

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

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

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

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

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

გამარჯობა ჰარი! $ GlobalName მნიშვნელობა: "Zoe" $ localName მნიშვნელობა: ""

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

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

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

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

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

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

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

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

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

"; global $ globalName; ექო" გამარჯობა $ globalName!
";) თქვა გამარჯობა ();?>

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

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

SayHello () ფუნქცია იყენებს გლობალურ საკვანძო სიტყვას $ globalName ცვლადის გლობალურად გამოსაცხადებლად. შემდეგ მას შეუძლია შეცვალოს ცვლადი და აჩვენოს მისი მნიშვნელობა ("ზოია").

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

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 superglobal ძალიან მოსახერხებელია გამოსაყენებლად, რადგან ის გაძლევთ საშუალებას ორგანიზება გაუწიოთ გლობალურ ცვლადებზე წვდომას ფუნქციაში გლობალური საკვანძო სიტყვის გამოყენების გარეშე. Მაგალითად:

";) sayHello (); // გამოდის" გამარჯობა, ზოი! "?>

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

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

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

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

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

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

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

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

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

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

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

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

სკრიპტი აწარმოებს მოსალოდნელ გამომავალს:

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

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

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

Windows- ის გარემოს ცვლადი (გარემო) შეიცავს სხვადასხვა ინფორმაციას სისტემის პარამეტრებისა და მომხმარებლის გარემოს შესახებ. განასხვავებენ მომხმარებლის, სისტემის და პროცესის გარემოს ცვლადებს.

Windows– ზე გარემოს ცვლადების შინაარსის სანახავად უმარტივესი გზაა სისტემის თვისებების გახსნა ( sysdm.cpl) -> გაფართოებული -> გარემოს ცვლადები.როგორც ხედავთ, გახსნილ განყოფილებაში არის ორი განყოფილება: ზედა შეიცავს მომხმარებლის გარემოს ცვლადებს, ქვედა შეიცავს სისტემურ.

გარდა ამისა, გარემოს ცვლადები ინახება სისტემის რეესტრში. მორგებული ცვლადები ინახება განყოფილებაში. სისტემა - შიგნით HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

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

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

PowerShell– ში შეგიძლიათ გამოიყენოთ ბრძანება გარემოს ყველა ცვლადის ჩვენების მიზნით:

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

Echo% systemroot%

მითითებული> c: \ tmp \ env_var.txt

კონკრეტული პროცესის გარემოს ცვლადების მიღება შესაძლებელია უფასოდ პროცესი Explorer კომუნალური(Sysinternals– დან). საკმარისია გახსნათ პროცესის თვისებები და გადადით ჩანართზე გარემო.

13 წლის წინ

ცოტა უნდა გავუფრთხილდეთ:

თუ გამორთავთ RegisterGlobals და სხვა, შემდეგ გამოიყენეთ get_defined_vars (), თქვენ შეიძლება ნახოთ მსგავსი რამ:

მასივი
[GLOBALS] => მასივი
[GLOBALS] => მასივი
* განმეორება *
[_POST] => მასივი ()
[_GET] => მასივი ()
[_COOKIE] => მასივი ()
[_FILES] => მასივი ()
)

[_POST] => მასივი ()
[_GET] => მასივი ()
[_COOKIE] => მასივი ()
[_FILES] => მასივი ()

)
?>

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

ამობეჭდვა "

". htmlspecialchars (print_r (get_defined_vars (), true))."

" ;
ამობეჭდვა "

". htmlspecialchars (print_r ($ _SERVER, ჭეშმარიტი))."

" ;
?>

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

6 წლის წინ

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

// თქვენი php სკრიპტის ზედა ნაწილი
$ vars = get_defined_vars ();

// ახლა გააკეთე შენი საქმე
$ foo = "foo";
$ bar = "ბარი";

// მიიღეთ მიმდინარე ფარგლებში განსაზღვრული ყველა ცვლადი
$ vars = array_diff (get_defined_vars (), $ vars);

ექო "

"
;
print_r ($ vars); 
ექო "

" ;
?>

15 წლის წინ

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

ფუნქცია generateDebugReport ($ მეთოდი, $ defin_vars, $ email = "განუსაზღვრელი") (
// ფუნქცია შექმნას გამართვის ანგარიში საჩვენებლად ან ელ.
// გამოყენება: generateDebugReport (მეთოდი, get_defined_vars (), ელ.ფოსტა);
// სად არის მეთოდი "ბრაუზერი" ან "ელექტრონული ფოსტა".

// შექმენით იგნორირების სია "get_defined_vars" - ის მიერ დაბრუნებული გასაღებებისათვის.
// მაგალითად, HTTP_POST_VARS, HTTP_GET_VARS და სხვა არის
// ზედმეტი (იგივე _POST, _GET)
// ასევე შეიტანეთ ვარდები, რომელთა იგნორირება გსურთ უსაფრთხოების მიზნით - ე.ი. PHPSESSID.
$ ignorelist = მასივი ("HTTP_POST_VARS", "HTTP_GET_VARS",
"HTTP_COOKIE_VARS", "HTTP_SERVER_VARS",
"HTTP_ENV_VARS", "HTTP_SESSION_VARS",
"_ENV", "PHPSESSID", "SESS_DBUSER",
"SESS_DBPASS", "HTTP_COOKIE");

$ timestamp = თარიღი ("m / d / y h: m: s");
$ message = "გამართვის ანგარიში შეიქმნა $ დროის ნიშნული \ n";

// მიიღეთ ბოლო SQL შეცდომა კარგი ზომებისთვის, სადაც $ link არის რესურსის იდენტიფიკატორი
// mysql_connect– ისთვის. გააკეთეთ კომენტარი ან შეცვალეთ თქვენი მონაცემთა ბაზა ან აბსტრაქციის დაყენება.
გლობალური $ ბმული;
$ sql_error = mysql_error ($ ბმული);
თუ ($ sql_error) (
$ message. = "\ nMysql შეტყობინებები: \ n". mysql_error ($ ბმული);
}
// MySQL დასრულება

// აქ შეიძლება გამოყენებულ იქნას რეკურსიული ფუნქცია. თქვენ გესმით იდეა ;-)
foreach ($ defin_vars როგორც $ key => $ val) (
if (is_array ($ val) &&! in_array ($ key, $ იგნორირების სია) && count ($ val)> 0) (
$ შეტყობინება. = "\ n $ გასაღების მასივი (გასაღები = მნიშვნელობა): \ n";
foreach ($ val როგორც $ subkey => $ subval) (
if (! in_array ($ subkey, $ იგნორირების სია) &&! is_array ($ subval)) (
$ შეტყობინება. = $ ქვე -გასაღები "=". $ subval. "\ n";
}
elseif (! in_array ($ subkey, $ იგნორირების სია) && is_array ($ subval)) (
foreach ($ subval როგორც $ subsubkey => $ subsubval) (
თუ (! in_array ($ subsubkey, $ იგნორირების სია)) (
$ message. = $ subsubkey. "=". $ სუბვალური. "\ n" ;
}
}
}
}
}
სხვაგან (! is_array ($ val) &&! in_array ($ გასაღები, $ იგნორირების სია) && $ val) (
$ message. = "\ n ცვლადი". $ გასაღები. "=". $ ვალ. "\ n";
}
}

თუ ($ მეთოდი == "ბრაუზერი") (
echo nl2br ($ შეტყობინება);
}
elseif ($ მეთოდი == "ელფოსტა") (
if ($ email == "განუსაზღვრელი") (
$ email = $ _SERVER ["SERVER_ADMIN"];
}

$ mresult = ფოსტა ($ email, "Debug Report for". $ _ENV ["HOSTNAME"]. "", $ შეტყობინება);
თუ ($ mresult == 1) (
ექო "გამართვის ანგარიში წარმატებით გაიგზავნა. \ N";
}
სხვა (
ექო "გამართვის ანგარიშის გაგზავნა ვერ მოხერხდა. \ N";
}
}
}
?>

17 წლის წინ

მარტივი რუტინა get_defined_vars ობიექტის XML- ზე გადასაყვანად.

ფუნქცია obj2xml ($ v, $ indent = "") (
while (სია ($ გასაღები, $ val) = თითოეული ($ v)) (
თუ ($ key == "__attr") გაგრძელდება;
// შეამოწმეთ __attr
if (is_object ($ val -> __attr)) (
ხოლო (სია ($ key2, $ val2) = თითოეული ($ val -> __attr)) (
$ attr. = "$ key2 = \" $ val2 \ "";
}
}
else $ attr = "";
if (is_array ($ val) || is_object ($ val)) (
ბეჭდვა ("$ indent< $key$attr >\ n ");
obj2xml ($ val, $ indent. "");
ბეჭდვა ("$ indent\ n ");
}
else print ("$ შეწევა< $key$attr >$ ვალ\ n ");
}
}

// ობიექტის მაგალითი
$ x -> name -> პირველი = "ჯონ";
$ x -> name -> last = "სმიტი";
$ x -> arr ["ხილი"] = "ბანანა";
$ x -> arr ["Veg"] = "სტაფილო";
$ y -> მომხმარებელი = $ x;
$ y -> მომხმარებელი -> __attr -> id = "176C4";

$ z = get_defined_vars ();
obj2xml ($ z ["y"]);
?>
გამოვა:


ჯონ
სმიტი


ბანანი
სტაფილო

11 წლის წინ

როგორც შენიშვნა, get_defined_vars () არ აბრუნებს ცვლადი მითითებების ერთობლიობას (როგორც ვიმედოვნებდი). Მაგალითად:

// ცვლადის განსაზღვრა
$ my_var = "foo";

// მიიღეთ ჩვენი განსაზღვრული ცვლადების სია
$ განსაზღვრული_ვარდები = მიიღეთ_დასადგენი_ვარდები ();

// ახლა შეეცადეთ შეცვალოთ მნიშვნელობა დაბრუნებული მასივის საშუალებით
$ defined_vars ["my_var"] = "ბარი";

ექო $ my_var, "\ n";

?>

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

$ defined_vars = მასივი ();
$ var_names = array_keys (get_defined_vars ());

foreach ($ var_names როგორც $ var_name)
{
$ defined_vars [$ var_name] = & $ $ var_name;
}

?>

1 წლის წინ

მე აქ ადრე დავწერე იმის შესახებ, რომ "ეს" არის get_defined_vars– ში.

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

Php -r "
კლასის ტესტი (
საჯარო ფუნქცია a () (var_dump (array_keys (get_defined_vars ())); $ a = 123;)
საჯარო ფუნქცია b () (var_dump (array_keys (get_defined_vars ())); $ this;)
}
$ t = ახალი ტესტი ();
$ t-> a ();
$ t-> b ();
"

მასივი ()
მასივი ("ეს")

ეს არ ხდება PHP 7.2– ში, მაგრამ მოხდება PHP 5.6– ში.

1 წლის წინ

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

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

საჯარო ფუნქცია x ($ a, $ b, $ c) (
foreach (array_keys (get_defined_vars ()) როგორც $ გასაღები)
თუ ($ გასაღები! == "ეს")
$ this-> y ($ ($ გასაღები));
}

საჯარო ფუნქცია y (& $ input) (
$ შეყვანა ++;
}

$ () - ის ნაცვლად ასევე შეგიძლიათ გამოიყენოთ $ $.

მე გავაკეთე რამდენიმე საშინელი რამ თავის დროზე უკიდურესად ზოგადი კოდის შესაქმნელად, მაგრამ მე არასოდეს მქონია მსგავსი რამის გაკეთება. ეს შეიძლება არც კი იმუშაოს (მაგრამ უნდა იყოს, რადგან ის არ განსხვავდება $ a [$ გასაღებიდან]).

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

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