Shuffle array elements by rearranging the key value associations

Question

PHP's shuffle() function destroys the array keys, so I decided to write a shuffle function that doesn't do that and instead rearranges key-value associations. As I would be using the function in place of shuffle() most of the time, I'd like it to be as fast and memory efficient (if a time-space tradeoff is needed, I think I would prioritise time) as possible:

<?
    function swap(&$a, &$b)
    {
        $tmp = $a;
        $a = $b;
        $b = $tmp;
    }

    function shuffleX(&$arr)    #Shuffles the key-value associations in an array.
    {
        $keys = array_keys($arr);   #extract the keys from the array.
        $length = count($keys);
        $i = 0; #Index.
        while ($i < $length-1) 
        {
            $target = rand(($i+1), $length-1);  #This ensures that no value ends up mapped to the same key.
            swap($arr[$keys[$i]], $arr[$keys[$target]]);    #Swap each element of the array with another.
            $i++;
        }
    }
?>

Answer 1

Rather than making iterated rand() calls, you should randomize the data once for best efficiency. To do this, just isolate the keys, shuffle them, then rejoin the values to the appropriate keys in the new order.

Code: (Demo)

function preserve_shuffle(&$arr)    #Shuffles the key-value associations in an array.
{
    $keys = array_keys($arr);   #extract the keys from the array.
    shuffle($keys);
    for ($index = 0, $length = count($keys); $index < $length; ++$index) {
        $result[$keys[$index]] = $arr[$keys[$index]];
    }
    $arr = $result;
}

$arr = ["a" => "apple", "b" => "banana", "c" => "capsicum", "d" => "dill"];
preserve_shuffle($arr);
var_export($arr);

Or, if you prefer greater brevity or a functional syntax, you could use the following inside your custom function:

$keys = array_keys($arr);   #extract the keys from the array.
shuffle($keys);
$arr = array_merge(array_flip($keys), $arr);

Proof that it also works: https://3v4l.org/eLMo6

---

My earlier snippets only reorder the associative data. The following will shuffle the associations without shuffling the key orders. It does not guarantee that all initially associations will be destroyed -- which I feel is beneficial / less predictable in a randomized result.

function random_disassociate(&$assoc_array)
{
    if (sizeof($assoc_array) < 2) {
        return;  // data cannot be disassociated
    }
    $keys = array_keys($assoc_array);
    shuffle($assoc_array);
    $assoc_array = array_combine($keys, $assoc_array);
}

$arr = ["a" => "apple", "b" => "banana", "c" => "capsicum", "d" => "dill"];
random_disassociate($arr);
var_export($arr);

Answer 2

The swap() function is unecessary

There's no need to create a swap() function. This can be done as a one-liner using native PHP. And, generally speaking, native functionality is going to be more performant than user-defined functions. It also means less code for you to write or maintain.

list($a,$b) = [$b, $a];

This takes two values, places them in an array and then using list() swaps them. In your case it would look like:

list($arr[$keys[$i]],$arr[$keys[$target]]) = [$arr[$keys[$target]], $arr[$keys[$i]]];

Friendly reminder: don't use short tags

Short PHP tags (<?) has been discouraged for a long time. Although it is still supported it is disabled by default in the php.ini file and its use is discouraged. It sounds like it is not a big deal but this means having to make sure every time you set up an environment for this to run you have to make a special configuration change which is risky and time consuming and really shouldn't be necessary. (The short echo tag (<?=) is not discouraged and always available so feel free to use that as much as you like).

PHP also allows for short open tag <? (which is discouraged since it is only available if enabled using the short_open_tag php.ini configuration file directive, or if PHP was configured with the --enable-short-tags option).

Source