multidimensional - ¿Cómo puedo ordenar matrices y datos en PHP?
sort array php (9)
Esta pregunta está pensada como referencia para preguntas sobre la clasificación de matrices en PHP. Es fácil pensar que su caso particular es único y que merece una nueva pregunta, pero la mayoría son variaciones menores de una de las soluciones en esta página.
Si su pregunta está cerrada como duplicado de esta, solicite que se vuelva a abrir solo si puede explicar por qué difiere notablemente de todo lo que se indica a continuación.
¿Cómo ordeno una matriz en PHP?
¿Cómo ordeno una matriz compleja en PHP?
¿Cómo ordeno una matriz de objetos en PHP?
Arrays básicos unidimensionales; Incl. Arreglos multidimensionales, incl. matrices de objetos; Incl. Ordenar una matriz basada en otra
Clasificando con SPL
Tipo estable
Para obtener una respuesta práctica utilizando las funciones existentes de PHP, vea 1., para obtener una respuesta académica detallada sobre algoritmos de clasificación (las funciones de PHP se implementan y las que puede necesitar para casos realmente complejos), vea 2.
Arrays básicos unidimensionales
$array = array(3, 5, 2, 8);
Funciones de clasificación aplicables:
-
sort -
rsort -
asort -
arsort -
natsort -
natcasesort -
ksort -
krsort
La diferencia entre estos es simplemente si se mantienen las asociaciones clave-valor (las funciones " a "), si clasifica de bajo a alto o inverso (" r "), si ordena valores o claves (" k ") y cómo compara valores (" nat " vs. normal). Consulte http://php.net/manual/en/array.sorting.php para obtener una descripción general y enlaces a más detalles.
Arreglos multidimensionales, incluyendo arreglos de objetos
$array = array(
array(''foo'' => ''bar'', ''baz'' => 42),
array(''foo'' => ..., ''baz'' => ...),
...
);
Si desea ordenar $array por la clave ''foo'' de cada entrada, necesita una función de comparación personalizada . El orden anterior y las funciones relacionadas funcionan con valores simples que saben comparar y ordenar. PHP no simplemente "sabe" qué hacer con un valor complejo como array(''foo'' => ''bar'', ''baz'' => 42) ; así que tienes que decirlo.
Para hacer eso, necesitas crear una función de comparación . Esa función toma dos elementos y debe devolver 0 si estos elementos se consideran iguales, un valor inferior a 0 si el primer valor es menor y un valor superior a 0 si el primer valor es mayor. Eso es todo lo que se necesita:
function cmp(array $a, array $b) {
if ($a[''foo''] < $b[''foo'']) {
return -1;
} else if ($a[''foo''] > $b[''foo'']) {
return 1;
} else {
return 0;
}
}
A menudo, deseará usar una función anónima como la devolución de llamada. Si desea utilizar un método o un método estático, consulte las otras formas de especificar una devolución de llamada en PHP .
A continuación, utiliza una de estas funciones:
Nuevamente, solo difieren en si mantienen las asociaciones clave-valor y las ordenan por valores o claves. Lea su documentación para más detalles.
Ejemplo de uso:
usort($array, ''cmp'');
usort tomará dos elementos de la matriz y llamará a su función cmp con ellos. Entonces se llamará a cmp() con $a como array(''foo'' => ''bar'', ''baz'' => 42) y $b como otra array(''foo'' => ..., ''baz'' => ...) . Luego, la función regresa a usort cuál de los valores era mayor o si eran iguales. usort repite este proceso pasando diferentes valores para $b hasta que se ordena la matriz. La función cmp se llamará muchas veces, al menos tantas como valores en $array , con diferentes combinaciones de valores para $b cada vez.
Para acostumbrarte a esta idea, prueba esto:
function cmp($a, $b) {
echo ''cmp called with $a:'', PHP_EOL;
var_dump($a);
echo ''and $b:'', PHP_EOL;
var_dump($b);
}
Todo lo que hizo fue definir una forma personalizada de comparar dos elementos, eso es todo lo que necesita. Eso funciona con todo tipo de valores.
Por cierto, esto funciona en cualquier valor, los valores no tienen que ser matrices complejas. Si tiene una comparación personalizada que desea hacer, también puede hacerlo en una simple serie de números.
sort ordena por referencia y no devuelve nada útil!
Tenga en cuenta que la matriz se ordena en su lugar , no es necesario asignar el valor de retorno a nada. $array = sort($array) reemplazará la matriz con true , no con una matriz ordenada. Solo sort($array); trabajos.
Comparaciones numéricas personalizadas
Si desea ordenar por la tecla baz , que es numérica, todo lo que necesita hacer es:
function cmp(array $a, array $b) {
return $a[''baz''] - $b[''baz''];
}
Gracias a The PoWEr oF MATH, esto devuelve un valor <0, 0 o> 0 dependiendo de si $a es menor, igual o mayor que $b .
Tenga en cuenta que esto no funcionará bien para los valores float , ya que se reducirán a int y perderán precisión. Utilice explícito -1 , 0 y 1 devuelve valores en su lugar
Objetos
Si tienes una matriz de objetos, funciona de la misma manera:
function cmp($a, $b) {
return $a->baz - $b->baz;
}
Funciones
Puede hacer lo que necesite dentro de una función de comparación, incluidas las funciones de llamada:
function cmp(array $a, array $b) {
return someFunction($a[''baz'']) - someFunction($b[''baz'']);
}
Instrumentos de cuerda
Un atajo para la primera versión de comparación de cadena:
function cmp(array $a, array $b) {
return strcmp($a[''foo''], $b[''foo'']);
}
strcmp hace exactamente lo que se espera de cmp aquí, devuelve -1 , 0 o 1 .
Operador de nave espacial
PHP 7 introdujo el operador de la nave espacial , que unifica y simplifica iguales / más pequeños / más grandes que las comparaciones entre tipos:
function cmp(array $a, array $b) {
return $a[''foo''] <=> $b[''foo''];
}
Clasificación por campos múltiples
Si desea ordenar principalmente por foo , pero si foo es igual para dos elementos, ordene por baz :
function cmp(array $a, array $b) {
if (($cmp = strcmp($a[''foo''], $b[''foo''])) !== 0) {
return $cmp;
} else {
return $a[''baz''] - $b[''baz''];
}
}
Para aquellos que están familiarizados, esto es equivalente a una consulta SQL con ORDER BY foo, baz .
También vea esta versión abreviada muy clara y cómo crear tal función de comparación de forma dinámica para un número arbitrario de claves .
Clasificación en orden manual, estático
Si desea ordenar los elementos en un "orden manual" como "foo", "barra", "baz" :
function cmp(array $a, array $b) {
static $order = array(''foo'', ''bar'', ''baz'');
return array_search($a[''foo''], $order) - array_search($b[''foo''], $order);
}
Por todo lo anterior, si estás usando PHP 5.3 o superior (y deberías hacerlo), usa funciones anónimas para un código más corto y para evitar tener otra función global flotando alrededor:
usort($array, function (array $a, array $b) { return $a[''baz''] - $b[''baz'']; });
Así de simple puede ser clasificar una matriz multidimensional compleja. Nuevamente, solo piense en términos de enseñar a PHP cómo saber cuál de los dos elementos es "mayor" ; dejar que PHP haga la clasificación real.
También para todo lo anterior, para cambiar entre orden ascendente y descendente, simplemente intercambie los argumentos $b . P.ej:
return $a[''baz''] - $b[''baz'']; // ascending
return $b[''baz''] - $a[''baz'']; // descending
Ordenar una matriz basada en otra
Y luego está el peculiar array_multisort , que te permite ordenar un array en función de otro:
$array1 = array( 4, 6, 1);
$array2 = array(''a'', ''b'', ''c'');
El resultado esperado aquí sería:
$array2 = array(''c'', ''a'', ''b''); // the sorted order of $array1
Utilice array_multisort para llegar allí:
array_multisort($array1, $array2);
A partir de PHP 5.5.0 puede usar array_column para extraer una columna de una matriz multidimensional y ordenar la matriz en esa columna:
array_multisort(array_column($array, ''foo''), SORT_DESC, $array);
A partir de PHP 7.0.0 también puede extraer propiedades de una matriz de objetos.
Si tiene casos más comunes, no dude en editar esta respuesta.
LINQ
En .NET, LINQ se usa con frecuencia para ordenar, lo que proporciona una sintaxis mucho más agradable sobre las funciones de comparación, especialmente cuando los objetos deben ser ordenados por múltiples campos. Hay varios puertos de LINQ a PHP, incluida la biblioteca de YaLinqo *. Con él, los arreglos pueden ordenarse con una sola línea sin escribir complejas funciones de comparación.
$sortedByName = from($objects)->orderBy(''$v->name'');
$sortedByCount = from($objects)->orderBy(''$v->count'');
$sortedByCountAndName = from($objects)->orderBy(''$v->count'')->thenBy(''$v->name'');
Las comparaciones se pueden personalizar aún más pasando una devolución de llamada como segundo argumento, por ejemplo:
$sortedByFilenameNat = from($objects)->orderBy(''$v->filename'', ''strnatcmp'');
Aquí, ''$v->count'' es una abreviatura de la function ($v) { return $v->count; } function ($v) { return $v->count; } (cualquiera puede ser usado). Estas cadenas de métodos devuelven iteradores, los iteradores se pueden transformar en arreglos agregando ->toArray() al final si es necesario.
Internamente, orderBy y los métodos relacionados llaman a las funciones de ordenamiento de matriz apropiadas ( uasort , krsort , uasort , krsort , etc.).
LINQ contiene muchos más métodos inspirados en SQL: filtrado, agrupación, unión, agregación, etc. Es mejor para casos en los que se deben realizar transformaciones complejas en matrices y objetos sin depender de bases de datos.
* desarrollado por mí, vea el archivo Léame para obtener más detalles y comparación con otros puertos LINQ
Tipo estable
Digamos que tienes una matriz como esta:
[''Kale'', ''Kaleidoscope'', ''Aardvark'', ''Apple'', ''Leicester'', ''Lovely'']
Y ahora quiere ordenar solo en la primera letra:
usort($array, function($a, $b) {
return strcmp($a[0], $b[0]);
});
El resultado es este:
[''Apple'', ''Aardvark'', ''Kale'', ''Kaleidoscope'', ''Lovely'', ''Leicester'']
¡El género no era estable!
El agudo observador puede haber notado que el algoritmo de ordenamiento de matrices (QuickSort) no produjo un resultado estable y que no se conservó el orden original entre las palabras de la misma primera letra. Este caso es trivial y deberíamos haber comparado toda la cadena, pero supongamos que su caso de uso es más complicado, como dos clasificaciones consecutivas en diferentes campos que no deberían cancelar el trabajo del otro.
La transformada de Schwartzian
La transformada de Schwartz , también conocida como el lenguaje decorate-sort-undecorate, efectúa una clasificación estable con un algoritmo de clasificación inherentemente inestable.
Primero, decorar cada elemento de la matriz con otra matriz que comprende una clave primaria (el valor) y una clave secundaria (su índice o posición):
array_walk($array, function(&$element, $index) {
$element = array($element, $index); // decorate
});
Esto transforma la matriz en esto:
[
[''Kale'', 0], [''Kaleidoscope'', 1],
[''Aardvark'', 2], [''Apple'', 3],
[''Leicester'', 4], [''Lovely'', 5]
]
Ahora, ajustamos el paso de comparación; Comparamos la primera letra de nuevo, pero si son iguales, la clave secundaria se usa para conservar el orden original:
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
});
Después, decapamos:
array_walk($array, function(&$element) {
$element = $element[0];
});
El resultado final:
[''Aardvark'', ''Apple'', ''Kale'', ''Kaleidoscope'', ''Leicester'', ''Lovely'']
¿Qué pasa con la reutilización?
Tuvo que volver a escribir su función de comparación para trabajar con los elementos de matriz transformados; es posible que no desee editar sus delicadas funciones de comparación, así que aquí hay un contenedor para la función de comparación:
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];
}
};
}
Vamos a escribir el paso de clasificación utilizando esta función:
usort($array, stablecmp(function($a, $b) {
return strcmp($a[0], $b[0]);
}));
Voila! Su código de comparación prístino está de vuelta.
A partir de PHP 5.3 con cierres, también es posible utilizar un cierre para determinar el orden de su clasificación.
Por ejemplo, suponiendo que $ array es una matriz de objetos que contienen una propiedad del mes.
$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);
});
Bueno, la mayoría de los métodos básicos ya están cubiertos por el share . Intentaría ver otros tipos de clases.
Clasificando con 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));
Salida
c
b
a
SplMaxHeap
La clase SplMaxHeap proporciona las principales funcionalidades de un montón, manteniendo el máximo en la parte superior.
$heap = new SplMaxHeap();
$heap->insert(1);
$heap->insert(2);
$heap->insert(3);
SplMaxHeap
La clase SplMinHeap proporciona las principales funcionalidades de un montón, manteniendo el mínimo en la parte superior.
$heap = new SplMinHeap ();
$heap->insert(3);
$heap->insert(1);
$heap->insert(2);
Otros tipos de clasificación
Ordenamiento de burbuja
Del artículo de Wikipedia sobre Bubble Sort:
La clasificación de burbujas, a veces denominada incorrectamente clasificación de hundimiento, es un algoritmo de clasificación simple que funciona repasando repetidamente la lista para ser ordenada, comparando cada par de elementos adyacentes e intercambiándolos si están en el orden incorrecto. El paso por la lista se repite hasta que no se necesitan swaps, lo que indica que la lista está ordenada. El algoritmo obtiene su nombre de la forma en que los elementos más pequeños "burbujean" al principio de la lista. Debido a que solo usa comparaciones para operar con elementos, es una ordenación de comparación. Aunque el algoritmo es simple, la mayoría de los otros algoritmos de clasificación son más eficientes para listas grandes.
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;
}
Selección de selección
Del artículo de Wikipedia sobre selección de selección:
En ciencias de la computación, la clasificación por selección es un algoritmo de clasificación, específicamente una clasificación de comparación in situ. Tiene una complejidad de tiempo O (n2), lo que la hace ineficiente en listas grandes y, en general, tiene un desempeño peor que el de la inserción similar. El orden de selección se caracteriza por su simplicidad y tiene ventajas de rendimiento sobre algoritmos más complicados en ciertas situaciones, particularmente cuando la memoria auxiliar es limitada.
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;
}
Tipo de inserción
Del artículo de Wikipedia sobre el orden de inserción:
La ordenación por inserción es un algoritmo de clasificación simple que construye la matriz final ordenada (o lista) un elemento a la vez. Es mucho menos eficiente en listas grandes que los algoritmos más avanzados como quicksort, heapsort o merge sort. Sin embargo, la ordenación por inserción ofrece varias ventajas:
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
Del artículo de Wikipedia sobre Shellsort:
Shellsort, también conocido como clasificación de Shell o método de Shell, es una clasificación de comparación in situ. Generaliza un tipo de intercambio, como la inserción o el tipo de burbuja, al iniciar la comparación y el intercambio de elementos con elementos que están muy separados antes de terminar con elementos vecinos.
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;
}
Peine tipo
Del artículo de Wikipedia sobre el peine del peine
La clasificación de peines es un algoritmo de clasificación relativamente simple diseñado originalmente por Wlodzimierz Dobosiewicz en 1980. Más tarde, fue redescubierto por Stephen Lacey y Richard Box en 1991. La clasificación de peines mejora la clasificación de burbujas.
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;
}
Fusionar orden
Del artículo de Wikipedia sobre la clasificación Merge:
En ciencias de la computación, una ordenación de combinación (también comúnmente combinada ortográficamente) es un algoritmo de clasificación basado en comparación O (n log n). La mayoría de las implementaciones producen una clasificación estable, lo que significa que la implementación conserva el orden de entrada de elementos iguales en la salida ordenada
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;
}
Ordenación rápida
Del artículo de Wikipedia en Quicksort:
Quicksort, o partición de intercambio de particiones, es un algoritmo de clasificación desarrollado por Tony Hoare que, en promedio, hace comparaciones de O (n log n) para ordenar n elementos. En el peor de los casos, hace comparaciones de O (n2), aunque este comportamiento es raro.
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));
}
Orden de permutación
Del artículo de Wikipedia sobre la ordenación de permutación:
Ordenación de permutación, que continúa generando las permutaciones posibles de la matriz / lista de entrada hasta que descubre la ordenada.
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;
}
Tipo radix
Del artículo de Wikipedia sobre Radix sort:
En ciencias de la computación, la clasificación de radix es un algoritmo de ordenación de enteros no comparativo que ordena los datos con claves de enteros agrupando las claves por los dígitos individuales que comparten la misma posición y valor significativos.
// 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;
}
Es muy conveniente ordenar los arreglos con la función sorted de Nspl :
Clasificación básica
// Sort array
$sorted = sorted([3, 1, 2]);
// Sort array in descending order
$sortedDesc = sorted([3, 1, 2], true);
Clasificación por resultado de función
// 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
Ordenando matriz multidimensional
// 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
Ordenando matriz de objetos
// 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
Clasificación con una función de comparación
// 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]);
});
Puedes ver todos estos ejemplos here .
Hay varias formas de ordenar una matriz. Mencionaré algunos métodos para realizar esa tarea. En primer lugar, daré una matriz de enteros que se llama "números".
$number = array(8,9,3,4,0,1,2);
Esta es la forma normal de crear una matriz. Supongamos que quiero ordenar esa matriz en orden ascendente. Para eso, se puede usar el método ''sort ()''.
<?php
$number = array(8,9,3,4,0,1,2);
sort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
Ahora considera la salida de eso,
Se puede ver ordenada la matriz de números impresos. Si desea que la matriz numérica se clasifique en orden descendente, se puede usar el método ''rsort ()'' para esa tarea.
<?php
$number = array(8,9,3,4,0,1,2);
rsort($number);
foreach ($number as $value) {
echo $value." ";
}
?>
considerar la salida ..
Ahora la matriz está ordenada en orden descendente. Bien, consideremos una matriz asociativa. Daré una matriz asociativa (Matriz asociativa significa que, Una matriz cuyo índice tiene un valor de clave único) como esto,
$number = array(''eight''=>8,''nine''=>9,''three''=>3,''fore''=>4,''zero''=>0,''one''=>1,''two''=>2);
Por lo tanto, ahora quiero ordenar esta matriz en orden ascendente según su valor. El método "asort ()" se puede usar para eso.
<?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." ";
}
?>
Si se ordena el orden descendente según su valor, se puede usar el método ''arsort ()''. Supongamos que desea ordenar esa matriz según su valor clave. En esto, el método ''ksort ()'' puede ser usado.
<?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." ";
}
?>
Ahora la matriz está ordenada según su valor clave. Si desea ordenar la matriz en orden descendente según su valor clave, se puede usar el método ''krsort ()''.
<?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." ";
}
?>
Ahora la matriz asociativa está ordenada en orden descendente según su valor clave. Mire la salida.
Estos son algunos de los métodos para clasificar una matriz en orden ascendente o descendente en php. Espero que puedas tener una idea. ¡Gracias!
Lo más simple es usar la función usort para ordenar la matriz sin ningún bucle: a continuación se muestra un ejemplo:
$array_compare= array("0" =>4,"1"=>2,"2"=>500,"3"=>100);
Esto ordenará en orden desending:
usort($array_compare, function($a, $b) {
return ($b[''x1''] - $a[''x1'']) > 0 ? 1 :-1;
});
Esto ordenará en orden de envío:
usort($array_compare, function($a, $b) {
return ($b[''x1''] - $a[''x1'']) < 0 ? 1 :-1;
});
Ordenamiento multidimensional por valor clave.
El tipo natural de una matriz multidimensional por un valor de clave y también mantener el orden original (no mezclar las claves principales):
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;
}
Caso de prueba:
$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,
),
)
*/