Certains éléments de mon tableau sont des chaînes vides basées sur ce que l'utilisateur a soumis. Je dois supprimer ces éléments. J'ai ceci:

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

Mais ça ne marche pas. $linksArraya encore des éléments vides. J'ai également essayé de le faire avec la empty()fonction, mais le résultat est le même.

Comme vous avez affaire à un tableau de chaînes, vous pouvez simplement utiliser array_filter()ce qui gère tout cela à votre place:

print_r(array_filter($linksArray));

Gardez à l'esprit que si aucun rappel n'est fourni , toutes les entrées de tableau égales à FALSE(voir conversion en booléen ) seront supprimées. Donc, si vous devez conserver des éléments qui sont par exemple une chaîne exacte '0', vous aurez besoin d'un rappel personnalisé:

// PHP 7.4 and later
print_r(array_filter($linksArray, fn($value) => !is_null($value) && $value !== ''));

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

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

Vous pouvez utiliser array_filterpour supprimer des éléments vides:

$emptyRemoved = array_filter($linksArray);

Si vous en avez (int) 0dans votre tableau, vous pouvez utiliser ce qui suit:

$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;
}

EDIT: Peut-être que vos éléments ne sont pas vides en soi mais contiennent un ou plusieurs espaces ... Vous pouvez utiliser ce qui suit avant d'utiliserarray_filter

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

La réponse la plus populaire sur ce sujet est absolument INCORRECTE.

Considérez le script PHP suivant:

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

Pourquoi est-ce? Parce qu'une chaîne contenant un seul caractère «0» est également évaluée comme booléenne false, donc même si ce n'est pas une chaîne vide, elle sera toujours filtrée. Ce serait un bug.

Le passage de la fonction strlen intégrée en tant que fonction de filtrage fonctionnera, car il renvoie un entier non nul pour une chaîne non vide et un entier zéro pour une chaîne vide. Les entiers non nuls sont toujours évalués comme vrais lorsqu'ils sont convertis en booléens, tandis que les entiers nuls sont toujours évalués comme faux lorsqu'ils sont convertis en booléens.

Donc, la réponse absolue, définitive et correcte est:

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

$linksArray = array_filter($linksArray);

"Si aucun rappel n'est fourni, toutes les entrées d'entrée égales à FALSE seront supprimées." - http://php.net/manual/en/function.array-filter.php

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

Tu peux juste faire

array_filter($array)

array_filter: "Si aucun rappel n'est fourni, toutes les entrées d'entrée égales à FALSE seront supprimées." Cela signifie que les éléments avec les valeurs NULL, 0, '0', '', FALSE, array () seront également supprimés.

L'autre option fait

array_diff($array, array(''))

qui supprimera les éléments avec les valeurs NULL, '' et FALSE.

J'espère que cela t'aides :)

MISE À JOUR

Voici un exemple.

$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())

Pour résumer:

• 0 ou '0' supprimera 0 et '0'
• NULL, FALSE ou '' supprimera NULL, FALSE et ''

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

Un autre liner pour supprimer les éléments vides ("" chaîne vide) de votre tableau.

$array = array_filter($array, function($a) {return $a !== "";});

Remarque: Ce code maintient délibérément null, 0et des falseéléments.

Ou peut-être souhaitez-vous d'abord couper vos éléments de tableau:

$array = array_filter($array, function($a) {
    return trim($a) !== "";
});

Remarque: Ce code supprime également les éléments nullet false.

En bref:

Voici mon code suggéré:

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

Explication:

Je pense que l'utilisation array_filterest bonne, mais pas suffisante, car les valeurs sont comme spaceet \n, ... gardez dans le tableau et c'est généralement mauvais.

Donc , je vous suggère d' utiliser le mélange array_filteret array_map.

array_mapsert à rogner, array_filterà supprimer les valeurs vides, strlenà conserver la 0valeur et array_valuesà réindexer si vous en avez besoin.

Échantillons:

$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);

Résultats:

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"
}

Test en ligne:

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

Si vous travaillez avec un tableau numérique et devez réindexer le tableau après avoir supprimé les éléments vides, utilisez la fonction array_values :

array_values(array_filter($array));

Voir aussi: tableau de réindexation PHP?

La réponse la plus votée est fausse ou du moins pas complètement vraie car l'OP ne parle que de chaînes vides. Voici une explication approfondie:

Que signifie vide ?

Tout d'abord, nous devons convenir de ce que signifie vide . Voulez-vous filtrer:

1. les chaînes vides uniquement ("")?
2. les valeurs strictement fausses ? ( $element === false)
3. les valeurs de falsey ? (ie 0, 0.0, "", "0", NULL, array () ...)
4. l'équivalent de la empty()fonction de PHP ?

Comment filtrez-vous les valeurs

Pour filtrer uniquement les chaînes vides :

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

Pour filtrer uniquement les valeurs strictement fausses , vous devez utiliser une fonction de rappel :

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

Le rappel est également utile pour toute combinaison dans laquelle vous souhaitez filtrer les valeurs "falsey", à l'exception de certaines. (Par exemple, filtrez chaque nullet false, etc., en laissant uniquement 0):

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

Les troisième et quatrième cas sont (pour nos fins enfin) équivalents, et pour cela tout ce que vous avez à utiliser est la valeur par défaut:

$filtered = array_filter($originalArray);

Je devais le faire afin de garder une valeur de tableau de (chaîne) 0

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

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

print_r($b)

Pour tableau multidimensionnel

$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']); 
}
);

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

J'utilise le script suivant pour supprimer des éléments vides d'un tableau

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

Je veux juste contribuer à une alternative aux boucles ... combler également les lacunes dans les clés ...

Dans mon cas, je voulais conserver les clés de tableau séquentielles une fois l'opération terminée (pas seulement les nombres impairs, c'est ce que je regardais. La configuration du code pour rechercher uniquement les clés impaires m'a semblé fragile et pas pour l'avenir.)

Je cherchais quelque chose de plus comme ceci: http://gotofritz.net/blog/howto/removing-empty-array-elements-php/

La combinaison de array_filter et array_slice fait l'affaire.

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

Aucune idée sur l'efficacité ou les repères mais ça marche.

$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>';
} 

production

1: 5

2: 6

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

Une seule ligne: mise à jour (grâce à @suther):

$array_without_empty_values = array_filter($array);

utilisez la array_filterfonction pour supprimer les valeurs vides:

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

Supprimer les éléments de tableau vides

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);

Ça marche!

Selon votre méthode, vous pouvez simplement attraper ces éléments dans un autre tableau et utiliser celui-ci comme suit,

foreach($linksArray as $link){
   if(!empty($link)){
      $new_arr[] = $link
   }
}

print_r($new_arr);

essayez ceci ** ** Exemple

$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
    );

Je pense que array_walk est beaucoup plus approprié ici

$linksArray = array('name', '        ', '  342', '0', 0.0, null, '', false);

array_walk($linksArray, function(&$v, $k) use (&$linksArray){
    $v = trim($v);
    if ($v == '')
        unset($linksArray[$k]);
});
print_r($linksArray);

Production:

Array
(
    [0] => name
    [2] => 342
    [3] => 0
    [4] => 0
)

• Nous nous sommes assurés que les valeurs vides sont supprimées même si l'utilisateur ajoute plus d'un espace

• Nous avons également coupé les espaces vides des valeurs valides

• Enfin, seuls (null), (Boolean False) et ('') seront considérés comme des chaînes vides

Pour Falsece qui est de la supprimer, car AFAIK, l'utilisateur ne peut pas soumettre de valeurs booléennes.

Avec ce genre de choses, il vaut mieux être explicite sur ce que vous voulez et ce que vous ne voulez pas.

Cela aidera le prochain gars à ne pas se laisser surprendre par le comportement de array_filter()sans rappel. Par exemple, je me suis retrouvé sur cette question car j'ai oublié si array_filter()supprime NULLou non. J'ai perdu du temps alors que j'aurais pu utiliser la solution ci-dessous et avoir ma réponse.

De plus, la logique est un langage angnostique dans le sens où le code peut être copié dans un autre langage sans avoir à comprendre le comportement d'une fonction php comme array_filterquand aucun rappel n'est passé.

Dans ma solution, il est clair au regard de ce qui se passe. Supprimez une condition pour conserver quelque chose ou ajoutez une nouvelle condition pour filtrer des valeurs supplémentaires.

Ne tenez pas compte de l'utilisation réelle de array_filter()car je ne fais que lui faire un rappel personnalisé - vous pouvez continuer et l'extraire dans sa propre fonction si vous le souhaitez. Je l'utilise juste comme sucre pour une foreachboucle.

<?php

$xs = [0, 1, 2, 3, "0", "", false, null];

$xs = array_filter($xs, function($x) {
    if ($x === null) { return false; }
    if ($x === false) { return false; }
    if ($x === "") { return false; }
    if ($x === "0") { return false; }
    return true;
});

$xs = array_values($xs); // reindex array   

echo "<pre>";
var_export($xs);

Un autre avantage de cette approche est que vous pouvez séparer les prédicats de filtrage en une fonction abstraite qui filtre une seule valeur par tableau et créer une solution composable.

Voir cet exemple et les commentaires en ligne pour la sortie.

<?php

/**
 * @param string $valueToFilter
 *
 * @return \Closure A function that expects a 1d array and returns an array
 *                  filtered of values matching $valueToFilter.
 */
function filterValue($valueToFilter)
{
    return function($xs) use ($valueToFilter) {
        return array_filter($xs, function($x) use ($valueToFilter) {
            return $x !== $valueToFilter;
        });
    };
}

// partially applied functions that each expect a 1d array of values
$filterNull = filterValue(null);
$filterFalse = filterValue(false);
$filterZeroString = filterValue("0");
$filterEmptyString = filterValue("");

$xs = [0, 1, 2, 3, null, false, "0", ""];

$xs = $filterNull($xs);        //=> [0, 1, 2, 3, false, "0", ""]
$xs = $filterFalse($xs);       //=> [0, 1, 2, 3, "0", ""]
$xs = $filterZeroString($xs);  //=> [0, 1, 2, 3, ""]
$xs = $filterEmptyString($xs); //=> [0, 1, 2, 3]

echo "<pre>";
var_export($xs); //=> [0, 1, 2, 3]

Vous pouvez maintenant créer dynamiquement une fonction appelée filterer()using pipe()qui appliquera ces fonctions partiellement appliquées pour vous.

<?php

/**
 * Supply between 1..n functions each with an arity of 1 (that is, accepts
 * one and only one argument). Versions prior to php 5.6 do not have the
 * variadic operator `...` and as such require the use of `func_get_args()` to
 * obtain the comma-delimited list of expressions provided via the argument
 * list on function call.
 *
 * Example - Call the function `pipe()` like:
 *
 *   pipe ($addOne, $multiplyByTwo);
 *
 * @return closure
 */
function pipe()
{
    $functions = func_get_args(); // an array of callable functions [$addOne, $multiplyByTwo]
    return function ($initialAccumulator) use ($functions) { // return a function with an arity of 1
        return array_reduce( // chain the supplied `$arg` value through each function in the list of functions
            $functions, // an array of functions to reduce over the supplied `$arg` value
            function ($accumulator, $currFn) { // the reducer (a reducing function)
                return $currFn($accumulator);
            },
            $initialAccumulator
        );
    };
}

/**
 * @param string $valueToFilter
 *
 * @return \Closure A function that expects a 1d array and returns an array
 *                  filtered of values matching $valueToFilter.
 */
function filterValue($valueToFilter)
{
    return function($xs) use ($valueToFilter) {
        return array_filter($xs, function($x) use ($valueToFilter) {
            return $x !== $valueToFilter;
        });
    };
}

$filterer = pipe(
    filterValue(null),
    filterValue(false),
    filterValue("0"),
    filterValue("")
);

$xs = [0, 1, 2, 3, null, false, "0", ""];
$xs = $filterer($xs);

echo "<pre>";
var_export($xs); //=> [0, 1, 2, 3]