问题
I have an array of arrays:
Array (
[0] => Array (
[id] = 7867867,
[title] = 'Some Title'),
[1] => Array (
[id] = 3452342,
[title] = 'Some Title'),
[2] => Array (
[id] = 1231233,
[title] = 'Some Title'),
[3] => Array (
[id] = 5867867,
[title] = 'Some Title')
)
The need to go in a specific order:
- 3452342
- 5867867
- 7867867
- 1231233
How would I go about doing that? I have sorted arrays before, and read plenty of other posts about it, but they are always comparison based (i.e. valueA < valueB).
Help is appreciated.
回答1:
You can use usort() to dictate precisely how the array is to be sorted. In this case, the $order array can be used within the comparison function.
The example below uses a closure to make life easier.
$order = array(3452342, 5867867, 7867867, 1231233);
$array = array(
array('id' => 7867867, 'title' => 'Some Title'),
array('id' => 3452342, 'title' => 'Some Title'),
array('id' => 1231233, 'title' => 'Some Title'),
array('id' => 5867867, 'title' => 'Some Title'),
);
usort($array, function ($a, $b) use ($order) {
$pos_a = array_search($a['id'], $order);
$pos_b = array_search($b['id'], $order);
return $pos_a - $pos_b;
});
var_dump($array);
The key to this working is having the values that are being compared, be the positions of the ids within the $order array.
The comparison function works by finding the positions of the ids of two items to be compared within the $order array. If $a['id'] comes before $b['id'] in the $order array, then the return value of the function will be negative ($a is less so "floats" to the top). If $a['id'] comes after $b['id'] then the function returns a positive number ($a is greater so "sinks" down).
Finally, there is no special reason for using a closure; it's just my go-to way of writing these sorts of throwaway functions quickly. It could equally use a normal, named function.
回答2:
Extending salathe's answer for this additional requirement:
Now what happens when I add items to the array and not to the sort? I don't care what order they appear, as long as it comes after the ones that I did specify.
You need to add two additional conditions in the sorting function:
- A "dont care" item must be considered greater than whitelisted items
- Two "dont care" items must be considered equal
So the revised code would be:
$order = array(
3452342,
5867867,
7867867,
1231233
);
$array = array(
array("id" => 7867867, "title" => "Must Be #3"),
array("id" => 3452342, "title" => "Must Be #1"),
array("id" => 1231233, "title" => "Must Be #4"),
array("id" => 5867867, "title" => "Must Be #2"),
array("id" => 1111111, "title" => "Dont Care #1"),
array("id" => 2222222, "title" => "Dont Care #2"),
array("id" => 3333333, "title" => "Dont Care #3"),
array("id" => 4444444, "title" => "Dont Care #4")
);
shuffle($array); // for testing
var_dump($array); // before
usort($array, function ($a, $b) use ($order) {
$a = array_search($a["id"], $order);
$b = array_search($b["id"], $order);
if ($a === false && $b === false) { // both items are dont cares
return 0; // a == b
} else if ($a === false) { // $a is a dont care
return 1; // $a > $b
} else if ($b === false) { // $b is a dont care
return -1; // $a < $b
} else {
return $a - $b; // sort $a and $b ascending
}
});
var_dump($array); // after
Output:
Before | After
-------------------------------+-------------------------------
array(8) { | array(8) {
[0]=> | [0]=>
array(2) { | array(2) {
["id"]=> | ["id"]=>
int(4444444) | int(3452342)
["title"]=> | ["title"]=>
string(12) "Dont Care #4" | string(10) "Must Be #1"
} | }
[1]=> | [1]=>
array(2) { | array(2) {
["id"]=> | ["id"]=>
int(3333333) | int(5867867)
["title"]=> | ["title"]=>
string(12) "Dont Care #3" | string(10) "Must Be #2"
} | }
[2]=> | [2]=>
array(2) { | array(2) {
["id"]=> | ["id"]=>
int(1231233) | int(7867867)
["title"]=> | ["title"]=>
string(10) "Must Be #4" | string(10) "Must Be #3"
} | }
[3]=> | [3]=>
array(2) { | array(2) {
["id"]=> | ["id"]=>
int(1111111) | int(1231233)
["title"]=> | ["title"]=>
string(12) "Dont Care #1" | string(10) "Must Be #4"
} | }
[4]=> | [4]=>
array(2) { | array(2) {
["id"]=> | ["id"]=>
int(5867867) | int(2222222)
["title"]=> | ["title"]=>
string(10) "Must Be #2" | string(12) "Dont Care #2"
} | }
[5]=> | [5]=>
array(2) { | array(2) {
["id"]=> | ["id"]=>
int(2222222) | int(1111111)
["title"]=> | ["title"]=>
string(12) "Dont Care #2" | string(12) "Dont Care #1"
} | }
[6]=> | [6]=>
array(2) { | array(2) {
["id"]=> | ["id"]=>
int(3452342) | int(3333333)
["title"]=> | ["title"]=>
string(10) "Must Be #1" | string(12) "Dont Care #3"
} | }
[7]=> | [7]=>
array(2) { | array(2) {
["id"]=> | ["id"]=>
int(7867867) | int(4444444)
["title"]=> | ["title"]=>
string(10) "Must Be #3" | string(12) "Dont Care #4"
} | }
} | }
回答3:
The other answers which are using methods with iterated calls of array_search() are not as efficient as they can be. By restructuring/flipping the "order" lookup array, you can completely omit all array_search() calls -- making your task much more efficient and brief. I'll use the most modern "spaceship operator" (<=>), but earlier techniques will work the same for the comparison line.
Method #1 - usort when all id values exist in $order (Demo)
$order=array_flip([3452342,5867867,7867867,1231233]); // restructure with values as keys, and keys as order (ASC)
// generating $order=[3452342=>0,5867867=>1,7867867=>2,1231233=>3];
$array=[
['id'=>7867867,'title'=>'Some Title'],
['id'=>3452342,'title'=>'Some Title'],
['id'=>1231233,'title'=>'Some Title'],
['id'=>5867867,'title'=>'Some Title']
];
usort($array,function($a,$b)use($order){
return $order[$a['id']]<=>$order[$b['id']];
// when comparing ids 3452342 & 1231233, the actual comparison is 0 vs 3
});
// uasort() if you want to preserve keys
var_export($array);
Method #2 - usort when some id values do not exist in $order (Demo)
*note, isset() is a less expensive call than array_search()
$order=array_flip([3452342,5867867,7867867,1231233]); // restructure with values as keys, and keys as order (ASC)
// generating $order=[3452342=>0,5867867=>1,7867867=>2,1231233=>3];
$outlier=1+max($order);
// generating $outlier=4
$array=[
['id'=>7867867,'title'=>'Some Title'],
['id'=>3452342,'title'=>'Some Title'],
['id'=>'foo','title'=>'Some Title'],
['id'=>1231233,'title'=>'Some Title'],
['id'=>'bar','title'=>'Some Title'],
['id'=>5867867,'title'=>'Some Title']
];
usort($array,function($a,$b)use(&$order,$outlier){ // make $order modifiable with &
if(!isset($order[$a['id']])){$order[$a['id']]=$outlier;} // update lookup array with [id]=>[outlier number]
if(!isset($order[$b['id']])){$order[$b['id']]=$outlier;} // and again
return $order[$a['id']]<=>$order[$b['id']];
});
var_export($array);
Alternate Method #2 - usort when some id values do not exist in $order
...I'd also like to mention that in some cases, avoiding the iterated double-call of isset() may be less attractive versus fully preparing the $order array prior to calling usort().
This one-liner will ensure that there are no missing id values, thus eliminating the need for anything other than the comparison line inside the sorting function. (Full Snippet Demo)
$order=array_replace(array_fill_keys(array_column($array,'id'),$outlier),$order);
回答4:
You need to define your own comparison function and use usort or uasort if you want to maintain index association.
回答5:
@salathe For those of you that are having a hard time understanding what salathe's usort is doing:
Each item in $array is a 'champion' in a tournament to be at the start of a new array (except instead of being number one they want to be number 0).
$a is the home champion, and $b the opponent champion in a match.
$pos_a and $pos_b from the callback are what attributes will be used in the fight for champion a and b. In this case this attribute is the index of the champions id in $order.
Then there is the fight at the return. Now we look to see if having more or less of the attribute is better. In a usort battle the home champion wants a negative number so he can be sooner in the array. The away champion wants a positive number. And should there be a 0 it is a tie.
So following this analogy when away champions attribute(index in $order) is subtracted from the home teams attribute, the larger the away champions attribute is the less likely it is to win by getting a positive number. However if you were to reverse the way the attributes are used, now home champion's attribute is subtracted from away champion's. In this case a larger number for the away champion is more likely to make him have the match end in a positive number.
Code would look like:
note: code is run many times much like a real tournament has many battles in order to decide who gets first(ie 0 / start of array)
//tournament with goal to be first in array
usort($champions, function ($home, $away) use ($order) {
$home_attribute = array_search($a['id'], $order);
$away_attribute = array_search($b['id'], $order);
//fight with desired outcome for home being negative and away desiring positive
return $home_attribute - $away_attribute;
});
回答6:
Without sort you also can get it.
It there is no duplicate id;
<?php
$order = array(3452342, 5867867, 7867867, 1231233);
$array = array(
array('id' => 7867867, 'title' => 'Some Title'),
array('id' => 3452342, 'title' => 'Some Title'),
array('id' => 1231233, 'title' => 'Some Title'),
array('id' => 5867867, 'title' => 'Some Title'),
);
$order = array_flip($order);
$array = array_column($array,null,"id");
$result = array_replace($order,$array);
var_dump(array_values($result));
With duplicate id,
<?php
$order = array(3452342, 5867867, 7867867, 1231233);
$array = array(
array('id' => 7867867, 'title' => 'Some Title'),
array('id' => 3452342, 'title' => 'Some Title'),
array('id' => 1231233, 'title' => 'Some Title'),
array('id' => 5867867, 'title' => 'Some Title'),
);
$order_dict = array_flip($order);
$order_dict = array_combine($order,array_fill(0,count($order),[]));
foreach($array as $item){
$order_dict[$item["id"]][] = $item;
}
//$order_dict = array_filter($order_dict); // if there is empty item on some id in $order array
$result = [];
foreach($order_dict as $items){
foreach($items as $item){
$result[] = $item;
}
}
var_dump($result);
回答7:
This is how I sort my multi-dimensional array in ASC order based on id value:
$arrayFilter = array(
array('product_tag' => 'xenia', 'id' => 4),
array('product_tag' => 'worn', 'id' => 5),
array('product_tag' => 'woven', 'id' => 3),
array('product_tag' => 'nude', 'id' => 1)
);
for ($i = 0; $i < sizeof($arrayFilter); $i++) {
for ($j=$i+1; $j < sizeof($arrayFilter); $j++) {
if ($arrayFilter[$i]['id'] > $arrayFilter[$j]['id']) {
$c = $arrayFilter[$i];
$arrayFilter[$i] = $arrayFilter[$j];
$arrayFilter[$j] = $c;
}
}
}
print_r($arrayFilter);
OUTPUT:
Array
(
[0] => Array
(
[product_tag] => nude
[id] => 1
)
[1] => Array
(
[product_tag] => woven
[id] => 3
)
[2] => Array
(
[product_tag] => xenia
[id] => 4
)
[3] => Array
(
[product_tag] => worn
[id] => 5
)
)
来源：https://stackoverflow.com/questions/11877973/how-to-sort-array-on-behalf-of-another-when-one-array-index-is-of-string-m-using