值得注意的是，array_walk 不能用于更改数组中的键。
函数可以定义为 (&$value, $key) 但不能定义为 (&$value, &$key)。
即使 PHP 没有报错/警告，它也不会修改键。
(PHP 4, PHP 5, PHP 7, PHP 8)
array_walk — 将用户提供的函数应用于数组的每个成员
将用户定义的 callback 函数应用于 array 数组的每个元素。
array_walk() 不受 array 的内部数组指针的影响。 array_walk() 将遍历整个数组，无论指针位置如何。
array输入数组。
callback通常，callback 接受两个参数。 array 参数的值是第一个，键/索引是第二个。
注意:
如果
callback需要使用数组的实际值，请将callback的第一个参数指定为 引用。 然后，对这些元素所做的任何更改都将在原始数组本身中进行。
注意:
许多内部函数（例如 strtolower()）如果传递了超过预期数量的参数，并且不能直接用作
callback，将会抛出警告。
只有 array 的值可能会更改；它的结构不能更改，即程序员不能添加、取消设置或重新排序元素。 如果回调不满足此要求，则此函数的行为是未定义的，并且不可预测的。
arg如果提供了可选的 arg 参数，它将作为第三个参数传递给 callback。
始终返回 true。
从 PHP 7.1.0 开始，如果 callback 函数需要超过 2 个参数（数组成员的值和键），或者如果 arg 也被传递，则将抛出 ArgumentCountError。 以前，在这种情况下，每次 array_walk() 调用 callback 时，都会生成一个级别为 E_WARNING 的错误。
示例 #1 array_walk() 示例
<?php
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
function test_alter(&$item1, $key, $prefix)
{
$item1 = "$prefix: $item1";
}
function test_print($item2, $key)
{
echo "$key. $item2\n";
}
echo "Before ...:\n";
array_walk($fruits, 'test_print');
array_walk($fruits, 'test_alter', 'fruit');
echo "... and after:\n";
array_walk($fruits, 'test_print');
?>上面的示例将输出
Before ...: d. lemon a. orange b. banana c. apple ... and after: d. fruit: lemon a. fruit: orange b. fruit: banana c. fruit: apple
示例 #2 使用匿名函数的 array_walk() 示例
<?php
$elements = ['a', 'b', 'c'];
array_walk($elements, function ($value, $key) {
echo "{$key} => {$value}\n";
});
?>上面的示例将输出
0 => a 1 => b 2 => c
值得注意的是，array_walk 不能用于更改数组中的键。
函数可以定义为 (&$value, $key) 但不能定义为 (&$value, &$key)。
即使 PHP 没有报错/警告，它也不会修改键。在类中调用数组遍历
如果类是静态的
array_walk($array, array('self', 'walkFunction'));
或
array_walk($array, array('className', 'walkFunction'));
否则
array_walk($array, array($this, 'walkFunction'));我注意到
PHP 忽略了使用 array_walk() 时参数的类型，即使有
declare(strict_types=1) 。
以下代码就是一个例子...
<?php
declare(strict_types=1);
$fruits = array("butter" => 5.3, "meat" => 7, "banana" => 3);
function test_print(int $item2, $key) {
echo "$key: $item2<br />\n";
}
array_walk($fruits, 'test_print');
?>
输出是
butter: 5
meat: 7
banana: 3
而预期输出是
致命错误：未捕获的类型错误：传递给 test_print() 的参数 1 必须是整数类型
因为 “butter” => 5.3 是浮点数
我问了别人，他们说“这是因为从内部代码调用的回调函数总是使用弱类型”。但我尝试了一些测试，当使用 call_user_func() 时，这种行为不是问题。作为对 'ibolmo' 的回应，这是 string_walk 的扩展版本，允许传递用户数据（如 array_walk）并像 array_walk 允许的那样让函数编辑字符串，但现在请注意你必须传递一个变量，因为 PHP 不能按引用传递字符串文字（合乎逻辑的）。
<?php
function string_walk(&$string, $funcname, $userdata = null) {
for($i = 0; $i < strlen($string); $i++) {
# NOTE: PHP 的解引用很烂，我们必须这么做。
$hack = $string{$i};
call_user_func($funcname, &$hack, $i, $userdata);
$string{$i} = $hack;
}
}
function yourFunc($value, $position) {
echo $value . ' ';
}
function yourOtherFunc(&$value, $position) {
$value = str_rot13($value);
}
# NOTE: 我们现在需要这个丑陋的 $x = hack。
string_walk($x = 'interesting', 'yourFunc');
// 输出: i n t e r e s t i n g
string_walk($x = 'interesting', 'yourOtherFunc');
echo $x;
// 输出: vagrerfgvat
?>
还要注意，直接对 $x 调用 str_rot13() 会快得多 ;-)，只是一个示例。对 zlobnygrif 的速度测试的修正。
<?php
// 测试结果
$array1 = test('array_walk');
$array2 = test('array_walk_list_each');
$array3 = test('array_walk_foreach1');
$array4 = test('array_walk_foreach2');
// 检查数组是否相等
var_dump($array1 == $array2, $array1 == $array3, $array1 == $array4);
// 测试函数 1
function array_walk_list_each(&$array, $function, $userData = null) {
/* 确保每次都遍历数组 */
reset($array);
while ( list($key, $value) = each($array) )
$function($array[$key], $key, $userData);
}
// 测试函数 2
function array_walk_foreach1(&$array, $function, $userData = null) {
foreach ($array as $key => &$value )
$function($value, $key, $userData);
}
// 测试函数 3
function array_walk_foreach2(&$array, $function, $userData = null) {
foreach ($array as $key => $value )
$function($array[$key], $key, $userData);
}
function some_function(&$value, $key, $userData) {
$value = "$key => $userData";
}
function test($function, $count = 10000, $arrayElements = 1000) {
echo $function, ' ... ';
$array = array_fill(0, $arrayElements, "some text value");
$timer = microtime(true);
for( $i = 0; ++$i < $count; )
/* 更改每个 $i 的数据 */
$function($array, 'some_function', 'some user data ' . $i);
printf("%.3f sec\n", microtime(true) - $timer);
return $array;
}请注意，对 array_walk 使用 intval 是不合适的。
互联网上有很多例子建议使用以下代码来安全地转义 $_POST 数组中的整数
<?php
array_walk($_POST['something'],'intval'); // 在 PHP 5.3.3 中没有任何作用
?>
它在 _某些_ 较旧的 PHP 版本（5.2）中有效，但与规范不符。由于 intval() 不会修改其参数，而是返回修改后的结果，因此上面的代码对数组没有任何影响，并且会留下网站的安全漏洞。
你可以改为使用以下代码
<?php
$_POST['something'] = array_map(intval,$_POST['something']);
?>大约 3 年前有一篇关于使用此方法进行修剪的文章。array_map() 可能更适合这种情况。我还没有检查时间/资源的影响
$result = array_map("trim", $array);不要忘记 array_map() 函数，它可能更容易使用！
以下是将数组中的所有元素转换为小写的方法
<?php
$arr = array_map('strtolower', $arr);
?>由于 array_walk 无法修改/更改/重新索引键，正如前面提到的，我提供了这个小型包装函数，它通过闭包、“use”关键字实现了传递数组引用和索引。
function indexArrayByElement($array, $element)
{
$arrayReindexed = [];
array_walk(
$array,
function ($item, $key) use (&$arrayReindexed, $element) {
$arrayReindexed[$item[$element]] = $item;
}
);
return $arrayReindexed;
}array_walk 不适用于 SplFixedArray 对象
<?php
$array = new SplFixedArray(2);
$array[0] = 'test_1';
$array[1] = 'test_2';
array_walk($array, function(&$val){
$val .= '__';
return $val;
});
foreach ($array as $a) {
echo "$a\n";
}
?>
结果是
test_1
test_2我想遍历一个数组并将其反向映射到第二个数组。我决定使用 array_walk，因为它应该比 reset、next 循环或 foreach(x as &$y) 循环更快。
<?php
$output = array();
array_walk($input, 'gmapmark_reverse', $output);
function gmapmark_reverse(&$item, $index, &$target) {
$target[$item['form_key']] = $index;
}
?>
在调试器中，我可以看到 $target 正在逐步更新，但是当 array_walk 返回时，$output 是空的。但是，如果我使用一个（已弃用）的按引用调用
<?php
array_walk($input, 'gmapmark_reverse', &$output);
?>
$output 会被正确地返回。不幸的是，没有一种简单的方法来抑制警告
<?php
@array_walk($input, 'gmapmark_reverse', &$output);
?>
不会使它们静音。我设计了一种使用静态数组的解决方法
<?php
$reverse = array();
array_walk($input, 'gmapmark_reverse');
// 再次调用函数以获取目标数组，因为参数不起作用
$reverse = gmapmark_reverse($reverse);
function gmapmark_reverse(&$item, $index = 0) {
static $target;
if (!$target) {
$target = array();
}
if (isset($item['form_key'])) {
$target[$item['form_key']] = $index;
}
return($target);
}
?>在回调函数中，将第三个（可选）参数按引用传递并在其中永久修改它非常有用。这将导致修改后的参数被传递给 array_walk() 的下一次迭代。以下示例枚举了数组中的项目
<?php
function enumerate( &$item1, $key, &$startNum ) {
$item1 = $startNum++ ." $item1";
}
$num = 1;
$fruits = array( "lemon", "orange", "banana", "apple");
array_walk($fruits, 'enumerate', $num );
print_r( $fruits );
echo '$num is: '. $num ."\n";
?>
这将输出
Array
(
[0] => 1 lemon
[1] => 2 orange
[2] => 3 banana
[3] => 4 apple
)
$num is: 1
请注意输出的最后一行，在 array_walk() 之外，$num 参数的初始值为 1。这是因为 array_walk() 不会按引用获取第三个参数。那么，如果我们按引用传递可选参数呢？
<?php
$num = 1;
$fruits = array( "lemon", "orange", "banana", "apple");
array_walk($fruits, 'enumerate', &$num ); // 这里使用引用
print_r( $fruits );
echo '$num is: '. $num ."\n";
echo "we've got ". ($num - 1) ." fruits in the basket!";
?>
这将输出
Array
(
[0] => 1 lemon
[1] => 2 orange
[2] => 3 banana
[3] => 4 apple
)
$num is: 5
we've got 4 fruits in the basket!
现在 $num 发生了变化，因此我们能够计算项目数量（无需不必要地调用 count()）。
总之，在 array_walk() 中使用引用可能是一个强大的工具，但应谨慎使用，因为在 array_walk() 外部修改第三个参数并不总是我们想要的。// 我们可以用这个简单的 FOREACH 循环来实现
$fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
foreach($fruits as $cls => $vls)
{
$fruits[$cls] = "fruit: ".$vls;
}
结果
Array
(
[d] => fruit: lemon
[a] => fruit: orange
[b] => fruit: banana
[c] => fruit: apple
)对于那些认为无法使用 array_walk 更改/替换键名的人，请看这里
<?php
function array_explore(array &$array, callable $callback)
{
array_walk($array, function(&$value, $key) use (&$array, $callback)
{
$callback($array, $key, $value);
if(is_array($value))
{
array_explore($value, $callback);
}
});
}
/**
* 摘自：https://stackoverflow.com/questions/13233405/change-key-in-associative-array-in-php
*/
function renameKey(array &$data, $oldKey, $newKey, $ignoreMissing = false, $replaceExisting = false)
{
if (!empty($data))
{
if (!array_key_exists($oldKey, $data))
{
if ($ignoreMissing)
{
return FALSE;
}
throw new \Exception('Old key does not exist.');
}
else
{
if (array_key_exists($newKey, $data))
{
if ($replaceExisting)
{
unset($data[$newKey]);
}
else
{
throw new \Exception('New key already exist.');
}
}
$keys = array_keys($data);
// EllisGL 的修正：https://php.net/manual/en/function.array-search.php#122377
$keys[array_search($oldKey, array_map('strval', $keys))] = $newKey;
$data = array_combine($keys, $data);
return TRUE;
}
}
return FALSE;
}
$array = [
"_10fish" => 'xyz',
"_11fish" => [
"_22" => "a", "b", "c"
],
"someFish" => [
'xyz',
'@attributes' => ['type' => 'cod']
]
];
array_explore($array, function(&$value, $key)
{
// 将键 '@attrutes' 替换为 '_attributes'
if('@attributes' === $key)
{
renameKey($value, $key, '_attributes');
}
});
print_r($array);
?>使用 lambda，您可以创建一个方便的 zip 函数，将数组的键和值压缩在一起。我将其扩展，允许您将“粘合”字符串作为可选的用户数据参数传递。以下示例用于压缩一组电子邮件标头
<?php
/**
* 使用提供的粘合剂将数组的键和值压缩在一起
*
* 数组的值被替换为新的计算值
*
* @param array $data
* @param string $glue
*/
function zip(&$data, $glue=': ')
{
if(!is_array($data)) {
throw new InvalidArgumentException('第一个参数必须是数组');
}
array_walk($data, function(&$value, $key, $joinUsing) {
$value = $key . $joinUsing . $value;
}, $glue);
}
$myName = 'Matthew Purdon';
$myEmail = '[email protected]';
$from = "$myName <$myEmail>";
$headers['From'] = $from;
$headers['Reply-To'] = $from;
$headers['Return-path'] = "<$myEmail>";
$headers['X-Mailer'] = "PHP" . phpversion() . "";
$headers['Content-Type'] = 'text/plain; charset="UTF-8"';
zip($headers);
$headers = implode("\n", $headers);
$headers .= "\n";
echo $headers;
/*
From: Matthew Purdon <[email protected]>
Reply-To: Matthew Purdon <[email protected]>
Return-path: <[email protected]>
X-Mailer: PHP5.3.2
Content-Type: text/plain; charset="UTF-8"
*/
?>一些速度测试
<?php
// 测试结果
$array1 = test('array_walk');
$array2 = test('array_walk_list_each');
$array3 = test('array_walk_foreach1');
$array4 = test('array_walk_foreach2');
// 检查数组是否相等
var_dump($array1 == $array2, $array1 == $array3, $array1 == $array4);
// 测试函数 1
function array_walk_list_each(&$array, $function, $userData = null) {
while ( list($key, $value) = each($array) )
$function($array[$key], $key, $userData);
}
// 测试函数 2
function array_walk_foreach1(&$array, $function, $userData = null) {
foreach ($array as $key => &$value )
$function($value, $key, $userData);
}
// 测试函数 3
function array_walk_foreach2(&$array, $function, $userData = null) {
foreach ($array as $key => $value )
$function($array[$key], $key, $userData);
}
function some_function(&$value, $key, $userData) {
$value = "$key => $userData";
}
function test($function, $count = 10000, $arrayElements = 1000) {
echo $function, ' ... ';
$array = array_fill(0, $arrayElements, "some text value");
$timer = microtime(true);
for( $i = 0; ++$i < $count; )
$function($array, 'some_function', 'some user data');
printf("%.3f sec\n", microtime(true) - $timer);
return $array;
}
?>
输出 (PHP 5.4.9-4ubuntu2.2 (cli) (built: Jul 15 2013 18:24:39))
=========================
array_walk ... 13.572 sec
array_walk_list_each ... 0.027 sec
array_walk_foreach1 ... 15.356 sec
array_walk_foreach2 ... 17.416 sec
bool(true)
bool(true)
bool(true)
输出 (PHP 5.5.0 (cli) (built: Jul 16 2013 17:59:42) - 同一台服务器)
=========================
array_walk ... 4.776 sec
array_walk_list_each ... 0.006 sec
array_walk_foreach1 ... 4.482 sec
array_walk_foreach2 ... 5.166 sec
bool(true)
bool(true)
bool(true)
PHP 5.5 的 array_walk 看起来还不错，但是 list each 越来越快了...不幸的是，我花了很长时间试图使用 array_walk 函数将函数的效果永久应用于数组，而我真正想要的是 array_map。对于那些可能对这个函数感到非常沮丧的人来说，这里有一个非常简单但有效的例子...
<?php
$fruits = array("Lemony & Fresh","Orange Twist","Apple Juice");
print_r($fruits);
echo '<br />';
function name_base($key)
{
$name2 = str_replace(" ", "_", $key);
$name3 = str_replace("&", "and", $name2);
$name4 = strtolower($name3);
echo $name4.'<br />';
return $name4;
}
echo '<br />';
$test = array_map('name_base', $fruits);
$fruits_fixed = $test;
echo '<br />';
print_r($fruits_fixed);
?>为了完整起见，必须提到可以使用 PHP 5.3 闭包使用此函数的可能性
<?php
$names = array("D\'Artagnan", "Aramis", "Portos");
array_walk($names, function(&$n) {
$n = stripslashes($n);
});
?>
array_walk 的陷阱是它不返回数组，而是通过引用修改数组。您可以使用 lambda 函数作为第二个参数
<?php
array_walk($myArray, function(&$value, $key){
// 如果你想改变数组的值，那么在 $value 前面的 "&" 是必须的。
});
?>
示例（将正值乘以二）
<?php
$myArray = array(1, 2, 3, 4, 5);
array_walk($myArray, function(&$value, $index){
if ($value > 0) $value *= 2;
});
?>使用闭包，检查和删除数组中的值
<?php
$array = array('foo' => 'bar', 'baz' => 'bat');
array_walk($array, function($val,$key) use(&$array){
if ($val == 'bar') {
unset($array[$key]);
}
});
var_dump($array);使用键作为前缀，并将数组的值拼接成字符串，原始数组保持不变。我使用此方法从数组中创建了一些 SQL 查询。
<?php
function array_implode_prefix($outer_glue, $arr, $inner_glue, $prefix=false){
array_walk( $arr , "prefix", array($inner_glue, $prefix) );
return implode($outer_glue, $arr);
}
function prefix(&$value, $key, array $additional){
$inner_glue = $additional[0];
$prefix = isset($additional[1])? $additional[1] : false;
if($prefix === false) $prefix = $key;
$value = $prefix.$inner_glue.$value;
}
//Example 1:
$order_by = array("3"=>"ASC", "2"=>"DESC", "7"=>"ASC");
echo array_implode_prefix(",", $order_by, " ");
//Output: 3 ASC,2 DESC,7 ASC
//Example 2:
$columns = array("product_id", "category_id", "name", "description");
$table = "product";
echo array_implode_prefix(", ", $columns, ".", $table);
//Output:product.product_id, product.category_id, product.name, product.description
//Example 3 (function prefix) won't really be used on its own
$pre= "vacation";
$value = "lalaland";
prefix($value, $pre, array("."));
echo $value;
//Output: vacation.lalaland
?>此函数可以将一个数组中的值添加到另一个数组中
<?php
echo '<pre>';
// example code
$a = [ 1, 2, 3, 4, 5, 6];
$c = [10,20,30,40,50,60];
array_walk($a,
function(&$item, $key, $y) { $item += $y[$key];},
$c
);
print_r($a);
// result
Array
(
[0] => 11
[1] => 22
[2] => 33
[3] => 44
[4] => 55
[5] => 66
)我一直在寻找修剪数组中所有元素的方法，我发现这是最简单的解决方案
<?php
array_walk($ids, create_function('&$val', '$val = trim($val);'));
?>public function big_endian_array_walk(array $array, $callback) {
end($array);
for($i=sizeof($array);$i>0;$i--) {
$key = key($array);
$value = array_pop($array);
if(preg_match('/^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$/', $value)) {
call_user_func_array($callback, [$value, $key]);
}
}
}public function big_endian_array_walk(array $array, $callback) {
end($array);
for($i=sizeof($array);$i>0;$i--) {
$key = key($array);
$value = array_pop($array);
if(preg_match('/^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$/', $value)) {
call_user_func_array($callback, [$value, $key]);
}
}
}
我只是想从最后一个元素开始遍历。只有在网页浏览器中查看时，示例的输出才是正确的。但是，如果您将其传递给 PHP-CLI，您将看到额外的 HTML 换行符。当我使用 PHP 5.2.5 将第三个参数以引用方式传递时，
发生了这种情况：警告：在运行时通过引用传递已被弃用 - 按值传递参数...
并且根据 http://bugs.php.net/bug.php?id=19699 在 php.ini 中将 allow_call_time_pass_reference 设置为 true 不会起作用，因此要解决此问题
<?php
array_walk($arrChnOut, create_function('&$v, $k, $arr_rtn', 'if ($k{0}!="_") {$arr_rtn[0]["_".$v[\'ID\']]=$v; unset($arr_rtn[0][$k]);}'), array(&$arrChnOut));
?>对于所有尝试将 trim() 强行塞入 array_walk() 中并找到所有这些解决 array_walk() 向回调传递两个参数问题的技巧的人...
查看 array_map()。
https://php.net/array_map
它简直是太棒了。
记录一下。我本人就是其中之一，在 15 年的 PHP 开发之后，我很高兴地说，我仍在学习新东西。:) 我自己刚发现 array_map()...这是一个简单且易于使用的函数实现。
“原始”函数存在无法取消设置值的问题。
使用我的函数，您可以做到！
<?php
function array_walk_protected(&$a,$s,$p=null)
{
if(!function_exists($s)||!is_array($a))
{
return false;
}
foreach($a as $k=>$v)
{
if(call_user_func_array($s,array(&$a[$k],$k,$p))===false)
{
unset($a[$k]);
}
}
}
function get_name(&$e,$i,$p)
{
echo "$i: $e<br>";
return false;
}
$m=array('d'=>'33','Y'=>55);
array_walk_protected($m,'get_name');
var_dump($m); //returns array(0) { }
?>
我称之为 array_walk_protected，因为它可以防止使用原始函数取消设置值时发生的意外行为。
要删除元素，只需返回 false！
不需要做其他任何事情！
在您创建的函数中取消设置 $e 将保持数组原样，没有任何变化！
顺便说一下，如果 $a 不是数组或 $s 不是字符串，则函数将返回 false！
限制：它只能运行用户定义的函数。
我希望你喜欢它！您好，
如果你想将两个数组中具有相同键的值相加
<?php
function add(&$item,$key,$search) {
$item += (is_array($search))?((isset($search[$key]))?$search[$key]:0):0;
}
$a = ["orange" => 2, "banana" => 3, "apple" => 1];
$b = ["orange" => 1, "apple" => 4];
array_walk($c,"add",$b);
echo "<pre>".print_r($c,true)."</pre>";
?>
这将输出
"orange" => 3,
"banana" => 3,
"apple" => 5如果你想修改多维数组的每个值，请使用这里使用的函数
<?php
$array = array (1=>1, 2=> 2, 3 => array(1=>11, 2=>12, 3=>13));
$text = "test";
function modarr(&$array, $text) {
foreach ($array as $key => $arr) {
if(is_array($arr)) $res[$key] = modarr(&$arr,$text);
// 修改函数在这里
else $res[$key] = $arr.$text;
}
return $res;
}
$erg = modarr($array, $text);
print_r($erg);
?>
结果将是
<?php
Array ( [1] => 1test [2] => 2test [3] => Array ( [1] => 11test [2] => 12test [3] => 13test ) )
?>您想清除用户在表单字段中添加的空格吗…？
只需使用…
class SomeVeryImportantClass
{
...
public function mungeFormData(&$data)
{
array_walk($data, array($this, 'munge'));
}
private function munge(&$value, &$key)
{
if(is_array($value))
{
$this->mungeFormData($value);
}
else
{
$value = trim($value);
}
}
...
}
所以…
$obj = new SomeVeryImportantClass;
$obj->mungeFormData($_POST);
___
eNc如果您在函数内部使用全局临时返回数组，则可以使用 array_walk 更改键或值。例如
$array = ['a'=>10, 'b'=>20];
$sequence = array ();
$newArray = array_values(array_walk($array, 'fn'));
function fn(&$val,$key){
global $sequence;
$sequence [] = $val;
}
无需担心内部指针在子数组中的位置。现在您有了倒带的、以 0 为基准的新数组，而不是字符串键。我在使用此函数时遇到了一些问题 - 它不想应用 PHP 定义的函数。因此我决定编写自己的函数 - 这里就是。我不得不使用一些泛型编程技巧，没有真正检查速度（我认为它可能很慢）… 我相信它可以更好，但我不知道怎么做 - 嗯，我认为多数组支持和递归会很棒。那么？
原型
bool arrayWalk(array &$arry, callback $callback, mixed $params=false)
<?php
function arrayWalk(&$arry, $callback, $params=false) {
$P=array(""); // 参数
$a=""; // 参数字符串 :)
if($params !== false) { // 添加参数
if(is_array($params)) { // 多个附加参数
foreach($params as $par)
{ $P[]=$par; }
}
else // 只需一个额外的
{ $P[]=$params; }
}
for( // 创建参数字符串
$i=0; isset($P[$i]); ++$i
)
{ $a.='$'.chr($i + 97).', '; } // 随机参数名
$a=substr($a, 0, -2); // 去掉最后一个逗号和两个空格
$func=create_function($a, 'return '.$callback.'('.$a.');'); // 泛型函数
if(is_callable($func)) {
for( // 遍历数组
$i=0; isset($arry[$i]); ++$i
) {
$P[0]=$arry[$i]; // 第一个元素必须是第一个参数 - 数组值
$arry[$i] = call_user_func_array($func, $P); // 将泛型函数获得的新值赋值
}
}
else
{ return false; } // 失败 - 函数不可调用
return true; // 成功！
} // arrayWalk()
?>
到目前为止，我注意到一个大问题 - 例如，如果你想对数组使用 str_replace，你就会失败 - 仅仅是因为 str_replace 的参数顺序，其中修改的字符串是第三个参数，而不是 arrayWalk 所需的第一个参数。
所以，还有一些工作要做…注意“array ($this, method)” 结构。如果您想在“method”内部更改“$this”对象中的成员，您应该像这样构造回调
$callback[] = &$this;
$callback[] = method;
array_walk ($input, $callback);
使用“appletalk”建议的 array() 方法创建回调会导致将 $this 的副本传递给 method，而不是原始对象，因此 method 对对象所做的任何更改将在 array_walk() 返回时丢失。虽然您可以使用“array(&$this, method)”构造回调，但我认为这依赖于已弃用的运行时按引用传递机制，该机制可能会在 PHP 的未来版本中删除。最好现在不要依赖于此功能，而是在将来不得不跟踪并修复它。使用键过滤数组。
<?php
$product_1 = 'test';
$product_2 = 'test 2';
function array_key_filter($array,$callback = 'trim')
{
$filtered = array();
array_walk($array,function ($degeri,$degisken_adi) use (&$filtered,$callback)
{
if($callback($degisken_adi))
{
$filtered[$degisken_adi] = $degeri;
}
});
return $filtered;
}
#使用
$degiskenler = array_key_filter(get_defined_vars(),function($key)
{
return strpos($key,'product_') === 0;
});
print_r($degiskenler);
?>
output
Array
(
[product_1] => test
[product_2] => test 2
)