ksort

    (PHP 4, PHP 5, PHP 7, PHP 8)

    ksort — Ordena um array pelas chaves em ordem crescente

    Descrição

    ksort(array &$array, int $flags = SORT_REGULAR): true

    Ordena o array pelas chaves em ordem crescente.

    Nota:

    Se dois elementos são comparados como iguais, eles mantêm sua ordem original. Antes do PHP 8.0.0, sua ordem relativa no array ordenado era indefinida.

    Nota:

    Redefine o ponteiro interno do array para o primeiro elemento.

    Parâmetros

    array

    O array de entrada.

    flags

    O segundo parâmetro opcional flags pode ser usado para modificar o comportamento da ordenação usando estes valores:

    Flags dos tipos de ordenação:

    Valor Retornado

    Sempre retorna true.

    Registro de Alterações

    Versão Descrição
    8.2.0 O tipo do retorno agora é true; anteriormente, era bool.
    8.2.0 Esta função agora faz comparação numérica de string com a constante SORT_REGULAR usando as regras padrão do PHP 8.

    Exemplos

    Exemplo #1 Exemplo da ksort()

    <?php
    $frutas     = array("d"=>"limão", "a"=>"laranja", "b" =>"banana", "c"=>"maçã");
    ksort($frutas);
    foreach (    $frutas as $chave => $valor) {
    echo     "$chave = $valor\n";
    }
    ?>

    O exemplo acima produzirá:

    a = laranja
b = banana
c = maçã
d = limão

    Exemplo #2 ksort() com chaves int

    <?php
    $a     = [0 => 'Primeiro', 2 => 'Último', 1 => 'Intermediário'];
    var_dump($a);
    ksort($a);
    var_dump($a);
    ?>

    O exemplo acima produzirá:

    array(3) {
  [0]=>
  string(5) "Primeiro"
  [2]=>
  string(4) "Último"
  [1]=>
  string(6) "Intermediário"
}
array(3) {
  [0]=>
  string(5) "Primeiro"
  [1]=>
  string(6) "Intermediário"
  [2]=>
  string(4) "Último"
}

    Veja Também

    Melhore Esta Página

    Aprenda Como Melhorar Esta Página • Envie uma Solicitação de Modificação • Reporte um Problema
    ＋adicione uma nota

    Notas Enviadas por Usuários (em inglês) 16 notes

    up
    8
    orlov0562 at gmail dot com
    7 years ago
    The first thing that I didn't find in description it's that this function return results from MIN value to MAX value, ex: [-5=>'', 0=>'', 5=>'' ]

    Also you should know that by default, it has correct sorting for keys that represented as string but has a number as value, ex: ['-5'=>'', '0'=>'', '5'=>'' ]

    Few examples with results:

    -----------------------------------------

    DESCRIPTION: Keys are numbers + default flag (SORT_REGULAR)

    $arr = [
    -5 => 'minus five',
    0 => 'zero',
    1 => 'one',
    2 => 'two',
    100 => 'hundred',
    ];

    ksort($arr);
    print_r($arr);

    RESULT:

    Array
    (
    [-5] => minus five
    [0] => zero
    [1] => one
    [2] => two
    [100] => hundred
    )

    -----------------------------------------
    DESCRIPTION: Keys are string numbers + default flag (SORT_REGULAR)

    $arr = [
    '-5' => 'minus five',
    '0' => 'zero',
    '1' => 'one',
    '2' => 'two',
    '100' => 'hundred',
    ];

    ksort($arr);
    print_r($arr);

    RESULT:

    Array
    (
    [-5] => minus five
    [0] => zero
    [1] => one
    [2] => two
    [100] => hundred
    )

    -----------------------------------------
    DESCRIPTION: Keys are string numbers + SORT_STRING flag

    $arr = [
    '-5' => 'minus five',
    '0' => 'zero',
    '1' => 'one',
    '2' => 'two',
    '100' => 'hundred',
    ];

    ksort($arr, SORT_STRING);
    print_r($arr);

    RESULT:

    Array
    (
    [-5] => minus five
    [0] => zero
    [1] => one
    [100] => hundred
    [2] => two
    )

    -----------------------------------------

    DESCRIPTION: Keys are string numbers + SORT_NUMERIC flag

    $arr = [
    '-5' => 'minus five',
    '0' => 'zero',
    '1' => 'one',
    '2' => 'two',
    '100' => 'hundred',
    ];

    ksort($arr, SORT_NUMERIC);
    print_r($arr);

    RESULT:

    Array
    (
    [-5] => minus five
    [0] => zero
    [1] => one
    [2] => two
    [100] => hundred
    )
    up
    50
    DavidG
    14 years ago
    A nice way to do sorting of a key on a multi-dimensional array without having to know what keys you have in the array first:

    <?php
    $people     = array(
    array(    "name"=>"Bob","age"=>8,"colour"=>"red"),
    array(    "name"=>"Greg","age"=>12,"colour"=>"blue"),
    array(    "name"=>"Andy","age"=>5,"colour"=>"purple"));

    var_dump($people);

    $sortArray = array();

    foreach(    $people as $person){
    foreach(    $person as $key=>$value){
    if(!isset(    $sortArray[$key])){
    $sortArray[$key] = array();
    }
    $sortArray[$key][] = $value;
    }
    }

    $orderby = "name"; //change this to whatever key you want from the array

    array_multisort($sortArray[$orderby],SORT_DESC,$people);

    var_dump($people);
    ?>

    Output from first var_dump:

    [0]=&gt;
    array(3) {
    ["name"]=&gt;
    string(3) "Bob"
    ["age"]=&gt;
    int(8)
    ["colour"]=&gt;
    string(3) "red"
    }
    [1]=&gt;
    array(3) {
    ["name"]=&gt;

    string(4) "Greg"
    ["age"]=&gt;
    int(12)
    ["colour"]=&gt;
    string(4) "blue"
    }
    [2]=&gt;
    array(3) {
    ["name"]=&gt;
    string(4) "Andy"
    ["age"]=&gt;
    int(5)
    ["colour"]=&gt;

    string(6) "purple"
    }
    }

    Output from 2nd var_dump:

    array(3) {
    [0]=&gt;
    array(3) {
    ["name"]=&gt;
    string(4) "Greg"
    ["age"]=&gt;
    int(12)
    ["colour"]=&gt;
    string(4) "blue"
    }
    [1]=&gt;
    array(3) {
    ["name"]=&gt;

    string(3) "Bob"
    ["age"]=&gt;
    int(8)
    ["colour"]=&gt;
    string(3) "red"
    }
    [2]=&gt;
    array(3) {
    ["name"]=&gt;
    string(4) "Andy"
    ["age"]=&gt;
    int(5)
    ["colour"]=&gt;

    string(6) "purple"
    }

    There's no checking on whether your array keys exist, or the array data you are searching on is actually there, but easy enough to add.
    up
    14
    thegrandoverseer
    12 years ago
    I wrote this function to sort the keys of an array using an array of keynames, in order.
    <?php
    /**
    * function array_reorder_keys
    * reorder the keys of an array in order of specified keynames; all other nodes not in $keynames will come after last $keyname, in normal array order
    * @param array &$array - the array to reorder
    * @param mixed $keynames - a csv or array of keynames, in the order that keys should be reordered
    */
    function array_reorder_keys(&$array, $keynames){
    if(empty(    $array) || !is_array($array) || empty($keynames)) return;
    if(!    is_array($keynames)) $keynames = explode(',',$keynames);
    if(!empty(    $keynames)) $keynames = array_reverse($keynames);
    foreach(    $keynames as $n){
    if(    array_key_exists($n, $array)){
    $newarray = array($n=>$array[$n]); //copy the node before unsetting
    unset($array[$n]); //remove the node
    $array = $newarray + array_filter($array); //combine copy with filtered array
    }
    }
    }
    $seed_array = array('foo'=>'bar', 'someotherkey'=>'whatev', 'bar'=>'baz', 'baz'=>'foo', 'anotherkey'=>'anotherval');
    array_reorder_keys($seed_array, 'baz,foo,bar'); //returns array('baz'=>'foo', 'foo'=>'bar', 'bar'=>'baz', 'someotherkey'=>'whatev', 'anotherkey'=>'anotherval' );
    ?>
    up
    12
    Anonymous
    22 years ago
    here 2 functions to ksort/uksort an array and all its member arrays

    function tksort(&$array)
    {
    ksort($array);
    foreach(array_keys($array) as $k)
    {
    if(gettype($array[$k])=="array")
    {
    tksort($array[$k]);
    }
    }
    }

    function utksort(&$array, $function)
    {
    uksort($array, $function);
    foreach(array_keys($array) as $k)
    {
    if(gettype($array[$k])=="array")
    {
    utksort($array[$k], $function);
    }
    }
    }
    up
    7
    ssb45 at cornell dot edu
    19 years ago
    The function that justin at booleangate dot org provides works well, but be aware that it is not a drop-in replacement for ksort as is. While ksort sorts the array by reference and returns a status boolean, natksort returns the sorted array, leaving the original untouched. Thus, you must use this syntax:

    $array = natksort($array);

    If you want to use the more natural syntax:

    $status = natksort($array);

    Then use this modified version:

    function natksort(&$array) {
    $keys = array_keys($array);
    natcasesort($keys);

    foreach ($keys as $k) {
    $new_array[$k] = $array[$k];
    }

    $array = $new_array;
    return true;
    }
    up
    2
    bimal at sanjaal dot com
    10 years ago
    An example of reverse sorting a domain name by its name.

    <?php
    $domains     = array(
    'sub.domain.com',
    'sub2.domain.com',
    );

    foreach(    $domains as $d => $domain)
    {
    $chunks = explode('.', $domain);
    krsort($chunks);

    echo     "\r\n<br>", implode('/', $chunks);
    }

    /**
    * Outputs as:
    *
    * com/domain/sub
    * com/domain/sub2
    */
    ?>
    up
    5
    sbarnum at mac dot com
    23 years ago
    ksort on an array with negative integers as keys yields some odd results. Not sure if this is a bad idea (negative key values) or what.
    up
    9
    delvach at mail dot com
    23 years ago
    A real quick way to do a case-insensitive sort of an array keyed by strings:

    uksort($myArray, "strnatcasecmp");
    up
    10
    serpro at gmail dot com
    15 years ago
    Here is a function to sort an array by the key of his sub-array.

    <?php

    function sksort(&$array, $subkey="id", $sort_ascending=false) {

    if (    count($array))
    $temp_array[key($array)] = array_shift($array);

    foreach(    $array as $key => $val){
    $offset = 0;
    $found = false;
    foreach(    $temp_array as $tmp_key => $tmp_val)
    {
    if(!    $found and strtolower($val[$subkey]) > strtolower($tmp_val[$subkey]))
    {
    $temp_array = array_merge( (array)array_slice($temp_array,0,$offset),
    array(    $key => $val),
    array_slice($temp_array,$offset)
    );
    $found = true;
    }
    $offset++;
    }
    if(!    $found) $temp_array = array_merge($temp_array, array($key => $val));
    }

    if (    $sort_ascending) $array = array_reverse($temp_array);

    else     $array = $temp_array;
    }

    ?>

    Example
    <?php
    $info     = array("peter" => array("age" => 21,
    "gender" => "male"
    ),
    "john" => array("age" => 19,
    "gender" => "male"
    ),
    "mary" => array("age" => 20,
    "gender" => "female"
    )
    );

    sksort($info, "age");
    var_dump($info);

    sksort($info, "age", true);
    var_dump($ifno);
    ?>

    This will be the output of the example:

    /*DESCENDING SORT*/
    array(3) {
    ["peter"]=>
    array(2) {
    ["age"]=>
    int(21)
    ["gender"]=>
    string(4) "male"
    }
    ["mary"]=>
    array(2) {
    ["age"]=>
    int(20)
    ["gender"]=>
    string(6) "female"
    }
    ["john"]=>
    array(2) {
    ["age"]=>
    int(19)
    ["gender"]=>
    string(4) "male"
    }
    }

    /*ASCENDING SORT*/
    array(3) {
    ["john"]=>
    array(2) {
    ["age"]=>
    int(19)
    ["gender"]=>
    string(4) "male"
    }
    ["mary"]=>
    array(2) {
    ["age"]=>
    int(20)
    ["gender"]=>
    string(6) "female"
    }
    ["peter"]=>
    array(2) {
    ["age"]=>
    int(21)
    ["gender"]=>
    string(4) "male"
    }
    }
    up
    5
    Anonymous
    11 years ago
    Note that this function will output the given $fields in the order they were added to the data array and not automatically in numerical key order.

    To output in ascending key order, you'll need to ksort the array first (or use appropriate natural order sorting, depending on your keys).

    For example:
    <?php
    $data    [2] = 'C';
    $data[0] = 'A';
    $data[1] = 'B';

    fputcsv($fh, $data); // outputs: "C,A,B"

    ksort($data);
    fputcsv($fh, $data); // outputs: "A,B,C"
    ?>
    up
    2
    Anonymous
    10 years ago
    @thegrandoverseer

    you could also use the build-in php array functions to get exactly what you want to have:

    <?php
    $seed_array     = array('foo'=>'bar', 'someotherkey'=>'whatev', 'bar'=>'baz', 'baz'=>'foo', 'anotherkey'=>'anotherval');
    $keys_array = array('baz', 'foo', 'bar');

    $return_array = array_intersect_key($seed_array, array_flip($keys_array)) + array_diff_key($seed_array, array_flip($keys_array));

    ?>
    up
    2
    justin at booleangate dot org
    19 years ago
    Here's a handy function for natural order sorting on keys.

    function natksort($array) {
    // Like ksort but uses natural sort instead
    $keys = array_keys($array);
    natsort($keys);

    foreach ($keys as $k)
    $new_array[$k] = $array[$k];

    return $new_array;
    }
    up
    -2
    jakub dot lopuszanski at nasza-klasa dot pl
    13 years ago
    Note that ksort will NOT help you much if numeric and string keys are mixed together.
    <?php
    $t     = array(
    "a"=>"A",
    0=>"A",
    "b"=>"A",
    1=>"A"
    );
    var_dump($t);
    ksort($t);
    var_dump($t);
    ?>

    produces (on PHP 5.3.6-4 with Suhosin-Patch) :

    array(4) {
    ["a"]=>
    string(1) "A"
    [0]=>
    string(1) "A"
    ["b"]=>
    string(1) "A"
    [1]=>
    string(1) "A"
    }

    array(4) {
    ["b"]=>
    string(1) "A"
    [0]=>
    string(1) "A"
    ["a"]=>
    string(1) "A"
    [1]=>
    string(1) "A"
    }

    note that the second array should be sorted by keys, but is even more messed up than the first one!
    up
    -1
    stephen [ at ] brooksie-net [ dot ] co [ dot ] uk
    11 years ago
    ksort and krsort fail to undestand scientific notation, https://bugs.php.net/bug.php?id=43053, therefore when sorting numeric keys, if the key is of the form 0.00001 php will represent it as 1.0E-5.

    These methods will assume this to be a string and therefore not organise your array as you may expect.

    When using value of this form for array keys use sprintf('%f', 0.00001) to generate the key, for smaller values the precision needs to be included
    e.g. sprintf('%0.10f', 0.00000001)
    up
    -3
    maik dot riechert at animey dot net
    16 years ago
    Be careful when using ksort for mixed type keys!!

    $a = array(
    'first' => true,
    0 => 'sally',
    );

    $b = array(
    0 => 'sally',
    'first' => true,
    );

    ksort($a);
    ksort($b);
    var_dump($a);
    var_dump($b);

    Output is:
    array(
    0 => 'sally',
    'first' => true,
    )

    array(
    'first' => true,
    0 => 'sally',
    )

    If you want same results for both arrays, use:

    ksort($a, SORT_STRING);

    The reason for that lays in the compare mechanism which would normally just typecast 'first' to an integer or 0 to a string when comparing it to each other. So you have to use SORT_STRING, otherwise you would lose information when 'first' is converted to int.
    up
    -5
    centraleffects at yahoo dot com
    11 years ago
    I wrote this function to sort meta_value in wordpress. I tried a lot of array sorting but neither of them work. But this is not suitable for multidimensional array. This is intended only for wordpress meta_value

    The problem is to sort below( the order should be ascending; alphabetically then numerically like A-Z then 0-9):
    500-999 users
    25-49 users
    All Sizes
    1-4 users
    5-9 users
    10-24 users
    250-499 users
    1000-4999
    5000-9999

    The solution:

    function array_sort($arr){
    if(is_array($arr)){
    $numeric = array();
    $string = array();
    foreach($arr as $k => $v)
    {
    if(isset($v["meta_value"])){
    $str = explode(" ",trim($v["meta_value"]));
    $firstWord = explode("-",trim($str[0]));
    }else{
    $str = $v;
    $firstWord = explode("-",trim($str));
    }

    $firstWord = $firstWord[0];

    if(is_numeric($firstWord))
    {
    $numeric[(int)$firstWord] = $v;
    }else{
    $string[$firstWord] = $v;
    }
    unset($firstWord);
    }
    ksort($string,SORT_STRING);
    ksort($numeric,SORT_NUMERIC);

    return array_merge((array)$string, (array)$numeric);
    }


    return false;
    }

    The usage:
    $meta =get_post_meta($post_id,$meta_key);
    $sorted = array_sort($meta);

    The result:
    All Sizes
    1-4 users
    5-9 users
    10-24 users
    25-49 users
    250-499 users
    500-999 users
    1000-4999
    5000-9999
    ＋adicione uma nota
    To Top