복붙노트

PHP에서 배열과 데이터를 어떻게 정렬합니까?

PHP

PHP에서 배열과 데이터를 어떻게 정렬합니까?

PHP에서 배열을 어떻게 정렬합니까? PHP에서 복잡한 배열을 어떻게 정렬합니까? PHP에서 객체 배열을 어떻게 정렬합니까?

PHP의 기존 함수를 사용하여 실용적인 답을 얻으려면 1.을 참조하십시오. 정렬 알고리즘 (PHP의 함수가 구현하고 정말로 복잡하고 복잡한 경우에 필요할 수 있음)에 대한 학계의 상세 답변은 2를 참조하십시오.

해결법

  1. ==============================

    1.

    $array = array(3, 5, 2, 8);

    적용 가능한 정렬 기능 :

    키 - 값 연관 ( "a"함수), 낮은 값에서 높은 값 또는 역방향 ( "r") 정렬 여부, 값 또는 키 ( "k") 정렬 여부, 값 ( "nat"대 normal)을 비교합니다. 자세한 내용과 링크를 보려면 http://php.net/manual/en/array.sorting.php를 참조하십시오.

    $array = array(
    array('foo' => 'bar', 'baz' => 42),
    array('foo' => ...,   'baz' => ...),
    ...
);

    $ array를 각 항목의 'foo'키로 정렬하려면 사용자 정의 비교 함수가 필요합니다. 위의 정렬 및 관련 함수는 비교하고 정렬하는 방법을 알고있는 간단한 값에서 작동합니다. PHP는 단순히 array ( 'foo'=> 'bar', 'baz'=> 42)와 같은 복잡한 값으로 무엇을해야하는지 "알지 못합니다. 그래서 당신은 그것을 말할 필요가 있습니다.

    그렇게하려면 비교 함수를 만들어야합니다. 이 함수는 두 개의 요소를 취하고이 요소가 같다고 간주되면 0을 반환해야하며 첫 번째 값이 더 낮 으면 0보다 작은 값을, 첫 번째 값이 더 높으면 0보다 큰 값을 반환해야합니다. 그게 전부입니다.

    function cmp(array $a, array $b) {
    if ($a['foo'] < $b['foo']) {
        return -1;
    } else if ($a['foo'] > $b['foo']) {
        return 1;
    } else {
        return 0;
    }
}

    흔히 익명의 함수를 콜백으로 사용하기를 원할 것이다. 메서드 나 정적 메서드를 사용하려면 PHP에서 콜백을 지정하는 다른 방법을 참조하십시오.

    그런 다음 다음 함수 중 하나를 사용합니다.

    다시 말하면 키 - 값 연관을 유지하고 값 또는 키별로 정렬하는지 여부 만 다릅니다. 자세한 내용은 해당 설명서를 참조하십시오.

    사용 예 :

    usort($array, 'cmp');

    usort는 배열에서 두 개의 항목을 취해 그것들과 함께 cmp 함수를 호출 할 것입니다. 따라서 $ a를 배열 ( 'foo'=> 'bar', 'baz'=> 42)로 그리고 $ b를 다른 배열 ( 'foo'=> ..., 'baz'=> ...). 이 함수는 usort에 값이 더 큰지 또는 같은지 여부를 반환합니다. usort는 배열이 정렬 될 때까지이 프로세스가 $ a와 $ b에 대해 다른 값을 전달하는 것을 반복합니다. cmp 함수는 $ array에 값이있을 때마다 여러 번 호출됩니다. $ a와 $ b에 대한 값의 조합은 매번 다릅니다.

    이 아이디어에 익숙해 지려면 다음을 시도하십시오.

    function cmp($a, $b) {
    echo 'cmp called with $a:', PHP_EOL;
    var_dump($a);
    echo 'and $b:', PHP_EOL;
    var_dump($b);
}

    당신이 한 모든 것은 두 가지 아이템을 비교할 수있는 맞춤식 방법을 정의하는 것뿐입니다. 그것은 모든 종류의 가치와 함께 작동합니다.

    그건 그렇고, 이것은 어떤 값에서도 작동합니다. 값은 복잡한 배열 일 필요는 없습니다. 당신이하고 싶은 커스텀 비교가 있다면, 간단한 숫자 배열에서도 그렇게 할 수 있습니다.

    배열이 정 위치에 정렬되므로 반환 값을 아무 것도 지정하지 않아도됩니다. $ array = sort ($ array) 배열을 정렬 된 배열이 아닌 true로 대체합니다. 그냥 정렬 ($ 배열); 공장.

    baz 키 (숫자)로 정렬하려면, 다음을 수행하면됩니다.

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

    The PoWEr of MATH 덕분에 $ a가 $ b보다 작거나 $ b보다 큰지 여부에 따라 <0, 0 또는> 0 값을 반환합니다.

    float 값은 int로 축소되어 정밀도가 떨어질 것이므로 잘 작동하지 않습니다. 명시적인 -1, 0 및 1 반환 값을 대신 사용하십시오.

    객체 배열이있는 경우에도 동일한 방식으로 작동합니다.

    function cmp($a, $b) {
    return $a->baz - $b->baz;
}

    함수 호출을 포함하여 비교 함수 내에서 필요한 모든 작업을 수행 할 수 있습니다.

    function cmp(array $a, array $b) {
    return someFunction($a['baz']) - someFunction($b['baz']);
}

    첫 번째 문자열 비교 버전의 바로 가기 :

    function cmp(array $a, array $b) {
    return strcmp($a['foo'], $b['foo']);
}

    strcmp는 cmp에 대해 정확히 예상되는 것을 수행합니다. -1, 0 또는 1을 반환합니다.

    PHP 7은 우주선 연산자를 도입했습니다.이 연산자는 타입 간의 비교보다 같거나 작은 / 큰 것을 통합하고 단순화합니다 :

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

    주로 foo로 정렬하려고하지만 foo가 두 개의 요소에 대해 동일하면 baz로 정렬하십시오.

    function cmp(array $a, array $b) {
    if (($cmp = strcmp($a['foo'], $b['foo'])) !== 0) {
        return $cmp;
    } else {
        return $a['baz'] - $b['baz'];
    }
}

    익숙한 사람들에게는 ORDER BY foo, baz가있는 SQL 쿼리와 같습니다. 또한이 아주 간결한 약식 버전과 임의의 수의 키에 대해 이러한 비교 함수를 동적으로 만드는 방법을 살펴보십시오.

    "foo", "bar", "baz"와 같은 요소를 "manual order"로 정렬하려면 다음과 같이하십시오.

    function cmp(array $a, array $b) {
    static $order = array('foo', 'bar', 'baz');
    return array_search($a['foo'], $order) - array_search($b['foo'], $order);
}

    위의 모든 경우에, PHP 5.3 이상을 사용하고 있다면 (그리고 정말로해야 함) 더 짧은 코드에는 익명의 함수를 사용하고 또 다른 전역 함수는 주위에 떠 다니는 것을 피하십시오.

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

    이것이 복잡한 다차원 배열을 정렬하는 방법입니다. 다시 말하지만, PHP를 가르치는 관점에서 두 항목 중 어느 것이 "더 큰지"를 알려주는 방법을 생각해보십시오. PHP가 실제 정렬을하도록하십시오.

    위의 모든 것에 대해서도 오름차순과 내림차순 사이를 전환하려면 $ a 및 $ b 인수를 바꿔 넣기 만하면됩니다. 예 :

    return $a['baz'] - $b['baz']; // ascending
return $b['baz'] - $a['baz']; // descending

    그리고 다른 배열을 기반으로 한 배열을 정렬 할 수있게 해주는 특이한 array_multisort가 있습니다 :

    $array1 = array( 4,   6,   1);
$array2 = array('a', 'b', 'c');

    여기에 예상되는 결과는 다음과 같습니다.

    $array2 = array('c', 'a', 'b');  // the sorted order of $array1

    array_multisort를 사용하여 거기에 도달하십시오.

    array_multisort($array1, $array2);

    PHP 5.5.0에서 array_column을 사용하여 다차원 배열에서 열을 추출하고 해당 열에서 배열을 정렬 할 수 있습니다.

    array_multisort(array_column($array, 'foo'), SORT_DESC, $array);

    PHP 7.0.0부터 객체 배열에서 속성을 추출 할 수도 있습니다.

  2. ==============================

    2.

    그럼 가장 기본적인 방법은 이미 deceze에 의해 덮여있다 나는 다른 종류의 정렬을 보려고 할 것이다.

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

    산출

    c
b
a

    SplMaxHeap 클래스는 힙의 주요 기능을 제공하며 맨 위에 최대 값을 유지합니다.

    $heap = new SplMaxHeap();
$heap->insert(1);
$heap->insert(2);
$heap->insert(3);

    $heap = new SplMinHeap ();
$heap->insert(3);
$heap->insert(1);
$heap->insert(2);

    Bubble Sort에 관한 Wikipedia 기사에서 :

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

    선택 분류에 관한 Wikipedia 기사에서 :

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

    삽입 정렬에 관한 Wikipedia 기사에서 :

    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에 관한 Wikipedia 기사에서 :

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

    빗 정렬에 관한 Wikipedia 기사에서 :

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

    병합 정렬에 관한 Wikipedia 기사에서 :

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

    Quicksort에 관한 Wikipedia 기사에서 :

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

    순열 정렬에 관한 Wikipedia 기사에서 :

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

    기수 정렬에 관한 Wikipedia 기사에서 :

    // 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;
}
  3. ==============================

    3.

    다음과 같은 배열이 있다고 가정 해 보겠습니다.

    ['Kale', 'Kaleidoscope', 'Aardvark', 'Apple', 'Leicester', 'Lovely']

    이제 첫 글자 만 정렬하려고합니다.

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

    결과는 다음과 같습니다.

    ['Apple', 'Aardvark', 'Kale', 'Kaleidoscope', 'Lovely', 'Leicester']

    정렬이 안정적이지 않았습니다!

    예리한 관찰자는 배열 정렬 알고리즘 (QuickSort)이 안정적인 결과를 산출하지 못했고 동일한 첫 번째 문자의 단어 사이의 원래 순서가 유지되지 않음을 알았을 수 있습니다. 이 경우는 사소한 일이며 전체 문자열을 비교해야하지만 서로의 작업을 취소하지 않아야하는 여러 필드의 연속 된 두 가지 유형과 같이 사용 사례가 더 복잡하다고 가정 해 봅시다.

    Schwartzian 변형

    Decorating-sort-undecorate 관용구라고도하는 Schwartzian 변형은 본질적으로 불안정한 정렬 알고리즘을 사용하여 안정적인 정렬을 수행합니다.

    먼저 각 배열 요소를 기본 키 (값)와 보조 키 (인덱스 또는 위치)로 구성된 다른 배열로 꾸미십시오.

    array_walk($array, function(&$element, $index) {
    $element = array($element, $index); // decorate
});

    이렇게하면 배열이 다음과 같이 변환됩니다.

    [
    ['Kale', 0], ['Kaleidoscope', 1], 
    ['Aardvark', 2], ['Apple', 3], 
    ['Leicester', 4], ['Lovely', 5]
]

    이제 비교 단계를 조정합니다. 첫 번째 문자를 다시 비교하지만 두 문자가 같으면 원래 순서를 유지하는 데 보조 키가 사용됩니다.

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

    그 후에, 우리는 꾸며 내지 않습니다 :

    array_walk($array, function(&$element) {
    $element = $element[0];
});

    최종 결과 :

    ['Aardvark', 'Apple', 'Kale', 'Kaleidoscope', 'Leicester', 'Lovely']

    재사용은 어떨까요?

    변형 된 배열 요소로 작업하려면 비교 함수를 다시 작성해야합니다. 섬세한 비교 함수를 편집하고 싶지 않을 수도 있습니다. 비교 함수의 래퍼는 다음과 같습니다.

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

    이 함수를 사용하여 정렬 단계를 작성해 보겠습니다.

    usort($array, stablecmp(function($a, $b) {
    return strcmp($a[0], $b[0]);
}));

    빌라! 귀하의 초기 비교 코드가 돌아 왔습니다.

  4. ==============================

    4.

    클로저가있는 PHP 5.3부터 클로저를 사용하여 정렬 순서를 결정할 수도 있습니다.

    예를 들어 $ array가 month 속성을 포함하는 객체의 배열이라고 가정합니다.

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

    5.

    .NET에서 LINQ는 정렬 기능으로 자주 사용됩니다. 특히 개체를 여러 필드로 정렬해야하는 경우 비교 기능보다 훨씬 멋진 구문을 제공합니다. YaLinqo 라이브러리 *를 포함하여 PHP에 LINQ의 여러 포트가 있습니다. 이를 통해 복잡한 비교 함수를 작성하지 않고 배열을 한 줄로 정렬 할 수 있습니다.

    $sortedByName         = from($objects)->orderBy('$v->name');
$sortedByCount        = from($objects)->orderBy('$v->count');
$sortedByCountAndName = from($objects)->orderBy('$v->count')->thenBy('$v->name');

    콜백을 두 번째 인수로 전달하여 비교를 추가로 사용자 정의 할 수 있습니다 (예 :

    $sortedByFilenameNat  = from($objects)->orderBy('$v->filename', 'strnatcmp');

    여기에서 '$ v-> count'는 함수 ($ v)의 줄임말이다. {return $ v-> count; } (둘 중 하나만 사용 가능). 이 메소드 체인은 반복자를 반환하고, 필요하다면 끝에 -> toArray ()를 추가하여 반복자를 배열로 변환 할 수 있습니다.

    내부적으로 orderBy 및 관련 메서드는 적절한 배열 정렬 함수 (uasort, krsort, multisort, usort 등)를 호출합니다.

    LINQ에는 SQL에서 영감을받은 여러 가지 방법 (필터링, 그룹화, 결합, 집계 등)이 포함되어 있습니다. 데이터베이스에 의존하지 않고 배열과 개체의 복잡한 변환을 수행해야하는 경우에 가장 적합합니다.

    * 저에 의해 개발되었습니다. 자세한 내용과 다른 LINQ 포트와 비교할 때 readme를 참조하십시오.

  6. ==============================

    6.

    키 값에 따른 다차원 정렬

    키값에 의한 다차원 배열의 자연 정렬 및 원래 순서 유지 (기본 키를 섞지 않음) :

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

    테스트 케이스 :

    $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,
  ),
)
*/
  7. ==============================

    7.

    Nspl에서 정렬 된 함수로 배열을 정렬하는 것이 매우 편리합니다.

    기본 정렬

    // Sort array
$sorted = sorted([3, 1, 2]);

// Sort array in descending order
$sortedDesc = sorted([3, 1, 2], true);

    함수 결과별로 정렬

    // 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

    다차원 배열 정렬하기

    // 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

    객체 배열 정렬하기

    // 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

    비교 함수로 정렬하기

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

    이 모든 예를 여기서 볼 수 있습니다.

  8. ==============================

    8.

    배열을 정렬하는 방법에는 여러 가지가 있습니다. 그 작업을 수행하는 몇 가지 방법을 언급 할 것입니다. 모두의 목록으로, '$ numbers'라고하는 정수 배열을 제공 할 것입니다.

    $number = array(8,9,3,4,0,1,2);

    이것은 배열을 만드는 일반적인 방법입니다. 그 배열을 오름차순으로 정렬하려고한다고 가정하면 'sort ()'메서드를 사용할 수 있습니다.

    <?php

    $number = array(8,9,3,4,0,1,2);
    sort($number);

   foreach ($number as $value) {
       echo $value."  ";
   }
?>

    이제 그 결과를 고려해보십시오.

    인쇄 된 숫자 배열이 정렬 된 것을 볼 수 있습니다. 해당 숫자 배열을 내림차순으로 정렬하려면 'rsort ()'메서드를 해당 작업에 사용할 수 있습니다.

    <?php

     $number = array(8,9,3,4,0,1,2);
     rsort($number);

     foreach ($number as $value) {
        echo $value."  ";
     }
?>

    출력을 고려해 보라 ..

    이제 배열은 내림차순으로 정렬됩니다 .Ok, 연관 배열을 생각해 봅시다. 연관 배열 (연결 배열은 각 색인의 고유 한 키 값을 가진 배열입니다.)과 같은 배열을 제공합니다.

    $number = array('eight'=>8,'nine'=>9,'three'=>3,'fore'=>4,'zero'=>0,'one'=>1,'two'=>2);

    자, 이제이 배열을 값에 따라 오름차순으로 정렬하려고합니다 .'asort () '메서드를 사용할 수 있습니다.

    <?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."  ";
    }
?>

    그들의 값에 따라 내림차순 정렬, 'arsort ()'메서드를 사용할 수 있습니다. 키 값에 따라 해당 배열을 정렬하려고한다고 가정합니다. 이 경우 'ksort ()'메소드를 사용할 수 있습니다.

    <?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."  ";
     }
?>

    이제 출력을 고려하십시오.

    이제 배열은 키 값에 따라 정렬됩니다. 키 값에 따라 내림차순으로 배열을 정렬하려면 '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."  ";
    }
?>

    이제 연관 배열은 키 값에 따라 내림차순으로 정렬됩니다. 출력을 봅니다.

    이것들은 PHP에서 오름차순 또는 내림차순으로 배열을 정렬하는 몇 가지 방법입니다. 여러분이 아이디어를 얻을 수 있기를 바랍니다. 감사합니다!

  9. ==============================

    9.

    가장 간단한 방법은 어떤 루핑없이 배열을 정렬하기 위해 usort 함수를 사용하는 것입니다 : 아래는 그 예입니다 :

       $array_compare= array("0" =>4,"1"=>2,"2"=>500,"3"=>100);

    내림차순으로 정렬됩니다.

    usort($array_compare, function($a, $b) {
        return ($b['x1'] - $a['x1']) > 0 ? 1 :-1;
    });

    그러면 오름차순으로 정렬됩니다.

    usort($array_compare, function($a, $b) {
        return ($b['x1'] - $a['x1']) < 0 ? 1 :-1;
    });

    10. from https://stackoverflow.com/questions/17364127/how-can-i-sort-arrays-and-data-in-php by cc-by-sa and MIT lisence

'PHP' 카테고리의 다른 글

참조 : 변수 범위 란 무엇이며 어디에서 그리고 무엇이 "정의되지 않은 변수"오류에서 액세스 할 수 있습니까?  (0) 2018.09.01
PHP로 JSON에서 데이터를 추출하려면 어떻게해야합니까?  (0) 2018.09.01
PHP에서 작은 따옴표와 큰 따옴표로 묶인 문자열의 차이점은 무엇입니까?  (0) 2018.09.01
PHP에서 유용한 오류 메시지를 얻는 방법?  (0) 2018.09.01
PHP 코드가 실행되지 않고 코드가 페이지에 표시됩니다.  (0) 2018.09.01
,

티스토리툴바