如何过滤一个关联数组比较键与值在一个索引数组?

使用array_intersect_key和array_flip:

var_dump(array_intersect_key($my_array, array_flip($allowed)));


array(1) {
["foo"]=>
int(1)
}

下面是一个使用设置()的不太灵活的替代方法:

$array = array(
1 => 'one',
2 => 'two',
3 => 'three'
);
$disallowed = array(1,3);
foreach($disallowed as $key){
unset($array[$key]);
}

print_r($array)的结果为:

Array
(
[2] => two
)

如果你想保留过滤后的值供以后使用，但如果你确定你不这样做，这是不适用的。

下面是一个使用闭包的更灵活的解决方案:

$my_array = array("foo" => 1, "hello" => "world");
$allowed = array("foo", "bar");
$result = array_flip(array_filter(array_flip($my_array), function ($key) use ($allowed)
{
return in_array($key, $allowed);
}));
var_dump($result);

输出:

array(1) {
'foo' =>
int(1)
}

在函数中，你可以做其他特定的测试。

如果你正在寻找一个方法，通过出现在键中的字符串来过滤数组，你可以使用:

$mArray=array('foo'=>'bar','foo2'=>'bar2','fooToo'=>'bar3','baz'=>'nope');
$mSearch='foo';
$allowed=array_filter(
array_keys($mArray),
function($key) use ($mSearch){
return stristr($key,$mSearch);
});
$mResult=array_intersect_key($mArray,array_flip($allowed));

print_r($mResult)的结果是

Array ( [foo] => bar [foo2] => bar2 [fooToo] => bar3 )

对这个答案的改编，支持正则表达式

function array_preg_filter_keys($arr, $regexp) {
$keys = array_keys($arr);
$match = array_filter($keys, function($k) use($regexp) {
return preg_match($regexp, $k) === 1;
});
return array_intersect_key($arr, array_flip($match));
}


$mArray = array('foo'=>'yes', 'foo2'=>'yes', 'FooToo'=>'yes', 'baz'=>'nope');


print_r(array_preg_filter_keys($mArray, "/^foo/i"));

输出

Array
(
[foo] => yes
[foo2] => yes
[FooToo] => yes
)

PHP 5.6引入了第三个参数array_filter()， flag，你可以将它设置为ARRAY_FILTER_USE_KEY来通过键而不是值进行过滤:

$my_array = ['foo' => 1, 'hello' => 'world'];
$allowed  = ['foo', 'bar'];
$filtered = array_filter(
$my_array,
function ($key) use ($allowed) {
// N.b. in_array() is notorious for being slow
return in_array($key, $allowed);
},
ARRAY_FILTER_USE_KEY
);

由于PHP 7.4引入了箭头函数，我们可以让它更简洁:

$my_array = ['foo' => 1, 'hello' => 'world'];
$allowed  = ['foo', 'bar'];
$filtered = array_filter(
$my_array,
fn ($key) => in_array($key, $allowed),
ARRAY_FILTER_USE_KEY
);

显然，这没有array_intersect_key($my_array, array_flip($allowed))那么优雅，但它确实提供了额外的灵活性，可以对键执行任意测试，例如$allowed可以包含正则表达式模式，而不是普通字符串。

你也可以使用ARRAY_FILTER_USE_BOTH将值和键传递给你的过滤器函数。下面是一个基于第一个例子的虚构示例，但请注意，我不建议这样使用$allowed编码过滤规则:

$my_array = ['foo' => 1, 'bar' => 'baz', 'hello' => 'wld'];
$allowed  = ['foo' => true, 'bar' => true, 'hello' => 'world'];
$filtered = array_filter(
$my_array,
fn ($val, $key) => isset($allowed[$key]) && (
$allowed[$key] === true || $allowed[$key] === $val
),
ARRAY_FILTER_USE_BOTH
); // ['foo' => 1, 'bar' => 'baz']

当使用array_filter时，如何获得数组的当前键

不管我多么喜欢Vincent解决maek问题的方法，它实际上并没有使用array_filter。如果你从搜索引擎来到这里，并在array_filter的回调中寻找访问当前迭代的键的方法，你可能在寻找类似于(PHP >= 5.3)的东西:

$my_array = ["foo" => 1, "hello" => "world"];


$allowed = ["foo", "bar"];


reset($my_array ); // Unnecessary in this case, as we just defined the array, but
// make sure your array is reset (see below for further explanation).


$my_array = array_filter($my_array, function($value) use (&$my_array, $allowed) {
$key = key($my_array); // request key of current internal array pointer
next($my_array); // advance internal array pointer


return isset($allowed[$key]);
});


// $my_array now equals ['foo' => 1]

它将筛选的数组作为回调的引用传递。由于array_filter不会通过增加数组的公共内部指针来迭代数组，所以你必须自己前进它。

这里重要的是，你需要确保你的数组被重置，否则你可能会从它的中间开始(因为内部数组指针被之前执行的一些代码留在那里)。

如果你只需要它一次，可能有点多余，但你可以使用YaLinqo library*来过滤集合(并执行任何其他转换)。这个库允许以流畅的语法对对象执行类似sql的查询。它的where函数接受带有两个参数的回调:一个值和一个键。例如:

$filtered = from($array)
->where(function ($v, $k) use ($allowed) {
return in_array($k, $allowed);
})
->toArray();

(where函数返回一个迭代器，所以如果你只需要用foreach在结果序列上迭代一次，->toArray()可以被删除。)

_{*由我开发}

从PHP 5.6开始，你可以在array_filter中使用ARRAY_FILTER_USE_KEY标志:

$result = array_filter($my_array, function ($k) use ($allowed) {
return in_array($k, $allowed);
}, ARRAY_FILTER_USE_KEY);

function filter_array_keys(array $array, $callback)
{
$matchedKeys = array_filter(array_keys($array), $callback);


return array_intersect_key($array, array_flip($matchedKeys));
}


$result = filter_array_keys($my_array, function ($k) use ($allowed) {
return in_array($k, $allowed);
});

function filter_array_keys(array $array, $keys)
{
if (is_callable($keys)) {
$keys = array_filter(array_keys($array), $keys);
}


return array_intersect_key($array, array_flip($keys));
}


// using a callback, like array_filter:
$result = filter_array_keys($my_array, function ($k) use ($allowed) {
return in_array($k, $allowed);
});


// or, if you already have the keys:
$result = filter_array_keys($my_array, $allowed));

$result = [];
foreach ($my_array as $key => $value) {
if (in_array($key, $allowed)) {
$result[$key] = $value;
}
}

数组过滤器函数:

array_filter ( $array, $callback_function, $flag )

$array -它是输入数组

$callback_function -要使用的回调函数，如果回调函数返回真正的，则数组中的当前值返回到结果数组中。

$flag -它是可选参数，它将决定什么参数被发送给回调函数。如果此参数为空，则回调函数将接受数组值作为参数。如果你想将数组key作为参数发送，则使用$flag作为ARRAY_FILTER_USE_KEY。如果你想同时发送键和值，你应该使用$flag作为ARRAY_FILTER_USE_BOTH。

例如:考虑简单数组

$array = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);

如果你想基于数组的键过滤数组，我们需要使用ARRAY_FILTER_USE_KEY作为数组函数array_filter的第三个参数。

$get_key_res = array_filter($array,"get_key",ARRAY_FILTER_USE_KEY );

如果你想基于数组键和数组值筛选数组，我们需要使用ARRAY_FILTER_USE_BOTH作为数组函数array_filter的第三个参数。

$get_both = array_filter($array,"get_both",ARRAY_FILTER_USE_BOTH );

回调函数示例:

 function get_key($key)
{
if($key == 'a')
{
return true;
} else {
return false;
}
}
function get_both($val,$key)
{
if($key == 'a' && $val == 1)
{
return true;
}   else {
return false;
}
}

它会输出

Output of $get_key is :Array ( [a] => 1 )
Output of $get_both is :Array ( [a] => 1 )

天真而丑陋(但似乎更快)的解决方案?

只在php 7.3.11中尝试了这个，但是一个丑陋的循环似乎在大约三分之一的时间内执行。在一个有几百个键的数组上也有类似的结果。微优化，可能在RW中没有用，但发现它令人惊讶和有趣:

$time = microtime(true);
$i = 100000;
while($i) {
$my_array = ['foo' => 1, 'hello' => 'world'];
$allowed  = ['foo', 'bar'];
$filtered = array_filter(
$my_array,
function ($key) use ($allowed) {
return in_array($key, $allowed);
},
ARRAY_FILTER_USE_KEY
);
$i--;
}
print_r($filtered);
echo microtime(true) - $time . ' on array_filter';


// 0.40600109100342 on array_filter
$time2 = microtime(true);
$i2 = 100000;
while($i2) {
$my_array2 = ['foo' => 1, 'hello' => 'world'];
$allowed2  = ['foo', 'bar'];
$filtered2 = [];
foreach ($my_array2 as $k => $v) {
if (in_array($k, $allowed2)) $filtered2[$k] = $v;
}
$i2--;
}
print_r($filtered2);
echo microtime(true) - $time2 . ' on ugly loop';
// 0.15677785873413 on ugly loop

基于@sepiariver，我在PHP 8.0.3上做了一些类似的测试:

$arr = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5, 'f' => 6, 'g' => 7, 'h' => 8];
$filter = ['a', 'e', 'h'];




$filtered = [];
$time = microtime(true);
$i = 1000000;
while($i) {
$filtered = array_intersect_key($arr, array_flip($filter));
$i--;
}
print_r($filtered);
echo microtime(true) - $time . " using array_intersect_key\n\n";




$filtered = [];
$time = microtime(true);
$i = 1000000;
while($i) {
$filtered = array_filter(
$arr,
function ($key) use ($filter){return in_array($key, $filter);},
ARRAY_FILTER_USE_KEY
);
$i--;
}
print_r($filtered);
echo microtime(true) - $time . " using array_filter\n\n";


$filtered = [];
$time = microtime(true);
$i = 1000000;
while($i) {
foreach ($filter as $key)
if(array_key_exists($key, $arr))
$filtered[$key] = $arr[$key];
$i--;
}
print_r($filtered);
echo microtime(true) - $time . " using foreach + array_key_exists\n\n";

• 0.28603601455688使用array_intersect_key
• 1.3096671104431 using array_filter
• 0.19402384757996使用foreach + array_key_exists

array_filter的“问题”是它将遍历$arr的所有元素，而array_intersect_key和foreach只遍历$filter。后者更有效，假设$filter小于$arr。

我用小号的“utils”;类中，我添加了两个过滤器静态函数过滤器数组使用denylist或allowlist。

<?php


class Utils {
 

/**
* Filter an array based on a allowlist of keys
*
* @param array $array
* @param array $allowlist
*
* @return array
*/
public static function array_keys_allowlist( array $array, array $allowlist ): array {
return array_intersect_key( $array, array_flip( $allowlist ) );
}




/**
* Filter an array based on a denylist of keys
*
* @param array $array
* @param array $denylist
*
* @return array
*/
public static function array_keys_denylist( array $array, array $denylist ): array {
return array_diff_key($array,array_flip($denylist));
}


}

然后你可以像这样使用它

<?php


$my_array = array("foo" => 1, "hello" => "world");
$allowed = array("foo", "bar");


$my_array = Utils::array_keys_allowlist($my_array,  $allowed)