php - Eliminar elementos de matriz vacíos


Algunos elementos en mi matriz son cadenas vacías basadas en lo que el usuario ha enviado. Necesito eliminar esos elementos. Tengo esto:

foreach($linksArray as $link)
{
    if($link == '')
    {
        unset($link);
    }
}
print_r($linksArray);

Pero no funciona, $linksArray todavía tiene elementos vacíos. También he intentado hacerlo con la función empty() pero el resultado es el mismo.


Answers


Como se trata de una variedad de cadenas, simplemente puede usar array_filter() , que maneja todo esto de manera conveniente para usted:

print_r(array_filter($linksArray));

Tenga en cuenta que si no se proporciona una devolución de llamada , se eliminarán todas las entradas de la matriz FALSE (ver conversión a booleano ). Por lo tanto, si necesita conservar elementos que son, por ejemplo, cadena exacta '0' , necesitará una devolución de llamada personalizada:

// PHP < 5.3
print_r(array_filter($linksArray, create_function('$value', 'return $value !== "";')));

// PHP 5.3 and later
print_r(array_filter($linksArray, function($value) { return $value !== ''; }));



Puede usar array_filter para eliminar elementos vacíos:

$emptyRemoved = array_filter($linksArray);

Si tiene (int) 0 en su matriz, puede usar lo siguiente:

$emptyRemoved = remove_empty($linksArray);

function remove_empty($array) {
  return array_filter($array, '_remove_empty_internal');
}

function _remove_empty_internal($value) {
  return !empty($value) || $value === 0;
}

EDITAR: Quizás sus elementos no estén vacíos per se pero contengan uno o más espacios ... Puede usar lo siguiente antes de usar array_filter

$trimmedArray = array_map('trim', $linksArray);






    $myarray = array_filter($myarray, 'strlen');  //removes null values but leaves "0"
    $myarray = array_filter($myarray);            //removes all null values



La respuesta más popular sobre este tema es absolutamente INCORRECTA.

Considere el siguiente script PHP:

<?php
$arr = array('1', '', '2', '3', '0');
// Incorrect:
print_r(array_filter($arr));
// Correct:
print_r(array_filter($arr, 'strlen'));

¿Por qué es esto? Debido a que una cadena que contiene un solo carácter '0' también evalúa a booleano falso, por lo tanto, aunque no es una cadena vacía, se filtrará. Eso sería un error.

Pasar la función strlen incorporada como la función de filtrado funcionará, porque devuelve un entero distinto de cero para una cadena no vacía y un entero cero para una cadena vacía. Los enteros distintos de cero siempre se evalúan como verdaderos cuando se convierten a booleanos, mientras que los enteros cero siempre los evalúan como falsos cuando se convierten a booleanos.

Entonces, la respuesta absoluta, definitiva y correcta es:

$arr = array_filter($arr, 'strlen');



Puedes simplemente hacer

array_filter($array)

array_filter: "Si no se proporciona devolución de llamada, se eliminarán todas las entradas de entrada igual a FALSE". Esto significa que los elementos con valores NULL, 0, '0', '', FALSE, array () se eliminarán también.

La otra opción es hacer

array_diff($array, array(''))

que eliminará elementos con valores NULL, '' y FALSE.

Espero que esto ayude :)

ACTUALIZAR

Aquí hay un ejemplo.

$a = array(0, '0', NULL, FALSE, '', array());

var_dump(array_filter($a));
// array()

var_dump(array_diff($a, array(0))) // 0 / '0'
// array(NULL, FALSE, '', array());

var_dump(array_diff($a, array(NULL))) // NULL / FALSE / ''
// array(0, '0', array())

Para resumir:

  • 0 o '0' eliminará 0 y '0'
  • NULL, FALSE o '' eliminará NULL, FALSE y ''



foreach($linksArray as $key => $link) 
{ 
    if($link === '') 
    { 
        unset($linksArray[$key]); 
    } 
} 
print_r($linksArray); 



Otro revestimiento para eliminar los elementos vacíos ("" cadena vacía) de su matriz.

$array = array_filter($array, create_function('$a','return $a!=="";'));

Nota: Este código mantiene deliberadamente nulo, 0 y elementos falsos.

O tal vez quieras recortar tus elementos de matriz primero:

$array = array_filter($array, create_function('$a','return trim($a)!=="";'));

Nota: Este código también elimina elementos nulos y falsos.




La respuesta más votada es errónea o, al menos, no completamente cierta, ya que el OP solo habla de cadenas en blanco. Aquí hay una explicación completa:

¿Qué significa vacío ?

En primer lugar, debemos acordar qué significa vacío . ¿Quiere filtrar?

  1. solo las cadenas vacías ("")?
  2. los valores estrictamente falsos ? ( $element === false )
  3. los valores falsey ? (es decir, 0, 0.0, "", "0", NULL, array () ...)
  4. el equivalente de la función empty() de PHP?

¿Cómo filtra los valores?

Para filtrar cadenas vacías solamente :

$filtered = array_diff($originalArray, array(""));

Para filtrar solo los valores estrictamente falsos , debe usar una función de devolución de llamada :

$filtered = array_diff($originalArray, 'myCallback');
function myCallback($var) {
    return $var === false;
}

La devolución de llamada también es útil para cualquier combinación en la que desee filtrar los valores "falsey", excepto algunos. (Por ejemplo, filtra cada null y false , etc., dejando solo 0 ):

$filtered = array_filter($originalArray, 'myCallback');
function myCallback($var) {
    return ($var === 0 || $var === '0');
}

El tercer y cuarto caso son (para nuestros fines al fin) equivalentes, y para eso todo lo que tiene que usar es el predeterminado:

$filtered = array_filter($originalArray);



Uso la siguiente secuencia de comandos para eliminar elementos vacíos de una matriz

for ($i=0; $i<$count($Array); $i++)
  {
    if (empty($Array[$i])) unset($Array[$i]);
  }



$a = array(1, '', '', '', 2, '', 3, 4);
$b = array_values(array_filter($a));

print_r($b)



Si está trabajando con una matriz numérica y necesita volver a indexar la matriz después de eliminar los elementos vacíos, use la función array_values :

array_values(array_filter($array));

Ver también: matriz de reindexación PHP?




Tenía que hacer esto para mantener un valor de matriz de (cadena) 0

$url = array_filter($data, function ($value) {
  return (!empty($value) || $value === 0 || $value==='0');
});



Para una matriz multidimensional

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



$out_array = array_filter($input_array, function($item) 
{ 
    return !empty($item['key_of_array_to_check_whether_it_is_empty']); 
}
);



Solo quiero contribuir con una alternativa a los bucles ... también abordando las lagunas en las claves ...

En mi caso, quería mantener las teclas de matriz secuenciales cuando la operación estaba completa (no solo los números impares, que es lo que estaba mirando. Configurar el código para buscar solo las teclas impares me parecía frágil y no favorable para el futuro).

Estaba buscando algo más como esto: http://gotofritz.net/blog/howto/removing-empty-array-elements-php/

La combinación de array_filter y array_slice hace el truco.

$example = array_filter($example); $example = array_slice($example,0);

No tengo idea de las eficiencias o puntos de referencia, pero funciona.




function trim_array($Array)
{
        foreach ($Array as $value)
                if (trim($value) == "")
                {
                        $index = array_search($value, $Array);
                        unset($Array[$index]);
                }
        return $Array;
}



foreach($arr as $key => $val){
   if (empty($val)) unset($arr[$key];
}



use la función array_filter para eliminar valores vacíos:

$linksArray = array_filter($linksArray);
print_r($linksArray);



Solo una línea: Actualización (gracias a @suther):

$array_without_empty_values = array_filter($array);



$my = ("0"=>" ","1"=>"5","2"=>"6","3"=>" ");   

foreach ($my as $key => $value) {
    if (is_null($value)) unset($my[$key]);
}

foreach ($my as $key => $value) {
    echo   $key . ':' . $value . '<br>';
} 

salida

1: 5

2: 6




Eliminar elementos de matriz vacíos

function removeEmptyElements(&$element)
{
    if (is_array($element)) {
        if ($key = key($element)) {
            $element[$key] = array_filter($element);
        }

        if (count($element) != count($element, COUNT_RECURSIVE)) {
            $element = array_filter(current($element), __FUNCTION__);
        }

        return $element;
    } else {
        return empty($element) ? false : $element;
    }
}

$data = array(
    'horarios' => array(),
    'grupos' => array(
        '1A' => array(
            'Juan' => array(
                'calificaciones' => array(
                    'Matematicas' => 8,
                    'Español' => 5,
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => 20,
                    'febrero' => 10,
                    'marzo' => '',
                )
            ),
            'Damian' => array(
                'calificaciones' => array(
                    'Matematicas' => 10,
                    'Español' => '',
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => 20,
                    'febrero' => '',
                    'marzo' => 5,
                )
            ),
        ),
        '1B' => array(
            'Mariana' => array(
                'calificaciones' => array(
                    'Matematicas' => null,
                    'Español' => 7,
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => null,
                    'febrero' => 5,
                    'marzo' => 5,
                )
            ),
        ),
    )
);

$data = array_filter($data, 'removeEmptyElements');
var_dump($data);

¡funciona!




prueba esto ** ** Ejemplo

$or = array(
        'PersonalInformation.first_name' => $this->request->data['User']['first_name'],
        'PersonalInformation.last_name' => $this->request->data['User']['last_name'],
        'PersonalInformation.primary_phone' => $this->request->data['User']['primary_phone'],
        'PersonalInformation.dob' => $this->request->data['User']['dob'],
        'User.email' => $this->request->data['User']['email'],
    );



 $or = array_filter($or);

    $condition = array(
        'User.role' => array('U', 'P'),
        'User.user_status' => array('active', 'lead', 'inactive'),
        'OR' => $or
    );



En breve:

Este es mi código sugerido:

$myarray =  array_values(array_filter(array_map('trim', $myarray), 'strlen'));

Explicación:

Creo que use array_filter es bueno, pero no lo suficiente, porque los valores son como el space y \n , ... mantén el array y esto suele ser malo.

Así que sugiero que uses la mezcla array_filter y array_map .

array_map es para recortar, array_filter es para eliminar valores vacíos, strlen es para mantener 0 value, y array_values es para volver a indexar si es necesario.

Muestras:

$myarray = array("\r", "\n", "\r\n", "", " ", "0", "a");

// "\r", "\n", "\r\n", " ", "a"
$new1 = array_filter($myarray);

// "a"
$new2 = array_filter(array_map('trim', $myarray));

// "0", "a"
$new3 = array_filter(array_map('trim', $myarray), 'strlen');

// "0", "a" (reindex)
$new4 = array_values(array_filter(array_map('trim', $myarray), 'strlen'));

var_dump($new1, $new2, $new3, $new4);

Resultados:

array(5) {
  [0]=>
" string(1) "
  [1]=>
  string(1) "
"
  [2]=>
  string(2) "
"
  [4]=>
  string(1) " "
  [6]=>
  string(1) "a"
}
array(1) {
  [6]=>
  string(1) "a"
}
array(2) {
  [5]=>
  string(1) "0"
  [6]=>
  string(1) "a"
}
array(2) {
  [0]=>
  string(1) "0"
  [1]=>
  string(1) "a"
}

Prueba en línea:

http://phpio.net/s/5yg0