Kaip rūšiuoti masyvus ir duomenis PHP?

Šis klausimas susijęs su masyvų rūšiavimu PHP. Lengva manyti, kad jūsų konkreti byla yra unikali ir nusipelno naujo klausimo, tačiau dauguma jų iš tikrųjų yra nedideli vieno iš šiame puslapyje pateiktų sprendimų variantai.

Jei jūsų klausimas uždarytas kaip šio klausimo dublikatas, paprašykite jo iš naujo atidaryti tik tada, jei galite paaiškinti, kodėl jis skiriasi nuo visko.

Kaip rūšiuoti masyvą PHP?
Kaip rūšiuoti sudėtingą masyvą PHP?
Kaip rūšiuoti PHP masyvą?


  1. Pagrindinės vienmatės matricos; Inkliuziniai daugialypiai elementai, įsk. objektų masyvai; Įskaitant vieną masyvo rūšiavimą pagal kitą

  2. Rūšiavimas su SPL

  3. Stabili veislė

Norėdami gauti praktinį atsakymą naudojant esamas PHP funkcijas, žr. 1. akademinį išsamų atsakymą į rūšiavimo algoritmus (kuriuos įgyvendina PHP funkcijos ir kurios gali būti reikalingos tikrai, labai sudėtingiems atvejams), žr. 2.

256
28 июня '13 в 14:53 2013-06-28 14:53 deceze nustatoma birželio 28 d ., 13 val. 14:53 2013-06-28 14:53
@ 9 atsakymai

Pagrindinės vienmatės matricos

 $array = array(3, 5, 2, 8); 

Taikomos rūšiavimo funkcijos:

  • sort
  • rsort
  • asort
  • arsort
  • natsort
  • natcasesort
  • ksort
  • krsort

Vienintelis skirtumas tarp jų yra tas, ar asociacijos palaikomos su raktu (funkcijos " a "), neatsižvelgiant į tai, ar ji rūšiuoja nuo mažo iki didelio, ar atvirkščiai (" r "), rūšiuoja reikšmes ar raktus (" k ") ir kaip ji lygina vertes („ nat “ ir normalus). Daugiau informacijos rasite nuorodose http://php.net/manual/en/array.sorting.php .

Daugiamatės matricos, įskaitant objektų masyvus

 $array = array( array('foo' => 'bar', 'baz' => 42), array('foo' => ..., 'baz' => ...), ... ); 

Jei norite suskirstyti $array pagal „foo“ klavišą kiekvienam įrašui, jums reikia pritaikytos palyginimo funkcijos. Pirmiau nurodytos rūšys ir susijusios funkcijos veikia su paprastomis vertėmis, kurias jie gali palyginti ir rūšiuoti. PHP ne tik „žino“, ką daryti su sudėtine tipo array('foo' => 'bar', 'baz' => 42) reikšme array('foo' => 'bar', 'baz' => 42) ; taigi jums reikia tai pasakyti.

Norėdami tai padaryti, turite sukurti palyginimo funkciją. Ši funkcija užima du elementus ir turėtų grąžinti 0 jei šie elementai laikomi lygiaverčiais, o vertė mažesnė nei 0 jei pirmoji vertė yra mažesnė, o vertė didesnė nei 0 jei pirmoji vertė yra didesnė. Viskas ko jums reikia:

 function cmp(array $a, array $b) { if ($a['foo'] < $b['foo']) { return -1; } else if ($a['foo'] > $b['foo']) { return 1; } else { return 0; } } 

Dažnai norite naudoti anoniminę funkciją kaip atgalinį. Jei norite naudoti metodą arba statinį metodą, žr. „ Kiti būdai, kaip nustatyti atgalinį ryšį PHP“ .

Tada naudojate vieną iš šių funkcijų:

Vėlgi, jie skiriasi tik tuo, ar jie išsaugo pagrindinių vertybių asociacijas ir rūšiuoti pagal vertę ar raktą. Išsamesnės informacijos skaitykite jų dokumentuose.

Naudojimo pavyzdys:

 usort($array, 'cmp'); 

usort “ imsis dviejų elementų iš masyvo ir su jais skambins „ cmp funkcija. Taigi, cmp() bus vadinamas $a kaip array('foo' => 'bar', 'baz' => 42) ir $b kaip kitas array('foo' =>..., 'baz' =>...) . Tuomet funkcija grįžta į „ usort kurios vertės buvo didesnės arba lygios. usort pakartoja šį procesą, išlaikydamas skirtingas $a ir $b reikšmes, kol masyvas bus rūšiuojamas. cmp funkcija bus vadinama daug kartų, bent jau tiek kartų, kiek yra $array reikšmių, su skirtingais $a ir $b reikšmių deriniais.

Norėdami priprasti prie šios idėjos, pabandykite:

 function cmp($a, $b) { echo 'cmp called with $a:', PHP_EOL; var_dump($a); echo 'and $b:', PHP_EOL; var_dump($b); } 

Viskas, ką darėte, yra apibrėžti savo būdą lyginti du jums reikalingus elementus. Jis veikia su visų rūšių vertėmis.

Beje, ji veikia bet kokia verte, vertybės neturėtų būti sudėtingos matricos. Jei turite individualų palyginimą, kurį norite padaryti, galite tai padaryti paprastu skaičių skaičiumi.

sort pagal nuorodą ir niekas nėra naudingas!

Atkreipkite dėmesį, kad masyvas yra surūšiuotas vietoje, jums nereikia priskirti grąžinimo vertės nieko. $array = sort($array) pakeis masyvą true , o ne su rūšiuojamu masyvu. Tiesiog sort($array); veikia.

Pasirinktiniai skaitmeniniai palyginimai

Jei norite surūšiuoti pagal baz klavišą, kuris yra skaitinis, jums tereikia:

 function cmp(array $a, array $b) { return $a['baz'] - $b['baz']; } 

Matematikos PoWEr oF dėka , jis grąžina <0, 0 arba> 0, priklausomai nuo to, ar $a mažesnis arba didesnis už $b .

Atkreipkite dėmesį, kad tai neveikia float reikšmėms, nes jos bus sumažintos iki int ir neteks tikslumo. -1 naudoti aiškias -1 , 0 ir 1 grąžinimo reikšmes.

Objektai

Jei turite įvairių objektų, jis veikia taip pat:

 function cmp($a, $b) { return $a->baz - $b->baz; } 

funkcijos

Galite atlikti viską, ko reikia lyginimo funkcijoje, įskaitant skambinimo funkcijas:

 function cmp(array $a, array $b) { return someFunction($a['baz']) - someFunction($b['baz']); } 

Stygos

Spartusis pirmosios eilutės palyginimo variantas:

 function cmp(array $a, array $b) { return strcmp($a['foo'], $b['foo']); } 

strcmp daro tai, ko tikimasi iš cmp čia, ji grąžina -1 , 0 arba 1 .

Kosminio laivo operatorius

PHP 7 parodė , kad erdvėlaivių operatorius suvienija ir supaprastina lygybę / mažiau / daugiau nei tipų palyginimas:

 function cmp(array $a, array $b) { return $a['foo'] <=> $b['foo']; } 

Rūšiuoti pagal kelis laukus

Jei norite rūšiuoti daugiausia foo , bet jei foo yra lygus dviem elementams, baz by baz :

 function cmp(array $a, array $b) { if (($cmp = strcmp($a['foo'], $b['foo'])) !== 0) { return $cmp; } else { return $a['baz'] - $b['baz']; } } 

Draugams tai atitinka SQL užklausą su ORDER BY foo, baz .
Taip pat žiūrėkite šią labai tvarkingą sutrumpintą versiją ir kaip dinamiškai sukurti tokį palyginimo funkciją savavališkai daugeliui raktų .

Rūšiuoti į rankinę, statinę tvarką

Jei norite rūšiuoti elementus „rankiniu būdu“, pvz., „Foo“, „bar“, „baz“:

 function cmp(array $a, array $b) { static $order = array('foo', 'bar', 'baz'); return array_search($a['foo'], $order) - array_search($b['foo'], $order); } 

Jei naudojate aukščiau pateiktą informaciją, jei naudojate 5,3 ar daugiau PHP (ir jums iš tikrųjų reikia), naudokite anonimines funkcijas trumpesniam kodui ir venkite kitos pasaulinės funkcijos:

 usort($array, function (array $a, array $b) { return $a['baz'] - $b['baz']; }); 

Tai gali būti paprastas kompleksinio daugiamačio masyvo rūšiavimas. Dar kartą pagalvokite apie tai, kaip mokyti PHP, kaip nustatyti, kuris iš dviejų elementų yra „daugiau“; leiskite php atlikti faktinį rūšiavimą.

Be to, norėdami pereiti nuo didėjančios ir mažėjančios tvarkos, tiesiog pakeiskite argumentus $a ir $b . Pavyzdžiui:

 return $a['baz'] - $b['baz']; // ascending return $b['baz'] - $a['baz']; // descending 

Vienos masyvo rūšiavimas pagal kitą

Ir tada yra tam tikra masyvo masyvo dalis, kuri leidžia surūšiuoti vieną masyvą pagal kitą:

 $array1 = array( 4, 6, 1); $array2 = array('a', 'b', 'c'); 

Laukiamas rezultatas čia:

 $array2 = array('c', 'a', 'b'); // the sorted order of $array1 

Naudokite „ array_multisort kad pasiektumėte:

 array_multisort($array1, $array2); 

Pradedant nuo PHP 5.5.0, galite naudoti array_column kad ištrauktumėte stulpelį iš daugiamatės matricos ir surūšiuotumėte masyvą šiame stulpelyje:

 array_multisort(array_column($array, 'foo'), SORT_DESC, $array); 

Pradedant nuo PHP 7.0.0, galite atkurti ir objektų masyvą.


Jei turite daugiau bendrų atvejų, nedvejodami redaguokite šį atsakymą.

136
28 июня '13 в 14:53 2013-06-28 14:53 atsakymas duotas dekadui birželio 28, 13, 14:53 2013-06-28 14:53

Na, daugelis pagrindinių metodų jau yra padengti. Stengiuosi pažvelgti į kitų rūšių rūšiavimą.

Rūšiavimas su SPL

SplHeap

 class SimpleHeapSort extends SplHeap { public function compare($a, $b) { return strcmp($a, $b); } } // Let populate our heap here (data of 2009) $heap = new SimpleHeapSort(); $heap->insert("a"); $heap->insert("b"); $heap->insert("c"); echo implode(PHP_EOL, iterator_to_array($heap)); 

Išeiti

 c b a 

SplMaxHeap

„SplMaxHeap“ klasė suteikia pagrindines krūvos funkcijas, išlaikydama maksimalią viršuje.

 $heap = new SplMaxHeap(); $heap->insert(1); $heap->insert(2); $heap->insert(3); 

SplMinHeap

„SplMinHeap“ klasė suteikia pagrindines krūvos funkcijas, išlaikydama minimalų aukštį.

 $heap = new SplMinHeap (); $heap->insert(3); $heap->insert(1); $heap->insert(2); 

Kiti rūšiavimo būdai

Burbulų rūšiavimas

Wikipedia straipsnio apie „Bubble Sort“:

Burbulų rūšiavimas, kartais neteisingai vadinamas panardinimu, yra paprastas rūšiavimo algoritmas, kuris veikia iteriuodamas per sąrašą, kurį reikia surūšiuoti, lyginant kiekvieną kaimyninių elementų porą ir pakeičiant juos, jei jie yra neteisingoje eilėje. Perėjimas iš sąrašo kartojamas tol, kol bus reikalingi apsikeitimo sandoriai, o tai rodo, kad sąrašas yra rūšiuojamas. Algoritmas savo pavadinimą gauna iš mažesnių elementų „burbulas“ sąrašo viršuje. Kadangi jis naudoja palyginimus, kad dirbtų su elementais, tai yra rūšiuoti. Nors algoritmas yra paprastas, daugelis kitų rūšiavimo algoritmų yra efektyvesni dideliems sąrašams.

 function bubbleSort(array $array) { $array_size = count($array); for($i = 0; $i < $array_size; $i ++) { for($j = 0; $j < $array_size; $j ++) { if ($array[$i] < $array[$j]) { $tem = $array[$i]; $array[$i] = $array[$j]; $array[$j] = $tem; } } } return $array; } 

Rūšiuoti rūšiuoti

Wikipedia straipsnio dėl rūšiavimo rūšiavimo:

Kompiuterių moksle pasirinkimo rūšiavimas yra rūšiavimo algoritmas, ypač rūšiavimas pagal vietą. Jis turi O (n2) laikinį sudėtingumą, dėl kurio jis yra neveiksmingas dideliuose sąrašuose ir paprastai yra blogesnis nei panašus įterpimas. Rūšiavimas pastebimas dėl savo paprastumo ir tam tikrais atvejais turi pranašumų, palyginti su sudėtingesniais algoritmais, ypač kai papildoma atmintis yra ribota.

 function selectionSort(array $array) { $length = count($array); for($i = 0; $i < $length; $i ++) { $min = $i; for($j = $i + 1; $j < $length; $j ++) { if ($array[$j] < $array[$min]) { $min = $j; } } $tmp = $array[$min]; $array[$min] = $array[$i]; $array[$i] = $tmp; } return $array; } 

Įdėkite rūšiavimą

Wikipedia straipsnio apie rūšiavimo lapus:

Rūšiavimo įterpimas yra paprastas rūšiavimo algoritmas, kuris sudaro galutinį rūšiuojamą masyvą (arba sąrašą) vienu elementu vienu metu. Jis yra daug mažiau efektyvus dideliems sąrašams nei sudėtingesni algoritmai, pvz., Quicksort, heapsort arba susiliejimas. Tačiau rūšiavimo įdėklas turi keletą privalumų:

 function insertionSort(array $array) { $count = count($array); for($i = 1; $i < $count; $i ++) { $j = $i - 1; // second element of the array $element = $array[$i]; while ( $j >= 0  $array[$j] > $element ) { $array[$j + 1] = $array[$j]; $array[$j] = $element; $j = $j - 1; } } return $array; } 

Shellsort

„Shellsort Wikipedia“ straipsnio:

„Shellsort“, taip pat žinomas kaip „Shell“ ar „Shell“, yra tam tikras palyginimas. Jis apibendrina rūšiavimą, pvz., Burbuliukų įterpimą ar rūšiavimą, pradedant elementų palyginimą ir keitimą su elementais, kurie yra toli vienas nuo kito, prieš užbaigiant gretimus elementus.

 function shellSort(array $array) { $gaps = array( 1, 2, 3, 4, 6 ); $gap = array_pop($gaps); $length = count($array); while ( $gap > 0 ) { for($i = $gap; $i < $length; $i ++) { $tmp = $array[$i]; $j = $i; while ( $j >= $gap  $array[$j - $gap] > $tmp ) { $array[$j] = $array[$j - $gap]; $j -= $gap; } $array[$j] = $tmp; } $gap = array_pop($gaps); } return $array; } 

Rūšiuoti rūšiuoti

Vikipedijos straipsnio apie kraigo rūšiavimą:

Šukos rūšiavimas yra gana paprastas rūšiavimo algoritmas, kurį iš pradžių sukūrė Vlodzimierz Doboshevich 1980 m. Vėliau ją atidarė Stephen Lacey ir Richard Boxing 1991 m. Rūšiavimo rūšiavimas pagerėja, kai rūšiuojami burbuliukai.

 function combSort(array $array) { $gap = count($array); $swap = true; while ( $gap > 1 || $swap ) { if ($gap > 1) $gap /= 1.25; $swap = false; $i = 0; while ( $i + $gap < count($array) ) { if ($array[$i] > $array[$i + $gap]) { // swapping the elements. list($array[$i], $array[$i + $gap]) = array( $array[$i + $gap], $array[$i] ); $swap = true; } $i ++; } } return $array; } 

Sujungti rūšiuoti

Wikipedia straipsnio apie sujungimą:

Kompiuterių moksle sujungimo rūšiavimas (taip pat dažnai vadinamas mergesort) yra O (n log n) palyginimo rūšiavimo algoritmas. Dauguma įgyvendinimų sukuria stabilų vaizdą, o tai reiškia, kad įgyvendinimas išsaugo lygių elementų įvedimo į rūšiavimą rezultatą.

 function mergeSort(array $array) { if (count($array) <= 1) return $array; $left = mergeSort(array_splice($array, floor(count($array) / 2))); $right = mergeSort($array); $result = array(); while ( count($left) > 0  count($right) > 0 ) { if ($left[0] <= $right[0]) { array_push($result, array_shift($left)); } else { array_push($result, array_shift($right)); } } while ( count($left) > 0 ) array_push($result, array_shift($left)); while ( count($right) > 0 ) array_push($result, array_shift($right)); return $result; } 

Quicksort

Wikipedia straipsnio apie „Quicksort“:

„Quicksort“ arba „sort-exchange sort“ yra rūšiavimo algoritmas, sukurtas Tony Hoare, kuris vidutiniškai lygina „O“ (n log n), kad surūšiuotų n elementus. Blogiausiu atveju jis daro O (n2) palyginimus, nors toks elgesys yra retas.

 function quickSort(array $array) { if (count($array) == 0) { return $array; } $pivot = $array[0]; $left = $right = array(); for($i = 1; $i < count($array); $i ++) { if ($array[$i] < $pivot) { $left[] = $array[$i]; } else { $right[] = $array[$i]; } } return array_merge(quickSort($left), array( $pivot ), quickSort($right)); } 

Rūšiuoti permutacijas

Wikipedia straipsnio apie rūšiavimo permutacijas:

Permutacijos rūšiavimas, kuris tęsiasi sukuriant galimas įvesties masyvo / sąrašo permutacijas prieš surandant surūšiuotą.

 function permutationSort($items, $perms = array()) { if (empty($items)) { if (inOrder($perms)) { return $perms; } } else { for($i = count($items) - 1; $i >= 0; -- $i) { $newitems = $items; $newperms = $perms; list($foo) = array_splice($newitems, $i, 1); array_unshift($newperms, $foo); $res = permutationSort($newitems, $newperms); if ($res) { return $res; } } } } function inOrder($array) { for($i = 0; $i < count($array); $i ++) { if (isset($array[$i + 1])) { if ($array[$i] > $array[$i + 1]) { return False; } } } return True; } 

Radix veislė

Wikipedia straipsnio apie Radix rūšiavimą:

Kompiuterių moksluose radiksų rūšiavimas nėra lyginamasis sveikasis skaičiavimo algoritmas, kuris suskirsto duomenis naudojant visus raktus, grupavimo raktus į atskirus skaitmenis, turinčius tą pačią reikšmingą poziciją ir vertę.

 // Radix Sort for 0 to 256 function radixSort($array) { $n = count($array); $partition = array(); for($slot = 0; $slot < 256; ++ $slot) { $partition[] = array(); } for($i = 0; $i < $n; ++ $i) { $partition[$array[$i]->age  0xFF][] =  } $i = 0; for($slot = 0; $slot < 256; ++ $slot) { for($j = 0, $n = count($partition[$slot]); $j < $n; ++ $j) { $array[$i ++] =  } } return $array; } 
 // Radix Sort for 0 to 256 function radixSort($array) { $n = count($array); $partition = array(); for($slot = 0; $slot < 256; ++ $slot) { $partition[] = array(); } for($i = 0; $i < $n; ++ $i) { $partition[$array[$i]->age  0xFF][] =  } $i = 0; for($slot = 0; $slot < 256; ++ $slot) { for($j = 0, $n = count($partition[$slot]); $j < $n; ++ $j) { $array[$i ++] =  } } return $array; } 
134
28 июня '13 в 15:11 2013-06-28 15:11 atsakymą pateikė „ Baba “ birželio 28 d. 13 val. 15:11 2013-06-28 15:11

Stabilus rūšiavimas

Tarkime, jūs turite tokią masyvą:

 ['Kale', 'Kaleidoscope', 'Aardvark', 'Apple', 'Leicester', 'Lovely'] 

Ir dabar norite surūšiuoti tik pirmuoju laišku:

 usort($array, function($a, $b) { return strcmp($a[0], $b[0]); }); 

Rezultatas:

 ['Apple', 'Aardvark', 'Kale', 'Kaleidoscope', 'Lovely', 'Leicester'] 

Veislė nebuvo stabili!

Galbūt stebėtojas pastebėjo, kad masyvo rūšiavimo algoritmas (QuickSort) nesuteikė stabilaus rezultato ir kad nebuvo išsaugota pirminės eilės tarp to paties pirmosios raidės žodžių. Šis atvejis yra nereikšmingas, ir mes turėjome palyginti visą eilutę, bet tarkime, kad jūsų precedentas yra sudėtingesnis, pavyzdžiui, dvi eilės iš eilės skirtingose ​​srityse, kurios neturėtų atšaukti vienas kito darbų.

Schwartz transformacija

Schwarzijos transformacija , dar vadinama idicum decorate-sort-undecorate, paveikia stabilią veislę su ne nuolatiniu rūšiavimo algoritmu.

Pirma, kiekvieną masyvo elementą papuošiate kitu masyvu, kuriame yra pagrindinis raktas (vertė) ir papildomas raktas (jo indeksas arba padėtis):

 array_walk($array, function( $index) { $element = array($element, $index); // decorate }); 

Tai konvertuoja masyvą į šį:

 [ ['Kale', 0], ['Kaleidoscope', 1], ['Aardvark', 2], ['Apple', 3], ['Leicester', 4], ['Lovely', 5] ] 

Dabar koreguojame palyginimo etapą; mes vėl lyginame pirmąją raidę, bet jei jie yra tokie patys, antrinis raktas naudojamas pirminiam užsakymui išsaugoti:

 usort($array, function($a, $b) { // $a[0] and $b[0] contain the primary sort key // $a[1] and $b[1] contain the secondary sort key $tmp = strcmp($a[0][0], $b[0][0]); if ($tmp != 0) { return $tmp; // use primary key comparison results } return $a[1] - $b[1]; // use secondary key }); 

Vėliau suskaidome:

 array_walk($array, function( { $element = $element[0]; }); 

Galutinis rezultatas:

 ['Aardvark', 'Apple', 'Kale', 'Kaleidoscope', 'Leicester', 'Lovely'] 

Kaip apie pakartotinį naudojimą?

Jūs turėjote perrašyti palyginimo funkciją, kad galėtumėte dirbti su konvertuotos masyvo elementais; Galbūt nenorite redaguoti savo subtilių palyginimo funkcijų, todėl čia naudojama palyginimo funkcijos pakuotė:

 function stablecmp($fn) { return function($a, $b) use ($fn) { if (($tmp = call_user_func($fn, $a[0], $b[0])) != 0) { return $tmp; } else { return $a[1] - $b[1]; } }; } 

Įrašykite rūšiavimo pakopą naudodami šią funkciją:

 usort($array, stablecmp(function($a, $b) { return strcmp($a[0], $b[0]); })); 

Voila! Jūsų pradinis palyginimo kodas grįžta.

42
28 июня '13 в 16:05 2013-06-28 16:05 atsakymą pateikė Ja͢ck , birželio 28 d., 13 val

Kaip ir su 5.3 uždarymo PHP, taip pat galite naudoti uždarymą, kad nustatytumėte savo požiūrio tvarką.

Pavyzdžiui, darant prielaidą, kad $ masyvas yra objektų, kuriuose yra mėnesio nuosavybė, masyvas.

  $orderArray = array("Jan","Feb","Mar","Apr","May","June","July","Aug","Sept","Oct","Nov","Dec"); usort($array, function($a, $b) use ($orderArray){ return array_search($a->month, $orderArray) - array_search($b->month, $orderArray); }); 
15
19 авг. atsakymą pateikė Orangepilis 19 rug . 2013-08-19 22:16 '13, 10:16 pm 2013-08-19 22:16

LINQ

.NET LINQ sistemoje jis dažnai naudojamas rūšiavimui, kuris suteikia daug geresnę sintaksę palyginimo funkcijoms, ypač kai objektai turi būti suskirstyti į kelis laukus. Yra keletas LINQ prie PHP prievadų, įskaitant „ YaLinqo“ biblioteką *. Su juo matricos gali būti rūšiuojamos viena eilute, nesudarius sudėtingų palyginimo funkcijų.

 $sortedByName = from($objects)->orderBy('$v->name'); $sortedByCount = from($objects)->orderBy('$v->count'); $sortedByCountAndName = from($objects)->orderBy('$v->count')->thenBy('$v->name'); 

Palyginimą galima toliau konfigūruoti perjungiant atgalinį ryšį kaip antrąjį argumentą, pavyzdžiui:

 $sortedByFilenameNat = from($objects)->orderBy('$v->filename', 'strnatcmp'); 

Čia '$v->count' yra function ($v) { return $v->count; } function ($v) { return $v->count; } (arba galima naudoti). Šių metodų grandinės grąžina iteratorius, iteratoriai gali būti konvertuojami į matricas, prireikus pridedant ->toArray() .

Viduje orderBy ir su jais susiję metodai vadina atitinkamas masyvo rūšiavimo funkcijas ( uasort , krsort , multisort , multisort ir kt.).

LINQ yra daug daugiau SQL pagrindu veikiančių metodų: filtravimas, grupavimas, sujungimas, sujungimas ir kt. Tai geriausiai tinka tais atvejais, kai sudėtingos transformacijos masyvuose ir objektuose turi būti atliekamos nenaudojant duomenų bazių.

* sukūrė mane, daugiau informacijos ir palyginimų su kitais LINQ prievadais žr

9
04 июня '15 в 3:58 2015-06-04 03:58 Athari atsakymas birželio 4 d. 15 d. 3:58 2015-06-04 03:58

Daugiamatė rūšiavimas pagal pagrindinę vertę

Natūrali daugialypės matricos išvaizda pagal pagrindinę vertę, taip pat išsaugoti pradinę tvarką (nejaukite pagrindinių raktų):

 function multisortByKeyValue( $k, $arr ) { $ids = array(); $index = 1; foreach ( $arr as $key => $row ) { $ids[ $key ] = intval( $row[ $k ] ) . '-' . $index . '-' . $key; $index ++; } natsort( $ids ); $arr = array_merge( $ids, $arr ); return $arr; } 

Precedentas:

 $arr = array( 'id1' => array( 'label' => 'ID 1', 'priority' => 30, ), 'id2' => array( 'label' => 'ID 2', 'priority' => 70, ), 'id3' => array( 'label' => 'ID 3', 'priority' => 20, ), 'id4' => array( 'label' => 'ID 4', 'priority' => 30, ), ); $sorted = multisortByKeyValue( 'priority', $arr ); // $sorted equals to:  
3
30 янв. Andrejo Surdu atsakymas, pateiktas sausio 30 d 2018-01-30 22:26 '18, 22:26 pm 2018-01-30 22:26

Labai patogu surūšiuoti masyvus, surūšiuotusNspl :

Pagrindinis rūšiavimas

 // Sort array $sorted = sorted([3, 1, 2]); // Sort array in descending order $sortedDesc = sorted([3, 1, 2], true); 

Rūšiuoti pagal funkcijų rezultatą

 // Sort array by the result of a given function (order words by length) $sortedByLength = sorted(['bc', 'a', 'abc'], 'strlen'); $sortedByLengthDesc = sorted(['bc', 'a', 'abc'], true, 'strlen'); // Sort array by the result of user-defined function (order words by the 1st character) $sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], function($v) { return $v[0]; }); // Which is the same as $sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], itemGetter(0)); $sortedByTheFirstCharacterDesc = sorted(['bc', 'a', 'abc'], true, itemGetter(0)); // itemGetter(0) returns a function which takes an argument with access by index/key // and returns the value at index 0 

Сортировка многомерного массива

 // Sort multidimensional array (sort list of users by their names) $users = [ array('name' => 'Robert', 'age' => 20), array('name' => 'Alex', 'age' => 30), array('name' => 'Jack', 'age' => 25), ]; $sortedByName = sorted($users, itemGetter('name')); $sortedByNameDesc = sorted($users, true, itemGetter('name')); // itemGetter('name') returns a function which takes an argument with access by index/key // and returns the value of the 'name' key 

Сортировка массива объектов

 // Lets assume we have class User(name, age) with properties name and age // and public methods getName() and getAge() $users = [ new User('Robert', 20), new User('Alex', 30), new User('Jack', 25), ]; // Sort list of objects by property value (sort list of users by their name) $sortedByName = sorted($users, propertyGetter('name')); $sortedByNameDesc = sorted($users, true, propertyGetter('name')); // propertyGetter('name') returns a function which takes an object // and returns the value of its 'name' property // Sort list of objects by method result (sort list of users by their age) $sortedByAge = sorted($users, methodCaller('getAge')); $sortedByAgeDesc = sorted($users, true, methodCaller('getAge')); // methodCaller('getAge') returns a function which takes an object // and returns the result of its getAge() method 

Сортировка с функцией сравнения

 // Sort with a comparison function (order words lexicographically with strcmp) $sortedLexicographically = sorted(['bc', 'a', 'abc'], false, null, 'strcmp'); // Sort with user-defined comparison function (order words by the 1st character) $sortedByTheFirstCharacter = sorted(['bc', 'a', 'abc'], false, null, function($v1, $v2) { return chr($v1[0]) - chr($v2[0]); }); 

Вы можете увидеть все эти примеры здесь .

2
ответ дан Ihor Burlachenko 16 янв. '16 в 2:03 2016-01-16 02:03