* THIS FUNCTION ONLY VISITS LEAF NODES *

That is to say that if you have a tree of arrays with subarrays of subarrays, only the plain values at the leaves of the tree will be visited by the callback function. The callback function isn't ever called for a nodes in the tree that subnodes (i.e., a subarray). This has the effect as to make this function unusable for most practical situations.

<?php
$arr = [
'one' => ['one_one' => 11, 'one_two' => 12],
'two' => 2
];$counter = 0;array_walk_recursive( $arr, function($value, $key, $counter) {
$counter++;
echo "$value : $counter";
}, $counter);
echo "counter : $counter"; array_walk_recursive( $arr, function($value, $key, &$counter) {
$counter++;
echo "$value : $counter";
}, $counter);array_walk_recursive( $arr, function($value, $key) use (&$counter) {
$counter++;
echo "$value : $counter";
}, $counter);
echo "counter : $counter";

Unfortunately the PHP example given doesn't do this. It actually took me a while to figure out why my function wasn't changing the original array, even though I was passing by reference.

Here's the tip: Don't return any value from the function! Just change the value of $item that you passed in by reference. This is rather counter-intuitive since the vast majority of functions return a value.

<?php
function bad_example($item,$key){
if($key=='test'){
return 'PHP Rocks'; }else{
return $item; }
}function good_example(&$item,$key){
if($key=='test'){
$item='PHP Rocks'; }
}$arr = array('a'=>'1','b'=>'2','test'=>'Replace This');array_walk_recursive($arr,'bad_example');
var_dump($arr);
array_walk_recursive($arr,'good_example');
var_dump($arr);
?>

One other silly thing you might try first is something like this:

<?php
$filtered = array_walk_recursive($unfiltered,'filter_function');
?>

<?php
foreach (new RecursiveIteratorIterator(new RecursiveArrayIterator($candidate), RecursiveIteratorIterator::CATCH_GET_CHILD) as $key => $value) {
echo 'My node ' . $key . ' with value ' . $value . PHP_EOL;
}
?>

<?php
function array_walk_recursive_array(array &$array, callable $callback) {
foreach ($array as $k => &$v) {
if (is_array($v)) {
array_walk_recursive_array($v, $callback);
} else {
$callback($v, $k, $array);
}
}
}
?>

<?php

$results

function

<?php
function trim_by_reference(&$string) {
$string = trim($string);
}
?>

<?php
function array_walk_recursive_referential(&$array, $function, $parameters = array()) {
$reference_function = function(&$value, $key, $userdata) {
$parameters = array_merge(array($value), $userdata[1]);
$value = call_user_func_array($userdata[0], $parameters);
};
array_walk_recursive($array, $reference_function, array($function, $parameters));
}
?>

<?php
function walk_recursive_remove (array $array, callable $callback) {
foreach ($array as $k => $v) {
if (is_array($v)) {
$array[$k] = walk_recursive_remove($v, $callback);
} else {
if ($callback($v, $k)) {
unset($array[$k]);
}
}
}

return

<?php
array_walk_recursive(
$myArray,
function (&$value) {
if () {
$value = 'New value';
}
}
);
?>

<?phpfunction setNodes($data, &$array)
{
$separator = '.'; foreach ($data as $name => $value) {
if (strpos($name, $separator) === false) {
$array[$name] = $value;
} else {
$keys = explode($separator, $name);
$opt_tree =& $array;
while ($key = array_shift($keys)) {
if ($keys) {
if (!isset($opt_tree[$key]) || !is_array($opt_tree[$key])) {
$opt_tree[$key] = array();
}
$opt_tree =& $opt_tree[$key];
} else {
$opt_tree[$key] = $value;
}
}
}
}
}?>

<?php

$x

foreach ($args as $fn) {

takes an array as the first argument, and functions as the other arguments. it applies those functions recursively to the array

<?php

$key

echo

The following example is for usage within a class. To use as a standalone function take it out of the class and rename it. (Example: array_walk_recursive_2)

<?php
class A_Class {

function

if(!

foreach(

if(

if(

function

$array=[1=>[2,5=>[4,2],[7,8=>[3,6]],5],4];

Output

Array ( [0] => 2 [1] => 4 [2] => 2 [3] => 7 [4] => 3 [5] => 6 [6] => 5 [7] => 4 )

//1,2,2,3,6,7,3,1,4,2

function a($array){

print_r(a($arr));

$array=[1=>[2,5=>[4,2],[7,8=>[3,6]],5],4];

Output

Array ( [0] => 2 [1] => 4 [2] => 2 [3] => 7 [4] => 3 [5] => 6 [6] => 5 [7] => 4 )

// var example

// function for "trim" (or your function, use same structure)

// get array

// show array trimmed

/*

array (size=5)

*/

<?phpfunction convert_before_json(&$item, &$key)
{
$item=utf8_encode($item);
}array_walk_recursive($your_array,"convert_before_json");?>

The bug is here: http://bugs.php.net/bug.php?id=42850, and it looks like it will be fixed for 5.3.

If the array that you walk contains other array elements, they will be turned into references. This will happen even if the callback function doesn't take its first argument by reference, and doesn't do anything to the values.

For example, try this:

One workaround is to immediately make a deep copy of the array after calling array_walk_recursive, like this:

$x = chaseToPath ($nd, 'RSS_list/English News',false);

function &chaseToPath (&$wm, $path, $create=false) {

//echo '$wm=<pre>'; var_dump ($wm);echo '</pre>'; die();

$false = false;

function &chase (&$arr, $indexes, $create=false) {

//echo 'sitewide/functions.php --- $r=<pre>'; var_dump ($r); echo '</pre>';