უახლესი განახლება: 1.11.2015

არის_მასივის ფუნქცია

is_array() ფუნქცია ამოწმებს არის თუ არა ცვლადი მასივი და თუ არის, ის აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false. მაგალითად:

$isar = არის_მასივი ($ტექნიკა); echo ($isar==true)?"this is an array":"ეს არ არის მასივი";

რაოდენობა/ზომის ფუნქციები

count() და sizeof() ფუნქციები იღებენ ელემენტების რაოდენობას მასივში:

$number = count($technics); // იგივეა, რაც // $number = sizeof($technics); echo "ტექნიკის მასივში არის $number of ელემენტები";

ჩარევის ფუნქციები

Shuffle ფუნქცია შემთხვევით ანაწილებს მასივის ელემენტებს:

$os = მასივი ("Windows 95", "Windows XP", "Windows Vista", "Windows 7", "Windows 8", "Windows 10"); shuffle($os); print_r($os); // ერთ-ერთი შესაძლო ვარიანტი // Array ( => Windows 95 => Windows 7 => Windows Vista => Windows XP => Windows 10 => Windows 8)

კომპაქტური ფუნქციები

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

Apple II => Apple => 1978) ?>

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

მასივების დახარისხება

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

ზრდადი თანმიმდევრობით დასალაგებლად გამოიყენეთ asort ფუნქცია:

"Lenovo IdeaTab A3500", "samsung" => "Samsung Galaxy Tab 4", "apple" => "Apple iPad Air"); asort ($ტაბლეტები); ექო"

"; foreach ($ტაბლეტები $key => $value) (ექო"
• $key: $value
";) ექო"

"; ?>

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

SORT_REGULAR: დალაგების ავტომატური შერჩევა

SORT_NUMERIC: რიცხვითი დალაგება

SORT_STRING: დალაგება ანბანურად

მოდით პირდაპირ მივუთითოთ დახარისხების ტიპი:

Asort($ტაბლეტი, SORT_STRING);

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

Arsort ($ტაბლეტები);

დახარისხება გასაღებების მიხედვით

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

Ksort($ტაბლეტი, SORT_STRING);

კლავიშების მიხედვით დახარისხება საპირისპირო თანმიმდევრობით ხდება krsort() ფუნქციით:

Krsort ($ტაბლეტები);

ბუნებრივი დახარისხება

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

Windows 10 => Windows 7 => Windows 8) ?>

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

Windows 7 => Windows 8 => Windows 10) ?>

თუ ჩვენ ასევე გვჭირდება დალაგება, რომ რეგისტრირებული იყოს, მაშინ შეგვიძლია გამოვიყენოთ natcasesort() ფუნქცია.

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

კერძოდ, ამ გადაწყვეტის უპირატესობებში შედის:

• ის მრავალჯერადი გამოყენებადი: თქვენ აკონკრეტებთ დალაგების სვეტს, როგორც ცვლადს და არა მას ხისტი კოდირებისთვის.
• მოქნილი: შეგიძლიათ მიუთითოთ მრავალი დახარისხების სვეტი (რამდენიც გსურთ) - დამატებითი სვეტები გამოიყენება გამყოფებად ერთეულებს შორის, რომლებიც თავდაპირველად ადარებენ ერთმანეთს.
• შექცევადი: შეგიძლიათ მიუთითოთ, რომ დახარისხება უნდა გაუქმდეს - ინდივიდუალურად თითოეული სვეტისთვის.
• გაფართოებადი: თუ მონაცემთა ნაკრები შეიცავს სვეტებს, რომლებიც შეუძლებელია "მუნჯი" სახით (როგორიცაა თარიღის სტრიქონები), ასევე შეგიძლიათ მიუთითოთ, როგორ გადაიყვანოთ ეს ელემენტები იმ მნიშვნელობად, რომელიც შეიძლება პირდაპირ შეესაბამებოდეს (როგორიცაა DateTime მაგალითი).
• ასოციაციურად თუ გინდა: ეს კოდი აკეთებს ელემენტების დახარისხებას, მაგრამ თქვენ ირჩევთ რეალურ დახარისხების ფუნქციას (usort ან uasort).
• და ბოლოს, ის არ იყენებს array_multisort: მიუხედავად იმისა, რომ array_multisort მოსახერხებელია, ის ეყრდნობა ყველა თქვენი შეყვანილი მონაცემების პროექციას დახარისხებამდე. ეს ხარჯავს დროსა და მეხსიერებას და შეიძლება სრულიად აკრძალული იყოს, თუ თქვენი მონაცემთა ბაზა დიდია.

კოდი

ფუნქცია make_comparer() (// კრიტერიუმების ნორმალიზება წინ ისე, რომ შემდარებელმა იპოვნოს ყველაფერი მოწესრიგებული $criteria = func_get_args(); foreach ($criteria როგორც $index => $criterion) ($criteria[$index] = is_array($criterion) array_pad ($criterion, 3, null) : array ($criterion, SORT_ASC, null) დაბრუნების ფუნქცია ($first, $second) გამოიყენოს (&$criteria) ( foreach ($criteria როგორც $კრიტერიუმი) ( // როგორ მოვიქცეთ შევადაროთ ეს რაუნდი ($sortOrder, $projection) = $sortOrder = $sortOrder === SORT_DESC მნიშვნელობები ახლა თუ ($lhs = call_user_func)? $first[$column] $rhs = call_user_func($projection, $second[$column]) else ($lhs = $first[$column]); ) // გააკეთეთ რეალური შედარება, თუ ტოლია, თუ ($lhs)< $rhs) { return -1 * $sortOrder; } else if ($lhs >$rhs) ( return 1 * $sortOrder; ) ) return 0; // ტაიბრეიკერები ამოწურულია, ამიტომ $first == $second ); )

როგორ გამოვიყენოთ

$data = array(array("zz", "name" => "Jack", "number" => 22, "birthday" => "12/03/1980"), array ("xx", "name" => "ადამ", "რიცხვი" => 16, "დაბადების დღე" => "01/12/1979"), მასივი ("aa", "სახელი" => "პავლე", "რიცხვი" => 16, " დაბადების დღე" => "03/11/1987"), მასივი ("cc", "name" => "Helen", "number" => 44, "birthday" => "24/06/1967")) ;

საფუძვლები

make_comparer ფუნქცია იღებს არგუმენტების ცვლადი რაოდენობას, რომელიც განსაზღვრავს თქვენთვის სასურველ ტიპს და აბრუნებს ფუნქციას, რომელიც უნდა გამოიყენოთ როგორც არგუმენტი usort-ისთვის ან uasort-ისთვის.

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

Usort($data, make_comparer("სახელი"));

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

Usort($data, make_comparer(0)); // 0 = პირველი რიცხვითი ინდექსირებული სვეტი

დალაგების მრავალი სვეტი

თქვენ შეგიძლიათ მიუთითოთ მრავალი დახარისხების სვეტი make_comparer-ზე დამატებითი პარამეტრების გადაცემით. მაგალითად, დალაგება "რიცხვის" და შემდეგ ნულოვანი ინდექსირებული სვეტის მიხედვით:

Usort($data, make_comparer("ნომერი", 0));

გაფართოებული ფუნქციები

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

0 => სვეტის სახელი დასალაგებლად (სავალდებულო) 1 => SORT_ASC ან SORT_DESC (სურვილისამებრ) 2 => პროექციის ფუნქცია (სურვილისამებრ)

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

საპირისპირო დალაგება

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

Usort($data, make_comparer(["სახელი", SORT_DESC]));

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

Usort($data, make_comparer(["ნომერი", SORT_DESC], ["სახელი", SORT_DESC]));

მომხმარებლის პროგნოზები

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

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

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

მოდით დავახარისხოთ მაგალითის მონაცემთა ნაკრები პროექციის გარეშე და ვნახოთ რა მოხდება:

Usort($data, make_comparer("დაბადების დღე"));

ეს არ იყო სასურველი შედეგი. მაგრამ ჩვენ შეგვიძლია გამოვიყენოთ date_create როგორც პროექცია:

Usort($data, make_comparer(["დაბადების დღე", SORT_ASC, "თარიღი_შექმნის"]));

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

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

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

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

Usort($data, make_comparer(["number", SORT_DESC], ["დაბადების დღე", SORT_ASC, "თარიღი_შექმნის"]));

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

200, "წარმოება" => "Telina LLP"); $goods = მასივი ("ფასი" => 400, "წარმოება" => "IP Devyatkin"); $goods = მასივი ("ფასი" => 800, "წარმოება" => "სს აგრარნიკი"); $goods = მასივი ("ფასი" => 790, "წარმოება" => "კრასნი ვოსტოკი სს"); ?>

თქვენ უნდა დაალაგოთ ეს მასივი გასაღების მიხედვით. ამისათვის ჩვენ გამოვიყენებთ "ksort" ფუნქციას:

ქსორტი($ საქონელი); print_r ($საქონელი); ?>

შედეგად, ჩვენ ვიღებთ დახარისხებულ მასივს გასაღების მიხედვით:

Array ( => Array ( => 400 => IP Devyatkin) => Array ( => 200 => Tselina LLP) => Array ( => 800 => JSC Agrarnik) => Array ( => 790 => JSC Krasny Vostok ))

როგორც ხედავთ, კლავიშები 45-დან 89-მდე აღმავალი თანმიმდევრობითაა. ახლა ჩვენ უნდა დავახარისხოთ მასივი ღილაკის „ფასის“ მნიშვნელობით, ამისთვის გამოვიყენებთ „uasort“ ფუნქციას და დავწერთ მორგებულ ფუნქციას "sort_p" ამისთვის:

დალაგება_გვ($a, $b) ( დაბრუნება strcmp($a["ფასი"], $b["ფასი"]); ) უასორტი($ საქონელი, "sort_p"); print_r ($საქონელი); ?>

შედეგად, ჩვენ ვიღებთ დახარისხებულ მასივს "ფასის" გასაღებით:

მასივი ( => მასივი ( => 200 => Tselina LLP) => Array ( => 400 => IP Devyatkin) => მასივი ( => 790 => სს კრასნი ვოსტოკი) => მასივი ( => 800 => სს აგრარნიკი))

როგორც ხედავთ, "ფასის" ღილაკის მნიშვნელობები აღმავალი თანმიმდევრობით არის 200-დან 800-მდე. იმისათვის, რომ "ფასის" ღილაკის მნიშვნელობები საპირისპირო მიმდევრობით წავიდეს, კლებადი მიმდევრობით, შევცვალოთ პარამეტრების პარამეტრები. "strcmp" ფუნქცია "sort_p" მომხმარებლის მიერ განსაზღვრულ ფუნქციაში:

ბ["ფასი"], $ ა["ფასი"]); ) uasort($goods, "sort_p"); print_r ($საქონელი); ?>

ჩვენ ვიღებთ შემდეგ შედეგს:

მასივი ( => მასივი ( => 800 => სს აგრარნიკი) => მასივი ( => 790 => სს კრასნი ვოსტოკი) => მასივი ( => 400 => IP Devyatkin) => მასივი ( => 200 => Tselina LLP))

როგორც ხედავთ, ახლა „ფასის“ ღილაკის მნიშვნელობები კლებადია 800-დან 200-მდე. ახლა ჩვენ უნდა დავახარისხოთ მასივი ორი გასაღების „წარმოების“ და „ფასის“ მნიშვნელობით დაწერს მორგებულ ფუნქციას "sort_pm":

sort_pm($a, $b) ( $r1 = strcmp($a["წარმოება"], $b["წარმოება"]$a["ფასი"], $b["ფასი"]) : $r1; ) uasort ($ საქონელი, "sort_pm"); print_r ($საქონელი); ?>

ახლა დახარისხება ხდება ორი კლავიშის მნიშვნელობებით აღმავალი თანმიმდევრობით, პრიორიტეტით არის "წარმოების" გასაღები.

მასივი ( => მასივი ( => 800 => სს აგრარნიკი) => მასივი ( => 790 => სს კრასნი ვოსტოკი) => მასივი ( => 400 => IP Devyatkin) => მასივი ( => 200 => Tselina LLP))

თუ პრიორიტეტს ანიჭებთ ღილაკის „ფასის“ მნიშვნელობებს, შეცვალეთ „strcmp“ ფუნქციების პარამეტრები და ჩაწერეთ ფუნქცია „sort_pm“ შემდეგნაირად:

$a["ფასი"], $b["ფასი"]);

დაბრუნება ($r1 == 0) ? strcmp(): $r1; ) uasort($goods, "sort_pm"); print_r ($საქონელი); ?>

ანუ შეიცვალა "strcmp" ფუნქციების პარამეტრები. ახლა "ფასის" გასაღების მნიშვნელობებს ექნებათ პრიორიტეტი, რაც ნიშნავს, რომ დახარისხება განხორციელდება ჯერ მათ მიერ, შემდეგ დახარისხდება "წარმოების" გასაღების მნიშვნელობები. მოდით ავხსნათ შემდეგი მაგალითით: 200, "წარმოება" => "Telina LLP"); $goods = მასივი ("ფასი" => 400, "წარმოება" => "IP Devyatkin");$goods = მასივი ("ფასი" => 400, "წარმოება" => "სს დასვენება"); $a["ფასი"], $b["ფასი"]$goods = მასივი ("ფასი" => 800, "წარმოება" => "სს აგრარნიკი"); $goods = მასივი ("ფასი" => 790, "წარმოება" => "კრასნი ვოსტოკი სს"); ფუნქცია sort_pm($a, $b) ($r1 = strcmp( );დაბრუნება ($r1 == 0) ? strcmp(

$a ["წარმოება"], $b ["წარმოება"]

): $r1; ) uasort($goods, "sort_pm"); print_r ($საქონელი); ?> (PHP 4, PHP 5, PHP 7)

array_multisort —

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

array_multisort()

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

SORT_DESC მასივი.

დახარისხება კლებადობით.

ეს არგუმენტი შეიძლება შეიცვალოს array1_sort_flags-ით ან საერთოდ გამოტოვოთ. ამ შემთხვევაში იგულისხმება მნიშვნელობა Array1_sort_order:

Array1_sort_flags

• კოლექციის პარამეტრები ზემოთ არგუმენტისთვისდახარისხების მეთოდის დროშა:
• SORT_REGULAR- ელემენტების ნორმალური შედარება (ტიპების შეცვლის გარეშე)
• SORT_NUMERIC- ელემენტების შედარება რიცხვებად
• SORT_STRING- შეადარეთ ელემენტები, როგორც სტრიქონები SORT_LOCALE_STRING
• - შეადარეთ ელემენტები, როგორც სტრიქონები, მიმდინარე ლოკალის გათვალისწინებით. გამოიყენება ლოკალი, რომელიც შეიძლება შეიცვალოს ფუნქციის გამოყენებით setlocale () SORT_NATURAL
• - შეადარეთ ელემენტები, როგორც სტრიქონები "ბუნებრივი რიგის" ალგორითმის გამოყენებით, ისევე როგორც ფუნქციაშინაცორტი () SORT_NUMERIC SORT_FLAG_CASE - შეადარეთ ელემენტები, როგორც სტრიქონები, მიმდინარე ლოკალის გათვალისწინებით. გამოიყენება ლოკალი, რომელიც შეიძლება შეიცვალოს ფუნქციის გამოყენებით- შეიძლება გაერთიანდეს (ორობითი OR).

ან კოლექციის პარამეტრები ზემოთ არგუმენტისთვის .

...

ქეისების დალაგებისთვის

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

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

ცვლილებების სია

მაგალითები

მაგალითი #1 მრავალი მასივის დახარისხება

$ar1 = მასივი (10, 100, 100, 0);
$ar2 = მასივი(1, 3, 2, 4);
array_multisort ($ar1, $ar2);

Var_dump ($ar1);
var_dump ($ar2);
?>

ზემოთ მოყვანილ მაგალითში, დახარისხების დასრულების შემდეგ, პირველი მასივი შეიცავს 0, 10, 100, 100. მეორე შეიცავს 4, 1, 2, 3. მეორე მასივის ელემენტებს, რომლებიც შეესაბამება პირველის იდენტურ ელემენტებს (100). და 100) ასევე დალაგდება.

მასივი(4) ( => int(0) => int(10) => int(100) => int(100) ) მასივი(4) ( => int(4) => int(1) => int (2) => int (3) )

მაგალითი #2 მრავალგანზომილებიანი მასივის დახარისხება

$ar = მასივი(
მასივი ("10", 11, 100, 100, "a"),
მასივი (1, 2, "2", 3, 1)
);
array_multisort ($ar [0], SORT_ASC, SORT_STRING,
$ar [1], SORT_NUMERIC, SORT_DESC);
var_dump ($ar);
?>

ზემოხსენებულ მაგალითში, დახარისხების შემდეგ, პირველი მასივი შეიცავს "10", 100, 100, 11, "a" (მისი ელემენტები დალაგებულია ზრდის მიხედვით) და მეორე მასივი შეიცავს 1, 3, "2", 2, 1 (ელემენტები დალაგებულია რიცხვებად, კლებადობით).

მასივი (2) ( => მასივი (5) ( => სტრიქონი (2) "10" => int(100) => int(100) => int(11) => სტრიქონი (1) "a" ) = > მასივი(5) ( => int(1) => int(3) => string(1) "2" => int(2) => int(1) )

მაგალითი #3 მონაცემთა ბაზიდან შედეგების დახარისხება

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

ნიმუშის მონაცემები:

# ტომი | გამოცემის მოცულობა | გამოცემა-------+-------- 67 | 2 86 | 1 85 | 6 98 | 2 86 | 6 67 | 7

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

$data = მასივი("ტომი" => 67 , "გამოცემა" => 2 );
$data = მასივი("ტომი" => 86 , "გამოცემა" => 1 );
$data = მასივი("ტომი" => 85 , "გამოცემა" => 6);
$data = მასივი("ტომი" => 98 , "გამოცემა" => 2 );
$data = მასივი("ტომი" => 86 , "გამოცემა" => 6 );
$data = მასივი("ტომი" => 67 , "გამოცემა" => 7 );
?>

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

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

// მიიღეთ სვეტების სია
foreach ($data როგორც $key => $row ) (
$volume [ $key ] = $row [ "volume" ];
$edition [ $key ] = $row [ "გამოცემა" ];
}

// მონაცემების დალაგება მოცულობის მიხედვით კლებადი მიმდევრობით და გამოცემის მიხედვით ზრდის მიხედვით
// დაამატეთ $data, როგორც ბოლო პარამეტრი საერთო გასაღების მიხედვით დასალაგებლად
array_multisort($volume, SORT_DESC, $edition, SORT_ASC, $data);
?>

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

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

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

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

პატარა თეორია php მასივების შესახებ

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

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

პროგრამირების მასივი არის გარკვეული მონაცემების კრებული. ისინი შედგება მასივის ელემენტებისაგან, რომლებიც არის წყვილები [ინდექსი] => [მნიშვნელობა].

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

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

ერთგანზომილებიანი php მასივი:

მასივი ( => 1 => 2 => 3)

PHP მრავალგანზომილებიანი მასივი:

მასივი ( => მასივი ( => 1) => მასივი ( => 2) => მასივი ( => 3))

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

ახლა მგონი გასაგებია :)

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

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

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

მასივი ( => 12 [სრული სახელი] => ივანოვი ივან ივანოვიჩი [საშუალო_ქულა] => 3)

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

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

თავად PHP-ში მასივები იქმნება ორი გზით:

1. $books = მასივი ('ABC', 'Primer', 'Dictionary'); ან $books = მასივი (‘azb’ => ‘ABC’, ‘buk’ => ‘პრაიმერი’, ‘slov’ => ‘ლექსიკონი’); მეორე ვარიანტი გამოიყენება მაშინ, როდესაც ელემენტს სჭირდება ცალსახად მიუთითოს საკვანძო ველი (შესაბამისია ასოციაციური მასივებისთვის). თუ არ მიუთითებთ, მასივის ელემენტის ღილაკები ნაგულისხმევად იქნება რიცხვები. დაწყებული 0-დან (ნული).
2. $books = 'ABC'; $books = 'ABC წიგნი'; $books = 'ABC წიგნი';

ორივე შემთხვევაში, $books იქნება მასივი. ასე რომ, თუ თქვენი საიტის კოდში შეხვდებით ასეთ კონსტრუქციებს, ეს თქვენთვის გაუგებარი აღარ იქნება :)

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

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

ექო"

"; print_r(მასივი_ცვლადი); die();
თუ თქვენ მიერ დაბეჭდილი ცვლადი არის მასივი, ტექსტი დაიწყება შემდეგი ხაზით:
მასივი (...
და კიდევ რამდენიმე სიტყვა ჩვენი სტატიის თემის შესახებ - მასივების დახარისხებაphp.
როგორც გესმით, მასივების მონაცემები სტრუქტურირებულია და ელემენტები განლაგებულია გარკვეული თანმიმდევრობით.  მის შესაცვლელად, უბრალოდ გვჭირდება PHP მასივის დახარისხება, რომელიც ხორციელდება მზა ენის ფუნქციებით.
ამიტომ, ყველაფერი რაც უნდა გავაკეთოთ არის საჭირო ფუნქციის გამოძახება მასივის გამოცხადების შემდეგ, პარამეტრად მის მითითებით.
მოდით გადავიდეთ თავად ფუნქციების მიმოხილვაზე.
php მასივის დახარისხების ფუნქციები
მათი სრული სია წარმოდგენილია php ენის ოფიციალურ დოკუმენტაციაში:
იმისათვის, რომ დაალაგოთ PHP მასივი კონკრეტული ფუნქციის გამოყენებით, თქვენ დაგჭირდებათ მისი გამოძახება მასივის გამოცხადების და მნიშვნელობებით შევსების შემდეგ, პარამეტრებად ჩვენი მასივის მითითებით.  მაგალითად:
$cars = მასივი ("Toyota", "Mazda", "Mitsubishi");  დალაგება ($ მანქანები);
მოკლედ განვიხილოთ თითოეული მათგანის ფუნქციონირება.  ფუნქციები მითითებული იქნება იმ ფორმატში, რომლითაც საჭირო იქნება მათი გამოძახება კოდში, ე.ი.  "სახელი (პარამეტრი1, პარამეტრი2, ...);".
არ დაგავიწყდეთ ფუნქციის გამოძახების შემდეგ „;“-ის ჩასმა, რადგან  ამის გარეშე ეკრანზე გამოჩნდება ლამაზი შეცდომის შეტყობინება :)
როგორც საილუსტრაციო მაგალითი, ავიღოთ მარტივი ერთგანზომილებიანი მასივი, რომელშიც კლავიშებიც და მნიშვნელობებიც შეურიგებელი იქნება ისე, რომ ფუნქციების შესრულების შედეგები უფრო ვიზუალური და გასაგები იყოს.
მასივი ( => 11 => 18 => 9)
მაშ, როგორ შეიძლება დაალაგოთ მასივი სასურველი თანმიმდევრობით PHP-ში?
ფუნქციები მარტივი php მასივის მნიშვნელობის მიხედვით დახარისხებისთვის
თუ თქვენ გირჩევნიათ ვიდეო მასალის ყურება კითხვას, მაშინ მინდა გირჩიოთ უყუროთ ამ ვიდეოს, რომელიც ნათლად და ნათლად აჩვენებს PHP მასივის დახარისხების ფუნქციების მუშაობას ამ ბლოკიდან:
 
თუ ამის შემდეგ კვლავ გაგიჩნდებათ შეკითხვები, შეგიძლიათ იხილოთ უფრო დეტალური ინფორმაცია თითოეულ ფუნქციაზე ქვემოთ.
sort ($მასივი, $flag);- ერთ-ერთი ყველაზე მარტივი და პოპულარული ფუნქცია.  საშუალებას გაძლევთ დაალაგოთ მასივი აღმავალი თანმიმდევრობით php-ში, ელემენტების მნიშვნელობების გათვალისწინებით, ე.ი.  ისინი დალაგდება უმცირესი მნიშვნელობებიდან დიდამდე.  პარამეტრებად იღებს მასივის ცვლადს და ერთ-ერთ დახარისხებას, რაც საშუალებას გაძლევთ შეცვალოთ დახარისხების ქცევა.
დროშების სია:
SORT_REGULAR – ელემენტები შედარებულია ტიპების შეცვლის გარეშე
SORT_NUMERIC – ელემენტები შედარებულია რიცხვებად
SORT_STRING – ელემენტები შედარებულია როგორც სტრიქონები
SORT_LOCALE_STRING – სტრიქონების შედარება, მაგრამ მიმდინარე ლოკალის გათვალისწინებით.
SORT_NATURAL - ელემენტების სიმებიანი შედარება მათი ბუნებრივი რიგის გათვალისწინებით (მაგალითად, ნაცორტი)
SORT_FLAG_CASE – php მასივის ელემენტების ასორტიმენტისადმი მგრძნობიარე დალაგება (შეიძლება გაერთიანდეს SORT_STRING ან SORT_NATURAL ბიტიური OR).
მაგრამ, უმეტეს შემთხვევაში, ფუნქციის შესრულების შედეგი სწორია ამ გასარკვევი დროშების გარეშეც.  ნაგულისხმევად (თუ არაფერია მითითებული) გამოყენებული იქნება SORT_REGULAR.
ჩვენი სატესტო მასივი sort() ფუნქციის გამოძახების შემდეგ ასე გამოიყურება:
მასივი ( => 9 => 11 => 18)
როგორც ხედავთ, მასივის მნიშვნელობების მიხედვით დახარისხების შემდეგ შეიცვალა მათი გასაღებების მნიშვნელობებიც, რადგან  სორტირება მუშაობს გასაღები-მნიშვნელობის ურთიერთობის შენარჩუნების გარეშე, როგორც ეს მითითებულია ოფიციალურ php დოკუმენტაციაში.
შედეგად, ეს ვარიანტი შესაფერისია შემთხვევების დიდი უმრავლესობისთვის.
rsort ($მასივი, $flag);- ფუნქცია, რომელიც ერთგვარი ანტაგონისტია.  ანტაგონისტი, რადგან მასივს ერთნაირად ახარისხებს, მხოლოდ არა აღმავალი, არამედ კლების მიხედვით, ე.ი.  php მასივის ელემენტები ყველაზე დიდი მნიშვნელობებით პირველ რიგში წავა.
თქვენ ასევე შეგიძლიათ გადასცეთ მას ორი პარამეტრი: თავად მასივი და დახარისხების დროშა და, როგორც დალაგება, უფრო შესაფერისია ერთგანზომილებიანი მასიებისთვის.  ჩვენი სატესტო მასივი ამ ფუნქციის გამოძახების შემდეგ მიიღებს შემდეგ ფორმას:
მასივი ( => 18 => 11 => 9)
asort ($მასივი, $flag);არის PHP ფუნქცია მასივის მნიშვნელობის მიხედვით დასალაგებლად, რომლის მექანიზმიც ძალიან ჰგავს სორტირებას.
ერთადერთი გამონაკლისი არის ის, რომ ის საშუალებას გაძლევთ დაალაგოთ php მასივი მისი ელემენტების მნიშვნელობის მიხედვით და შეინარჩუნოთ გასაღები-მნიშვნელობის ურთიერთობა.
ამიტომ, ეს ფუნქცია შესანიშნავია ასოციაციური მასივების დახარისხება php, ე.ი.  სტრუქტურები, სადაც ეს კავშირი ლოგიკური და მნიშვნელოვანია.
ელემენტები განლაგდება აღმავალი თანმიმდევრობით, რადგან...  ის საშუალებას გაძლევთ დაალაგოთ PHP ასოციაციური მასივი მნიშვნელობების მიხედვით, კლავიშების შენარჩუნებისას.
თქვენ ასევე შეგიძლიათ გადასცეთ ორი პარამეტრი.  ჩვენი სატესტო მასივი ასე გამოიყურება:
მასივი ( => 9 => 11 => 18)
როგორც ხედავთ, დახარისხებისგან განსხვავება მხოლოდ იმ მნიშვნელობების კლავიშების შენახვაშია, რომლითაც დალაგებულია php მასივი.  ამას ეწოდება გასაღები-მნიშვნელობის ურთიერთობის შენარჩუნება, რაც წარმოუდგენლად მნიშვნელოვანია PHP ასოციაციური მასივების დახარისხებისას.
arsort ($მასივი, $flag);- კიდევ ერთი php ფუნქცია მასივის მნიშვნელობის მიხედვით დასალაგებლად.  ანტაგონისტური ასორტი.
მუშაობს იმავე პრინციპით, როგორც აღნიშნული ფუნქცია, მხოლოდ php მასივი იქნება დალაგებული ამ შემთხვევაში კლებადობით.  ასევე შესანიშნავი ვარიანტია PHP ასოციაციური მასივების დახარისხებისას.
ამ ფუნქციის გამოძახების შემდეგ, ჩვენი მაგალითი ასე გამოიყურება:
მასივი ( => 18 => 11 => 9)
გაფართოებული php მასივის დახარისხების ფუნქციები მნიშვნელობის მიხედვით
ფუნქციების ეს ბლოკი, წინა ფუნქციებისგან განსხვავებით, რომლებიც საშუალებას მოგცემთ შეცვალოთ თანმიმდევრობა კლებად/აღმავალ მიმდევრობით, საშუალებას მოგცემთ დაამატოთ მრავალფეროვნება და მოაწყოთ ელემენტები სხვადასხვა თანმიმდევრობით, გარდა „ტრადიციულის“.
ეს ფუნქცია მათ შესაფერისს ხდის სხვადასხვა არასტანდარტული, ზოგჯერ ძალიან საინტერესო პრობლემების გადასაჭრელად :)
natsort ($მასივი);— ეს ფუნქცია მრავალფეროვნებას მატებს დალაგების მსგავსი გადაწყვეტილებების ოჯახს, რადგან  მისი მოქმედების მექანიზმი ძირეულად განსხვავდება მათგან.  natsort-ს აქვს მხოლოდ ერთი შეყვანის პარამეტრი - ეს არის დასალაგებელი მასივი, რომლის მნიშვნელობები განლაგდება ადამიანებისთვის ნაცნობი თანმიმდევრობით.  ამ ალგორითმს ეწოდება "ბუნებრივი შეკვეთა", რაც რუსულად ნიშნავს "ბუნებრივ წესრიგს".  ამ განცხადების მნიშვნელობის გასაგებად, მაგალითისთვის ავიღოთ სხვა მასივი:
მასივი ( => სტუდენტი5 => სტუდენტი1 => სტუდენტი10)
გარდა ამისა, ნაცორტის ფუნქცია ინარჩუნებს გასაღები-მნიშვნელობის ურთიერთობას.  ამიტომ, ჩვენ შევადარებთ მის ნამუშევრებს ასორტთან, რომელიც მაქსიმალურად ჰგავს მას.  ამ უკანასკნელის გამოძახების შემდეგ, ჩვენი მასივი მიიღებს შემდეგ ფორმას:
მასივი ( => სტუდენტი1 => სტუდენტი10 => სტუდენტი5)
თუ თქვენ უწოდებთ ნაცორტს, მიღებული მასივი იქნება ასეთი:
მასივი ( => სტუდენტი1 => სტუდენტი5 => სტუდენტი10)
ვფიქრობ, ახლა თქვენ ხედავთ განსხვავებას და თქვენთვის გასაგები იქნება ნაცორტის მუშაობის პრინციპი :-)
shuffle ($მასივი);მშვენიერი და ძალიან სასარგებლო ფუნქციაა, რომლითაც შეგიძლიათ PHP მასივის შერწყმა და მისი ელემენტების შემთხვევითი თანმიმდევრობით განთავსება.
ძალიან მოსახერხებელია, როცა ონლაინ მაღაზიის პროდუქტების კატეგორიაში ან სხვა გვერდზე შემთხვევითი თანმიმდევრობით უნდა მოაწყოთ, ან სავიზიტო ბარათის ვებსაიტზე გადასვლისას, აჩვენოთ მომხმარებლებს ინფორმაციის სხვადასხვა ბლოკი ყოველ ჯერზე სხვადასხვა თანმიმდევრობით.
ამ შემთხვევაში გასაღები-მნიშვნელობის ურთიერთობა არ არის დაცული.  ანუ, მასივი, რომელიც ჩვენ გამოვიყენეთ წინა მაგალითში, პირადად ჩემთვის, მიიღო ფორმა:
მასივი ( => student10 => student5 => student1)
უფრო მეტიც, ყოველი ფუნქციის გამოძახების შემდეგ ელემენტების რიგი განსხვავებული იქნება.
ფუნქციები, რომლებიც ადრე განვიხილეთ, საკმაოდ მარტივია და მათი მოქმედების მექანიზმი გასაგებია.  პარამეტრად გადაეცემა მასივი, რომლის შიგთავსი უნდა დალაგდეს მისი ელემენტების მნიშვნელობებით, ასევე დროშა, რომელსაც შეუძლია შეცვალოს დახარისხების ქცევა (ამის გარეშეც მარტივად შეგიძლიათ).
ის საკმაოდ პოპულარულია პროგრამისტებში, რადგან...  საშუალებას გაძლევთ გადაჭრათ დახარისხებასთან დაკავშირებული ნებისმიერი პრობლემა (სხვადასხვა ალგორითმის გამოყენებით) მისი ფუნქციის გამოყენებით.
ერთ-ერთი ასეთი ამოცანაა phpსაჭირო ველის მიხედვით.
იმისათვის, რომ ნათლად გაჩვენოთ, როგორ მუშაობს შემდეგი ფუნქციები, ავიღოთ შემდეგი მასივი, როგორც მაგალითი:
მასივი ( => მასივი ( => 32) => მასივი ( => 11) => მასივი ( => 27))
როგორც ხედავთ, ის მრავალგანზომილებიანია, რადგან...  მისი ელემენტები არის მასივები, რომელთა სტრუქტურა იდენტურია: ყველა მათგანს აქვს ველი გასაღები "id".  ახლა კი ჩვენი ამოცანაა ამ ელემენტების დახარისხება აღმავალი თანმიმდევრობით, ე.ი.  ისე, რომ მთავარ მასივში ელემენტები განლაგებულია ქვემასივებში ველების მნიშვნელობების შესაბამისად.
უნდა ვთქვა, საკმაოდ გავრცელებული დავალება.  შემდეგი ფუნქციები დაგვეხმარება მის მოგვარებაში:
usort($array, 'ფუნქცია');— PHP ფუნქცია მრავალგანზომილებიანი მასივის სასურველი ველის მიხედვით დასალაგებლად.
საშუალებას გაძლევთ დაალაგოთ php მასივის ელემენტები გასაღები-მნიშვნელობის ურთიერთობის შენარჩუნების გარეშე მომხმარებლის მიერ განსაზღვრული ფუნქციის შესაბამისად, რომლის სახელი გადაეცემა მეორე პარამეტრად usort-ის გამოძახებისას.
თავად ფუნქცია აღწერილია ცალკე.  რაც შეეხება ჩვენს მაგალითს, მრავალგანზომილებიანი php მასივის ელემენტების დასალაგებლად ['id'] ველის მიხედვით ზრდადი თანმიმდევრობით, მომხმარებლის ფუნქცია ასე გამოიყურება:
ფუნქცია myCmp($a, $b) ( if ($a["id"] == $b["id"]) დააბრუნეთ 0; დააბრუნეთ $a["id"] > $b["id"] ? 1 : -1;
ყველაფერი რაც ახლა უნდა გავაკეთოთ დახარისხების დასაწყებად არის გამოვიძახოთ usort($array, 'myCmp');  კოდში საჭირო ადგილას.  პირველი პარამეტრი განსაზღვრავს მასივის ცვლადის სახელს.
შედეგად, ჩვენ ვიღებთ შემდეგს:
მასივი ( => მასივი ( => 11) => მასივი ( => 27) => მასივი ( => 32))
uasort ($მასივი, 'ფუნქცია');— კიდევ ერთი PHP ფუნქცია მრავალგანზომილებიანი მასივის სასურველი ველის მიხედვით დასალაგებლად.
მუშაობს usort-ის მსგავსად, მაგრამ ინარჩუნებს გასაღები-მნიშვნელობის ურთიერთობას, რაც ქმნის ამ ფუნქციასშესაფერისია მრავალგანზომილებიანი ასოციაციური მასივების დასალაგებლად.
ჩვენი მაგალითისთვის მორგებული ფუნქცია იგივე იქნება.  მისი შესრულების შედეგები ასე გამოიყურება:
მასივი ( => მასივი ( => 11) => მასივი ( => 27) => მასივი ( => 32))
ელემენტების დალაგების თანმიმდევრობის შესაცვლელად და მონაცემთა დამატებითი ტრანსფორმაციის განსახორციელებლად, მოგიწევთ მომხმარებლის ფუნქციის რედაქტირება, როგორც თქვენ თვითონ მიხვდით :)
მაგალითად, თუ თქვენი მასივები, რომლებიც ორიგინალის ელემენტებია, შეიცავს ['name'] ველს სტრიქონის მნიშვნელობით, მაშინ მრავალგანზომილებიანი php მასივის დახარისხების მორგებული ფუნქცია ამ ველის მიხედვით ზრდადი მიმდევრობით ასე გამოიყურება:
ფუნქცია myCmp($a, $b) ( if (strcasecmp($a["name"], $b["person"]["name"]) == 0) return 0; დაბრუნება strcasecmp($a["name "], $b["სახელი"]) > 0 ? 1: -1;)
PHP მასივების დახარისხება მორგებული ფუნქციების გამოყენებით არ არის უმარტივესი ვარიანტი, მაგრამ ძალიან მოქნილია პერსონალიზაციაში და თუ მას დაეუფლებით, ის გახდება თქვენი საყვარელი გადაწყვეტა.
array_multisort ($array1, $array2, $flag);— ბოლოს მე შევინახე ყველაზე საშინელი და ბუნდოვანი PHP ფუნქცია მასივის დასალაგებლად.  როგორც შეყვანის პარამეტრებს, მას სჭირდება ორი მასივი და იგივე დახარისხების დროშები, რომლებიც შეიძლება მითითებული იყოს დალაგების მსგავს ფუნქციებში.  array_multisort მუშაობს შემდეგნაირად: პირველი პარამეტრი არის დახარისხებული მასივი, მეორე მასივი განსაზღვრავს პირველის დალაგების თანმიმდევრობას, რის შემდეგაც მეორე მასივი დალაგებულია ისევე, როგორც პირველი.  მასივის ნაცვლად, რომელიც წარმოადგენს დალაგების წესრიგს, შეგიძლიათ გამოიყენოთ მუდმივები SORT_DESC მასივის კლებადობით დასალაგებლად და SORT_ASC ზრდადი მიმდევრობით.  ყველა ამ დაბნეულობას, თქვენ ასევე შეგიძლიათ დაამატოთ დახარისხების დროშები, რომლებიც შეიძლება გამოვიდეს ყველა მასივის შემდეგ.
$books = მასივი (32, 11, 27);  $sort_array = მასივი (1, 2, 3);  array_multisort ($books, $sort_array);
ამ მაგალითში მე დავახარისხე მარტივი ერთგანზომილებიანი მასივი $books $sort_array მასივის მიხედვით.  შედეგად, პირველმა მასივმა მიიღო შემდეგი ფორმა:
მასივი ( => 11 => 27 => 32)
და მეორე გახდა ასე:
მასივი ( => 2 => 3 => 1)
ანუ დალაგდა პირველის მიხედვით.  ეს არის ოხრახუში :)
Array_multisort უფრო დეტალურად არის აღწერილი შემდეგ ვიდეოში.  ასევე იქ ნახავთ მისი გამოყენების დამატებით მაგალითებს:
 
ამ ფუნქციის გამოყენებით თქვენ ასევე შეგიძლიათ დაალაგოთ მრავალგანზომილებიანი მასივები:
$books = მასივი(მასივი(32), მასივი(11), მასივი(27));  $sort_array = მასივი (1, 2, 3);  array_multisort ($books, $sort_array);
$books მასივი ასე გამოიყურება:
მასივი ( => მასივი ( => 11) => მასივი ( => 27) => მასივი ( => 32))
ამავდროულად, ამ ფუნქციაში შეგიძლიათ მიუთითოთ რამდენიმე მასივი, დახარისხება რამდენიმე ველის მიხედვით.  ამ შემთხვევაში, წინა მასივების დახარისხების შედეგები გავლენას მოახდენს შემდეგზე, რაც საბოლოოდ გამოიწვევს უახლესი მასივების დახარისხებას სხვადასხვა კრიტერიუმების მიხედვით.
ეს არის ერთგვარი "თოვლის ბურთი" PHP-ში.
ამ ფუნქციის გამოყენებით PHP მასივის დალაგებისას, გასაღები-მნიშვნელობის ურთიერთობა შენარჩუნებულია ასოციაციური მასივებისთვის, მაგრამ არა რიცხვითი მასივებისთვის.
პროგრამისტები, რომლებმაც გამოსცადეს სხვადასხვა ფუნქციების მოქმედება, აღნიშნავენ, რომ მრავალგანზომილებიანი მასივის დახარისხებისას, php array_multisort აჩვენებს უკეთეს შედეგებს, ვიდრე usort.
მაგრამ array_multisort ვერ შეძლებს გაუმკლავდეს ყველა დავალებას, რაც usort-ს შეუძლია.  მაგალითად, იგივე მრავალგანზომილებიანი მასივის დახარისხებაphp საჭირო ველის მიხედვით.  ასე რომ, თითოეულ ცალკეულ შემთხვევაში თქვენ უნდა გაანალიზოთ თქვენი წარმატების შანსები ამა თუ იმ დიზაინის გამოყენებისას.
პირადად მე შემიძლია ვთქვა, რომ ცოტა არ მომწონს array_multisort მისი დაბნეულობისა და ტვინის გაზრდილი დაძაბვის გამო, რაც მოდის იმის გამო, რომ წარმოიდგინო მიღებული მასივი დალაგებულია მის გამოყენებით.
ამიტომ, ვცდილობ არ გამოვიყენო ის, თუ აბსოლუტურად აუცილებელი არ არის, უპირატესობას უსორტულ და მარტივ ფუნქციებს ვანიჭებ, რასაც თქვენც მოგიწოდებთ :)
ფუნქციები, რომლებიც ადრე განვიხილეთ, საშუალებას გაძლევთ დაალაგოთ მასივები PHP-ში ელემენტების მნიშვნელობის მიხედვით.  მოდით ვისაუბროთ იმაზე, თუ როგორ შეგიძლიათ შეასრულოთ მსგავსი მოქმედება ელემენტის კლავიშებზე.
PHP ფუნქციონირებს მასივის გასაღების მიხედვით დასალაგებლად
სანამ ამ ჯგუფის ფუნქციების მიმოხილვაზე გადავიდოდეთ, მინდა ვთქვა, რომ ყველას აქვს ერთი საერთო თვისება- ისინი ყველა ინარჩუნებენ საკვანძო-ღირებულების ურთიერთობას.  და, მკაცრად რომ ვთქვათ, სხვაგვარად არ შეიძლებოდა, რადგან...  მაშინ აზრი არ ექნება :)
ეს არის თავისებურება.  მოდით შევხედოთ თითოეულ ფუნქციას უფრო დეტალურად.
ksort ($მასივი, $flag);— ფუნქცია ასორტის ანალოგიურია, მასივის მხოლოდ ელემენტები დალაგდება არა მნიშვნელობებით, არამედ კლავიშებით.
ამ დიზაინს აქვს ორი შეყვანის პარამეტრი: დასახარისხებელი PHP მასივი და ერთ-ერთი დახარისხების დროშა, რომლის სრული სია შეგიძლიათ იხილოთ დახარისხების ფუნქციის აღწერაში (მისი გამოყენება არჩევითია).  ეს php ფუნქცია საშუალებას გაძლევთ დაალაგოთ მასივი აღმავალი თანმიმდევრობით.
იმის საჩვენებლად, თუ როგორ მუშაობს იგი, დავუბრუნდეთ სტატიის დასაწყისში აღწერილ მაგალითს:
მასივი ( => 11 => 18 => 9)
თუ დაალაგებთ მას ksort-ის გამოყენებით, შედეგი ასე გამოიყურება:
მასივი ( => 18 => 9 => 11)
ვფიქრობ, ყველაფერი მარტივი და გასაგებია.
krsort ($მასივი, $flag);- კიდევ ერთი PHP ფუნქცია კლავიშის მიხედვით მასივის დასალაგებლად, რომელიც ძალიან ჰგავს წინას.
ერთადერთი განსხვავება ისაა, რომ ის ახარისხებს php მასივს კლებადობით.  ანუ ის ქსორტის ანტაგონისტია, ისევე როგორც რსორტი დახარისხება.
მას ასევე აქვს ორი შეყვანის პარამეტრი: დასალაგებელი მასივი და ერთ-ერთი გასაღები.  მისი გაშვების შემდეგ, ჩვენი მაგალითი ასე გამოიყურება:
მასივი ( => 11 => 9 => 18)
მგონი კომენტარები ზედმეტია :)
ukrsort($array, 'ფუნქცია');- ადრე ნახსენები PHP ფუნქციის ანალოგი გასაღების მიხედვით მასივის დასახარისხებლად - usort.
იგი მუშაობს იმავე პრინციპით: ინარჩუნებს გასაღები-მნიშვნელობის ურთიერთობას და PHP მასივი დალაგებულია მომხმარებლის მიერ განსაზღვრული ფუნქციის შესაბამისად, რომლის სახელწოდებაც გადაეცემა მეორე პარამეტრად.  პირველი პარამეტრი უცვლელია - ეს არის დასალაგებელი მასივი.
usort-ისგან განსხვავება ისაა, რომ დახარისხება ხდება ელემენტის კლავიშებით.
იმის საილუსტრაციოდ, თუ როგორ მუშაობს ეს ფუნქცია, გამოიყენეთ შემდეგი მაგალითი:
მასივი ( => 40 => 0 => 10)
მაგალითად, php მასივი უნდა დავახარისხოთ კლავიშების მიხედვით ზრდადი თანმიმდევრობით.  ამ შემთხვევაში მომხმარებლის ფუნქცია ასე გამოიყურება:
ფუნქცია myCmp($a, $b) (თუ ($a == $b) დააბრუნეთ 0; დააბრუნეთ $a< $b ? 1: -1;
}
 
შედეგად, ჩვენი მასივი მიიღებს შემდეგ ფორმას:
მასივი ( => 0 => 10 => 40)
ამ ფუნქციის გამოყენების აშკარა უპირატესობა ის არის, რომ მისი გამოყენება შესაძლებელია PHP მასივის დასალაგებლად ზოგიერთი უჩვეულო კრიტერიუმის ან ალგორითმის მიხედვით.
შეგახსენებთ, რომ თქვენ უნდა გამოიყენოთ იგი მხოლოდ მაშინ, როდესაც მასივის ელემენტების კლავიშები ატარებენ რაიმე სახის სემანტიკურ მნიშვნელობას.  წინააღმდეგ შემთხვევაში, უმჯობესია გამოიყენოთ usort ან სხვა უფრო მარტივი ფუნქციები.
ჩვენი სტატია დასრულდა (მოიწონეთ თუ აქამდე გაქვთ წაკითხული) :)
მასში ვცდილობდი აღმეწერა ყველაფერი რაც შეიძლება მარტივად და ამავდროულად ნათლად და სრულად. შესაძლო გზებიდახარისხება სხვადასხვა სახისმასივი php-ში, თქვენი სიტყვების მხარდაჭერა მაგალითებით.
ვაღიარებ, რომ პუბლიკაცია საკმაოდ მოცულობითი და რთულად წასაკითხი იყო ერთხელ.  მაგრამ ყოველ ჯერზე, როცა გჭირდება php მასივის დალაგება, თქვენ ყოველთვის შეგიძლიათ მიმართოთ ამ სტატიას თქვენთვის საჭირო ფუნქციის აღწერისთვის და ნახოთ მისი გამოყენების მაგალითები.
ვიმედოვნებ, რომ ინფორმაცია თქვენთვის სასარგებლო იყო :)
გამოიწერეთ პროექტის განახლებები და