PHP: array_search - სწრაფი ძიება მასივის. PHP array_search: მოძებნეთ მნიშვნელობა მასივში PHP ძიება საკვანძო მნიშვნელობის მდიდარ მასივში

(PHP 4>=4.0.5, PHP 5)

array_search -- ეძებს მოცემულ მნიშვნელობას მასივში და წარმატებით აბრუნებს შესაბამის კლავიშს

აღწერა

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

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

Შენიშვნა: PHP 4.2.0-მდე, მასივის_ძიება ()შემობრუნდა, როცა არ მუშაობდა NULL zamіst ცრუ .

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

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

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

Სინტაქსი

array_search() ფუნქციის ოფიციალური აღწერა PHP-ში ასე გამოიყურება:

შერეული მასივი_ძიება (შერეული მნიშვნელობა, მასივი $კოლექცია [, bool მკაცრი])

შეყვანის პარამეტრები:

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

რობოტის მექანიზმი

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

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

თუ გაქცევები არ არის ნაპოვნი, ფუნქცია დააბრუნებს მნიშვნელობას FALSE-ზე.

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

წაისვით vikoristannya

მაგალითი 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, "myslyvets" ელემენტის ინდექსთან ერთად $ მასივში.

მაგალითი 3. შესაძლებელია შედეგის ანალიზის მცდელობა.

"ვაშინგტონი", 1 => "ადამსი", 2 => "ჯეფერსონი", 3 => "მედისონი", 4 => "მონრო"); $result = array_search ("ვაშინგტონი", $presidents); if (!$result) ( ექო "ჯი. ვაშინგტონი არ იყო შეერთებული შტატების პირველი პრეზიდენტი"; ) ?>

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

კონდახი 4. პირველი აღმოჩენილი გაქცევის გასაღები მოტრიალებულია.

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

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

მასივში ძიების სითხის რეგულირებით დამატებითი ფუნქციის გამოყენებით, მასივის გამეორებით foreach და while მარყუჟებში. 10-100 ელემენტზე ვარიაციების მასივი წარმოუდგენელია და ამავდროულად ცოტა რამ შეიძლება გამოტოვონ. და დიდი მასივების ღერძი კიდევ უფრო მრავალფეროვანი აღმოჩნდა. მასივის გაზრდილ ზომასთან ერთად, ძებნის დრო მნიშვნელოვნად გაიზარდა. ასი ათასი ელემენტით, foreach-ის სიჩქარე დაეცა 0,013 წამამდე, ხოლო ხოლო - 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 ციკლით *****************

// დაწყების დაწყების საათი
$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("სხვა Wicon კოდი შუაში: %.7f წამი", $ srednee2);
printf("მესამე ვიკონური კოდი შუაში: %.7f წამი", $ srednee3);

//შედეგი:
// პირველი Wiconano კოდი შუაში: 0.0000295 წამი
// სხვა Wiconano კოდი შუაში: 0.0153386 წამი
// მესამე Wicon კოდი შუაში: 0.0226001 წამი

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

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

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

ჩვენ მათ დღეს გადავხედავთ.

მასივის მნიშვნელობის აშკარაობის შემოწმება. ფუნქცია in_array()

ფუნქცია in_array ()საშუალებას გვაძლევს შევამოწმოთ მასივში რაიმე მნიშვნელობის არსებობა.

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

ფუნქცია იღებს 2 ძირითად პარამეტრს:<Что ищем>і<Где ищем>.

თქვენ ასევე შეგიძლიათ გამოიყენოთ კიდევ ერთი არასავალდებულო პარამეტრი:<Тип данных>. ვინაიდან ამ მესამე არასიბლანტის პარამეტრს აქვს მნიშვნელობა მართალიაშემდეგ მოწმდება სხვა ტიპის მონაცემები. მაშინ "2" და 2 არ იქნება იგივე. პირველს აქვს თანმიმდევრობა, მეორეს აქვს რიცხვი. შემდეგ კი მთელი ფუნქცია in_array ()არ შემობრუნდე მართალია.

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

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

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

შეცვალეთ ფუნქციის პირველი პარამეტრი ნებისმიერ შეუსაბამო ელემენტზე და მიიღებთ შეტყობინებას "არა".

მასივის მნიშვნელობის აშკარაობის შემოწმება. array_search() ფუნქცია

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

ფუნქცია იღებს იგივე პარამეტრებს, როგორც ადრე. ამ შემთხვევაში მესამე პარამეტრიც არასაჭიროა.

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

„ჟოვტენ“, „ფული“ => 200, „სახელი“ => „მილა“); $key = array_search ("Mila", $Mass1); if($key) echo $key; ?>

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

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

ძებნა მნიშვნელოვანია მდიდარ მსოფლიო მასივში

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

აქ უკვე განხილული ალგორითმები არ არის სასარგებლო.

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

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

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

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

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

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

"ანა", "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 = მასივი(); // აღწერების მასივი და არა შურისძიება

$aFact = მასივი ("ავოკადო", "ატამი", "ალუბალი"); // ამ მასივს აქვს სამი ელემენტი

მასივის შექმნა ნებისმიერი გონების შებრუნების პროცესში:

$cSrcLine = "ანალიზის მონაცემების ხაზი";

ამისთვის ($i=0; $i<13; $i++) {

if (checkFunc($cSrcLine, $cUserLine) (

$aResult = "დიახ"; // PHP მასივის დამატება

$aResult = "არა";

ამ ექსპერიმენტის შედეგად შეიქმნება 13 ელემენტისგან შემდგარი მასივი, რომელთა მნიშვნელობები იქნება "დიახ" ან "არა" რიგებში. ელემენტებს აქვთ ინდექსები 0-დან 12-მდე. იგივე ეფექტი შეიძლება შეიცვალოს მწკრივში „Mayday“ PHP მასივის წინასწარ ჩაწერით:

$cFutureArray = "";

ამისთვის ($i=0; $i<13; $i++) {

$cUserLine = inputUserLine(); // შეიყვანეთ chogos

if ($i > 0) ($cFutureArray .= "|"; )

if (checkFunc($cSrcLine, $cUserLine) ( $cFutureArray .= "დიახ";

) else ($cFutureArray .= "არა"; )

$aResult = აფეთქება ("|", $cFutureArray);

მდიდარი მსოფლიო მასივები

არსებობს უამრავი ვებსაიტის მართვის სისტემა (SMS), რომლებიც გამოიყენება დიდი რაოდენობით. ერთის მხრივ, ეს კარგი პრაქტიკაა, მეორე მხრივ, ძნელია სტაგნაცია. თუმცა, რადგან ავტორს ესმოდა დოქტრინა „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"))

ეს არის პრაქტიკის მაგალითი „PHP მასივი მასივში“ ZF 2-დან. თქვენ არ გჭირდებათ ამაზე ფიქრი, მაგრამ თქვენ შეგიძლიათ გახადოთ ეს ჩარჩო წარმატებული (მაგალითი ZendSkeletonApplication/module/Helloworld/config/module-დან. config.php მოდული).

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

მარტივი, ხელმისაწვდომი და გასაგები

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

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

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

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

აპატიე და ასოციაციური სფეროები

ორგანზომილებიანი მასივის ჩაწერა არის კიდევ ერთი წყვილი რკალი "[" და "]", მაგალითად: $aSrcData ნიშნავს მასივის ელემენტის მასშტაბირებას, რომელიც შედის $aSrcData მასივის წინ. PHP-ს არ აქვს უკნიდან მონაცემების გამჟღავნების შესაძლებლობა. ნებისმიერი მითითებული ინფორმაცია შეიძლება გადამოწმდეს გამოყენებამდე.

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

$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 = "Petriv; 34; მენეჯერი; 1
მენეჯერი";

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

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

გასაღებები რობოტებისთვის მასივებით

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

$aLine["fruit"] = "ფორთოხალი"; // აქ PHP გასაღების მასივი = "ნაყოფი"

ან (ისე, რომ ყველაფერი სწორია წინა კოდების მიხედვით):

$aLine = iconv("UTF-8", "CP1251", "ფორთოხალი");

$aLine მასივში ახალი მნიშვნელობის დამატებისას:

$aLine = iconv("UTF-8", "CP1251", "ატამი");
$aLine = iconv("UTF-8", "CP1251", "ogirok");
$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 მასივიდან, რაც არის რეალური ფუნქციების სახელები, რომლებიც აკავშირებს სამუშაოს დოკუმენტის რეალურ ელემენტებთან.

$functions ფუნქციის გამოძახებით $elements-ისთვის, შეგიძლიათ მიიღოთ სრულყოფილი ძიება და სწრაფი შედეგი.

ელემენტების დახარისხება

მონაცემთა სწორი დახარისხება მნიშვნელოვანია და PHP ამისთვის უზრუნველყოფს უამრავ ფუნქციას: sort(), rsort(), asort(), ksort(), ... ელემენტების გაზრდისა და ცვლილებებისთვის, ორი ფუნქცია ინახავს მონაცემებს კლავიშებს შორის. ამი და მნიშვნელობები. ზოგჯერ შეგიძლიათ მასივის მნიშვნელობების არევა შემთხვევითი მეთოდის გამოყენებით - shuffle().

Vickory 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 მნიშვნელობები შეიძლება იყოს "რუსული", მაგრამ გასაღები პასუხისმგებელია სინტაქსურად სწორი იყოს არა მხოლოდ მოცემული ენის, არამედ ნაწარმოების შუა ნაწილის პოზიციაზე.