vacios - eliminar valores de un arreglo php

Eliminar de forma recursiva elementos vacíos y subarrays de una matriz multidimensional

Question

Parece que no puedo encontrar una solución simple y directa al viejo problema de eliminar elementos vacíos de arreglos en PHP.

Mi matriz de entrada puede tener este aspecto:

Array ( [0] => Array ( [Name] => [EmailAddress] => ) ) 

(Y así sucesivamente, si hay más datos, aunque puede que no haya ...)

Si se parece a lo anterior, quiero que esté completamente vacío después de procesarlo.

Así que print_r($array); saldría:

Array ( )

Si ejecuto $arrayX = array_filter($arrayX); Todavía tengo la misma salida de print_r . Sin embargo, en todas partes que he visto, esta es la forma más sencilla de eliminar elementos de una matriz vacía en PHP5.

También probé $arrayX = array_filter($arrayX,''empty_array''); pero tengo el siguiente error:

Advertencia: array_filter () [function.array-filter]: el segundo argumento, ''empty_array'', debe ser una devolución de llamada válida

¿Qué estoy haciendo mal?

Answer 1

Hay numerosos ejemplos de cómo hacer esto. Puede probar los docs , por docs (vea el primer comentario).

function array_filter_recursive($array, $callback = null) {
    foreach ($array as $key => & $value) {
        if (is_array($value)) {
            $value = array_filter_recursive($value, $callback);
        }
        else {
            if ( ! is_null($callback)) {
                if ( ! $callback($value)) {
                    unset($array[$key]);
                }
            }
            else {
                if ( ! (bool) $value) {
                    unset($array[$key]);
                }
            }
        }
    }
    unset($value);

    return $array;
}

Concedido, este ejemplo no usa realmente array_filter pero se entiende el punto.

Answer 2

Intenta con:

$array = array_filter(array_map(''array_filter'', $array));

Ejemplo:

$array[0] = array(
   ''Name''=>'''',
   ''EmailAddress''=>'''',
);
print_r($array);

$array = array_filter(array_map(''array_filter'', $array));

print_r($array);

Salida:

Array
(
    [0] => Array
        (
            [Name] => 
            [EmailAddress] => 
        )
)

Array
(
)

Answer 3

Intente usar array_map() para aplicar el filtro a cada matriz en $array :

$array = array_map(''array_filter'', $array);
$array = array_filter($array);

Demostración: http://codepad.org/xfXEeApj

Answer 4

La respuesta aceptada no hace exactamente lo que pidió el OP. Si desea eliminar de forma recursiva TODOS los valores que se evalúan como falsos, incluidas las matrices vacías, utilice la siguiente función:

function array_trim($input) {
    return is_array($input) ? array_filter($input, 
        function (& $value) { return $value = array_trim($value); }
    ) : $input;
}

O puede cambiar la condición de devolución según sus necesidades, por ejemplo:

{ return !is_array($value) or $value = array_trim($value); }

Si solo quieres eliminar matrices vacías. O puede cambiar la condición para solo probar "" o falso o nulo, etc ...

Answer 5

Siguiendo la sugerencia de Jeremyharris, así es como necesitaba cambiarla para que funcione:

function array_filter_recursive($array) {
   foreach ($array as $key => &$value) {
      if (empty($value)) {
         unset($array[$key]);
      }
      else {
         if (is_array($value)) {
            $value = array_filter_recursive($value);
            if (empty($value)) {
               unset($array[$key]);
            }
         }
      }
   }

   return $array;
}

Answer 6

array_filter() no es sensible al tipo por defecto. Esto significa que cualquier valor cero-ish , false-y, null, vacío será eliminado. Mis enlaces a seguir demostrarán este punto.

La matriz de entrada de muestra del OP es bidimensional. Si la estructura de datos es estática, entonces la recursión no es necesaria. Para cualquier persona que quiera filtrar los valores de longitud cero de una matriz multidimensional, proporcionaré un método estático de 2 tenues y un método recursivo.

Static 2-dim Array : este código realiza un filtro de "cero-seguro" en los elementos de segundo nivel y luego elimina las subarreglas vacías: ( Vea esta demostración para ver cómo funciona este método con diferentes datos de arreglos (más complejos) )

$array=[
    [''Name''=>'''',''EmailAddress''=>'''']
];   

var_export(
    array_filter(  // remove the 2nd level in the event that all subarray elements are removed
        array_map(  // access/iterate 2nd level values
            function($v){
                return array_filter($v,''strlen'');  // filter out subarray elements with zero-length values
            },$array  // the input array
        )
    )
);

Aquí está el mismo código que una sola línea:

var_export(array_filter(array_map(function($v){return array_filter($v,''strlen'');},$array)));

Salida (según lo especificado originalmente por el OP):

array (
)

* Si no desea eliminar los subarreglos vacíos, simplemente elimine la array_filter() externa array_filter() .

Método recursivo para matrices multidimensionales de profundidad desconocida : cuando se desconoce el número de niveles en una matriz, la recursión es una técnica lógica. El siguiente código procesará cada subarreglo, eliminando los valores de longitud cero y cualquier subarrays vacío a medida que avanza. Aquí hay una demostración de este código con algunas entradas de muestra.

$array=[
    [''Name''=>'''',''Array''=>[''Keep''=>''Keep'',''Drop''=>[''Drop2''=>'''']],''EmailAddress''=>'''',''Pets''=>0,''Children''=>null],
    [''Name''=>'''',''EmailAddress''=>'''',''FavoriteNumber''=>''0'']
];

function removeEmptyValuesAndSubarrays($array){
   foreach($array as $k=>&$v){
        if(is_array($v)){
            $v=removeEmptyValuesAndSubarrays($v);  // filter subarray and update array
            if(!sizeof($v)){ // check array count
                unset($array[$k]);
            }
        }elseif(!strlen($v)){  // this will handle (int) type values correctly
            unset($array[$k]);
        }
   }
   return $array;
}

var_export(removeEmptyValuesAndSubarrays($array));

Salida:

array (
  0 => 
  array (
    ''Array'' => 
    array (
      ''Keep'' => ''Keep'',
    ),
    ''Pets'' => 0,
  ),
  1 => 
  array (
    ''FavoriteNumber'' => ''0'',
  ),
)

Si alguien descubre una matriz de entrada que rompe mi método recursivo, publíquela (en su forma más simple) como un comentario y actualizaré mi respuesta.