Custom key-sort a flat associative based on another array

Question

Is it possible in PHP to do something like this? How would you go about writing a function? Here is an example. The order is the most important thing.

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

And I'd like to do something like

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

Because at the end I use a foreach() and they're not in the right order (because I append the values to a string which needs to be in the correct order and I don't know in advance all of the array keys/values).

I've looked through PHP's internal array functions but it seems you can only sort alphabetically or numerically.

Covering

VERY similar: Custom sort an associative array by its keys using a lookup array and Usort Without Replacing Keys PHP – Multiracial

Answer 1

Just use array_merge or array_replace. array_merge works by starting with the array you give it (in the proper order) and overwriting/adding the keys with data from your actual array:

$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',
//   'dob'        => '12/08/1986',
//   'address'    => '123 fake st',
//   'dontSortMe' => 'this value doesnt need to be sorted')

PS: I'm answering this 'stale' question, because I think all the loops given as previous answers are overkill.

Sheep

It works nicely if you have string keys but not for the numerical one. PHP Docs: "If the input arrays have the same string keys, then the later value for that key will overwrite the previous one. If, however, the arrays contain numeric keys, the later value will not overwrite the original value, but will be appended." – Norite

Nice, but what if the keys do not exist in the values? I need this, but only if any of the keys exist... Probably need a foreach on it then... – Prepuce

for my case it's array_replace instead of array_merge. array_merge combine both value instead of replacing the second array into the ordered keys. – Ulcerative

@Norite Use array_replace as @Ulcerative suggested and it works with numeric keys too. – Onondaga

I stumbled across your solution a couple of years ago while searching for something different - and I thought to myself, this is extremely efficient compared to the loops. Now I have a need for your solution and it took me an hour of searching to find it again! Thanks! – Klemens

Additionally, if 'order' array (i.e., array('name', 'dob', 'address')) has more keys than the array to sort, then additional array_intersect of the the resulted sorted array with the original array would cut off stray keys that were added at array_merge. – Paulenepauletta

To correct @bbe, you should use array_intersect_key, because this one compares the keys and not the values. (in case the values are not comparable ie.: if they're arrays) – Forespent

Is it really necessary to use array_flip instead of declaring array keys with empty values? – Braid

This solution sucks hard, when you have arrays where not all they key value pairs are the same BOTH solutions just put new keys into the array and put numbers into the values. – Boyes

Answer 2

There you go:

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

Webby

So you can join 2 arrays with a + sign? I never knew that, I've been using array_merge()! – Covering

Is this better than using usort() or uasort()? – Transmittal

You should insert a break statement once value has been found. – Villalba

@Covering Be very careful when you replace array_merge() with the array + operator. It merges by key (also for numeric keys) and from left to right, while array_merge merges from right to left and never overwrites numeric keys. E.g. [0,1,2]+[0,5,6,7] = [0,1,2,7] while array_merge([0,1,2],[0,5,6,7]) = [0,1,2,0,5,6,7] and ['a' => 5] + ['a' => 7] = ['a' => 5] but array_merge(['a' => 5], ['a' => 7]) = ['a' => 7]. – Nunnally

Is it safe to use the + sign? – Dry

The + or union operator is perfectly valid according to PHP Documentation in some use cases it's exactly what you want if you have to keep the numeric keys. – Dune

Answer 3

How about this solution

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

Lvov

This is not very efficient. For every comparison, two linear searches in the array are performed. If we assume the time complexity of uksort() to be O(n * log n), then this algorithm runs in O(n^2 * log(n)). – Megalopolis

This solutions work pretty well for arrays missing a value from the sort order. For small arrays the complexity is probably negligible. The solutions with multiple array functions might be even worse. – Melva

just array_flip the $order before use, and it goes faster – Nowise

@Nowise But in that case you'll get a wrong result – Lvov

@PeterdeGroot sorry for not clarifying :) $order = array_flip( $order ); before the uksort and return $order[ $key1 ] > $order[ $key2 ]; inside uksort – Nowise

Like this solution. Also since PHP 8 one should switch from boolean comparison. (RFC for stable sorting wiki.php.net/rfc/stable_sorting) so instead logical operation ">" use arithmetic "-" – Atheistic

Answer 4

Another way for 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);

Result:

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

Works fine with string and numeric keys.

Kandis

+ While they both work, I found array_replace() to relay intent better than array_merge(). – Piddle

array_replace also leaves the variable type intact. If one of the values in your array would have been (string) '1' and you'd have used the + operator, the value would have been turned into (int) 1 – Weeper

This also works on numeric keys (array_merge() would just append them?). The logic is very well explained here. First, array_flip() changes the $order array's values to keys. Second, array_replace() replaces the values of the first array with values having the same keys in the second array. If you need to sort an array according to keys from another, you don't even have to use array_flip. – Diamond

Answer 5

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

Sot

Answer 6

I used the Darkwaltz4's solution but used array_fill_keys instead of array_flip, to fill with NULL if a key is not set in $array.

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

Pact

To remove items from $array which not listed in $keys I've used: array_replace(array_fill_keys($keys, null), array_intersect_key($array, array_flip($keys))); – Fechner

I don't know when I upvoted this, but I'm back, and wish I could upvote again :D Unlike any solution using array_flip() This answer works when the values are not scalars. – Internist

Answer 7

Take one array as your order:

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

You can sort another array based on values using array_intersect^­Docs:

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

Or in your case, to sort by keys, use array_intersect_key^­Docs:

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

Both functions will keep the order of the first parameter and will only return the values (or keys) from the second array.

So for these two standard cases you don't need to write a function on your own to perform the sorting/re-arranging.

Frowst

The intersect would get rid of those entries he doesn't know in advance. – Manthei

This is incorrect for sorting by keys. array_intersect_key will only return the values from array1, not array2 – Gujarat

Agreed with pavsid - the array_intersect_key example is incorrect - it returns the values from the first array, not the second. – Phaedra

Answer 8

Without magic...

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

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

Aubreir

This works nice thanks, just update $dataset to match parameter name – Aconcagua

This answer has no magic, no explanation, no defined constants, no adherence to PSR-12 coding guidelines, and will conditionally return false instead of an array. – Multiracial

Answer 9

IF you have array in your array, you'll have to adapt the function by Eran a little bit...

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

Accentuation

Answer 10

PHP has functions to help you with this:

$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 does all the work for you and array_search provides the keys. array_search() returns false when it can't find a match so items that are not in the sort array naturally move to the bottom of the array.

Note: uasort() will order the array without affecting the key => value relationships.

Inheritor

Answer 11

A bit late, but I couldn't find the way I implemented it, this version needs closure, php>=5.3, but could be altered not to:

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

Of course 'dontSortMe' needs to be sorted out, and may appear first in the example

Output from above snippet: (Demo)

Warning: Undefined array key "dontSortMe" in /in/Q4osh on line 12

Warning: Undefined array key "dontSortMe" in /in/Q4osh on line 12

Warning: Undefined array key "dontSortMe" in /in/Q4osh on line 12
Array
(
    [name] => Tim
    [dontSortMe] => this value doesnt need to be sorted
    [dob] => 12/08/1986
    [address] => 123 fake st
)

Mcroberts

Doesn't work for me with uksort but does if it's usort – Virago

Answer 12

• sort as requested
• save for int-keys (because of array_replace)
• don't return keys are not existing in inputArray
• (optionally) filter keys no existing in given keyList

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

Prevent

Answer 13

This function return a sub and sorted array based in second parameter $keys

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

Example:

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

Uropygium

Answer 14

First Suggestion

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

Second Suggestion

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

I wanted to point out that both of these suggestions are awesome. However, they are apples and oranges. The difference? One is non-associative friendly and the other is associative friendly. If you are using 2 fully associative arrays then the array merge/flip will actually merge and overwrite the other associative array. In my case that is not the results I was looking for. I used a settings.ini file to create my sort order array. The data array I was sorting did not need to written over by my associative sorting counterpart. Thus array merge would destroy my data array. Both are great methods, both need to be archived in any developers toolbox. Based on your needs you may find you actually need both concepts in your archives.

Potto

Sooooo... your first suggestion is this earlier posted answer and your second suggestion is this earlier posted answer It seems sensible to clarify where "your suggestions" came from. – Multiracial

Answer 15

I adopted the answer from @Darkwaltz4 for its brevity and would like to share how I adapted the solution to situations where the array may contain different keys for each iteration like so:

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

and maintained a "master key" like so:

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

array_merge would have executed the merge in the Array[1] iteration based on $master_key and produced ['some_key'] = '', an empty value, for that iteration. Hence, array_intersect_key was used to modify $master_key in each iterations like so:

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

Popovich

Answer 16

If you have arrays like this, and you need to sort your array based on order, you can easily use this code:

$order = ['a', 'b', 'c', 'd', 'e'];
$needToSortArray = ['d', 'c', 'e'];

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

Challis