გაკვეთილი მოიცავს PHP-ში მასივებით მუშაობის შესაძლებლობებს, მასივის გამოცხადებას, მასივების ტიპებს: მრავალგანზომილებიანი და ასოციაციური მასივები.
- მასივები რიცხვითი ინდექსებით
- ასოციაციური მასივი
$fruts="ვაშლი"; $fruts="მსხალი"; $fruts="ფორთოხალი"; $fruts="გარგარი";
მასივის ინიციალიზაციის ეს ვარიანტი დღეს პრაქტიკულად არ გამოიყენება. მასივებთან მუშაობის შემდეგი ვარიანტი გამოიყენება:
მასივის შესაქმნელად ეს ვარიანტი იყენებს მასივის ობიექტს:
$fruits = მასივი(1 => "ვაშლი", 2 => "მსხალი", 3 => "ფორთოხალი", 4 => "გარგარი"); // დაწყებული PHP ვერსიები 5.4 $fruits = მასივი[ 1 => "ვაშლი", 2 => "მსხალი", 3 => "ფორთოხალი", 4 => "გარგარი" ];
მასივის ელემენტებზე წვდომა
| 1 2 3 4 5 6 7 8 | $fruts [ 0 ] = "ვაშლი" ; $fruts [ 1 ] = "მსხალი" ;$fruts [ 2 ] = "ფორთოხალი" ; $fruits [ 3 ] = "გარგარი" ; ექო"მაივის პირველი ელემენტია" $fruits [ 3 ] = "გარგარი" ; .$ ხილი[0]. " " ; |
"; ექო
"მაივის მეორე ელემენტია"
.
";
$ ხილი [1]. "
"მაივის მესამე ელემენტი არის". $ ხილი [2]. ")
$fruts="ვაშლი"; $fruts="მსხალი"; $fruts="ფორთოხალი"; $fruts="გარგარი"; echo "მაივის პირველი ელემენტია". $ ხილი."
"; echo "მაივის მეორე ელემენტია ". $fruts .""; echo "მაივის მესამე ელემენტია ". $fruts ."
პროგრამის შესრულების შედეგი იქნება:
";
მნიშვნელოვანია:
ასოციაციურ მასივში ელემენტის ინდექსი შეიძლება იყოს არა რიცხვი, არამედ სიტყვა (ტიპი
სიმებიანი
";
მოდით შევხედოთ მაგალითს:
"მაივის მესამე ელემენტი არის"მაგალითი:
შექმენით სტუდენტური მასივი სტუდენტების სახელის, გვარისა და ასაკის მნიშვნელობებით. აჩვენეთ მასივის ელემენტების მნიშვნელობები
$student = მასივი ("სახელი" => ჯონ, "გვარი" => სმიტი, "ასაკი" => 20); ექო "მომხმარებლის სახელი" . $student["სახელი"] . " $student["Name"] = "ჯონ"; $student["გვარი"] = "სმიტი"; $student["ასაკი"] = 20; ექო "მომხმარებლის სახელი" . $student["სახელი"] . "("; echo "მომხმარებლის გვარი " . $student["გვარი"] . "):
"; echo "მომხმარებლის ასაკი " . $student["ასაკი"] ." შედეგი:
ამ შემთხვევაში, თარჯიმანი თავად მიანიჭებს მათ რიცხვით ინდექსებს, დაწყებული 0-დან
მაგალითიტიპის კონვერტაციები და ელემენტების გადაწერა.
გაითვალისწინეთ var_dump() პროცედურის გამოყენება
| 1 2 3 4 5 6 7 8 9 | "a" , "1" => "b" , 2 => "c" , 2 => "d" , ); |
var_dump ($my_array) ;
მოდით შევხედოთ მაგალითს:
?>
მაგალითი"a", "1"=> "b", 2 => "c", 2 => "d",); var_dump ($my_array); ?> მასივი (3) ( => სტრიქონი (1) "a" => სტრიქონი (1) "ბ" => სტრიქონი (1) "დ" )გამოყენება
| 1 2 3 4 5 6 7 8 9 10 11 12 | მრავალგანზომილებიანი მასივი |
და მის ელემენტებზე წვდომის ორგანიზება
მოდით შევხედოთ მაგალითს:
"1" , 2 => 2, "multi" => მასივი ("1_1" => "1_1") );
"; echo "მაივის მეორე ელემენტია ". $fruts ." var_dump ($array_odnom["პირველი"]);
var_dump ($array_odnom[2]);
| 1 2 3 4 5 6 7 8 9 10 11 12 | var_dump ($array_odnom["multi"]["1_1"]); |
?>
"1", 2 => 2, "multi" => მასივი ("1_1" => "1_1")); var_dump ($array_odnom ["პირველი"]); var_dump ($array_odnom); var_dump ($array_odnom ["multi"]["1_1"]); ?>სტრიქონი(1) "1" int(2) სტრიქონი(3) "1_1"
შექმენით ორგანზომილებიანი მასივი ზომით 3 x 2. შეავსეთ იგი პირველი ხაზის მნიშვნელობებით: "1_1", "1_2", "1_3"; მეორე სტრიქონისთვის: "2_1", "2_2", "2_3". მასივის პირველი ელემენტის ჩვენება
შესრულება:
$array_odnom = მასივი ( 1 => მასივი ( 1 => "1_1" , 2 => "1_2", 3 => "1_3") , 2 => მასივი (1 => "2_1", 2 => "2_2" , 3 => "2_3" ) , );
echo $array_odnom [ 1 ] [ 1 ] ;
$array_odnom = მასივი (1 => მასივი (1 => "1_1", 2 => "1_2", 3 => "1_3"), 2 => მასივი (1 => "2_1", 2 => "2_2" , 3 => "2_3"))); echo $array_odnom;
სამუშაო php2_1:
შექმენით ორგანზომილებიანი 3 x 3 მასივი - პითაგორას გამრავლების ცხრილის ზედა მარცხენა კუთხე (1, 2, 3; 4, 6, 8 ...)
ლაბორატორიული სამუშაოები: დავუშვათ, თქვენ გაქვთ რაიმე სახის რეკლამა და რამდენიმე განსხვავებული ადამიანი, რომლებსაც უნდა გაუგზავნოთ ეს რეკლამა. ამისათვის თქვენ ამზადებთ შაბლონს რეკლამის შინაარსით, რომლის შიგნით არის რამდენიმე ცვალებადი პარამეტრი: ადამიანების სახელების მასივი და მოვლენების მთელი რიგი. ეკრანზე აჩვენეთ საბოლოო რეკლამის ერთი ვერსია. მასივების განსაზღვრისთვის გამოიყენეთ ასოციაციური მასივი. გამოიყენეთ რეკლამის შაბლონი და ყურადღება გაამახვილეთ ფერებზე:
.
წითელი - მასივები.
ყავისფერი – რიცხვითი ცვლადი.
ლურჯი - მუდმივი.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | ძვირფასო ივან ივანოვიჩ!გეპატიჟებით დღე)
;
ღია კარებიღონისძიების თარიღი: 12 მაისი. პატივისცემით, ვასილი.შეავსეთ კოდი: // მუდმივის გამოცხადება define("SIGN" , "პატივისცემით, ვასია" " // მასივი მიმღების სახელებისთვის |
// მუდმივი define-ის დეკლარაცია ("SIGN","Regards, Vasya"); // მასივი მიმღების სახელებისთვის $names = array(...); // მასივი მოვლენებისთვის $events = array("op_doors" => "ღია დღე", "vistavka" => "გამოფენა", ...); $str = "ძვირფასო $names!
"; $str .= ...; $str .= ...; ექო ...;
ამ სტატიაში ჩვენ ვაგრძელებთ PHP-ის საფუძვლების შესწავლას და მასივების გაცნობას. ცალკე, მაგალითების გამოყენებით, გადავხედავთ რეგულარული მასივის შექმნას, შემდეგ შეუფერხებლად გადავალთ ასოციაციურ და მრავალგანზომილებიან მასივებზე. წარმოდგენილი მასალა საკმარისი იქნება შემდეგი ნაწილის მტკიცედ გასაგებად. PHP საფუძვლები, კერძოდ PHP მასივები.
PHP მასივები – რა არის PHP მასივები და როგორ იქმნება ისინი. მარტივი (ინდექსის) მასივები
PHP-ში მასივები თამაშობენ ძალიან მნიშვნელოვან როლს და ფართოდ გამოიყენება ვებსაიტების შექმნისას. მასივი არის ეგრეთ წოდებული ცვლადი (), რომელიც შეიძლება შეიცავდეს რამდენიმე მნიშვნელობას, რომელიც ხელმისაწვდომია გარკვეულ ინდექსებზე. მასივის ინფორმაციაზე წვდომისთვის, უბრალოდ მიუთითეთ მასივის სახელი და მონაცემთა უჯრედის ინდექსი. სიცხადისთვის მივცემ მარტივი ინდექსის მასივის სტრუქტურისა და ცვლადის მაგალითს.
როგორც სურათიდან ხედავთ, განსხვავება მასივსა და ცვლადს შორის არც თუ ისე დიდია. ცვლადს შეუძლია მიიღოს მხოლოდ ერთი მნიშვნელობა, მაგრამ მასივს შეუძლია მიიღოს რამდენიმე მნიშვნელობა ერთდროულად. უფრო მეტიც, მასივიდან ინფორმაციის ამოსაღებად საკმარისია უბრალოდ მიუთითოთ მასივის სახელი და ინდექსი, რომლისთვისაც ხელმისაწვდომია ინფორმაცია. უფრო სრულყოფილი გაგებისთვის, მოდით შევხედოთ მაგალითს და შევქმნათ მასივი, შემდეგ ამოვიღოთ ინფორმაცია მისგან და გამოვაჩინოთ ეკრანზე.
/*მაივის შექმნა*/ $name = "A"; $name = "B"; $name = "C"; $name = "D"; $name = "E"; /*გამოიტანეთ მასივის უჯრედის მნიშვნელობა 2 ინდექსით ეკრანზე*/ echo $name;
ზემოთ მოყვანილ მაგალითში ვხედავთ, რომ ჩვენ ჯერ ვქმნით მასივის პირველ ელემენტს ინდექსით „0“ და მას მნიშვნელობას „A“ ვანიჭებთ. შემდეგ ანალოგიურად ვქმნით მასივის დარჩენილ 4 ელემენტს. ამის შემდეგ, გამოყენებით ექო ოპერატორიჩვენ გამოვხატავთ მასივის მესამე ელემენტს ეკრანზე. როგორც უკვე შენიშნეთ, მასივის ელემენტის ეკრანზე გამოსატანად, თქვენ უნდა მიუთითოთ მასივის სახელი და უჯრედის ინდექსი მონაცემებით.
ზემოაღნიშნული მეთოდის გარდა, PHP-ში მასივი შეიძლება შეიქმნას სხვა გზით. მისი არსი გამოყენებაშია საკვანძო სიტყვა მასივი. სიცხადისთვის, მოდით შევხედოთ მასივის შექმნის იგივე მაგალითს, მაგრამ სხვაგვარად.
$name = მასივი (0 => "A", 1 => "B", 2 => "C", 3 => "D", 4 => "E");
ეს მეთოდი ასევე ძალიან მარტივია. მასივის შესაქმნელად ვქმნით $name ცვლადს, შემდეგ ვათავსებთ მინიჭების ნიშანს „=“ და მივუთითებთ, რომ ეს არის მასივი. ამის შემდეგ, ჩვენ ვქმნით უჯრედებს და ვავსებთ მათ მონაცემებით. ეს კეთდება ინდექსის მითითებით და მისთვის მნიშვნელობის მინიჭებით "=" და ">" ნიშნების გამოყენებით. ანუ, "0 => "A" ნიშნავს, რომ ჩვენ მივანიჭებთ მნიშვნელობას "A" უჯრედს ინდექსით "0". ცოტა უხერხულია ამ თემის ტექსტით ახსნა, მაგრამ ვფიქრობ, გესმით, რაზეც ვსაუბრობ.
ასევე მინდა დაუყოვნებლივ აღვნიშნო, რომ თუ შექმნილ მასივში პირველი ელემენტის ინდექსი ნულია, მაშინ ინდექსების შეყვანა არ არის საჭირო. ამ შემთხვევაში, PHP ავტომატურად დაამატებს ინდექსებს ნულიდან დაწყებული. ეს ყველაფერი ასე გამოიყურება.
პირველი ვარიანტი PHP-ში მასივების შესაქმნელად
$name = "A"; $name = "B"; $name = "C"; $name = "D"; $name = "E";
მეორე ვარიანტი PHP-ში მასივების შესაქმნელად
$name = მასივი ("A", "B", "C", "D", "E");
PHP ასოციაციური მასივები
ასოციაციური მასივები PHP მასივის კიდევ ერთი ტიპია. განსხვავება ასოციაციურ მასივებსა და მარტივ მასივებს შორის არის ინდექსები. თუ მარტივ მასივებში ეს იყო რიცხვითი ინდექსები, მაშინ ასოციაციურ მასივებში ეს ინდექსები ტექსტია. ეს ხდის ასოციაციურ მასივებს უფრო ორგანიზებულ და შინაარსობრივს. ამის გამო, ისინი უფრო ფართოდ გამოიყენება, ვიდრე მარტივი ინდექსი.
ასოციაციური მასივები იქმნება ანალოგიურად. განვიხილოთ 2 ძირითადი მეთოდი.
ასოციაციური მასივის შექმნის პირველი გზა.
$color["white"] = "თეთრი"; $color["black"] = "შავი"; $color["red"] = "წითელი"; $color["green"] = "მწვანე"; $color["blue"] = "ლურჯი";
ასოციაციური მასივის შექმნის მეორე გზა.
$color = მასივი ("თეთრი" => "თეთრი", "შავი" => "შავი", "წითელი" => "წითელი", "მწვანე" => "მწვანე", "ლურჯი" => "ლურჯი") ;
როგორც ხედავთ, ასოციაციური მასივის შექმნის პროცედურა იდენტურია ინდექსის შექმნის პროცედურისა. ეკრანზე მასივის ელემენტის გამოსატანად, შეგვიძლია გამოვიყენოთ . განვიხილოთ ორი მეთოდი - ჩვეულებრივი და ცვლადი დოკის გამოყენებით.
Echo "შერჩეული ფერი - $color"; echo "შერჩეულია ".$color["red"]." ფერი";
როგორც უკვე შენიშნეთ, პირველ შემთხვევაში უჯრედის ინდექსი არ არის აღებული ორმაგი ციტატები. ეს წესი უნდა გვახსოვდეს დაუყოვნებლივ, რათა თავიდან იქნას აცილებული შეცდომები მომავალში. თუ იყენებთ პირველ მეთოდს და გსურთ მასივის ელემენტის ჩვენება ცვლადების შეერთების გარეშე, მაშინ ინდექსი არ არის ციტირებული. მეორე მაგალითში, როგორც ხედავთ, ყველაფერი ჩვეულებრივად წერია და ციტატები არ არის ამოღებული.
მე პირადად პირველი მეთოდი უფრო მომწონს, ვინაიდან, ჩემი აზრით, ის ბევრად უფრო მარტივია, ვიდრე მეორე და განსახორციელებლად ნაკლებ ნაბიჯებს მოითხოვს. თუმცა, თქვენზეა დამოკიდებული, რომელ მეთოდს გამოიყენებთ.
ახლა გადავიდეთ სტატიის ბოლო ნაწილზე და გადავხედოთ PHP მრავალგანზომილებიან მასივებს.
PHP მრავალგანზომილებიანი მასივები
მრავალგანზომილებიანი მასივი არის მასივი, რომელიც შეიცავს სხვა მასივს. სიცხადისთვის, მოდით განვახორციელოთ მრავალგანზომილებიანი მასივი სამი ტიპის კომპიუტერის გამოყენებით, როგორც მაგალითი. ჩვენს შემთხვევაში ასეა დესკტოპ კომპიუტერი, ლეპტოპი და ნეტბუქი. მახასიათებლები იქნება მოცულობა ოპერატიული მეხსიერება, მოცულობა მყარი დისკიდა პროცესორის სიხშირე. სქემატურად მრავალგანზომილებიანი PHP მასივიამ პრობლემის გადაჭრა შეიძლება ასე გამოიყურებოდეს.
თქვენ შეგიძლიათ შექმნათ მრავალგანზომილებიანი მასივი, როგორც ყველა სხვა, რამდენიმე გზით. დროის დაზოგვის მიზნით განვიხილავთ მხოლოდ მეორე მეთოდს. ვფიქრობ, თქვენ უკვე დაიმახსოვრეთ როგორ იქმნება მასივები PHP-ში და არ უნდა გქონდეთ პრობლემა.
$massiv["Desktop PC"] = მასივი ("RAM" => "4096", "HDD" => "500", "GC" => "3"); $massiv["ლეპტოპი"] = მასივი ("RAM" => "3072", "HDD" => "320", "GC" => "2"); $massiv["Netbook"] = მასივი ("RAM" => "2048", "HDD" => "250", "GC" => "1.6");
მრავალგანზომილებიანი მასივის ელემენტის ეკრანზე PHP-ში გამოსატანად საკმარისია გამოვიყენოთ echo გამომავალი ოპერატორი და ცვლადი დოკის მეთოდი, რადგან წინააღმდეგ შემთხვევაში (ცვლადი დოკის გარეშე) მრავალგანზომილებიანი მასივის ელემენტი არ იქნება ნაჩვენები. ეკრანი. ეს არის კიდევ ერთი განსხვავება PHP მრავალგანზომილებიან მასივებთან მუშაობისას.
Echo "Desktop PC RAM-ის ტევადობით ".$massiv["Desktop PC"]["RAM"]." და მყარი დისკის მოცულობა ".$massiv["Desktop PC"]["HDD"]." აქვს პროცესორის სიხშირე of " . $massiv["Desktop PC"]["GC"]. "GC.";
ახლა მოდით მოდით შევაჯამოთყველა ზემოთ ჩამოთვლილი.
ამ სტატიაში ჩვენ განვიხილეთ მასივების სამი ტიპი - ინდექსური, ასოციაციური და მრავალგანზომილებიანი. ვისწავლეთ როგორ შევქმნათ მასივები PHP-ში, ასევე ვისწავლეთ მასივის ელემენტის ამოღება და ეკრანზე გამოტანა. გაშუქდა მასივებით მუშაობის საფუძვლები, ასევე ეკრანზე ელემენტების გამოტანის რამდენიმე წესი.
ამით მთავრდება ეს სტატია. თუ არ გინდა გამოტოვო უახლესი განახლებებიბლოგი, შეგიძლიათ გამოიწეროთ საინფორმაციო ბიულეტენი თქვენთვის მოსახერხებელი ნებისმიერი გზით "" განყოფილებაში ან გამოიყენოთ ქვემოთ მოცემული ფორმა.
სულ ესაა. წარმატებებს გისურვებთ და მალე გნახავთ ბლოგის გვერდებზე
ამ მოკლე სტატიაში განვიხილავთ მასივებთან მუშაობის რამდენიმე გზას. აღსანიშნავია, რომ ეს არის მონაცემთა ერთ-ერთი ყველაზე მნიშვნელოვანი ტიპი და თანამედროვე ენებიმათ გარეშე პროგრამირების წარმოდგენაც კი რთულია. რა არის მასივი?
მასივი არის მონაცემთა სტრუქტურირებული ნაკრები.
მათი სტრუქტურის მიხედვით შეიძლება ამის დადგენა მარტივი მასივიან ასოციაციური. შეუძლებელია ზუსტად იმის თქმა, რომელია უკეთესი, რადგან... ამა თუ იმ ტიპის გამოყენება უნდა მოხდეს სიტუაციიდან გამომდინარე.
როგორ შევქმნათ მარტივი მასივი PHP-ში
ასე გამოიყურება მარტივი მასივი:
მინდა სასწრაფოდ მივაქციო თქვენი ყურადღება მონაცემებზე (დიახ, განზრახ დავწერე :)). მონაცემთა ტიპის სტრიქონი, ან $ ხილი [2]. "ყოველთვის წერე ბრჭყალებში, არ აქვს მნიშვნელობა რომელი, ერთჯერადი და ორმაგი იმუშავებს (მთავარია, რომ ხაზი იწყება და მთავრდება ერთი ბრჭყალებით). 29 ნომერს აქვს ტიპი მთელი რიცხვი, ან რიცხვი - ციტატები არ არის საჭირო მონაცემთა ამ ტიპებისთვის.
მოდით შევამოწმოთ როგორ გამოიყურება $my_array მასივი:
"; print_r ($my_array); echo ""; /* მიიღეთ მასივი ( => თავმჯდომარე => ღრუბელი => 29) */ ?>
ასე გამოიყურება მარტივი მასივი.
0,1,2
- ჩვენი მასივის ინდექსები. ინდექსების დახმარებით ჩვენ შეგვიძლია გამოვიტანოთ რაიმე კონკრეტული მასივიდან.
ასევე, ჩვენ შეგვიძლია შევქმნათ იგივე მასივი, თუ დავწერთ:
და არის მესამე გზაც:
"სკამი", 1 => "ღრუბელი", 2 => 29);?>
და მეოთხე :)
ინდექსები შეივსება 0-დან.
PHP რა არის ასოციაციური მასივი
ჩვენ უკვე გავარკვიეთ, რა არის მარტივი მასივი. ასოციაციური მასივი ამით განსხვავდება კლავიშები გამოიყენება ინდექსების ნაცვლად. ანუ, ჩვენ აღარ გამოვიყენებთ 0,1 ან 2 მნიშვნელობებზე წვდომისთვის, მოდით დავწეროთ ჩვენი მარტივი მასივი, როგორც ასოციაციური.
სკამი => ღრუბელი => 29) */ ?>
და დასარეკად გამოვიყენებთ
ნომრის ნაცვლად ( ინდექსი) ჩვენ დავაყენეთ მნიშვნელოვანი სახელი (ასოციაცია) და ჩვენს ინდექსს ახლა შეიძლება ვუწოდოთ მასივის გასაღები(პუნქტი, ცა, ნომერი). ყველაზე პოპულარული და, ალბათ, ყველაზე მოსახერხებელი აღნიშვნა ასოციაციური მასივისთვის:
"სკამი", "ცა" => "ღრუბელი", "რიცხვი" => 29); ?>
მრავალგანზომილებიანი მასივი
რამდენიმე სიტყვა ამ გიგანტზე :)
მასივი ("ფერი" => "წითელი", "წელი" => "2010", "ნიშანი" => "M5"), "აუდი" => მასივი ("ფერი" => "შავი", "წელი" = > "2011", "mark" => "TT")); print_r ($auto); // მასივის გამომავალი echo $auto["bmw"]["mark"]; // M5 ?>
როგორც გესმით, მნიშვნელობის ნაცვლად, რომელიც ადრე იყო სტრიქონი ან რიცხვი, ახლა არის მონაცემთა ტიპი, როგორიცაა მასივი ( მე გაგიკეთებ მასივს მასივის შიგნით, რათა მასივის დარეკვისას სხვა მასივი იყოს :)).
ასოციაციური მასივები
მარტივი მასივები იყენებენ გასაღებებს მხოლოდ ელემენტების განცალკევებისთვის და არ აქვთ პრაქტიკული მნიშვნელობა:
ასოციაციურ მასივებში კლავიშები აღწერს რა მნიშვნელობას შეიცავს - ასაკს, სახელს და ა.შ.:
"ვლადიმირი", "ასაკი" => 20]; ?>
ორგანზომილებიანი და მრავალგანზომილებიანი მასივები
აქამდე ჩვენ მხოლოდ ერთგანზომილებიან მასივებს გვქონდა საქმე, მაგრამ ასევე შეგვიძლია შევქმნათ ორგანზომილებიანი ან ნებისმიერი მრავალგანზომილებიანი მასივი:
"ვასია"];
$human["hands"] = ["მარცხნივ", "მარჯვნივ"];
print_r ($ადამიანი); ?>
როგორც ხედავთ, ჩვენ შევქმენით $human მასივი და შემდეგ მის შიგნით შევქმენით სხვა მასივი $human["hands"] . შედეგი ბრაუზერში:
მასივი ( => ვასია => მასივი ( => მარცხნივ => მარჯვნივ))
ჩვენ შეგვიძლია შევქმნათ ნებისმიერი ბუდეების მრავალგანზომილებიანი მასივები. ასეთი მასივის გამომავალი ასე გამოიყურება:
მრავალგანზომილებიანი მასივების პრაქტიკული გამოყენებაგახსოვთ წინა გაკვეთილზე გვინდოდა პროდუქტების და მათი მახასიათებლების დაჯგუფება? ნება მომეცით შეგახსენოთ კოდი, რომელიც მივიღეთ: Samsung Galaxy"; $product2_price = 5000; $product2_quantity = true; $product3_name = "
Nokia Lumia
"; $product3_price = 4000; $product3_quantity = true; ?>
ახლა ჩვენ შეგვიძლია მთელი ეს ინფორმაცია მოვათავსოთ ერთ ცვლადში. ამ შემთხვევაში, თითოეული პროდუქტი იქნება ასოციაციური მასივი და ყველა პროდუქტი განთავსდება მარტივი მასივის შიგნით:
"iPhone", "price" => 5000, "quantity" => true ], [ "name" => "Samsung Galaxy", "price" => 5000, "quantity" => true], [ "name" => > "Nokia Lumia", "price" => 4000, "quantity" => true ] ]; ?>
ან ალტერნატივა:
"iPhone", "price" => 5000, "quantity" => true ];
$products = [ "სახელი" => "Samsung Galaxy", "ფასი" => 5000, "რაოდენობა" => true];
$products = [ "name" => "Nokia Lumia", "price" => 4000, "quantity" => true ]; ?>
ორივე ვარიანტის შედეგი იქნება:
მასივი ( => მასივი ( => iPhone => 5000 => 1) => მასივი ( => Samsung Galaxy => 5000 => 1) => მასივი ( => Nokia Lumia => 4000 => 1))
1. შექმენით მასივი $city, დაამატეთ სახელის გასაღები ნებისმიერი მნიშვნელობით. 2. შექმენით ქუჩების ქვეჯგუფი ნებისმიერი შემთხვევითი ქუჩებით. თითოეულ ქუჩას უნდა ჰქონდეს სახელი (სახელი) და სახლების რაოდენობა (შენობების_თვლა), ასევე დასანგრევი სახლების ნომრების ქვეჯგუფი (ძველი_შენობები).
დღე მშვიდობისა, ჰაბრაჟიტელიკები!
მაგრამ რა მოხდება, თუ გვაქვს n-განზომილებიანი მასივი? მაგალითად, ხუთგანზომილებიანი:
$array = array("dimension1" => array("dimension2" => array("dimension3" => array("dimension4" => array("dimension5" => array("value1" => "Hey! I\ "m value1", "value2" => "Hey! I\"m value2"))))));
გასაღების მიხედვით მნიშვნელობის მისაღებად, მაგალითად, "მნიშვნელობა1", უნდა დავწეროთ შემდეგი კოდი:
ექო $მასივი["განზომილება1"]["განზომილება2"]["განზომილება3"]["განზომილება4"]["განზომილება5"]["მნიშვნელობა1"]; // ჰეი! მე ვარ ღირებულება 1
ასეთ ჩანაწერს ლამაზს არ დავარქმევ, თუმცა სწორია. მე ვთავაზობ, რომ ეს აღნიშვნა ცოტა უფრო ლამაზი გახადოთ, ასე რომ გამოიყურებოდეს:
Echo easyA($array)->dimension1->dimension2->dimension3->dimension4->dimension5->value1; // ჰეი! მე ვარ ღირებულება 1
დამეთანხმებით, ის ნამდვილად გამოიყურება ბევრად უფრო ლამაზად სტანდარტულ ჩანაწერთან შედარებით.
ასე რომ, ჯერ უნდა შევქმნათ კლასი, რომელიც დაამუშავებს ჩვენს მასივს. მოდით ვუწოდოთ მას easyArray და გავხადოთ Singleton:
კოდი
კლასი easyArray( private static $instance; // კლასის მდგომარეობა. private $Array; // მასივი, რომელიც გადაეცა კლასს. კერძო ფუნქცია __construct())( // შეიტანა კონსტრუქტორი. ) private ფუნქცია __clone()) ( // შეიტანა კლონირების მეთოდი. ) საჯარო სტატიკური ფუნქცია getInstance())( if(null === self::$instance)( self::$instance = new self(); ) return self::$instance; )
მას შემდეგ, რაც ჩვენი კლასი გახდება singleton, ჩვენ დავამატებთ მას ძალიან მნიშვნელოვან მეთოდს, რომელიც ჩაწერს მიღებულ მასივს კერძო ცვლადში:
კოდი
საჯარო ფუნქცია loadArray($newArray)( if(is_array($newArray))( $this->Array = $newArray; return $this; )else( $error = "უკაცრავად, თქვენ არ გაუშვით მასივი."; გადაყარეთ ახალი გამონაკლისი ($error);
კოდიდან ხედავთ, რომ ჩვენ ასევე ვამოწმებთ რა გადაეცა მეთოდის შეყვანას. თუ ეს არ იყო მასივი, რომელიც გადაცემულია, ჩვენ უბრალოდ გამოვრიცხავთ გამონაკლისს შეცდომით " სამწუხაროდ, თქვენ არ გაიარეთ მასივითუ შემოწმება წარმატებული იყო, მაშინ მიღებულ მასივს ვწერთ კერძო ცვლადში და ვაბრუნებთ მიმდინარე ობიექტს.
კარგად, ახლა ჩვენ გადავუშვებთ ჩვენი კლასის ჯადოსნურ მეთოდს "__get()". ეს აუცილებელია იმისათვის, რომ მივიღოთ სასურველი შედეგი. ასე რომ:
კოდი
საჯარო ფუნქცია __get($index)( if(isset($this->Array[$index]))(if(is_array($this->Array[$index]))($this->loadArray($this-> მასივი[$index] return $this; ($ შეცდომა);
უპირველეს ყოვლისა, ჩვენ ვამოწმებთ მასივში მოთხოვნილი გასაღების არსებობას, თუ ის იქ არ არის, გამონაკლისს ვაყენებთ შეცდომით "; "გასაღები აკლია (."$index.") მასივში"". შემდეგ ვამოწმებთ არის თუ არა მოთხოვნილი გასაღები მასივი. თუ მასივში არის ასეთი გასაღების მნიშვნელობა, მაშინ უბრალოდ ვაბრუნებთ ამ მნიშვნელობას. ხოლო თუ ის არის მასივი, მაშინ ვუგზავნით მას " loadArray ($newArray)და დააბრუნეთ მიმდინარე ობიექტი ($this).
და, როგორც საბოლოო შეხება ჩვენს კლასში, მოდით დავამატოთ მეთოდი, რომელიც დააბრუნებს მიმდინარე მასივს, რომლითაც ჩვენი კლასი მუშაობს:
კოდი
საჯარო ფუნქცია arrayReturn() ( return $this->Array; )
ასე რომ, ჩვენი კლასი მზად არის, მაგრამ მნიშვნელობების მისაღებად, ახლა უნდა გამოვიყენოთ ასეთი კოდი:
Echo easyArray::getInstance()->loadArray($array)->dimension1->dimension2->dimension3->dimension4->dimension5->value1; // ჰეი! მე ვარ ღირებულება 1
ის კიდევ უფრო გრძელი გახდა ვიდრე იყო. მაგრამ ეს პრობლემა შეიძლება მოგვარდეს და ამისათვის ჩვენ გვჭირდება მარტივი ფუნქცია:
ფუნქცია easyA($newArray)( დაბრუნება easyArray::getInstance()->loadArray($newArray); )
ახლა მოდით შევამოწმოთ რა მივიღეთ შედეგად:
კოდი
array("dimension2" => array("dimension3" => array("dimension4" => array("dimension5" => array("value1" => "Hey! I\"m value1", "value2" => "Hey! I\"m value2")))))); require_once ("easyArray.php"); require_once ("easyArrayFunction.php"); echo easyA($array)->dimension1->dimension2->dimension3->dimension4->dimension5->value1; // ჰეი! I\"m value1 echo easyA($array)->dimension1->dimension2->dimension3->dimension4->dimension5->value2; // Hey! I\"m value2 ?>
ყველაფერი მუშაობს ისე, როგორც დაგეგმილია.
გარდა ამისა, ამ კლასის გავლა შესაძლებელია კონფიგურაციის ფაილებიტიპი:
კოდი
array("dimension2" => array("dimension3" => array("dimension4" => array("dimension5" => array("value1" => "Hey! I\"m value1 ფაილიდან array.php", "value2" => "Hey! I\"m value2 from file array.php")))))); ?>
ამისათვის თქვენ უნდა გამოიყენოთ შემდეგი კონსტრუქცია:
კოდი
echo easyA(require_once("array.php"))->dimension1->dimension2->dimension3->dimension4->dimension5->value1; // ჰეი! I'm value1 ფაილიდან array.php
მე შეიძლება ხელახლა გამოვიგონე ბორბალი, მაგრამ ვფიქრობ, რომ ეს სტატია საინტერესო იქნება როგორც დამწყებთათვის, ასევე სხვა პროგრამისტებისთვის.
გმადლობთ ყურადღებისთვის.