Comment vérifier si un tableau est vide en utilisant PHP?

un tableau vide est falsey en PHP, donc vous n'avez même pas besoin d'utiliser empty() comme d'autres l'ont suggéré.

<?php
$playerList = array();
if (!$playerList) {
    echo "No players";
} else {
    echo "Explode stuff...";
}
// Output is: No players

PHP's empty() détermine si une variable n'existe pas ou a une valeur falsey (comme array() , 0 , null , false , etc).

dans la plupart des cas, vous voulez juste vérifier !$emptyVar . Utilisez empty($emptyVar) si la variable n'a pas été définie et que vous ne l'avez pas on ne veut pas déclencher un E_NOTICE ; IMO c'est généralement une mauvaise idée.

quelques bonnes réponses, mais j'ai juste pensé étendre un peu pour expliquer plus clairement quand PHP détermine si un tableau est vide.

Notes:

un tableau avec une clé (ou des clés) sera déterminé comme non vide par PHP.

comme valeurs de tableau il faut des clés pour exister, avoir des valeurs ou pas dans un tableau ne détermine pas si c'est vide, seulement s'il n'y a pas de clés (Et donc pas de valeurs).

vérifier un tableau avec empty() ne vous dit pas simplement si vous avez des valeurs ou non, il vous dit si le tableau est vide, et les clés font partie d'un tableau.

alors considérez comment vous produisez votre tableau avant de décider quelle méthode de vérification à utiliser.

Par exemple, un tableau aura des clés lorsqu'un utilisateur soumet votre formulaire HTML lorsque chaque formulaire le champ a un nom de tableau (ie name="array[]" ).

Un tableau non vide sera produit pour chaque champ car il y aura des valeurs clés incrémentées automatiquement pour le tableau de chaque champ du formulaire.

prendre ces tableaux par exemple:

/* Assigning some arrays */

// Array with user defined key and value
$ArrayOne = array("UserKeyA" => "UserValueA", "UserKeyB" => "UserValueB");

// Array with auto increment key and user defined value
// as a form field would return with user input
$ArrayTwo[] = "UserValue01";
$ArrayTwo[] = "UserValue02";

// Array with auto incremented key and no value
// as a form field would return without user input
$ArrayThree[] = '';
$ArrayThree[] = '';

si vous faites écho aux touches et aux valeurs des tableaux ci-dessus, vous obtenez ce qui suit:

ARRAY ONE:

[UserKeyA] = > [UserValueA]

[UserKeyB] = > [UserValueB]

ARRAY TWO:

[0] = > [UserValue01]

[1] = > [UserValue02]

ARRAY THREE:

[0] => []

[1] = > []

et tester les tableaux ci-dessus avec empty() renvoie ce qui suit résultats:

TABLEAU:

$ArrayOne n'est pas vide

ARRAY TWO:

$ArrayTwo n'est pas vide

ARRAY THREE:

$Arraytree n'est pas vide

un tableau sera toujours vide lorsque vous assignez un tableau mais ne l'utilisez pas par la suite, tel que:

$ArrayFour = array();

ce sera vide, ie PHP retournera TRUE en utilisant if empty() sur le dessus.

donc si votre tableau a des clés - soit par exemple les noms d'entrée d'un formulaire ou si vous les assignez manuellement (c'est-à-dire créer un tableau avec des noms de colonne de base de données comme les clés mais pas de valeurs/données de la base de données), alors le tableau ne sera pas empty() .

dans ce cas, vous pouvez boucler le tableau dans un foreach, en testant si chaque touche a une valeur. C'est un bon méthode si vous avez besoin d'exécuter à travers le tableau de toute façon, peut-être en vérifiant les clés ou les données d'assainissement.

Toutefois, il n'est pas la meilleure méthode si vous avez simplement besoin de savoir "s'il existe des valeurs" renvoie VRAI ou FALSE . Il y a diverses méthodes pour déterminer si un tableau a des valeurs quand il sait qu'il aura des clés. Une fonction ou une classe peut être la meilleure approche, mais comme toujours, cela dépend de votre environnement et exacte les exigences, ainsi que d'autres choses comme ce que vous faites actuellement avec le tableau (s'il y a lieu).

Voici une approche qui utilise très peu de code pour vérifier si un tableau a des valeurs:

utilisant array_filter() :

Itère sur chaque valeur dans le tableau en les passant à la fonction de rappel. Si la fonction callback retourne true, la valeur courante du tableau est retournée dans le tableau de résultat. Tableau les clés sont conservées.

$EmptyTestArray = array_filter($ArrayOne);

if (!empty($EmptyTestArray))
  {
    // do some tests on the values in $ArrayOne
  }
else
  {
    // Likely not to need an else, 
    // but could return message to user "you entered nothing" etc etc
  }

exécuter array_filter() sur les trois tableaux d'exemples (créés dans le premier bloc de code de cette réponse) donne les résultats suivants:

TABLEAU:

$arrayone n'est pas vide

ARRAY TWO:

$arraytwo n'est pas vide

ARRAY THREE:

$ arraytree est vide

ainsi quand il n'y a pas de valeurs, si il y a des clés ou non, en utilisant array_filter() pour créer un nouveau tableau et puis vérifier si le nouveau tableau est vide montre s'il y avait des valeurs dans le tableau original.

Il n'est pas idéal et un peu désordonné, mais si vous avez un tableau énorme et n'avez pas besoin de boucle à travers elle pour toute autre raison, alors c'est le plus simple en termes de code nécessaire.

Je n'ai pas l'habitude de vérifier les frais généraux, mais il serait bon de connaître les différences entre l'utilisation de array_filter() et foreach pour vérifier si une valeur est trouvée.

évidemment benchmark devrait être sur divers paramètres, sur les petits et grands tableaux et quand il ya des valeurs et pas etc

count($gamerow['players']) sera 0.

Si vous voulez savoir si la variable test est fait explicitement un tableau vide, vous pouvez utiliser quelque chose comme ceci:

if ($variableToTest === array()) {
    echo 'this is explicitly an empty array!';
}

is_array($detect) && empty($detect);

is_array

empty($gamerow['players'])

j'utilise ce code

$variable = array();

if( count( $variable ) == 0 )
{
    echo "Array is Empty";
}
else
{
    echo "Array is not Empty";
}

mais notez que si le tableau a un grand nombre de clés, ce code va passer beaucoup de temps à les compter, par rapport aux autres réponses ici.

 $gamerow = mysql_fetch_array($gameresult);

if (!empty(($gamerow['players'])) {
   $playerlist = explode(",", $gamerow['players']);
}else{

  // do stuf if array is empty
}

si vous devez vérifier le contenu du tableau vous pouvez utiliser:

$arr = array();

if(!empty($arr)){
  echo "not empty";
}
else 
{
  echo "empty";
}

voir ici: http://codepad.org/EORE4k7v

vous pouvez utiliser array_filter() qui fonctionne très bien pour toutes les situations:

$ray_state = array_filter($myarray);

if (empty($ray_state)) {
    echo 'array is empty';
} else {
    echo 'array is not empty';
}

pourquoi personne n'a dit cette réponse:

$array = [];

if($array == []) {
    // array is empty
}

cela semble fonctionner pour tous les cas

if(!empty(sizeof($array)))

je pense que la meilleure façon de déterminer si le tableau est vide ou non est d'utiliser count() comme ceci:

if(count($array)) {
    return 'anything true goes here';
}else {
    return 'anything false'; 
}

j'ai résolu ce problème avec le code suivant.

$catArray=array();                          

$catIds=explode(',',$member['cat_id']);
if(!empty($catIds[0])){
foreach($catIds as $cat_id){
$catDetail=$this->Front_Category->get_category_detail($cat_id);
$catArray[]=$catDetail['allData']['cat_title'];
}
echo implode(',',$catArray);
}

Que Diriez-vous de:

DepartmentPerSchool = array();
(empty(is_array($DepartmentPerSchool))) ? $DepartmentPerSchool //or echo is not empty : array('not set'=>'Not set. Contact Admin'); //or echo is empty

les solutions ci-dessus ne fonctionnaient pas pour moi. J'ai plutôt utilisé un moyen plus fiable (il peut avoir se déplacer au-dessus):

$countarr = count($newArr); // Count the elements in an array.
$checkarr = "" ; //Initialize the value of variable to blank.
for($x=0;$x<$countarr;$x++)
{
  $checkarr = $newArr1[$x] ;
  if($checkarr != "" ) 
  {
       // do stuff if array is not empty.
  }
}