Wie kann man mit PHP prüfen, ob ein Array leer ist?

Question

players ist entweder leer oder eine durch Kommata getrennte Liste (oder ein einzelner Wert). Wie kann ich am einfachsten überprüfen, ob sie leer ist? Ich nehme an, dass ich das tun kann, sobald ich die $gameresult Array in $gamerow ? In diesem Fall wäre es wahrscheinlich effizienter, die Explosion der $playerlist wenn es leer ist, aber um des Argumentes willen, wie würde ich prüfen, ob ein Array auch leer ist?

$gamerow = mysql_fetch_array($gameresult);
$playerlist = explode(",", $gamerow['players']);

Answer 1

Wenn Sie nur überprüfen wollen, ob es IRGENDEINE Elemente im Array gibt, können Sie entweder das Array selbst verwenden, da PHP eine lockere Typisierung zulässt, oder - wenn Sie einen strengeren Ansatz bevorzugen - verwenden Sie count() :

if (!$playerlist) {
     // list is empty.
}
if (count($playerlist) === 0) {
     // list is empty.
}

Wenn Sie vor der Prüfung leere Werte entfernen müssen (im Allgemeinen, um zu verhindern, dass explode sonderbare Zeichenketten):

foreach ($playerlist as $key => $value) {
    if (!strlen($value)) {
       unset($playerlist[$key]);
    }
}
if (!$playerlist) {
   //empty array
}

Answer 2

Ein leeres Array ist in PHP falsch, daher müssen Sie nicht einmal empty() wie andere vorgeschlagen haben.

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

PHP empty() bestimmt, ob eine Variable nicht existiert oder einen falschen Wert hat (wie array() , 0 , null , false , usw.).

In den meisten Fällen wollen Sie nur prüfen !$emptyVar . Verwenden Sie empty($emptyVar) wenn die Variable möglicherweise nicht gesetzt wurde UND Sie nicht wollen, dass ein E_NOTICE IMO ist dies generell eine schlechte Idee.

Answer 3

Einige gute Antworten, aber ich dachte, ich erkläre ein wenig, um klarer zu erklären, wann PHP feststellt, ob ein Array leer ist.

---

Wichtigste Anmerkungen:

Ein Array mit einem Schlüssel (oder Schlüsseln) wird bestimmt als NICHT leer mit PHP.

Da Array-Werte Schlüssel benötigen, um existieren zu können, bestimmt das Vorhandensein von Werten in einem Array nicht, ob es leer ist oder nicht, sondern nur, ob es keine Schlüssel (und damit keine Werte) gibt.

Das Überprüfen eines Arrays mit empty() sagt Ihnen nicht nur, ob Sie Werte haben oder nicht, sondern auch, ob das Array leer ist und die Schlüssel Teil eines Arrays sind.

---

Überlegen Sie also, wie Sie Ihr Array erstellen, bevor Sie sich für eine Prüfmethode entscheiden.
EG Ein Array wird Schlüssel haben, wenn ein Benutzer Ihr HTML-Formular absendet, wenn jedes Formularfeld einen Array-Namen hat (d.h. name="array[]" ).
A nicht leer Array wird für jedes Feld erzeugt, da es automatisch inkrementierte Schlüsselwerte für das Array jedes Formularfeldes geben wird.

Nehmen Sie zum Beispiel diese Arrays:

/* 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[] = '';

Wenn Sie die Array-Schlüssel und -Werte für die oben genannten Arrays als Echo ausgeben, erhalten Sie Folgendes:

ARRAY ONE:
[UserKeyA] => [UserValueA]
[UserKeyB] => [UserValueB]

ARRAY TWO:
[0] => [UserValue01]
[1] => [UserValue02]

ARRAY THREE:
[0] => []
[1] => []

Und das Testen der oben genannten Arrays mit empty() liefert die folgenden Ergebnisse:

ARRAY ONE:
$ArrayOne ist nicht leer

ARRAY TWO:
$ArrayTwo ist nicht leer

ARRAY THREE:
$ArrayThree ist nicht leer

Ein Array wird immer leer sein, wenn Sie ein Array zuweisen, es aber danach nicht mehr verwenden, z. B:

$ArrayFour = array();

Dieser wird leer sein, d.h. PHP gibt TRUE zurück, wenn if empty() zu den oben genannten Punkten.

Wenn Ihr Array also Schlüssel hat - entweder durch z.B. die Eingabenamen eines Formulars oder wenn Sie sie manuell zuweisen (d.h. ein Array mit Datenbankspaltennamen als Schlüssel, aber keine Werte/Daten aus der Datenbank erstellen), dann wird das Array NICHT empty() .

In diesem Fall können Sie das Array in einer foreach-Schleife durchlaufen und prüfen, ob jeder Schlüssel einen Wert hat. Dies ist eine gute Methode, wenn Sie das Array ohnehin durchlaufen müssen, um vielleicht die Schlüssel zu überprüfen oder Daten zu bereinigen.

Es ist jedoch nicht die beste Methode, wenn Sie einfach nur wissen wollen, ob Werte vorhanden sind". WAHR ou FALSCH . Es gibt verschiedene Methoden, um festzustellen, ob ein Array Werte hat, wenn bekannt ist, dass es Schlüssel hat. Eine Funktion oder Klasse könnte der beste Ansatz sein, aber wie immer hängt es von Ihrer Umgebung und den genauen Anforderungen ab, sowie von anderen Dingen, wie z.B. was Sie derzeit mit dem Array machen (wenn überhaupt).

---

Hier ist ein Ansatz, der sehr wenig Code benötigt, um zu prüfen, ob ein Array Werte hat:

使用方法 array_filter() :
Iteriert über jeden Wert im Array und übergibt ihn an die Callback-Funktion. Wenn die Callback-Funktion true zurückgibt, wird der aktuelle Wert aus dem Array in das Ergebnis-Array zurückgegeben. Array-Schlüssel werden beibehalten.

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

Laufen array_filter() auf alle drei Beispielarrays (die im ersten Codeblock dieser Antwort erstellt wurden) führt zu folgendem Ergebnis:

ARRAY ONE:
$arrayone ist nicht leer

ARRAY TWO:
$arraytwo ist nicht leer

ARRAY THREE:
$arraythree ist leer

Wenn also keine Werte vorhanden sind, unabhängig davon, ob es Schlüssel gibt oder nicht, kann mit array_filter() um ein neues Array zu erstellen und dann zu prüfen, ob das neue Array leer ist, zeigt an, ob es irgendwelche Werte im ursprünglichen Array gab.
Es ist nicht ideal und ein bisschen chaotisch, aber wenn Sie ein großes Array haben und es nicht aus anderen Gründen in einer Schleife durchlaufen müssen, dann ist dies der einfachste Code, der benötigt wird.

---

Ich habe keine Erfahrung mit der Überprüfung von Gemeinkosten, aber es wäre gut zu wissen, welche Unterschiede es zwischen der Verwendung von array_filter() et foreach Prüfung, ob ein Wert gefunden wird.

Offensichtlich müsste der Benchmark auf verschiedene Parameter, auf kleine und große Arrays und wenn es Werte und nicht usw. sein.

Answer 4

count($gamerow['players']) wird 0 sein.

Answer 5

Ich habe den Benchmark durchgeführt, der am Ende des Beitrags aufgeführt ist. Um die Methoden zu vergleichen:

• count($arr) == 0 : zählen
• empty($arr) : leer
• $arr == [] : comp
• (bool) $arr : Besetzung

und erhielt die folgenden Ergebnisse

Contents  \method |    count     |    empty     |     comp     |     cast     |
------------------|--------------|--------------|--------------|--------------|
            Empty |/* 1.213138 */|/* 1.070011 */|/* 1.628529 */|   1.051795   |
          Uniform |/* 1.206680 */|   1.047339   |/* 1.498836 */|/* 1.052737 */|
          Integer |/* 1.209668 */|/* 1.079858 */|/* 1.486134 */|   1.051138   |
           String |/* 1.242137 */|   1.049148   |/* 1.630259 */|/* 1.056610 */|
            Mixed |/* 1.229072 */|/* 1.068569 */|/* 1.473339 */|   1.064111   |
      Associative |/* 1.206311 */|   1.053642   |/* 1.480637 */|/* 1.137740 */|
------------------|--------------|--------------|--------------|--------------|
            Total |/* 7.307005 */|   6.368568   |/* 9.197733 */|/* 6.414131 */|

Der Unterschied zwischen leerem und booleschem Casting ist unbedeutend. Ich habe diesen Test mehrere Male durchgeführt und sie scheinen im Wesentlichen gleichwertig zu sein. Der Inhalt der Arrays scheint keine große Rolle zu spielen. Die beiden produzieren die entgegengesetzten Ergebnisse, aber die logische Negation ist kaum genug, um Casting zu gewinnen die meiste Zeit zu schieben, so dass ich persönlich lieber leer aus Gründen der Lesbarkeit in jedem Fall.

#!/usr/bin/php
<?php

//    012345678
$nt = 90000000;

$arr0 = [];
$arr1 = [];
$arr2 = [];
$arr3 = [];
$arr4 = [];
$arr5 = [];

for ($i = 0; $i < 500000; $i++) {
    $arr1[] = 0;
    $arr2[] = $i;
    $arr3[] = md5($i);
    $arr4[] = $i % 2 ? $i : md5($i);
    $arr5[md5($i)] = $i;
}

$t00 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr0) == 0;
}
$t01 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr0);
}
$t02 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr0 == [];
}
$t03 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr0;
}
$t04 = microtime(true);

$t10 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr1) == 0;
}
$t11 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr1);
}
$t12 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr1 == [];
}
$t13 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr1;
}
$t14 = microtime(true);

/* ------------------------------ */

$t20 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr2) == 0;
}
$t21 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr2);
}
$t22 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr2 == [];
}
$t23 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr2;
}
$t24 = microtime(true);

/* ------------------------------ */

$t30 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr3) == 0;
}
$t31 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr3);
}
$t32 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr3 == [];
}
$t33 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr3;
}
$t34 = microtime(true);

/* ------------------------------ */

$t40 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr4) == 0;
}
$t41 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr4);
}
$t42 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr4 == [];
}
$t43 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr4;
}
$t44 = microtime(true);

/* ----------------------------------- */

$t50 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr5) == 0;
}
$t51 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr5);
}
$t52 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr5 == [];
}
$t53 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr5;
}
$t54 = microtime(true);

/* ----------------------------------- */

$t60 = $t00 + $t10 + $t20 + $t30 + $t40 + $t50;
$t61 = $t01 + $t11 + $t21 + $t31 + $t41 + $t51;
$t62 = $t02 + $t12 + $t22 + $t32 + $t42 + $t52;
$t63 = $t03 + $t13 + $t23 + $t33 + $t43 + $t53;
$t64 = $t04 + $t14 + $t24 + $t34 + $t44 + $t54;

/* ----------------------------------- */

$ts0[1] = number_format(round($t01 - $t00, 6), 6);
$ts0[2] = number_format(round($t02 - $t01, 6), 6);
$ts0[3] = number_format(round($t03 - $t02, 6), 6);
$ts0[4] = number_format(round($t04 - $t03, 6), 6);

$min_idx = array_keys($ts0, min($ts0))[0];
foreach ($ts0 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts0[$idx] = "   $val   ";
    } else {
        $ts0[$idx] = "/* $val */";
    }

}

$ts1[1] = number_format(round($t11 - $t10, 6), 6);
$ts1[2] = number_format(round($t12 - $t11, 6), 6);
$ts1[3] = number_format(round($t13 - $t12, 6), 6);
$ts1[4] = number_format(round($t14 - $t13, 6), 6);

$min_idx = array_keys($ts1, min($ts1))[0];
foreach ($ts1 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts1[$idx] = "   $val   ";
    } else {
        $ts1[$idx] = "/* $val */";
    }

}

$ts2[1] = number_format(round($t21 - $t20, 6), 6);
$ts2[2] = number_format(round($t22 - $t21, 6), 6);
$ts2[3] = number_format(round($t23 - $t22, 6), 6);
$ts2[4] = number_format(round($t24 - $t23, 6), 6);

$min_idx = array_keys($ts2, min($ts2))[0];
foreach ($ts2 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts2[$idx] = "   $val   ";
    } else {
        $ts2[$idx] = "/* $val */";
    }

}

$ts3[1] = number_format(round($t31 - $t30, 6), 6);
$ts3[2] = number_format(round($t32 - $t31, 6), 6);
$ts3[3] = number_format(round($t33 - $t32, 6), 6);
$ts3[4] = number_format(round($t34 - $t33, 6), 6);

$min_idx = array_keys($ts3, min($ts3))[0];
foreach ($ts3 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts3[$idx] = "   $val   ";
    } else {
        $ts3[$idx] = "/* $val */";
    }

}

$ts4[1] = number_format(round($t41 - $t40, 6), 6);
$ts4[2] = number_format(round($t42 - $t41, 6), 6);
$ts4[3] = number_format(round($t43 - $t42, 6), 6);
$ts4[4] = number_format(round($t44 - $t43, 6), 6);

$min_idx = array_keys($ts4, min($ts4))[0];
foreach ($ts4 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts4[$idx] = "   $val   ";
    } else {
        $ts4[$idx] = "/* $val */";
    }

}

$ts5[1] = number_format(round($t51 - $t50, 6), 6);
$ts5[2] = number_format(round($t52 - $t51, 6), 6);
$ts5[3] = number_format(round($t53 - $t52, 6), 6);
$ts5[4] = number_format(round($t54 - $t53, 6), 6);

$min_idx = array_keys($ts5, min($ts5))[0];
foreach ($ts5 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts5[$idx] = "   $val   ";
    } else {
        $ts5[$idx] = "/* $val */";
    }

}

$ts6[1] = number_format(round($t61 - $t60, 6), 6);
$ts6[2] = number_format(round($t62 - $t61, 6), 6);
$ts6[3] = number_format(round($t63 - $t62, 6), 6);
$ts6[4] = number_format(round($t64 - $t63, 6), 6);

$min_idx = array_keys($ts6, min($ts6))[0];
foreach ($ts6 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts6[$idx] = "   $val   ";
    } else {
        $ts6[$idx] = "/* $val */";
    }

}

echo "             |    count     |    empty     |     comp     |     cast     |\n";
echo "-------------|--------------|--------------|--------------|--------------|\n";
echo "       Empty |";
echo $ts0[1] . '|';
echo $ts0[2] . '|';
echo $ts0[3] . '|';
echo $ts0[4] . "|\n";

echo "     Uniform |";
echo $ts1[1] . '|';
echo $ts1[2] . '|';
echo $ts1[3] . '|';
echo $ts1[4] . "|\n";

echo "     Integer |";
echo $ts2[1] . '|';
echo $ts2[2] . '|';
echo $ts2[3] . '|';
echo $ts2[4] . "|\n";

echo "      String |";
echo $ts3[1] . '|';
echo $ts3[2] . '|';
echo $ts3[3] . '|';
echo $ts3[4] . "|\n";

echo "       Mixed |";
echo $ts4[1] . '|';
echo $ts4[2] . '|';
echo $ts4[3] . '|';
echo $ts4[4] . "|\n";

echo " Associative |";
echo $ts5[1] . '|';
echo $ts5[2] . '|';
echo $ts5[3] . '|';
echo $ts5[4] . "|\n";

echo "-------------|--------------|--------------|--------------|--------------|\n";
echo "       Total |";
echo $ts6[1] . '|';
echo $ts6[2] . '|';
echo $ts6[3] . '|';
echo $ts6[4] . "|\n";