PHP：检查另一个数组中是否存在嵌套数组值，同时忽略其他值

问题描述：

Given the following haystack and needle:

$haystack = array(
  'foo' => array(
    1 => 'one',
    2 => 'two',
    3 => 'three',
  ),
);

$needle = array(
  'foo' => array(
    1 => 'one',
    2 => 'two',
  ),
);

I want to check if all nested key-value pairs of the needle occur in the haystack (like it does in the example above), while ignoring any additional key-value pairs that may exist in the haystack (like $haystack['foo'][3] in the example).

There are many similar questions on SO but I haven't found a solution for this specific use case. Is there a (combination of) standard PHP functions to do this? What is the most elegant solution?

[update]

I didn't make clear yet that the arrays may not always have the same depth. Also, the keys of the elements in the arrays may be different every time.

给出以下haystack和needle： p>

  $ haystack = 数组（
'foo'=＆gt;数组（
 1 =＆gt;'one'，
 2 =＆gt;'two'，
 3 =＆gt;'three'，
），
）;  
 
 $ needle = array（
'foo'=＆gt; array（
 1 =＆gt;'one'，
 2 =＆gt;'two'，
），
）; 
   pre> 
 
 我想检查针的所有嵌套键值对是否出现在大海捞针中（就像上面的例子中那样），同时忽略任何其他键值对 干草堆中可能存在的东西（例如 $ haystack ['foo'] [3]  code>。） p> 
 
 
关于SO有很多类似的问题但是我 尚未找到针对此特定用例的解决方案。 是否有（组合）标准PHP函数来执行此操作？ 什么是最优雅的解决方案？ p> 
 
 

 [更新]  p> 
 
 
我还没有说明数组可能并不总是具有相同的深度。 此外，数组中元素的键每次都可能不同。 p> 
  div>

答

This is what I came up with myself. It works, but it seems more complex than it should be...

/**
 * Helper function which recursively checks if the key-value pairs in one array
 * are all present in another array. If all key-value pairs in the needle are
 * present in the haystack, and the haystack also contains additional items,
 * the check wil still pass.
 *
 * @param array $needle
 *   The array with the key-value pairs to look for.
 * @param array $haystack
 *   The array in which to look for the key-value pairs.
 * @return bool
 *   TRUE if all key-value pairs of the needle occur in the haystack. FALSE if
 *   one or more keys or values are missing or different.
 */
function array_contains(array $needle, array $haystack) {
  // First, check if needle and haystack are identical. In that case it's easy.
  if ($needle === $haystack) {
    return TRUE;
  }
  foreach ($needle as $key => $value) {
    // If the key does not occur in the haystack, we're done.
    if (!isset($haystack[$key])) {
      return FALSE;
    }
    // If the value is an array...
    if (is_array($value)) {
      // ...see if the counterpart in $haystack is an array too...
      if (!is_array($haystack[$key])) {
        return FALSE;
      }
      // ...and if so, recurse.
      if (array_contains($value, $haystack[$key]) == FALSE) {
        return FALSE;
      }
    }
    // If the values are not arrays and not the same, the check fails.
    else if ($value != $haystack[$key]) {
      return FALSE;
    }
  }
  // If we still didn't fail, all tests have passed.
  return TRUE;
}

答

array_intersect() will tell you what values match. Just make sure that matches your $needle.

echo $needle['foo'] === array_intersect($needle['foo'], $haystack['foo']);

PHP：检查另一个数组中是否存在嵌套数组值，同时忽略其他值

相关推荐