PHP多维数组查找嵌套值方法

本教程详细探讨了如何在PHP中，当多维数组的某个字段本身也是数组时，高效地搜索特定值。文章介绍了如何结合使用`array_column`和`array_merge`函数来扁平化数据结构以进行搜索，并提供了两种代码实现方式。此外，还特别说明了如何获取原始多维数组的顶层键，以满足不同场景下的需求。

问题阐述：在复杂多维数组中搜索

在PHP开发中，我们经常需要处理多维数组。当我们需要在数组中搜索特定值并获取其键时，array_search结合array_column是一个常用的高效组合。例如，对于以下结构的多维数组：

$myArray = array(
    array(
        'score'   => '100',
        'name'    => 'Sam',
        'subject' => 'Data Structures'
    ),
    array(
        'score'   => '200',
        'name'    => 'Tanya',
        'subject' => 'Advanced Algorithms'
    ),
    array(
        'score'   => '300',
        'name'    => 'Jack',
        'subject' => 'Distributed Computing'
    )
);

// 搜索 'score' 列中值为 '100' 的项
$id = array_search('100', array_column($myArray, 'score'));
echo "找到的键（简单情况）：" . $id . PHP_EOL; // 输出 0

上述代码能够正确地返回值为 '100' 的项在 $myArray 中的顶层键（在此例中为 0）。然而，当数组结构变得更加复杂，例如某个字段本身也是一个数组时，这种直接的方法就会失效。

考虑以下修改后的 $myArray 结构，其中 'score' 字段现在是一个包含多个分数的数组：

$myArray = array(
    array(
        'score'   => array('100','200'),
        'name'    => 'Sam',
        'subject' => 'Data Structures'
    ),
    array(
        'score'   => array('300','400'),
        'name'    => 'Tanya',
        'subject' => 'Advanced Algorithms'
    ),
    array(
        'score'   => array('500','600'),
        'name'    => 'Jack',
        'subject' => 'Distributed Computing'
    )
);

此时，如果仍使用 array_search('100', array_column($myArray, 'score'))，array_column($myArray, 'score') 将返回 [['100','200'], ['300','400'], ['500','600']]。array_search 会尝试在这个由子数组构成的一维数组中查找标量值 '100'，而不是在子数组内部查找，因此无法得到预期的结果。

解决方案一：利用 array_column 和 array_merge 扁平化搜索

为了解决上述问题，我们需要一种方法将所有嵌套的 'score' 值提取出来，并合并成一个单一的一维数组，然后再进行搜索。这可以通过巧妙地结合使用 array_column 和 array_merge 来实现。

核心思路是：

1. 首先，使用 array_column 提取所有 'score' 字段，这将得到一个由数组组成的新数组。
2. 然后，再次使用 array_column 针对这个新数组，提取每个子数组的特定索引（例如，第一个元素、第二个元素等）。
3. 最后，使用 array_merge 将这些提取出的一维数组合并成一个完整的、可供 array_search 使用的扁平化数组。

以下是实现此逻辑的紧凑代码示例：

$myArray = array(
    array(
        'score'   => array('100','200'),
        'name'    => 'Sam',
        'subject' => 'Data Structures'
    ),
    array(
        'score'   => array('300','400'),
        'name'    => 'Tanya',
        'subject' => 'Advanced Algorithms'
    ),
    array(
        'score'   => array('500','600'),
        'name'    => 'Jack',
        'subject' => 'Distributed Computing'
    )
);

// 提取所有 'score' 字段（结果是数组的数组）
// 然后分别提取每个子数组的索引 0 和索引 1 的值
// 最后将这两部分合并成一个一维数组
$id = array_search('100', array_merge(
    array_column(array_column($myArray, 'score'), 0),
    array_column(array_column($myArray, 'score'), 1)
));

echo "找到的键（扁平化后）：" . $id . PHP_EOL; // 输出 0

在这个解决方案中，array_column($myArray, 'score') 首先返回 [['100','200'], ['300','400'], ['500','600']]。 接着，array_column(..., 0) 提取所有子数组的第一个元素，得到 ['100', '300', '500']。 array_column(..., 1) 提取所有子数组的第二个元素，得到 ['200', '400', '600']。 最后，array_merge() 将 ['100', '300', '500'] 和 ['200', '400', '600'] 合并成 ['100', '300', '500', '200', '400', '600']。 此时，array_search('100', ...) 就能在这个扁平化的一维数组中找到值 '100'，并返回其在合并数组中的键 0。

重要提示： 此方法返回的键是合并后的一维数组中的键，而不是原始 $myArray 的顶层键。

解决方案二：提升代码可读性

虽然上述紧凑的写法很高效，但对于复杂的表达式，可能会降低代码的可读性。为了提高代码的清晰度和可维护性，我们可以将中间步骤拆分到临时变量中：

$myArray = array(
    array(
        'score'   => array('100','200'),
        'name'    => 'Sam',
        'subject' => 'Data Structures'
    ),
    array(
        'score'   => array('300','400'),
        'name'    => 'Tanya',
        'subject' => 'Advanced Algorithms'
    ),
    array(
        'score'   => array('500','600'),
        'name'    => 'Jack',
        'subject' => 'Distributed Computing'
    )
);

// 步骤1：提取所有 'score' 字段，得到一个数组的数组
$scoresNested = array_column($myArray, 'score'); 
// $scoresNested 现在是：[['100','200'], ['300','400'], ['500','600']]

// 步骤2：从 $scoresNested 中提取每个子数组的第一个元素
$tempArray1 = array_column($scoresNested, 0); 
// $tempArray1 现在是：['100', '300', '500']

// 步骤3：从 $scoresNested 中提取每个子数组的第二个元素
$tempArray2 = array_column($scoresNested, 1); 
// $tempArray2 现在是：['200', '400', '600']

// 步骤4：将两个临时数组合并成一个完整的一维数组
$mergedScores = array_merge($tempArray1, $tempArray2);
// $mergedScores 现在是：['100', '300', '500', '200', '400', '600']

// 步骤5：在合并后的数组中搜索目标值
$id = array_search('100', $mergedScores);

echo "找到的键（可读性优化后）：" . $id . PHP_EOL; // 输出 0

这种写法虽然代码行数增多，但每一步的意图都非常明确，便于理解和调试。其最终结果与紧凑写法一致。

注意事项：获取原始数组的顶层键

如前所述，array_search 在扁平化数组中找到的键是该扁平化数组的索引。如果您的需求是获取原始 $myArray 中对应元素的顶层键（例如，如果 '100' 在 $myArray[0]['score'][0] 中，您希望得到 0），那么上述 array_merge 方案并不能直接提供。在这种情况下，更直观的方法是进行迭代遍历。

以下是一个函数示例，演示如何遍历多维数组并查找值，同时返回原始数组的顶层键：

/**
 * 在多维数组的指定子数组字段中搜索值，并返回原始数组的顶层键。
 *
 * @param array  $data        要搜索的多维数组。
 * @param string $keyToSearch 包含嵌套数组的字段名（例如 'score'）。
 * @param mixed  $targetValue 要搜索的目标值。
 * @return int|null 如果找到，返回原始数组的顶层键；否则返回 null。
 */
function findOriginalKeyInNestedArray(array $data, string $keyToSearch, $targetValue): ?int {
    foreach ($data as $originalIndex => $item) {
        // 检查目标键是否存在且其值是数组
        if (isset($item[$keyToSearch]) && is_array($item[$keyToSearch])) {
            // 在嵌套数组中搜索目标值
            if (in_array($targetValue, $item[$keyToSearch])) {
                return $originalIndex; // 找到，返回原始数组的顶层键
            }
        }
    }
    return null; // 未找到
}

$myArray = array(
    array(
        'score'   => array('100','200'),
        'name'    => 'Sam',
        'subject' => 'Data Structures'
    ),
    array(
        'score'   => array('300','400'),
        'name'    => 'Tanya',
        'subject' => 'Advanced Algorithms'
    ),
    array(
        'score'   => array('500','600'),
        'name'    => 'Jack',
        'subject' => 'Distributed Computing'
    )
);

$originalId = findOriginalKeyInNestedArray($myArray, 'score', '100');
echo "找到的原始数组键：" . ($originalId !== null ? $originalId : "未找到") . PHP_EOL; // 输出 0

$originalId2 = findOriginalKeyInNestedArray($myArray, 'score', '400');
echo "找到的原始数组键：" . ($originalId2 !== null ? $originalId2 : "未找到") . PHP_EOL; // 输出 1

$originalId3 = findOriginalKeyInNestedArray($myArray, 'score', '999');
echo "找到的原始数组键：" . ($originalId3 !== null ? $originalId3 : "未找到") . PHP_EOL; // 输出 未找到

这种迭代方法在需要获取原始数组键的场景下更为直接和准确，尤其当嵌套数组的结构（例如元素数量）不固定时，它也更具通用性。

总结

在PHP中处理复杂的多维数组搜索时，理解数据结构是关键。当目标字段本身是一个数组时，我们可以采取两种主要策略：

1. 扁平化搜索：通过多次使用 array_column 提取嵌套数组的特定元素，再结合 array_merge 将它们合并成一个可搜索的一维数组。这种方法简洁高效，但返回的键是扁平化数组的索引。
2. 迭代搜索：通过循环遍历原始多维数组，并在每个元素的嵌套子数组中使用 in_array 进行查找。这种方法能够直接返回原始多维数组的顶层键，对于需要精确追踪原始位置的场景更为适用，并且对嵌套数组的内部结构变化具有更好的适应性。

选择哪种方法取决于您的具体需求：如果您只需要知道目标值是否存在以及它在某个扁平化集合中的位置，扁平化搜索可能更优；如果您需要明确知道该值属于原始多维数组中的哪个顶层元素，则迭代搜索是更可靠的选择。熟练掌握这些技术将大大提高您处理PHP复杂数据结构的能力。