DarCas Sandbox

La funzione array_map(), nativa di PHP, applica una funzione callback, passata come primo parametro, a tutti gli elementi di uno o più array, passati come ulteriori parametri.

Questa funzione ha una limitazione: non è in grado di processare array multidimensionali. In altre parole, non è una funzione ricorsiva.

Come fare per avere una funzione array_map() che sia ricorsiva? Semplice, basta farsela da soli!

Per poterla creare dobbiamo utilizzare la funzione func_get_args(), func_num_args() e call_user_func(). Poi con un pò di foreach e if siamo pronti a realizzare la nostra funzione ricorsiva.

Le prime due hanno funzione introspettiva. Quando richiamate all’interno di una funzione, sono in grado, rispettivamente, di indicare quali e quanti argomenti sono stati passati alla funzione. Queste due funzioni ci permettono di passare “infiniti” array alla nostra funzione; array sui quali sarà eseguita la funzione callback, passato come primo parametro.

La terza funzione ha il compito di eseguire la funzione callback, e ci serve per elaborare i valori degli elementi dell’array.

Concettualmente la funzione lavora nel seguente modo:

1. Vedo quanti argomenti sono stati passati, se sono almeno due, il primo argomento è la callback, il secondo è l’array;
2. Con una interazione foreach, leggo i valori degli elementi dell’array: se il valore è un altro array, lo passo come parametro alla stessa funzione che stiamo scrivendo, altrimenti eseguo la funzione callback sull’elemento;
3. Restituito un nuovo array con tutti gli elementi elaborati.

Implemento anche qualche sistema di controllo, e per farlo mi avvalgo delle potenzialità del PHP 5 e del costrutto try/catch.

Il codice è il seguente:

/** * Applica la funzione callback a tutti gli elementi dell'array dato (ricorsiva) * * @param callback * @param array [, array $... ] * @return array */ function array_map_recursive ($callback, $array) { try { $args = func_get_args(); $num_args = func_num_args(); switch ($num_args) { case 0: case 1: throw new Exception('Wrong parameter count for array_map_recursive()'); break; default: $callback = array_shift($args); if (!function_exists($callback)) throw new Exception("array_map_recursive(): The first argument, '{$callback}', should be a valid callback"); if ($num_args == 2) { if (!is_array($args[0])) throw new Exception('array_map_recursive(): Argument #2 should be an array'); foreach ($args[0] as $key => $value) { if (is_array($value)) $return[$key] = array_map_recursive($callback, $value); else $return[$key] = call_user_func($callback, $value); } } else { foreach ($args as $index => $array) { if (!is_array($array)) throw new Exception('array_map_recursive(): Argument #' . ($index + 2) . ' should be an array'); foreach ($array as $key => $value) { if (is_array($value)) $returns[$key] = array_map_recursive($callback, $value); else $returns[$key] = call_user_func($callback, $value); } $return[] = $returns; } } return $return; } } catch (Exception $e) { $trace = $e->getTrace(); exit('<b>Warning: </b>' . $e->getMessage() . " in <b>{$trace[0]['file']}</b> on line <b>{$trace[0]['line']}</b>"); } }

Avere a disposizione una funzione di questo tipo è molto comodo, ad esempio per elaborare le variabile superglobali POST o GET prima di visualizzarli o di salvarli. Con una funzione di questo tipo facciamo tutte le operazioni in un colpo solo e senza correre il rischio che ci sia una situazione anomale nel caso di array multidimensionali.

Per evitare incompatibilità future, può essere utile racchiudere la funzione tra:

if (!function_exists('array_map_recursive')) { // function array_map_recursive(); }

In questo modo se dovesse essere implementata nel futuro, tale funzione non andrà in conflitto – generando il warning – con quella che sarà nativa di PHP.