Ein Array nach Schlüsseln sortieren, basierend auf einem anderen Array?

Ist es in PHP möglich, so etwas zu tun? Wie würden Sie eine Funktion schreiben? Hier ist ein Beispiel. Die Reihenfolge ist das Wichtigste.

$customer['address'] = '123 fake st';
$customer['name'] = 'Tim';
$customer['dob'] = '12/08/1986';
$customer['dontSortMe'] = 'this value doesnt need to be sorted';

Und ich würde gerne so etwas machen

$properOrderedArray = sortArrayByArray($customer, array('name', 'dob', 'address'));

Weil ich am Ende ein foreach () verwende und sie nicht in der richtigen Reihenfolge sind (weil ich die Werte an eine Zeichenfolge anhänge, die in der richtigen Reihenfolge sein muss und ich nicht alle Array-Schlüssel im Voraus kenne / Werte).

Ich habe die internen Array-Funktionen von PHP durchgesehen, aber anscheinend können Sie nur alphabetisch oder numerisch sortieren.

Verwenden Sie einfach array_mergeoder array_replace. Array_mergeBeginnen Sie mit dem Array, das Sie ihm gegeben haben (in der richtigen Reihenfolge), und überschreiben / fügen Sie die Schlüssel mit Daten aus Ihrem tatsächlichen Array hinzu:

$customer['address'] = '123 fake st';
$customer['name'] = 'Tim';
$customer['dob'] = '12/08/1986';
$customer['dontSortMe'] = 'this value doesnt need to be sorted';

$properOrderedArray = array_merge(array_flip(array('name', 'dob', 'address')), $customer);
//Or:
$properOrderedArray = array_replace(array_flip(array('name', 'dob', 'address')), $customer);

//$properOrderedArray -> array('name' => 'Tim', 'address' => '123 fake st', 'dob' => '12/08/1986', 'dontSortMe' => 'this value doesnt need to be sorted')

ps - Ich beantworte diese "abgestandene" Frage, weil ich denke, dass alle Schleifen, die als vorherige Antworten angegeben wurden, übertrieben sind.

Los geht's:

function sortArrayByArray(array $array, array $orderArray) {
    $ordered = array();
    foreach ($orderArray as $key) {
        if (array_key_exists($key, $array)) {
            $ordered[$key] = $array[$key];
            unset($array[$key]);
        }
    }
    return $ordered + $array;
}

Wie wäre es mit dieser Lösung

$order = array(1,5,2,4,3,6);

$array = array(
    1 => 'one',
    2 => 'two',
    3 => 'three',
    4 => 'four',
    5 => 'five',
    6 => 'six'
);

uksort($array, function($key1, $key2) use ($order) {
    return (array_search($key1, $order) > array_search($key2, $order));
});

Ein anderer Weg für PHP> = 5.3.0:

$customer['address'] = '123 fake st';
$customer['name'] = 'Tim';
$customer['dob'] = '12/08/1986';
$customer['dontSortMe'] = 'this value doesnt need to be sorted';

$customerSorted = array_replace(array_flip(array('name', 'dob', 'address')), $customer);

Ergebnis:

Array (
  [name] => Tim
  [dob] => 12/08/1986
  [address] => 123 fake st
  [dontSortMe] => this value doesnt need to be sorted
)

Funktioniert gut mit Zeichenfolgen und Zifferntasten.

function sortArrayByArray(array $toSort, array $sortByValuesAsKeys)
{
    $commonKeysInOrder = array_intersect_key(array_flip($sortByValuesAsKeys), $toSort);
    $commonKeysWithValue = array_intersect_key($toSort, $commonKeysInOrder);
    $sorted = array_merge($commonKeysInOrder, $commonKeysWithValue);
    return $sorted;
}

Nehmen Sie ein Array als Ihre Bestellung:

$order = array('north', 'east', 'south', 'west');

Sie können ein anderes Array anhand von Werten mithilfe von array_intersect^Dokumenten sortieren :

/* sort by value: */
$array = array('south', 'west', 'north');
$sorted = array_intersect($order, $array);
print_r($sorted);

Oder verwenden Sie in Ihrem Fall zum Sortieren nach Schlüsseln die folgenden array_intersect_key^Dokumente :

/* sort by key: */
$array = array_flip($array);
$sorted = array_intersect_key(array_flip($order), $array);
print_r($sorted);

Beide Funktionen behalten die Reihenfolge des ersten Parameters bei und geben nur die Werte (oder Schlüssel) des zweiten Arrays zurück.

Für diese beiden Standardfälle müssen Sie also keine eigene Funktion schreiben, um das Sortieren / Neuanordnen durchzuführen.

Ich habe die Lösung von Darkwaltz4 verwendet, aber array_fill_keysstattdessen verwendet array_flip, um zu füllen, NULLwenn kein Schlüssel eingegeben wurde $array.

$properOrderedArray = array_replace(array_fill_keys($keys, null), $array);

Ohne Magie ...

$array=array(28=>c,4=>b,5=>a);
$seq=array(5,4,28);    
SortByKeyList($array,$seq) result: array(5=>a,4=>b,28=>c);

function sortByKeyList($array,$seq){
    $ret=array();
    if(empty($array) || empty($seq)) return false;
    foreach($seq as $key){$ret[$key]=$dataset[$key];}
    return $ret;
}

Wenn Sie ein Array in Ihrem Array haben, müssen Sie die Funktion von Eran ein wenig anpassen ...

function sortArrayByArray($array,$orderArray) {
    $ordered = array();
    foreach($orderArray as $key => $value) {
        if(array_key_exists($key,$array)) {
                $ordered[$key] = $array[$key];
                unset($array[$key]);
        }
    }
    return $ordered + $array;
}

Diese Funktion gibt ein untergeordnetes und sortiertes Array zurück, das auf dem zweiten Parameter $ keys basiert

function array_sub_sort(array $values, array $keys){
    $keys = array_flip($keys);
    return array_merge(array_intersect_key($keys, $values), array_intersect_key($values, $keys));
}

Beispiel:

$array_complete = [
    'a' => 1,
    'c' => 3,
    'd' => 4,
    'e' => 5,
    'b' => 2
];

$array_sub_sorted = array_sub_sort($array_complete, ['a', 'b', 'c']);//return ['a' => 1, 'b' => 2, 'c' => 3];

PHP hat Funktionen, die Ihnen dabei helfen:

$arrayToBeSorted = array('west', 'east', 'south', 'north');
$order = array('north', 'south', 'east', 'west');

// sort array
usort($arrayToBeSorted, function($a, $b) use ($order){
    // sort using the numeric index of the second array
    $valA = array_search($a, $order);
    $valB = array_search($b, $order);

    // move items that don't match to end
    if ($valA === false)
        return -1;
    if ($valB === false)
        return 0;

    if ($valA > $valB)
        return 1;
    if ($valA < $valB)
        return -1;
    return 0;
});

Usort erledigt die ganze Arbeit für Sie und array_search stellt die Schlüssel bereit. array_search () gibt false zurück, wenn keine Übereinstimmung gefunden werden kann, sodass Elemente, die sich nicht im Sortierarray befinden, natürlich an den unteren Rand des Arrays verschoben werden.

Hinweis: uasort () ordnet das Array, ohne die Schlüssel => Wertebeziehungen zu beeinflussen.

• wie gewünscht sortieren
• Speichern Sie für Int-Keys (wegen array_replace)
• Keine Rückgabeschlüssel sind in inputArray nicht vorhanden
• (optional) Filterschlüssel, die in der angegebenen Schlüsselliste nicht vorhanden sind

Code:

 /**
 * sort keys like in key list
 * filter: remove keys are not listed in keyList
 * ['c'=>'red', 'd'=>'2016-12-29'] = sortAndFilterKeys(['d'=>'2016-12-29', 'c'=>'red', 'a'=>3 ]], ['c', 'd', 'z']){
 *
 * @param array $inputArray
 * @param string[]|int[] $keyList
 * @param bool $removeUnknownKeys
 * @return array
 */
static public function sortAndFilterKeys($inputArray, $keyList, $removeUnknownKeys=true){
    $keysAsKeys = array_flip($keyList);
    $result = array_replace($keysAsKeys, $inputArray); // result = sorted keys + values from input + 
    $result = array_intersect_key($result, $inputArray); // remove keys are not existing in inputArray 
    if( $removeUnknownKeys ){
        $result = array_intersect_key($result, $keysAsKeys); // remove keys are not existing in keyList 
    }
    return $result;
}

Erster Vorschlag

function sortArrayByArray($array,$orderArray) {
    $ordered = array();
    foreach($orderArray as $key) {
        if(array_key_exists($key,$array)) {
            $ordered[$key] = $array[$key];
            unset($array[$key]);
        }
    }
    return $ordered + $array;
}

Zweiter Vorschlag

$properOrderedArray = array_merge(array_flip(array('name', 'dob', 'address')), $customer);

Ich wollte darauf hinweisen, dass diese beiden Vorschläge großartig sind. Es sind jedoch Äpfel und Orangen. Der Unterschied? Einer ist nicht assoziativ freundlich und der andere ist assoziativ freundlich. Wenn Sie 2 vollständig assoziative Arrays verwenden, wird das Zusammenführen / Umdrehen des Arrays tatsächlich zusammengeführt und das andere assoziative Array überschrieben. In meinem Fall sind das nicht die Ergebnisse, nach denen ich gesucht habe. Ich habe eine settings.ini-Datei verwendet, um mein Sortierreihenfolge-Array zu erstellen. Das Datenarray, das ich sortierte, musste nicht von meinem Gegenstück zur assoziativen Sortierung überschrieben werden. Somit würde das Zusammenführen von Arrays mein Datenarray zerstören. Beide sind großartige Methoden, beide müssen in jeder Entwickler-Toolbox archiviert werden. Je nach Ihren Anforderungen benötigen Sie möglicherweise beide Konzepte in Ihren Archiven.

Ich habe die Antwort von @ Darkwaltz4 wegen ihrer Kürze übernommen und möchte mitteilen, wie ich die Lösung an Situationen angepasst habe, in denen das Array für jede Iteration unterschiedliche Schlüssel enthalten kann:

Array[0] ...
['dob'] = '12/08/1986';
['some_key'] = 'some value';

Array[1] ...
['dob'] = '12/08/1986';

Array[2] ...
['dob'] = '12/08/1986';
['some_key'] = 'some other value';

und pflegte einen "Hauptschlüssel" wie folgt:

$master_key = array( 'dob' => ' ' ,  'some_key' => ' ' );

array_merge hätte die Zusammenführung in der Array [1] -Iteration basierend auf $ master_key ausgeführt und für diese Iteration ['some_key'] = '', einen leeren Wert, erzeugt. Daher wurde array_intersect_key verwendet, um $ master_key in jeder Iteration wie folgt zu ändern:

foreach ($customer as $customer) {
  $modified_key = array_intersect_key($master_key, $unordered_array);
  $properOrderedArray = array_merge($modified_key, $customer);
}

Ein bisschen spät, aber ich konnte nicht finden, wie ich es implementiert habe. Diese Version muss geschlossen werden, php> = 5.3, könnte aber geändert werden, um nicht:

$customer['address'] = '123 fake st';
$customer['name'] = 'Tim';
$customer['dob'] = '12/08/1986';
$customer['dontSortMe'] = 'this value doesnt need to be sorted';

$order = array('name', 'dob', 'address');

$keys= array_flip($order);
uksort($customer, function($a, $b)use($keys){
    return $keys[$a] - $keys[$b];
});
print_r($customer);

Natürlich muss 'dontSortMe' aussortiert werden und erscheint möglicherweise zuerst im Beispiel