wake-up-neo.com

Wie kann ich Arrays und Daten in PHP sortieren?

Diese Frage ist als Referenz für Fragen zum Sortieren von Arrays in PHP gedacht. Es ist leicht zu glauben, dass Ihr spezieller Fall einzigartig und einer neuen Frage würdig ist, aber die meisten sind tatsächlich geringfügige Variationen einer der Lösungen auf dieser Seite.

Wenn Ihre Frage als Duplikat dieser Frage geschlossen ist, bitten Sie darum, dass Ihre Frage nur dann erneut geöffnet wird, wenn Sie erklären können, warum sie sich deutlich von den folgenden Punkten unterscheidet.

Wie sortiere ich ein Array in PHP?
Wie sortiere ich ein complex Array in PHP?
Wie sortiere ich ein Array von Objekten in PHP?


  1. Grundlegende eindimensionale Arrays; Inkl. Mehrdimensionale Arrays, inkl. Anordnungen von Objekten; Inkl. Ein Array nach einem anderen sortieren

  2. Sortieren mit SPL

  3. Stabile Sortierung

Für die praktische Antwort unter Verwendung der vorhandenen PHP-Funktionen siehe 1., für die detaillierte akademische Antwort zu Sortieralgorithmen (welche PHP-Funktionen implementieren und welche Sie für wirklich, wirklich komplexe Fälle benötigen) siehe 2.

265
deceze

Grundlegende eindimensionale Arrays

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

Anwendbare Sortierfunktionen:

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

Der Unterschied zwischen diesen besteht lediglich darin, ob Schlüssel-Wert-Assoziationen beibehalten werden (die Funktionen "a"), ob von niedrig nach hoch oder umgekehrt ("r"), ob Werte oder Schlüssel ("k") und wie sortiert werden es vergleicht Werte ("nat" vs. normal). Einen Überblick und Links zu weiteren Details finden Sie unter http://php.net/manual/de/array.sorting.php .

Mehrdimensionale Arrays, einschließlich Arrays von Objekten

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

Wenn Sie $array nach dem Schlüssel 'foo' jedes Eintrags sortieren möchten, benötigen Sie eine benutzerdefinierte Vergleichsfunktion. Die oben genannten sort und verwandten Funktionen arbeiten mit einfachen Werten, die sie miteinander vergleichen und sortieren können. PHP "weiß" jedoch nicht, was mit einem komplexen Wert wie array('foo' => 'bar', 'baz' => 42) zu tun ist; also musst du es sagen.

Dazu müssen Sie eine Vergleichsfunktion erstellen. Diese Funktion benötigt zwei Elemente und muss 0 zurückgeben, wenn diese Elemente als gleich betrachtet werden, ein Wert unter 0, wenn der erste Wert niedriger ist, und einen Wert, der höher ist als 0, wenn der erste Wert höher ist. Das ist alles was benötigt wird:

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

Häufig möchten Sie eine anonyme Funktion als Rückruf verwenden. Wenn Sie eine Methode oder eine statische Methode verwenden möchten, lesen Sie den Abschnitt andere Möglichkeiten zum Angeben eines Rückrufs in PHP .

Sie verwenden dann eine dieser Funktionen:

Wieder unterscheiden sie sich nur darin, ob sie Schlüsselwertzuordnungen beibehalten und nach Werten oder Schlüsseln sortieren. Lesen Sie ihre Dokumentation für Details.

Verwendungsbeispiel:

usort($array, 'cmp');

usort nimmt zwei Elemente aus dem Array und ruft Ihre cmp-Funktion auf. Daher wird cmp() mit $a als array('foo' => 'bar', 'baz' => 42) und $b als einer anderen array('foo' => ..., 'baz' => ...) aufgerufen. Die Funktion gibt dann an usort zurück, welcher der Werte größer war oder ob sie gleich waren. usort wiederholt diesen Vorgang und übergibt verschiedene Werte für $a und $b, bis das Array sortiert ist. Die cmp-Funktion wird mehrmals aufgerufen, mindestens so oft, wie in $array Werte vorhanden sind, wobei jeweils unterschiedliche Wertekombinationen für $a und $b vorhanden sind.

Versuchen Sie Folgendes, um sich an diese Idee zu gewöhnen:

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

Sie haben lediglich eine benutzerdefinierte Methode zum Vergleichen zweier Elemente definiert. Das ist alles, was Sie brauchen. Das funktioniert mit allen möglichen Werten.

Übrigens funktioniert dies bei jedem Wert, die Werte müssen keine komplexen Arrays sein. Wenn Sie einen benutzerdefinierten Vergleich durchführen möchten, können Sie dies auch mit einem einfachen Zahlenfeld tun.

sort sortiert nach Verweis und gibt nichts Nützliches zurück!

Beachten Sie, dass das Array in Stelle sortiert, Sie müssen den Rückgabewert jedoch keinem Objekt zuweisen. $array = sort($array) ersetzt das Array durch true, nicht durch ein sortiertes Array. Nur sort($array); funktioniert.

Benutzerdefinierte numerische Vergleiche

Wenn Sie nach dem baz-Schlüssel sortieren möchten, der numerisch ist, müssen Sie nur Folgendes tun:

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

Dank The PoWEr OF MATH wird ein Wert <0, 0 oder> 0 zurückgegeben, abhängig davon, ob $a kleiner als, gleich oder größer als $b ist.

Beachten Sie, dass dies für float-Werte nicht gut funktioniert, da sie auf int reduziert werden und an Genauigkeit verlieren. Verwenden Sie stattdessen die expliziten Rückgabewerte -1, 0 und 1.

Objekte

Wenn Sie über ein Array von Objekten verfügen, funktioniert es genauso:

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

Funktionen

Sie können alles tun, was Sie in einer Vergleichsfunktion benötigen, einschließlich aufrufender Funktionen:

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

Zeichenketten

Eine Abkürzung für die erste Stringvergleichsversion:

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

strcmp macht genau das, was von cmp erwartet wird, und gibt -1, 0 oder 1 zurück.

Raumschiff-Operator

PHP 7 führte den Spaceship-Operator ein, der gleiche/kleinere/größere Vergleiche zwischen verschiedenen Typen vereinheitlicht und vereinfacht:

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

Sortierung nach mehreren Feldern

Wenn Sie hauptsächlich nach foo sortieren möchten, aber wenn foo für zwei Elemente gleich ist, sortieren Sie nach baz:

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

Für vertraute Personen entspricht dies einer SQL-Abfrage mit ORDER BY foo, baz.
Siehe auch diese sehr nette Kurzfassung und wie eine solche Vergleichsfunktion dynamisch für eine beliebige Anzahl von Schlüsseln erstellt wird .

Sortieren in eine manuelle, statische Reihenfolge

Wenn Sie Elemente in eine "manuelle Reihenfolge" wie "foo", "bar", "baz" sortieren möchten:

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

Wenn Sie PHP 5.3 oder höher verwenden (und Sie sollten dies wirklich tun), verwenden Sie anonyme Funktionen für kürzeren Code und um zu vermeiden, dass eine andere globale Funktion verwendet wird:

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

So einfach kann ein komplexes mehrdimensionales Array sortiert werden. Denken Sie noch einmal in Form von Teaching PHP wie Sie feststellen können, welches von zwei Elementen "größer" ist; Lassen Sie PHP die eigentliche Sortierung durchführen.Für alle oben genannten Punkte müssen Sie zum Wechseln zwischen aufsteigender und absteigender Reihenfolge einfach die Argumente $a und $b vertauschen. Z.B.:.

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

array_multisort , mit dem Sie ein Array nach einem anderen sortieren können:

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

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

array_multisort($array1, $array2);

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

.


If you have more common cases, feel free to edit this answer.

145
deceze

Nun, die meisten grundlegenden Methoden werden bereits von deceze abgedeckt. Ich würde versuchen, andere Arten von Sorten zu betrachten

Sortierung mit SPL

SplHeap

class SimpleHeapSort extends SplHeap {
    public function compare($a, $b) {
        return strcmp($a, $b);
    }
}

// Let's 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));

Ausgabe 

c
b
a

SplMaxHeap

Die SplMaxHeap-Klasse stellt die Hauptfunktionalitäten eines Heaps bereit, wobei das Maximum oben bleibt.

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

SplMinHeap

Die SplMinHeap-Klasse stellt die Hauptfunktionalitäten eines Heaps bereit, wobei das Minimum oben bleibt.

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

Andere Sortenarten

Bubble Sort

Aus dem Wikipedia-Artikel zu Bubble Sort:

Die Blasensortierung, die manchmal fälschlicherweise als sinkende Sortierung bezeichnet wird, ist ein einfacher Sortieralgorithmus, der wiederholt durch die zu sortierende Liste blättert, jedes Paar benachbarter Elemente miteinander vergleicht und diese austauscht, wenn sie in der falschen Reihenfolge liegen. Das Durchlaufen der Liste wird wiederholt, bis keine Auslagerungen erforderlich sind. Dies zeigt an, dass die Liste sortiert ist. Der Algorithmus erhält seinen Namen von der Art und Weise, wie kleinere Elemente "Blasen" an den Anfang der Liste setzen. Da nur Vergleiche zur Bearbeitung von Elementen verwendet werden, handelt es sich um eine Vergleichssortierung. Obwohl der Algorithmus einfach ist, sind die meisten anderen Sortieralgorithmen für große Listen effizienter.

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;
}

Auswahl sortieren

Aus dem Wikipedia-Artikel zur Auswahl sortieren:

In der Informatik ist Auswahlsortierung ein Sortieralgorithmus, insbesondere eine Direktvergleichssortierung. Es hat O(n2) Zeitkomplexität, was es bei großen Listen ineffizient macht und im Allgemeinen schlechter abschneidet als die ähnliche Einfügesortierung. Die Auswahl der Auswahl ist für ihre Einfachheit bekannt und hat in bestimmten Situationen, insbesondere wenn der Hilfsspeicher begrenzt ist, Leistungsvorteile gegenüber komplizierteren Algorithmen.

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;
}

Sortieren durch Einfügen

Aus dem Wikipedia-Artikel zum Einfügen sortieren:

Einfügungssortierung ist ein einfacher Sortieralgorithmus, der das endgültige sortierte Array (oder die Liste) jeweils einzeln erstellt. Es ist bei großen Listen viel weniger effizient als fortschrittlichere Algorithmen wie Quicksort, Heapsort oder Merge Sort. Die Sortierreihenfolge bietet jedoch mehrere Vorteile:

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

Aus dem Wikipedia-Artikel zu Shellsort:

Shellsort, auch Shell-Sortierung oder Shell-Methode genannt, ist eine Direktvergleichssortierung. Sie verallgemeinert eine Austauschsortierung, z. B. Einfügung oder Blasensortierung, indem der Vergleich und der Austausch von Elementen mit weit auseinander liegenden Elementen begonnen wird, bevor sie mit benachbarten Elementen beendet werden. 

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;
}

Kamm sortieren

Von dem Wikipedia-Artikel über Kamm sortieren:

Kammsortierung ist ein relativ einfacher Sortieralgorithmus, der ursprünglich von Wlodzimierz Dobosiewicz im Jahr 1980 entwickelt wurde. Später wurde er von Stephen Lacey und Richard Box im Jahr 1991 wiederentdeckt. Kammsorte verbessert die Blasensortierung.

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;
}

Zusammenführen, sortieren

Aus dem Wikipedia-Artikel zum Zusammenführen sortieren:

In der Informatik ist eine Zusammenführungssortierung (auch als häufig zusammengesetzter Zusammenführungsort bezeichnet) ein Vergleichsalgorithmus, der auf O (n log n) basiert. Die meisten Implementierungen erzeugen eine stabile Sortierung, dh die Implementierung behält die Eingabereihenfolge gleicher Elemente in der sortierten Ausgabe bei

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;
}

Schnelle Sorte

Aus dem Wikipedia-Artikel zu Quicksort:

Quicksort oder Partitionsaustausch-Sortierung ist ein von Tony Hoare entwickelter Sortieralgorithmus, der im Durchschnitt O (n log n) Vergleiche anstellt, um n Elemente zu sortieren. Im schlimmsten Fall werden O(n2) Vergleiche durchgeführt, obwohl dieses Verhalten selten ist.

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));
}

Permutationsart

Aus dem Wikipedia-Artikel zur Permutation sortieren:

Permutations-Sortierung, die durch Generieren der möglichen Permutationen des Eingabearrays/der Eingabeliste fortfährt, bis die sortierte gefunden wird.

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-Sortierung

Von dem Wikipedia-Artikel zu Radix sortieren:

In der Informatik ist Radix Sort ein nicht vergleichender ganzzahliger Sortieralgorithmus, der Daten mit ganzzahligen Schlüsseln sortiert, indem die Schlüssel nach den einzelnen Ziffern gruppiert werden, die dieselbe signifikante Position und denselben Wert haben. 

// 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][] = &$array[$i];
    }

    $i = 0;

    for($slot = 0; $slot < 256; ++ $slot) {
        for($j = 0, $n = count($partition[$slot]); $j < $n; ++ $j) {
            $array[$i ++] = &$partition[$slot][$j];
        }
    }
    return $array;
}
136
Baba

Stabile Sorte

Nehmen wir an, Sie haben ein Array wie dieses:

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

Und jetzt möchten Sie nur nach dem ersten Buchstaben sortieren:

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

Das Ergebnis ist folgendes:

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

Die Sortierung war nicht stabil!

Der aufmerksame Beobachter hat möglicherweise bemerkt, dass der Arraysortierungsalgorithmus (QuickSort) nicht zu einem stabilen Ergebnis geführt hat und dass die ursprüngliche Reihenfolge zwischen Wörtern desselben ersten Buchstabens nicht beibehalten wurde. Dieser Fall ist trivial, und wir hätten die gesamte Zeichenfolge vergleichen sollen. Nehmen wir jedoch an, Ihr Anwendungsfall ist komplizierter, z. B. zwei aufeinanderfolgende Sortierungen in verschiedenen Feldern, die die Arbeit des anderen nicht beeinträchtigen sollten.

Die schwartzianische Transformation

Die Schwartzian-Transformation , die auch als Dekorate-Sort-Undecorate-Sprache bezeichnet wird, bewirkt eine stabile Sortierung mit einem inhärent instabilen Sortieralgorithmus.

Zunächst dekorieren Sie jedes Array-Element mit einem anderen Array, das einen Primärschlüssel (den Wert) und einen Sekundärschlüssel (dessen Index oder Position) enthält:

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

Das verwandelt das Array in folgendes:

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

Nun passen wir den Vergleichsschritt an. Wir vergleichen den ersten Buchstaben noch einmal, aber wenn sie gleich sind, wird der Sekundärschlüssel verwendet, um die ursprüngliche Reihenfolge beizubehalten:

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
});

Danach verzieren wir:

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

Das Endergebnis:

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

Was ist mit der Wiederverwendung?

Sie mussten Ihre Vergleichsfunktion neu schreiben, um mit den transformierten Array-Elementen zu arbeiten. Möglicherweise möchten Sie Ihre empfindlichen Vergleichsfunktionen nicht bearbeiten. Hier ist ein Wrapper für die Vergleichsfunktion:

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];
        }
    };
}

Schreiben wir den Sortierschritt mit dieser Funktion:

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

Voila! Ihr ursprünglicher Vergleichscode ist zurück.

44
Ja͢ck

Ab PHP 5.3 mit Schließungen ist es auch möglich, eine Schließung zu verwenden, um die Sortierreihenfolge zu bestimmen.

Angenommen, $ array ist ein Array von Objekten, die eine Monatseigenschaft enthalten.

 $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
Orangepill

LINQ

In .NET wird häufig LINQ zum Sortieren verwendet, was eine wesentlich schönere Syntax für Vergleichsfunktionen bietet, insbesondere wenn Objekte nach mehreren Feldern sortiert werden müssen. Es gibt mehrere Ports von LINQ zu PHP, einschließlich YaLinqo library *. Damit können Arrays mit einer einzelnen Zeile sortiert werden, ohne komplexe Vergleichsfunktionen schreiben zu müssen.

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

Vergleiche können weiter angepasst werden, indem ein Rückruf als zweites Argument übergeben wird. Beispiel:

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

Hier ist '$v->count' eine Abkürzung für function ($v) { return $v->count; } (beide können verwendet werden). Diese Methodenketten geben Iteratoren zurück, Iteratoren können in Arrays umgewandelt werden, indem bei Bedarf am Ende ->toArray() hinzugefügt wird.

Intern rufen orderBy und verwandte Methoden geeignete Arraysortierungsfunktionen auf (uasort, krsort, multisort, usort usw.).

LINQ enthält viele weitere von SQL inspirierte Methoden: Filtern, Gruppieren, Verknüpfen, Aggregieren usw. Dies ist am besten für Fälle geeignet, in denen komplexe Transformationen von Arrays und Objekten ohne Datenbankabhängigkeit durchgeführt werden müssen.

* von mir entwickelt, siehe Readme für weitere Details und Vergleiche mit anderen LINQ-Ports

9
Athari

Mehrdimensionale Sortierung nach Schlüsselwert

Natürliche Art eines mehrdimensionalen Arrays nach einem Schlüsselwert und auch die ursprüngliche Reihenfolge einhalten (die Hauptschlüssel nicht mischen):

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;
}

Testfall:

$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:
/*
array (
  'id3' => array (
    'label' => 'ID 3',
    'priority' => 20,
  ),
  'id1' => array (
    'label' => 'ID 1',
    'priority' => 30,
  ),
  'id4' => array (
    'label' => 'ID 4',
    'priority' => 30,
  ),
  'id2' => array (
    'label' => 'ID 2',
    'priority' => 70,
  ),
)
*/
3
Andrei Surdu

Wenn Sie nach dem Schlüsselwert ordnen möchten, können Sie dies in einer Zeile, elegant und klar, tun. Dies wird nach aufsteigendem Preis sortiert. Verwendet array_multisort und array_column.

   Array([0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => coffee [price] => 9.99 ) [2] => Array ( [name] => rice [price] => 4.04 ) )

   array_multisort (array_column($array, 'price'), SORT_ASC, $array);

produzieren

     Array ( [0] => Array ( [name] => eggs [price] => 1 ) [1] => Array ( [name] => rice [price] => 4.04 ) [2] => Array ( [name] => coffee [price] => 9.99 ) )
2
GAV

Es ist sehr praktisch, Arrays mit sortiert - Funktion aus Nspl zu sortieren:

Basissortierung

// Sort array
$sorted = sorted([3, 1, 2]);

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

Sortierung nach Funktionsergebnis

// 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

Mehrdimensionales Array sortieren

// 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

Sortierfeld von Objekten

// 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

Sortieren mit einer Vergleichsfunktion

// 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]);
});

Sie können alle diese Beispiele sehen hier .

2

Es gibt mehrere Möglichkeiten, ein Array zu sortieren. Ich erwähne einige Methoden, um diese task.fist auszuführen. Ich werde ein ganzzahliges Array angeben, das als '$ numbers' bezeichnet wird.

$number = array(8,9,3,4,0,1,2);

Dies ist der normale Weg zum Erstellen eines Arrays. Angenommen, ich möchte dieses Array in aufsteigender Reihenfolge sortieren. Dazu kann die 'sort ()' - Methode verwendet werden.

<?php

    $number = array(8,9,3,4,0,1,2);
    sort($number);

   foreach ($number as $value) {
       echo $value."  ";
   }
?>

Betrachten Sie nun die Ausgabe davon,

 enter image description here

Sie sehen, dass das gedruckte Zahlenfeld sortiert ist. Wenn Sie möchten, dass das Zahlenarray in absteigender Reihenfolge sortiert wird, kann die Methode 'rsort ()' für diese Aufgabe verwendet werden.

<?php

     $number = array(8,9,3,4,0,1,2);
     rsort($number);

     foreach ($number as $value) {
        echo $value."  ";
     }
?>

betrachte die Ausgabe ..

 enter image description here

Das Array ist jetzt in absteigender Reihenfolge sortiert.Ok, betrachten wir ein assoziatives Array. Ich gebe ein assoziatives Array (Assoziatives Array bedeutet: Ein Array, dessen Index einen eindeutigen Schlüsselwert hat.)

$number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);

Nun, ich möchte dieses Array in aufsteigender Reihenfolge nach ihrem Wert sortieren. Die Methode "asort ()" kann dafür verwendet werden.

<?php

   $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
   asort($number);

   foreach ($number as $value) {
      echo $value."  ";
    }
?>

Wenn Sie die absteigende Reihenfolge nach ihrem Wert sortieren, kann die 'arsort ()' - Methode verwendet werden . Angenommen, Sie möchten das Array nach ihrem Schlüsselwert sortieren. In diesem kann 'ksort ()' Methode verwendet werden.

<?php

     $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
     ksort($number);

     foreach ($number as $value) {
         echo $value."  ";
     }
?>

Betrachten Sie nun die Ausgabe .  enter image description here

Nun wird das Array nach ihrem Schlüsselwert sortiert. Wenn Sie das Array in absteigender Reihenfolge nach dem Schlüsselwert sortieren möchten, kann die Methode 'krsort ()' verwendet werden.

<?php

    $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);
    krsort($number);

    foreach ($number as $value) {
       echo $value."  ";
    }
?>

Nun wird das assoziative Array in absteigender Reihenfolge nach ihrem Schlüsselwert sortiert. Schauen Sie sich die Ausgabe an  enter image description here

Dies sind einige Methoden, um ein Array in php auf- oder absteigend zu sortieren. Ich hoffe, Sie könnten eine Idee bekommen. Vielen Dank!

0
GT_hash