PHP Sortuj tablicę według SubArray Wartość

Question

Mam następujący structue tablicy:

Array 
     (
      [0] => Array 
       (
        [configuration_id] => 10 
        [id] => 1 
        [optionNumber] => 3 
        [optionActive] => 1 
        [lastUpdated] => 2010-03-17 15:44:12 
       ) 

      [1] => Array 
       (
        [configuration_id] => 9 
        [id] => 1 
        [optionNumber] => 2 
        [optionActive] => 1 
        [lastUpdated] => 2010-03-17 15:44:12 
       ) 

      [2] => Array 
       (
        [configuration_id] => 8 
        [id] => 1 
        [optionNumber] => 1 
        [optionActive] => 1 
        [lastUpdated] => 2010-03-17 15:44:12 
       ) 
    ) 

Jaki jest najlepszy sposób, aby tablica, w sposób narastający na podstawie optionNumber?

Więc wyniki wyglądać następująco:

Array 
     (
      [0] => Array 
       (
        [configuration_id] => 8 
        [id] => 1 
        [optionNumber] => 1 
        [optionActive] => 1 
        [lastUpdated] => 2010-03-17 15:44:12 
       ) 

      [1] => Array 
       (
        [configuration_id] => 9 
        [id] => 1 
        [optionNumber] => 2 
        [optionActive] => 1 
        [lastUpdated] => 2010-03-17 15:44:12 
       ) 

      [2] => Array 
       (
        [configuration_id] => 10 
        [id] => 1 
        [optionNumber] => 3 
        [optionActive] => 1 
        [lastUpdated] => 2010-03-17 15:44:12 
       ) 
    ) 

Answer 1

Zastosowanie usort.

function cmp_by_optionNumber($a, $b) { 
    return $a["optionNumber"] - $b["optionNumber"]; 
} 

... 

usort($array, "cmp_by_optionNumber"); 

---

W PHP ≥5.3, należy użyć anonymous function zamiast:

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

Należy zauważyć, że zarówno kod powyżej zakładają $a['optionNumber'] jest liczbą całkowitą. Użyj @St. John Johnson's solution, jeśli są to ciągi.

---

W PHP ≥7.0 użyj spaceship operator <=> Zamiast odejmowania uniknąć problemów przelewowy/przycinania.

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

Answer 2

Zastosowanie usort

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

Answer 3

Klucze są usuwane po użyciu funkcji, takich jak te powyżej. Jeśli klucze są ważne, poniższa funkcja zachowałaby je ... ale pętle foreach są dość nieefektywne.

function subval_sort($a,$subkey) { 
    foreach($a as $k=>$v) { 
     $b[$k] = strtolower($v[$subkey]); 
    } 
    asort($b); 
    foreach($b as $key=>$val) { 
     $c[$key] = $a[$key]; 
    } 
    return $c; 
} 
$array = subval_sort($array,'optionNumber'); 

Użyj arsort zamiast asort, jeśli chcesz od wysokiego do niskiego.

kredytowej

Kod: http://www.firsttube.com/read/sorting-a-multi-dimensional-array-with-php/

Answer 4

PHP 5.3+

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

Answer 5

Kiedyś oba rozwiązania przez KennyTM i AJ Quick i wpadł funkcji, które mogą pomóc w tej kwestii dla wielu przypadkach jak używając ASC lub DESC sortowanie lub zachowywanie kluczy lub jeśli masz obiekty jako dzieci z tablicy.

Oto ta funkcja:

/** 
* @param array $array 
* @param string $value 
* @param bool $asc - ASC (true) or DESC (false) sorting 
* @param bool $preserveKeys 
* @return array 
* */ 
function sortBySubValue($array, $value, $asc = true, $preserveKeys = false) 
{ 
    if ($preserveKeys) { 
     $c = array(); 
     if (is_object(reset($array))) { 
      foreach ($array as $k => $v) { 
       $b[$k] = strtolower($v->$value); 
      } 
     } else { 
      foreach ($array as $k => $v) { 
       $b[$k] = strtolower($v[$value]); 
      } 
     } 
     $asc ? asort($b) : arsort($b); 
     foreach ($b as $k => $v) { 
      $c[$k] = $array[$k]; 
     } 
     $array = $c; 
    } else { 
     if (is_object(reset($array))) { 
      usort($array, function ($a, $b) use ($value, $asc) { 
       return $a->{$value} == $b->{$value} ? 0 : ($a->{$value} - $b->{$value}) * ($asc ? 1 : -1); 
      }); 
     } else { 
      usort($array, function ($a, $b) use ($value, $asc) { 
       return $a[$value] == $b[$value] ? 0 : ($a[$value] - $b[$value]) * ($asc ? 1 : -1); 
      }); 
     } 
    } 

    return $array; 
} 

Zastosowanie:

sortBySubValue($array, 'optionNumber', true, false); 

---

Edit

Pierwsza część może być zapisane w uasort() i functi na będzie krótszy:

/** 
* @param array $array 
* @param string $value 
* @param bool $asc - ASC (true) or DESC (false) sorting 
* @param bool $preserveKeys 
* @return array 
* */ 
function sortBySubValue($array, $value, $asc = true, $preserveKeys = false) 
{ 
    if (is_object(reset($array))) { 
     $preserveKeys ? uasort($array, function ($a, $b) use ($value, $asc) { 
      return $a->{$value} == $b->{$value} ? 0 : ($a->{$value} - $b->{$value}) * ($asc ? 1 : -1); 
     }) : usort($array, function ($a, $b) use ($value, $asc) { 
      return $a->{$value} == $b->{$value} ? 0 : ($a->{$value} - $b->{$value}) * ($asc ? 1 : -1); 
     }); 
    } else { 
     $preserveKeys ? uasort($array, function ($a, $b) use ($value, $asc) { 
      return $a[$value] == $b[$value] ? 0 : ($a[$value] - $b[$value]) * ($asc ? 1 : -1); 
     }) : usort($array, function ($a, $b) use ($value, $asc) { 
      return $a[$value] == $b[$value] ? 0 : ($a[$value] - $b[$value]) * ($asc ? 1 : -1); 
     }); 
    } 
    return $array; 
}