(PHP 4 >= 4.0.5, PHP 5)
array_search -- ეძებს მოცემულ მნიშვნელობას მასივში და წარმატების შემთხვევაში აბრუნებს შესაბამის გასაღებს
აღწერა
შერეული მასივის_ძიება(შერეული ნემსი, თივის გროვა [, bool მკაცრი])ეძებს თივის გროვში ნემსის მნიშვნელობას და აბრუნებს გასაღებს, თუ ის იმყოფება მასივში, ცრუწინააღმდეგ შემთხვევაში.
კომენტარი:თუ ნემსი არის სტრიქონი, ტარდება რეგისტრირებული შედარება.
კომენტარი: PHP 4.2.0-მდე, მასივის_ძიება ()წარუმატებლობის შემთხვევაში დაბრუნდა NULLნაცვლად ცრუ .
თუ გადააქვთ მნიშვნელობა მართალიროგორც სურვილისამებრ მესამე პარამეტრი მკაცრი , ფუნქცია მასივის_ძიება ()ასევე შეამოწმებს ნემსის ტიპს თივის მასივში.
თუ ნემსი არის თივის გროვში არაერთხელ, პირველი ნაპოვნი გასაღები დაბრუნდება. ყველა ნაპოვნი მნიშვნელობის გასაღებების დასაბრუნებლად გამოიყენეთ ფუნქცია array_keys ()სურვილისამებრ search_value პარამეტრით.
მაგალითი 1: გამოყენების მაგალითი მასივის_ძიება ()
|
| ყურადღება |
ეს ფუნქცია შეიძლება დაბრუნდეს როგორც ლოგიკური მნიშვნელობა ცრუ, არა ლოგიკური მნიშვნელობა, რომელიც გადაცემულია ცრუ, მაგალითად 0 ან "". მეტისთვის დეტალური ინფორმაციაიხილეთ განყოფილება ლოგიკური ტიპი. გამოიყენეთ === ოპერატორი ამ ფუნქციით დაბრუნებული მნიშვნელობის შესამოწმებლად. |
საკმაოდ დიდი ხანია ვიყენებ array_search() ფუნქციას მასივში მნიშვნელობების მოსაძებნად, რადგან არაერთხელ მსმენია და წამიკითხავს, რომ ის შესამჩნევად უფრო სწრაფად მუშაობს, ვიდრე მასივის მარყუჟში ძიება, მაგრამ მე არ გავაკეთე იცოდეთ რამდენად სწრაფია. ბოლოს მე თვითონ შევამოწმე და დავთვალე.
მე შევადარე მასივის ძიების სიჩქარე ამ ფუნქციის გამოყენებით მასივის ჩვეულ ძიებას foreach მარყუჟებისდა ხოლო. 10-100 მასივის ელემენტებზე განსხვავება შეუმჩნეველია და დრო იმდენად მოკლეა, რომ მისი უგულებელყოფა შეიძლება. მაგრამ დიდი მასივებისთვის განსხვავება საკმაოდ მნიშვნელოვანი აღმოჩნდა. როდესაც მასივის ზომა გაიზარდა სიდიდის რიგითობით, ძებნის დროც მნიშვნელოვნად გაიზარდა. ასი ათასი ელემენტით, foreach-ის სიჩქარე დაეცა 0,013 წამამდე, ხოლო while - 0,017-მდე, ხოლო array_search() ასევე შენელდა, მაგრამ მაინც დარჩა სიდიდის ბრძანებით უფრო სწრაფად - 0,004 წამი. დიდი მასივებით მომუშავე დიდი სკრიპტისთვის, ციკლში ძიების შეცვლა array_search()-ის გამოყენებით ძიებით საერთოდ არ იქნება „რწყილის ოპტიმიზაცია“.
ამასთან დაკავშირებით, გამახსენდა ბოლო დისკუსია ჩემს ერთ-ერთ კოლეგასთან სამსახურში იმის შესახებ, სჭირდება თუ არა პროგრამისტს ყველა ამ ჩაშენებული ენის ფუნქციის ცოდნა, თუ საკმარისია თუ არა „პროგრამერის აზროვნება“ და ზოგადი ცოდნა. ამ აზროვნების შესახებ დისკუსიის გარეშე, მე ვფიქრობ, რომ თქვენ ჯერ კიდევ გჭირდებათ ფუნქციების ცოდნა, შესაძლოა არა ყველა სინტაქსი დეტალურად, მაგრამ მაინც რა ფუნქციები არსებობს და რისი გაკეთება შეუძლიათ მათ ზოგადად.
UPD: თქვენ ასევე გჭირდებათ პროგრამისტის აზროვნება! და მეხსიერების სიფრთხილე არ დააზარალებს (შთაგონებულია შესვენებით და დიაპაზონით :)
ჰაკის ქვემოთ არის სკრიპტის კოდი, რომელიც გამოიყენებოდა დროის გამოსათვლელად:
$მასა=100000; // მნიშვნელობების რაოდენობა მასივში, რომელშიც ჩვენ მოვიძიებთ
$ძებნა=50000; // ჩვენ ვეძებთ ამ მნიშვნელობას მასივში
$first_result=მასივი(); // შედეგების მასივი პირველი ვარიანტის საშუალო მნიშვნელობის გამოსათვლელად
$second_result=მასივი(); // შედეგების მასივი მეორე ვარიანტის საშუალო მნიშვნელობის გამოსათვლელად
$third_result=მასივი(); // შედეგების მასივი მესამე ვარიანტის საშუალო მნიშვნელობის გამოსათვლელად
// შექმენით და შეავსეთ მასივი
$test_array = დიაპაზონი (0, $mass-1); // მადლობა SelenIT-ს))
/*
$test_array=მასივი();
ამისთვის ($i=0; $i<$mass; $i++)
{
$test_array=$i;
}
*/
// ციკლი საშუალო მნიშვნელობების გამოსათვლელად
ამისთვის ($d=0; $d<30; $d++) {
//**************** ძიება array_search-ის გამოყენებით *******************
// დაიწყეთ დროის დათვლა
$time_start = microtime(1);
// ძებნა
$key = მასივის_ძიება ($search, $test_array, true);
// თუ იპოვეს
თუ ($key!==FALSE) // აუცილებელია!== და არა!=, რადგან პირველი ელემენტის რიცხვი არის 0
{
echo $test_array[$key];
}
$time_end = microtime(1);
// დროის დასასრული დათვლა
// ჩაწერეთ მნიშვნელობათა მასივში
$first_result= $time_end - $time_start;
//**************** მოძებნეთ მასივი foreach ციკლით ******************
// დაიწყეთ დროის დათვლა
$time_start = microtime(1);
// თავად ძებნა
foreach ($test_array როგორც $ta)
{
თუ ($ta==$ძებნა)
{
ექო $ta;
შესვენება;
}
}
$time_end = microtime(1);
// დროის დასასრული დათვლა
// ჩაწერეთ მნიშვნელობათა მასივში
$second_result= $time_end - $time_start;
//**************** მოძებნეთ მასივი while loop-ით *****************
// დაიწყეთ დროის დათვლა
$time_start = microtime(1);
// განსაზღვრავს მასივის სიგრძეს
$count=count ($test_array);
$j=0;
// თავად ძებნა
ხოლო ($j<$count)
{
თუ ($test_array[$j]==$ძებნა) // თუ ნაპოვნია
{
echo $test_array[$j];
შესვენება;
}
$j++;
}
$time_end = microtime(1);
// დროის დასასრული დათვლა
// ჩაწერეთ მნიშვნელობათა მასივში
$third_result= $time_end - $time_start;
}
$srednee1=მასივი_ჯამ ($first_result)/count ($first_result);
$srednee2=მასივი_ჯამ ($second_result)/count($second_result);
$srednee3=მასივი_ჯამ ($ მესამე_შედეგი)/count($third_result);
Printf("პირველი კოდი შესრულებულია საშუალოდ: %.7f წამი", $srednee1);
printf("მეორე კოდი დასრულებულია საშუალოდ: %.7f წამში", $srednee2);
printf("მესამე კოდი დასრულებულია საშუალოდ: %.7f წამში", $srednee3);
// შედეგი:
// პირველი კოდი შესრულებულია საშუალოდ: 0.0000295 წამი
// საშუალოდ შესრულებული მეორე კოდი: 0.0153386 წამი
// მესამე კოდი შესრულებულია საშუალოდ: 0.0226001 წამი
ხშირად კოდის დაწერისას საჭიროა შეამოწმოთ არის თუ არა კონკრეტული ელემენტის მნიშვნელობა მასივში. დღეს ჩვენ განვიხილავთ რამდენიმე ფუნქციას, რომლითაც შეგიძლიათ ამის გაკეთება.
მასივში ელემენტის მნიშვნელობის არსებობის შემოწმება შეიძლება გამოყენებულ იქნას პროგრამირების სხვადასხვა პრობლემის გადასაჭრელად.
ჩვენ შეგვიძლია მივიღოთ სხვადასხვა მასივები ჩვენი მონაცემთა ბაზიდან და შევამოწმოთ მასში კონკრეტული მნიშვნელობის არსებობა. სასურველი მნიშვნელობა ასევე შეიძლება გადაეცეს ჩვენი სკრიპტის მომხმარებლისგან, როდესაც, მაგალითად, ის რაღაცას ეძებს. ასეთი ძიების შედეგების საფუძველზე, შეგიძლიათ შეასრულოთ გარკვეული მოქმედებები. ეს ყველაფერი დამოკიდებულია კონკრეტულ დავალებაზე, თუმცა, მასივში მნიშვნელობის ძიების ალგორითმები იგივე იქნება.
დღეს ჩვენ გადავხედავთ მათ.
მასივში მნიშვნელობის არსებობის შემოწმება. in_array() ფუნქცია
ფუნქცია in_array ()საშუალებას მოგვცემს შევამოწმოთ მასივში რაიმე მნიშვნელობის არსებობა.
თუ მისი მუშაობის შედეგი წარმატებულია და სასურველი ელემენტი მოიძებნება მასივში, მაშინ ფუნქცია დაბრუნდება მართალია, ანუ "სიმართლე".
ფუნქცია იღებს 2 საჭირო პარამეტრს:<Что ищем>და<Где ищем>.
მას ასევე შეუძლია მიიღოს კიდევ ერთი არჩევითი პარამეტრი:<Тип данных>. თუ ეს მესამე არჩევითი პარამეტრი დაყენებულია მართალია, შემდეგ ასევე მოწმდება მონაცემთა ტიპი. ანუ, "2" და 2 არ იქნება იგივე. პირველ შემთხვევაში ეს არის სტრიქონი, მეორეში კი რიცხვი. შემდეგ კი მთელი ფუნქცია in_array ()არ დააბრუნებს მნიშვნელობას მართალია.
თქვენ ასევე უნდა გახსოვდეთ, რომ ფუნქცია ახორციელებს შედარებებს.
მოდით შევხედოთ როგორ მუშაობს ეს ფუნქცია მარტივი მაგალითის გამოყენებით.
ჩვენ გვჭირდება რაიმე სახის მასივი. ფუნქციის გამოყენებით ჩვენ შევამოწმებთ მასივში მნიშვნელობის არსებობას და ეკრანზე გამოვაჩენთ კონკრეტულ შეტყობინებას.
შესრულების შემდეგ, ფუნქცია აჩვენებს შეტყობინებას "დიახ", რადგან ელემენტი "Marina" არის ჩვენს მასივში.
შეცვალეთ ფუნქციის პირველი პარამეტრი რაიმე არარსებულ ელემენტზე და ნახავთ შეტყობინებას "არა".
მასივში მნიშვნელობის არსებობის შემოწმება. array_search() ფუნქცია
არის კიდევ ერთი საძიებო ფუნქცია array_search (), რომელიც წინაგან განსხვავებით დააბრუნებს ნაპოვნი ელემენტის გასაღებს. ეს, თავის მხრივ, შეიძლება სასარგებლო იყოს, თუ ჩვენ ვმუშაობთ ასოციაციურ მასივთან.
ფუნქცია იღებს იგივე პარამეტრებს, როგორც წინა. ამ შემთხვევაში, მესამე პარამეტრი ასევე არჩევითია.
ვნახოთ, როგორ შეიძლება მისი გამოყენება ასოციაციურ მასივთან მუშაობისას.
"ოქტომბერი","ფული"=>200,"name"=>"მილა"); $key = მასივის_ძიება ("Mila",$Mass1); if($key) echo $key; ?>
ამ შემთხვევაში ეკრანზე დავინახავთ "სახელს", ანუ სასურველი ელემენტის გასაღებს "Mila" მნიშვნელობით.
ეს ორი ფუნქცია ძალიან ჰგავს და არსებითად განსხვავდება მხოლოდ დაბრუნების მნიშვნელობით.
მნიშვნელობის პოვნა მრავალგანზომილებიან მასივში
მაგრამ რა მოხდება, თუ ჩვენ ვმუშაობთ მრავალგანზომილებიან მასივთან? ყოველივე ამის შემდეგ, მისი ელემენტები იქნება სხვა მასივები.
აქ ჩვენ მიერ უკვე განხილული ალგორითმები არ იმუშავებს.
სინამდვილეში ეს არც ისე რთულია, თქვენ უბრალოდ უნდა გაართულოთ მთელი მექანიზმი და გამოიყენოთ მარყუჟი, მაგალითად, foreach (), რომელიც შესანიშნავად მუშაობს მასივებით.
ვთქვათ, გვაქვს მრავალგანზომილებიანი მასივი. მისი უშუალო მნიშვნელობები არის სხვა მასივები, რომლებიც შეიძლება შეიცავდეს ელემენტის სასურველ მნიშვნელობას.
ყველაფერი რაც თქვენ უნდა გააკეთოთ არის ორიგინალური მასივის ელემენტების ციკლი foreach (). ამ მასივის თითოეული ელემენტი იქნება გაანალიზებული კლავიშად ($key) და მნიშვნელობად ($value).
მნიშვნელობა იქნება თითოეული მასივი, რომელიც მდებარეობს მთავარი მრავალგანზომილებიანი მასივის შიგნით. ჩვენ ვიმუშავებთ ამ მნიშვნელობებთან, ვეძებთ თითოეულ შიდა მასივში სასურველი ელემენტის მნიშვნელობას.
თუ აღმოვაჩინეთ, ჩვენ გამოვაჩენთ შეტყობინებას, რომ ასეთი ელემენტი არსებობს, ხოლო თუ არა, ჩვენ ვაჩვენებთ სხვა შეტყობინებას, რომ ასეთი ელემენტი არ არსებობს.
ვნახოთ ეს ყველაფერი მაგალითის კოდით:
"anna","id"=>234); $Mass2 = მასივი ("name"=>"anton","id"=>24); $Mass2 = მასივი("name"=>"ivan","id"=>007); foreach ($Mass2 როგორც $key => $value) ($name .= in_array("ivan",$value); ) if ($name) ექო "OK! ელემენტი აქ!"; else echo "არ აქვს ელემენტი!"; ?>
როგორც ხედავთ, ჯერ ჩვენ ვაცხადებთ თავად მრავალგანზომილებიან მასივს.
უფრო მეტიც, აქ თქვენ უნდა დაწეროთ არა მხოლოდ ტოლობის ნიშანი, არამედ „.=“.
ეს კეთდება ისე, რომ $name ცვლადი არ გადაიწეროს ყოველი გამეორებისას, არამედ დამატებული იყოს. ბოლოს და ბოლოს, თუ პირველ გამეორებისას ელემენტი მოიძებნება და მნიშვნელობა "true" ჩაიწერება $name ცვლადზე, მაგრამ მეორე გამეორებისას (ანუ მეორე შიდა მასივში) ელემენტის სასურველი მნიშვნელობა არ არის წარმოდგენილი. , მაშინ $name ცვლადის მნიშვნელობა უბრალოდ გადაიწერება და საბოლოოდ უბრალოდ ვერ მივიღებთ სწორ შედეგს.
როგორც გესმით, ამ კოდის შედეგი იქნება შეტყობინება „OK! ელემენტი აქ არის!
სცადეთ შეცვალოთ თქვენთვის სასურველი ელემენტი არარსებულზე და დაინახავთ შეტყობინებას "არ აქვს ელემენტი!"
რა თქმა უნდა, როდესაც გარკვეული ელემენტი ნაპოვნია ან არ არის ნაპოვნი, ჩვენ შეგვიძლია არა მხოლოდ შეტყობინებების ჩვენება, არამედ სხვა მოქმედებების შესრულება. ეს ყველაფერი დამოკიდებულია იმაზე, თუ რა უნდა გააკეთოთ. მაგალითად, თუ სასურველი მნიშვნელობა არის მასივში, შეგიძლიათ მომხმარებელს მიაწოდოთ კონკრეტული ინფორმაცია და ა.შ.
დღეისთვის სულ ესაა! იმედი მაქვს გაკვეთილი იყო ნათელი და სასარგებლო! სცადეთ თავად დაწეროთ მსგავსი კოდი, რომ სრულად გაიგოთ ყველაფერი.
და ველოდები თქვენს კომენტარებს.
გაუზიარეთ გაკვეთილი თქვენს მეგობრებს სოციალური ღილაკების გამოყენებით. ქსელები, რომლებიც მდებარეობს ქვემოთ. და ასევე გამოიწერეთ ბლოგის განახლებები. ჩვენ უკვე შევაგროვეთ სასარგებლო მასალების საკმაოდ კარგი არქივი და ისინი მხოლოდ შეივსება!
წარმატებულ პროგრამირებას გისურვებთ!
შენთან იყო ანა კოტელნიკოვა!
პროგრამირება ეხება სინტაქსს და სემანტიკას. პირველი განისაზღვრება ენის წესებით, მეორე კი დეველოპერის გამოცდილებით. რაც შეეხება მასივებს, დეველოპერს შეუძლია კონკრეტულად ჩატვირთოს სინტაქსი სემანტიკით. ეს ჯერ კიდევ არ არის ობიექტი, მაგრამ ის აღარ არის მასივი ტრადიციული გაგებით. PHP გაძლევთ შესაძლებლობას შექმნათ სხვადასხვა ტიპის ცვლადების მასივები, მათ შორის თავადაც. მასივის ელემენტი შეიძლება იყოს ფუნქცია, ანუ უნარი ჩატვირთოს მასივი რეალური ალგორითმით, რეალური მნიშვნელობით.
სინტაქსი სტაბილურია, მაგრამ იცვლება ვერსიიდან ვერსიამდე და შეიძლება ყოველთვის არ იყოს თავსებადი, თუნდაც ქვემოდან ზევით. პროგრამის პორტაბელურობა გასული საუკუნის კარგად დავიწყებული მიღწევაა. სემანტიკა ვითარდება და ყოველთვის შეიძლება გამოყენებულ იქნას არა მხოლოდ ნებისმიერი ენის ნებისმიერ ვერსიაში; ტრადიციად იქცა სინტაქსური კონსტრუქციების გამოყენება იმის გამოსახატავად, რაც ენის წესებითაც კი არ იყო გათვალისწინებული. ამის გაგება ყველაზე მარტივად შეიძლება მასივების მაგალითის გამოყენებით.
მასივების აგება
მასივს PHP-ში აქვს მოსახერხებელი სინტაქსი და ფუნქციონირება. ეს შეიძლება წინასწარ იყოს აღწერილი, მაგრამ ხშირად მოსახერხებელია მასივების შექმნა საჭიროებისამებრ.
საჯარო $aNone = მასივი(); // მასივი აღწერილია და არაფერს შეიცავს
public $aFact = array("ავოკადო", "ატამი", "ალუბალი"); // ამ მასივს აქვს სამი ელემენტი
მდგომარეობის შემოწმებისას მასივის შექმნა:
$cSrcLine = "გაანალიზებული მონაცემთა ხაზი";
ამისთვის ($i=0; $i<13; $i++) {
if (checkFunc($cSrcLine, $cUserLine) (
$aResult = "დიახ"; // დაამატეთ PHP მასივში
$aResult = "არა";
ამ მაგალითის შესრულების შედეგად შეიქმნება 13 ელემენტის მასივი, რომელთა მნიშვნელობები იქნება მხოლოდ სტრიქონები "დიახ" ან "არა". ელემენტები მიიღებენ ინდექსებს 0-დან 12-მდე. იგივე ეფექტის მიღწევა შესაძლებელია PHP მასივის "მომავლის" სტრიქონში ჩაწერით:
$cFutureArray = "";
ამისთვის ($i=0; $i<13; $i++) {
$cUserLine = inputUserLine(); // შეიტანე რამე
if ($i > 0) ($cFutureArray .= "|"; )
if (checkFunc($cSrcLine, $cUserLine) ( $cFutureArray .= "დიახ";
) else ($cFutureArray .= "არა"; )
$aResult = აფეთქება ("|", $cFutureArray);
მრავალგანზომილებიანი მასივები
ბევრი კონტენტის მართვის სისტემა (CMS) ფართოდ იყენებს მასივებს. ერთის მხრივ, ეს კარგი პრაქტიკაა, მეორე მხრივ, ართულებს გამოყენებას. მაშინაც კი, თუ ავტორს ესმის "PHP მასივი მასივის შიგნით" დოქტრინა, მან არ უნდა ბოროტად გამოიყენოს იგი: არა მხოლოდ დეველოპერს მოუწევს შეეგუოს რთულ აღნიშვნას. ხშირად, გარკვეული პერიოდის შემდეგ, თავად შემქმნელს დიდხანს ემახსოვრება ის, რაც თავდაპირველად დაწერა:
"view_manager" => მასივი (41, "template_path_stack" => მასივი (__DIR__ . "/../view",),
"router" => array("routes" => array("sayhello" => array(
"type" => "Zend\Mvc\Router\Http\Literal",
"options" => array("route" => "/sayhello", "defaults" => array(
"კონტროლერი" => "Helloworld\Controller\Index", "action" => "ინდექსი")))))
"კონტროლერები" => მასივი ("invokables" => მასივი(
"Helloworld\Controller\Index" => "Helloworld\Controller\IndexController"))
ეს არის მაგალითი ZF 2-დან "PHP მასივი მასივის შიგნით" პრაქტიკის. თავიდან არ არის ძალიან შთამაგონებელი, მაგრამ ის მუშაობს და სავარაუდოდ ამ ჩარჩოს წარმატებულს ხდის (მაგალითი ZendSkeletonApplication/module/Helloworld/config/module.config.php) .
მასივი არის მნიშვნელოვანი მონაცემთა კონსტრუქცია დიზაინისა და განვითარების დროს. მისი მრავალგანზომილებიანი ვერსია ოდესღაც პოპულარული იყო, მაგრამ დროთა განმავლობაში რჩებოდა მაქსიმუმ ორი ან სამი განზომილების მასივების საჭიროება. ეს უფრო მარტივი და გასაგებია ამ გზით და პროფესიული თვალსაზრისით, როდესაც რაღაც იწყებს გამრავლებას, ეს ნიშნავს, რომ რაღაც არასწორია პრობლემის განცხადებაში ან კოდში.
მარტივი, ხელმისაწვდომი და გასაგები
PHP-ში მასივის შიგნით მასივის შექმნისას უმჯობესია თავი შეიზღუდოთ ორ ან სამ დონეზე. მიუხედავად PHP-ის სტაბილურობისა და სანდოობისა, ის უშვებს შეცდომებს სინტაქსური სტრუქტურების დამუშავებისას. თქვენ შეგიძლიათ შეეგუოთ ამას, თუ კარგი კოდის რედაქტორი გაქვთ და მიეჩვიეთ ფრჩხილების და მძიმეების ზუსტად დათვლას. ამასთან, PHP არ აკონტროლებს მონაცემთა ტიპებს (ეს არის თანამედროვე პროგრამირების კარმა) და დეველოპერს საშუალებას აძლევს გამოიყენოს სემანტიკური შეცდომები.
ცვლადების ტიპების ან საკუთარი იდეების კონტროლის წესი სემანტიკის სინტაქსად გადაქცევისთვის ხშირად მიუწვდომელი ფუფუნებაა. ეს არის სკრიპტის სიჩქარის, კოდის წაკითხვის დაკარგვა, ... რადგან კოდირების სიმარტივე ყოველთვის აუცილებელია.
PHP-ს აქვს მნიშვნელოვანი უარყოფითი თვისება: როდესაც გაურკვევლობა ჩნდება, სკრიპტი უბრალოდ იყინება. ყველა გამმართველს არ შეუძლია გაუმკლავდეს გაუთვალისწინებელ გარემოებებს და ბევრი რამ არის დამოკიდებული დეველოპერის გამოცდილებასა და ინტუიციაზე. რაც უფრო მარტივია ალგორითმი, მით უფრო ხელმისაწვდომია ინფორმაცია სტრუქტურირებული, მით მეტია შეცდომის პოვნის ან საერთოდ თავიდან აცილების შანსი.
დამახასიათებელია, რომ როდესაც პირველი მასივები გამოჩნდა, შემოთავაზებული იქნა მონაცემების ვარიანტები სტრუქტურების სახით - უხერხული მცდელობა, შექმნათ რაღაც სხვადასხვა ტიპის მონაცემებიდან. პირველი გადარჩა და შეიძინა ახალი ეფექტური სინტაქსი, ხოლო მეორე გახდა ისტორია.
მარტივი და ასოციაციური მასივები
ორგანზომილებიანი მასივის აღნიშვნა არის ფრჩხილების კიდევ ერთი წყვილი "[" და "]", მაგალითად: $aSrcData ნიშნავს მასივის ელემენტზე წვდომას, რომელიც შედის $aSrcData მასივში. PHP-ში მონაცემების წინასწარ გამოცხადების მოთხოვნა არ არის. ნებისმიერი მითითებული ინფორმაცია ყოველთვის შეიძლება დადასტურდეს არსებობის შესახებ.
ძალიან ეფექტურია რაღაცის შექმნა მხოლოდ მაშინ, როცა საჭიროა, იმ ფორმით, როგორიც იყო საჭირო და გაანადგურო, როცა ამის საჭიროება გაქრება. მნიშვნელოვანი სახელების გასაღებებად (ინდექსების) გამოყენებით შეგიძლიათ მიიღოთ წაკითხვადი კონსტრუქტები, რომლებიც აზრიანია ალგორითმში არსებული ადგილის კონტექსტში:
$aAnketa["name"] = "ივანოვი";
$aAnketa["ასაკი"] = 42;
$aAnketa["work"] = "დირექტორი";
$aAnketa["აქტიური"] = მართალია;
$aTable = $aAnketa;
$aAnketa["name"] = "პეტროვი";
$aAnketa["ასაკი"] = 34;
$aAnketa["work"] = "მენეჯერი";
$aAnketa["აქტიური"] = მართალია;
$aTable = $aAnketa;
$aAnketa["name"] = "აფანასიევი";
$aAnketa["ასაკი"] = 28;
$aAnketa["work"] = "მუშა";
$aAnketa["active"] = false;
$aTable = $aAnketa;
$sOne .= implode ("; ", $aTable) . "
"; // მეორე PHP მასივი სტრიქონში
$sOne .= $aTable["სამუშაო"]; // მეორე მასივის ერთ ელემენტზე წვდომა
ამ მაგალითის შედეგი (პირველი მასივი ნორმალურია, მასში კლავიშები იწყება 0-დან, მეორე მასივი ასოციაციურია, მას აქვს ოთხი კლავიში: "სახელი", "ასაკი", "სამუშაო", "აქტიური"):
$sOne = "პეტროვი; 34; მენეჯერი; 1
მენეჯერი";
ეს მარტივი მაგალითი გვიჩვენებს, თუ როგორ შეიძლება შექმნილი კითხვარის გამოყენება ყველა თანამშრომლისთვის. თქვენ შეგიძლიათ შექმნათ თანამშრომლების მასივი ინდექსებით პერსონალის ნომრებით და, თუ გჭირდებათ კონკრეტული თანამშრომელი, შეარჩიოთ იგი პერსონალის ნომრით.
თუ ორგანიზაციას აქვს განყოფილებები, ან არის სეზონური მუშები, ან ცალკე უნდა დაადგინოთ მომუშავე პენსიონერები, ... დიზაინი "PHP მასივი მასივში" ძალიან მოსახერხებელია, მაგრამ არასოდეს არ უნდა გაიტაცოთ განზომილებით. ორი ან სამი განზომილება არის ლიმიტი ეფექტური გადაწყვეტისთვის.
გასაღებები მასივებთან მუშაობისთვის
თუ ადრე მნიშვნელობა ჰქონდა, როგორ იყო ყველაფერი მოწყობილი, მაშინ ბოლო წლებში ბინარული ეპოქის ტრადიციები, როდესაც პროგრამისტს სურდა სცოდნოდა ზუსტად როგორ ინახებოდა მასივის ელემენტები და სურდა მათზე პირდაპირი წვდომა, სრულიად დავიწყებული იყო. გამოჩნდა მრავალი სიმბოლოს კოდირება, რომლებიც მეხსიერებაში ერთ ბაიტზე მეტს იკავებს. სიტყვა "ბიტი" ახლა მხოლოდ ბიტის საძიებო ოპერაციებშია შესაძლებელი, მაგრამ PHP მასივის ძებნა ცალკე თემაა. ელემენტებზე წვდომა შეიძლება იყოს მარტივი და ასოციაციური. პირველ შემთხვევაში, მასივის ელემენტები (რომლებიც PHP-ში ხელმისაწვდომია ნებისმიერი ტიპის) დანომრილია 0, 1, 2, ... მეორე შემთხვევაში, პროგრამისტი წვდომისთვის აკონკრეტებს საკუთარ ინდექსს, რომელსაც ხშირად "გასაღებს" უწოდებენ. სასურველი მნიშვნელობა.
$aLine["fruit"] = "ფორთოხალი"; // აქ PHP მასივის გასაღები = "ნაყოფი"
ან (ისე, რომ ყველაფერი სწორია, გვერდის კოდირებისა და კოდის გათვალისწინებით):
$aLine = iconv("UTF-8", "CP1251", "ფორთოხალი");
$aLine მასივში ახალი მნიშვნელობის დამატებისას:
$aLine = iconv("UTF-8", "CP1251", "ატამი");
$aLine = iconv("UTF-8", "CP1251", "კიტრი");
$aLine = iconv("UTF-8", "CP1251", "ბადრიჯანი");
მარყუჟის შესრულების შედეგად:
foreach ($aLine როგორც $ck => $cv) (
$cOne .= $ck . "=" . $cv. "
";
}
მიიღება:
ხილი = ფორთოხალი
0=ატამი
ბოსტნეული = კიტრი
1 = ბადრიჯანი
მასივის PHP გასაღები ელემენტების „ატმის“ და „ბადრიჯანის“ დამატებისას ფორმირდება თანმიმდევრობით 0-დან და მისი მნიშვნელობის მითითებისას ტოლი იქნება ამ მნიშვნელობის.
ელემენტების ამოღება მასივიდან
უმარტივესი გზაა მისი დამუშავების დროს. ამ შემთხვევაში, მაგალითად, მარყუჟის შესრულების შედეგად, ხდება ორიგინალური მასივის სკანირება და ყალიბდება ახალი, რომელშიც უბრალოდ არ იწერება ზედმეტი ელემენტები.
ეს შეიძლება უფრო ადვილი იყოს. თუ ბოლო მაგალითს მივმართავთ:
unset ($aLine); // ამოიღეთ მასივის ელემენტი PHP
მაშინ შედეგი იქნება:
ხილი = ფორთოხალი
ბოსტნეული = კიტრი
1 = ბადრიჯანი
მასივის ელემენტების მანიპულირების მრავალი ვარიანტი არსებობს. მაგალითად, ფუნქციების გამოყენებით: implode() და explode(), შეგიძლიათ ჩაწეროთ PHP მასივი სტრიქონში ერთი დელიმიტერით და გააანალიზოთ იგი სხვა მასივში სხვა დელიმიტერის გამოყენებით.
იმისათვის, რომ უბრალოდ წაშალოთ მთელი მასივი PHP-ში, უბრალოდ ჩაწერეთ: unset($aLine);
საკმარისია.
ძიება მასივში
PHP შეიცავს სპეციალურ საძიებო და in_array() ფუნქციებს, მაგრამ სანამ მათ გამოყენებას გადაწყვეტთ, თქვენ თავად უნდა განიხილოთ PHP მასივის ძიება.
ნებისმიერ პროექტს აქვს კონკრეტული კონსტრუქციული მასივები, განსაკუთრებით მაშინ, როდესაც სემანტიკის ნაწილი გადადის სინტაქსში და წარმოდგენილია ძალიან სპეციფიკური შინაარსიანი გასაღებების ნაკრებით. ეს საშუალებას გაძლევთ შეასრულოთ თქვენი საკუთარი საძიებო ფუნქციები, რომლებიც ასევე შეიძლება იყოს მარკირებული მნიშვნელობით.
PHP-ში შეგიძლიათ გამოიძახოთ ფუნქციები, რომელთა სახელიც განისაზღვრება პროგრამის შესრულების დროს. ძალიან პრაქტიკული მაგალითი PHPWord ბიბლიოთეკიდან, რომელიც საშუალებას გაძლევთ წაიკითხოთ და შექმნათ MS Word დოკუმენტები:
$elements = მასივი ("ტექსტი", "ინლაინ", "TextRun", "Link", "PreserveText", "TextBreak",
"ListItem", "ListItemRun", "Table", "Image", "Object", "Sootnote",
"Endnote", "CheckBox", "TextBox", "Field", "Line");
$ფუნქციები = მასივი();
ამისთვის ($i = 0; $i< count($elements); $i++) {
$functions[$i] = "დამატება" . $ელემენტები[$i];
}
შედეგად, $functions მასივი მიიღებს $elements მასივის მნიშვნელობებს, ანუ რეალური ფუნქციების სახელებს, რომლებიც მუშაობენ რეალური დოკუმენტის ელემენტებთან.
$elements-ზე $functions-ზე დარეკვით, შეგიძლიათ მიიღოთ სრულყოფილი ძიება და სწრაფი შედეგები.
ნივთების დახარისხება
მონაცემთა დახარისხების ამოცანა მნიშვნელოვანია და PHP გთავაზობთ რამდენიმე ფუნქციას ამისათვის: sort(), rsort(), asort(), ksort(), ... აღმავალი და დაღმავალი ელემენტები, მეორე ორი ფუნქცია ინახავს კავშირებს გასაღებებსა და მნიშვნელობებს შორის. . ზოგჯერ აზრი აქვს მასივის მნიშვნელობების შემთხვევით არევას - shuffle().
დახარისხებისთვის PHP ფუნქციების გამოყენებისას არ უნდა დაგვავიწყდეს, რომ ელემენტებს შეიძლება ჰქონდეს არა მხოლოდ სხვადასხვა ტიპის, არამედ არც მთლად ბუნებრივი შინაარსი. უპირველეს ყოვლისა, ძალიან ფრთხილად უნდა იყოთ რუსული ასოების შემცველი სტრიქონების დახარისხებაზე, თარიღების დახარისხებაზე, ასევე სხვადასხვა ფორმატში დაწერილ რიცხვებზე.
საუკეთესო გზა, რომ თავად დაწეროთ იდეალური გადაწყვეტა, ყოველ შემთხვევაში, სკრიპტის ტესტირების ეტაპზე, არის ხელით დახარისხება. ეს ხელს შეუწყობს გაუთვალისწინებელი სიტუაციების გათვალისწინებას.
სიმებიანი მასივები
implode() და explode() ფუნქციების წყალობით, მასივი შეიძლება ადვილად გარდაიქმნას სტრიქონად და დაბრუნდეს უკან. ეს საშუალებას გაძლევთ შეინახოთ მონაცემები კომპაქტურ წარმოდგენაში და საჭიროებისამებრ გააფართოვოთ ისინი მოსახერხებელ მდგომარეობაში.
სტრინგად გარდაქმნილი მასივი ხსნის ახალ შესაძლებლობებს. მაგალითად, ტექსტში საკვანძო სიტყვების ძიების ამოცანა მოითხოვს, რომ ნაპოვნი არ დაემატოს ხელახლა.
$cSrcLine = "ტექსტური ტექსტის ListItemRun TextBox ListItem TextBox CheckBox TextBox სქოლიო";
$aSrc = აფეთქება (" ", $cSrcLine);
$cDstLine = "";
ამისთვის ($i=0; $i< count($aSrc); $i++) {
$cFind = "[" . $aSrc[$i] . "]";
if (! is_integer(strpos($cDstLine, $cFind))) (
$cDstLine .= $cFind;
}
}
$aDst = აფეთქება ("][", $cDstLine);
$cOne = implode("; ", $aDst);
შედეგად, $cOne ცვლადი მიიღებს მხოლოდ იმ მნიშვნელობებს წყაროს სტრიქონიდან, რომლებიც იქ ერთხელ გამოჩნდება: "ტექსტი; ListItemRun; TextBox; ListItem; Check; Box; CheckBox; სქოლიო".
რუსული ენა გასაღებებში და მნიშვნელობებში
არ არის რეკომენდირებული სინტაქსურ სტრუქტურებში ეროვნულ დაშიფვრებთან დაკავშირებული რაიმეს გამოყენება. რუსული, ისევე როგორც ყველა სხვა ენა, რომლის სიმბოლოები სცილდება a-z-ს, არ შექმნის პრობლემებს მონაცემთა რეგიონში ყოფნისას, მაგრამ არა კოდის სინტაქსში. ზოგჯერ PHP-ში მარტივი დავალებაც კი „მაივი პრინტერზე ან ეკრანზე გამოტანა“ გამოიწვევს „გიჟურ შეცდომებს“ და უფრო ხშირად სკრიპტი უბრალოდ ჩერდება.
PHP არის ლოიალური ენა და ტოლერანტულია ეროვნული კოდირების მიმართ, მაგრამ არის ბევრი სიტუაციები, როდესაც სამუშაოს დასრულებული მოცულობა ხელახლა უნდა გაკეთდეს მხოლოდ იმიტომ, რომ საკვანძო მნიშვნელობა ჩნდება საჭირო ადგილას და საჭირო დროს, რაც შეუძლებელია. აღიარებს.
PHP სინტაქსი და ენის გარემო
უნდა გვახსოვდეს, რომ PHP სინტაქსი ერთია, მაგრამ ამ სინტაქსის კონსტრუქციები „საქმიანობს“ სხვა აპლიკაციებთან, ოპერაციულ სისტემასთან, ტექნიკის ვარიანტებთან. ბევრი ვარიანტია, ყველაფრის უზრუნველყოფა არასდროს არის შესაძლებელი.
წესი „კოდში არის მხოლოდ კოდი, მაგრამ არის ყველა სახის ინფორმაცია შეყვანისას, შიგნით და გამომავალში“ დაგეხმარებათ თავიდან აიცილოთ გაუთვალისწინებელი სიურპრიზები. მასივში PHP მნიშვნელობა შეიძლება იყოს „რუსული“, მაგრამ მისი გასაღები სინტაქსურად სწორი უნდა იყოს არა მხოლოდ მოცემული ენის, არამედ მისი ოპერაციული გარემოს თვალსაზრისითაც.
მასივებთან მუშაობისას ერთ-ერთი მთავარი ოპერაცია არის კონკრეტული მნიშვნელობის ძიება. ამისათვის შექმნილია PHP array_search() ფუნქცია. მას შეუძლია დაამუშავოს როგორც ერთგანზომილებიანი, ისე ასოციაციური კოლექციები, დააბრუნოს მოძიებული მნიშვნელობის გასაღები, თუ ის მასივშია ნაპოვნი.
სინტაქსი
array_search() ფუნქციის ოფიციალური აღწერა PHP-ში შემდეგია:
შერეული მასივი_ძიება (შერეული მნიშვნელობა, მასივი $კოლექცია [, bool მკაცრი])
შეყვანის პარამეტრები:
- $collection - მასივი, რომელშიც განხორციელდება ძიება;
- ღირებულება - ნებისმიერი ტიპის სასურველი მნიშვნელობა;
- მკაცრი არის არჩევითი ლოგიკური დროშა, რომელიც ადგენს მკაცრი ტიპის შედარების მექანიზმს.
მოქმედების მექანიზმი
PHP array_search() ფუნქცია სათითაოდ ადარებს მნიშვნელობას კოლექციური მასივის ყველა მნიშვნელობასთან. ნაგულისხმევად, შედარება ხორციელდება ოპერანდების ტიპების გათვალისწინების გარეშე. ამ პარამეტრის შეცვლა შესაძლებელია მკაცრი დროშის TRUE-ზე დაყენებით. სტრიქონების შედარება რეგისტრირებულია.
თუ შესატყვისი იქნა ნაპოვნი, ნაპოვნი ელემენტის შესაბამისი გასაღები ბრუნდება და ფუნქცია წყვეტს მუშაობას. ამიტომ, ის არ შეიძლება გამოყენებულ იქნას მასივში სასურველი მნიშვნელობის მრავალჯერადი შემთხვევების დასადგენად.
თუ შესატყვისები არ არის ნაპოვნი, ფუნქცია დააბრუნებს ლოგიკურ მნიშვნელობას მნიშვნელობა FALSE.
თქვენ უნდა შეამოწმოთ დაბრუნებული შედეგი მკაცრი თანასწორობის ოპერატორის გამოყენებით (===). ეს მნიშვნელოვანია, რადგან ფუნქციამ შეიძლება დააბრუნოს მნიშვნელობა, რომელიც გადაცემულია FALSE-ზე, როგორიცაა 0 ან ცარიელი სტრიქონი.
გამოყენების მაგალითები
მაგალითი 1. PHP array_search() ფუნქციაზე მრავალგანზომილებიანი მასივის გადაცემისას, სამუშაოს შედეგი იქნება მოძიებული ელემენტის გასაღები.
"ზამთარი", "season2" => "გაზაფხული", "season3" => "ზაფხული", "season4" => "შემოდგომა"); $result1 = array_search ("ზამთარი", $მასივი); $result2 = array_search ("ზაფხული", $მასივი); $result3 = array_search ("აპრილი", $მასივი); ?>
ამ მაგალითში $result1 დაყენდება "season1", $result2 დაყენდება "season3" და $result3 დაყენდება ლოგიკურ მნიშვნელობაზე FALSE, რადგან სტრიქონი "april" არ ჩანს წყაროს მასივში.
მაგალითი 2. PHP array_search() ფუნქციას ასევე შეუძლია დაამუშავოს ერთგანზომილებიანი მასივი, განიხილოს მისი გასაღებები, როგორც შემდეგი რიცხვითი ინდექსები.
$result ცვლადი დაყენდება 1-ზე, $მასივის "hunter" ელემენტის ინდექსის მიხედვით.
მაგალითი 3. შესაძლო შეცდომა შედეგის გაანალიზებისას.
"ვაშინგტონი", 1 => "ადამსი", 2 => "ჯეფერსონი", 3 => "მედისონი", 4 => "მონრო"); $result = array_search ("ვაშინგტონი", $presidents); if (!$result) ( ექო "გ. ვაშინგტონი არ იყო აშშ-ს პირველი პრეზიდენტი"; ) ?>
ასე რომ, შედეგის მკაცრი თანასწორობით შემოწმების გარეშე, შეგიძლიათ მიიღოთ მოულოდნელი შეტყობინება, რომ ჯორჯ ვაშინგტონი არ იყო შეერთებული შტატების პირველი პრეზიდენტი.
მაგალითი 4: ბრუნდება მხოლოდ პირველი ნაპოვნი მატჩის გასაღები.
მიუხედავად იმისა, რომ მნიშვნელობა, რომელსაც თქვენ ეძებთ, ჩნდება სამჯერ მასივში, ფუნქცია დააბრუნებს მხოლოდ აღმოჩენილ პირველ შედეგს - 0. მრავალი შესატყვისის საპოვნელად რეკომენდებულია PHP array_keys() ფუნქციის გამოყენება.