To disrupt the order of PHP arrays, 1. You can use the shuffle() function to randomly disrupt the array and reset the key name; 2. If you need to retain the original key name, you can use uasort() to combine a custom random comparison function to implement it; 3. For higher randomness requirements, you can manually implement the Fisher-Yates algorithm to ensure uniform randomness. shuffle() is the easiest and common method, but it will lose the original key name and modify the original array; uasort() is suitable for associative arrays to retain the key name but the randomness is not completely uniform; Fisher-Yates is more fair but suitable for specific needs, and in most cases it is recommended to use built-in functions.

It is actually not difficult to disrupt PHP arrays, the key is to use the right function. PHP itself provides built-in functions to accomplish this task, and you only need to pay attention to some details to avoid common problems.

Using shuffle() function is the most direct way

This is the most commonly used and easiest method. shuffle() function randomly disrupts the order of the array and resets the key name of the array to become a number index starting from 0.

For example:

 $numbers = [1, 2, 3, 4, 5];
shuffle($numbers);
print_r($numbers);

The order of outputs after execution will be different each time, such as [3, 1, 5, 2, 4] or other combinations.

Need to note:

• This function is operated in place , which means it will directly modify the original array.
• If you still want to keep the original key name, this method is not suitable.

If you need to preserve the key name, you can combine array_values() and shuffle()

If you want to keep the original key-value correspondence while disrupting the order, you can first copy a key-value pair and then implement it by random sorting.

A common approach is to use uasort() plus a custom comparison function:

 $assocArray = ['a' => 1, 'b' => 2, 'c' => 3];

uasort($assocArray, function($a, $b) {
    return random_int(-1, 1); // Randomly return -1, 0 or 1
});

print_r($assocArray);

The benefits of this approach are:

• The key name will not be lost
• Applicable to associative arrays

But it should be noted that the randomness of uasort() is not completely uniform. If you pursue a more "true random" effect, you may need to write a Fisher-Yates algorithm to implement it yourself.

For higher requirements, it can be manually implemented with Fisher-Yates

Fisher-Yates is a classic shuffle algorithm that ensures that the probability of each permutation appears consistent. Although PHP built-in functions are enough, if you want to achieve fairer randomness or learning purposes, you can try the following method:

 function fisherYatesShuffle(&$array) {
    $count = count($array);
    for ($i = $count - 1; $i > 0; $i--) {
        $j = random_int(0, $i);
        [$array[$i], $array[$j]] = [$array[$j], $array[$i]];
    }
}

$data = [10, 20, 30, 40];
fisherYatesShuffle($data);
print_r($data);

This writing method is suitable for:

• Higher demands random airport scene
• Manual control logic when customizing data structures

However, for most cases, it is recommended to use built-in functions to save trouble.

Basically that's it. Just choose the right method according to your needs, it doesn’t have to be so complicated.

The above is the detailed content of how to shuffle a php array. For more information, please follow other related articles on the PHP Chinese website!