Question

我有一个包含以下值的多维数组：

array(2) {
  [0]=>
  array(2) {
    [0]=>
    string(16) "5"
    [1]=>
    string(16) "4"
  }
  [1]=>
  array(3) {
    [0]=>
    string(16) "1"
    [1]=>
    string(16) "2"
    [2]=>
    string(16) "3"
  }
}

现在，数组的内容只是int，但更复杂的值可以通过括号传递。

然而，＆＃34;子阵列的数量＆＃34>我可以变化，可以小到1和大，因为PHP可以处理它。

我希望遍历第一个数组的第一个值，然后是第二个数组的第一个值，然后是第三个数组的第一个值，等等。

Array[0][0] -> Array[1][0] -> Array[2][0]
Array[0][0] -> Array[1][0] -> Array[2][1]
Array[0][0] -> Array[1][1] -> Array[2][0]
Array[0][0] -> Array[1][1] -> Array[2][1]
Array[0][0] -> Array[1][2] -> Array[2][0]
Array[0][0] -> Array[1][2] -> Array[2][1]
Array[0][1] -> Array[1][0] -> Array[2][0]
Array[0][1] -> Array[1][0] -> Array[2][1]
Array[0][1] -> Array[1][1] -> Array[2][0]
Array[0][1] -> Array[1][1] -> Array[2][1]
Array[0][1] -> Array[1][2] -> Array[2][0]
Array[0][1] -> Array[1][2] -> Array[2][1]
// Example with 2 values in each array.

我被告知递归功能可以解决这个问题，但我对它们没有经验，到目前为止我只能得到部分结果。

这是我目前的代码

// $array - Multidimensional array above
// $ini - Current array - ex: $array[0]
// $ini - Number of main arrays left - ex: count($array)
// $result - string that houses the temporary value
// $finalResult - Array that combines all the string when there is nothing left
function r ($array, $ini, $int, $result, $finalResult)
{            
    for ($i = 0; $i < count($array[$ini]); $i++)
    {
        $result = $array[$ini][$i] . ',' . $result;

        if ($int != 0)
        {
            $result = $this->r($array, ++$ini, --$int, $result, $finalResult);
        }
        else
        {
            $finalResult[] = $result;
        }
    }
    return $finalResult;
}

这是我从中得到的

array(2) {
  [0]=>
  string(22) "2,Array"
  [1]=>
  string(39) "3,2,Array"
}
// I managed at some point get the values separate but, sadly

该函数的预期结果是在此问题中显示值：

array(2) {
  [0]=>
  string(16) "5, 1"
  [0]=>
  string(16) "5, 2"
  [0]=>
  string(16) "5, 3"
  [0]=>
  string(16) "4, 1"
  [0]=>
  string(16) "4, 2"
  [0]=>
  string(16) "4, 3"
}

非常感谢任何正确方向的指导。

提前致谢！

Answer 1

这是递归的基本思想：

$data = array(/* multi-dimensional */);
$result = iterate($data);

function iterate(array $array)
{
    $result = array();

    foreach($array as $item) {
        if(is_array($item)) {
            $result[] = iterate($item);
        } else {
            $changed = $item; // do something to the value.

            $result[] = $changed;
        }
    }

    return $result;
}

对于数组中的每个节点，您检查它本身是否可以迭代，因此您可以从内部再次调用相同的函数并每次都返回该值。

如果无法迭代，则该节点是目标，应该读取，更改，删除或忽略该节点。

有一个更高级的数组迭代实现，它是Iterator接口系列的一部分，适用于你的那个将是RecursiveArrayIterator。

http://www.php.net//manual/en/class.recursivearrayiterator.php

Answer 2

我快速制作了一个你可以尝试的功能，告诉我它是否符合你的愿望。

function recursive ($array, &$final)
    {
        $length = count($array);
        for ($i = 0; $i < $length; $i++)
        {
            if (is_array($array[$i]))
                recursive($array[$i], $final);
            else 
                $final[] = $array[$i];
        }
    }

$array是要转换的数组，$final是通过引用传递时的转换结果。

Answer 3

也许我已经太晚了，但我相信这就是你所要求的，不需要递归，但我仍然害怕记忆！

function array_combine_subarray_values( array $groupArray ){

    //  boost available memory
    //ini_set('memory_limit', '512M');
    //count the elements in each subarray index
    $lenArrs = [];

    foreach ($groupArray as $arr) {
        $lenArrs[] = count($arr);
    }



    // total number of distinct cases
    $m = array_product($lenArrs);


    // save our arrays' lengths
    $lenArrskeep=$lenArrs;

    $repArr = [];
    // find the number of sequential repetitions for a given index of the subarrays
    foreach ($lenArrs as $lenKey => $len) {

        $repetitions = 1;
        unset($lenArrs[$lenKey]);

        foreach ($lenArrs as $lenMultiplierKey => $lenMultiplier) {
            $repetitions *= $lenMultiplier;
        }

        $repArr[$lenKey] = $repetitions;

    }



    $target=[];
    // iterate through all possible cases
    for ($i =0;$i<$m;$i++){

        //fill each combination/case 
        foreach ($repArr as $index => $repetitions) {
            $target[$i][]=$groupArray[$index][($i/$repetitions)%$lenArrskeep[$index]];

        }


    }

   return $target;


}

$groupArr = [
    [0, 3, 6],
    [1, 4 ,7],
    [2, 5, 8]
];
//result
    0   1   2
 #1 0   1   2
 #2 0   1   5
 #3 0   1   8
 #4 0   4   2
 #5 0   4   5
 #6 0   4   8
 #7 0   7   2
 #8 0   7   5
 #9 0   7   8
#10 3   1   2
#11 3   1   5
#12 3   1   8
#13 3   4   2
#14 3   4   5
#15 3   4   8
#16 3   7   2
#17 3   7   5
#18 3   7   8
#19 6   1   2
#20 6   1   5
#21 6   1   8
#22 6   4   2
#23 6   4   5
#24 6   4   8
#25 6   7   2
#26 6   7   5
#27 6   7   8

递归foreach循环（我认为）

3 个答案: