Wie überprüft man, ob ein Array in PHP leer ist?

Question

players wird entweder leer sein oder eine durch Kommas getrennte Liste (oder ein einzelner Wert). Wie kann man am einfachsten überprüfen, ob es leer ist? Ich nehme an, dass ich dies sofort tun kann, sobald ich das $gameresult-Array in $gamerow abrufe? In diesem Fall wäre es wahrscheinlich effizienter, das Aufteilen des $playerlist zu überspringen, wenn es leer ist, aber um des Arguments willen, wie würde ich auch überprüfen, ob ein Array leer ist?

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

Answer 1

Wenn Sie nur überprüfen müssen, ob sich IRGENDWELCHE Elemente im Array befinden, können Sie entweder das Array selbst verwenden, aufgrund der lockeren Typisierung von PHP, oder - wenn Sie einen strengeren Ansatz bevorzugen - count() verwenden:

if (!$playerlist) {
     // Liste ist leer.
}
if (count($playerlist) === 0) {
     // Liste ist leer.
}

Wenn Sie leere Werte bereinigen müssen, bevor Sie überprüfen (generell, um das explodeen von seltsamen Zeichenfolgen zu verhindern):

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

Answer 2

Ein leeres Array ist in PHP falsch, daher brauchen Sie nicht einmal empty() zu verwenden, wie es andere vorgeschlagen haben.

``

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

In den meisten Fällen möchten Sie einfach !$emptyVar überprüfen. Verwenden Sie empty($emptyVar), wenn die Variable möglicherweise nicht gesetzt wurde UND Sie keine E_NOTICE auslösen möchten; meiner Meinung nach ist das im Allgemeinen keine gute Idee.

``

Answer 3

Einige akzeptable Antworten, aber ich dachte, ich würde etwas ausführlicher erklären, wann PHP bestimmt, ob ein Array leer ist.

---

Hauptnotizen:

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

Da Array-Werte Schlüssel benötigen, bestimmt das Vorhandensein oder Nichtvorhandensein von Werten in einem Array nicht, ob es leer ist, sondern ob es keine Schlüssel (und somit auch keine Werte) gibt.

Daher sagt das Überprüfen eines Arrays mit empty() nicht einfach aus, ob Sie Werte haben oder nicht, sondern ob das Array leer ist und Schlüssel Bestandteil eines Arrays sind.

---

Denken Sie daher darüber nach, wie Sie Ihr Array erstellen, bevor Sie sich für eine Überprüfungsmethode entscheiden.
Zum Beispiel wird ein Array Schlüssel haben, wenn ein Benutzer Ihr HTML-Formular übermittelt und jedes Formularfeld einen Array-Namen hat (d. h. name="array[]").
Ein nicht leeres Array wird für jedes Feld erstellt, da für jedes Formularfeldarray automatisch inkrementierte Schlüsselwerte vorhanden sind.

Betrachten Sie beispielsweise diese Arrays:

/* Einige Arrays zuweisen */

// Array mit vom Benutzer definierten Schlüssel und Wert
$ArrayOne = array("BenutzerSchlüsselA" => "BenutzerWertA", "BenutzerSchlüsselB" => "BenutzerWertB");

// Array mit automatisch inkrementiertem Schlüssel und benutzerdefiniertem Wert
// da ein Formularfeld mit Benutzereingabe zurückgegeben würde
$ArrayTwo[] = "BenutzerWert01";
$ArrayTwo[] = "BenutzerWert02";

// Array mit automatisch inkrementiertem Schlüssel und ohne Wert
// da ein Formularfeld ohne Benutzereingabe zurückgegeben würde
$ArrayThree[] = '';
$ArrayThree[] = '';

Wenn Sie die Array-Schlüssel und -Werte für die obigen Arrays ausgeben, erhalten Sie Folgendes:

ARRAY EINS:
[BenutzerSchlüsselA] => [BenutzerWertA]
[BenutzerSchlüsselB] => [BenutzerWertB]

ARRAY ZWEI:
[0] => [BenutzerWert01]
[1] => [BenutzerWert02]

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

Und die Überprüfung der obigen Arrays mit empty() liefert die folgenden Ergebnisse:

ARRAY EINS:
$ArrayOne ist nicht leer

ARRAY ZWEI:
$ArrayTwo ist nicht leer

ARRAY DREI:
$ArrayThree ist nicht leer

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

$ArrayFour = array();

Dies wird leer sein, d. h. PHP gibt TRUE zurück, wenn Sie empty() auf das obenstehende anwenden.

Wenn Ihr Array also Schlüssel hat - sei es z. B. durch Eingaben in einem Formular oder wenn Sie sie manuell zuweisen (d. h. ein Array mit Datenbankspaltennamen als Schlüssel erstellen, jedoch ohne Werte/Daten aus der Datenbank), dann wird das Array NICHT empty() sein.

In diesem Fall können Sie das Array in einem foreach durchlaufen und überprüfen, ob jeder Schlüssel einen Wert hat. Dies ist eine gute Methode, wenn Sie sowieso durch das Array durchlaufen müssen, möglicherweise die Schlüssel überprüfen oder Daten bereinigen.

Es ist jedoch nicht die beste Methode, wenn Sie einfach nur wissen müssen, ob "Werte vorhanden sind" TRUE oder FALSE zurückgibt. Es gibt verschiedene Methoden, um festzustellen, ob ein Array Werte enthält, 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 Ihren genauen Anforderungen ab, sowie anderen Dingen wie dem, was Sie derzeit mit dem Array machen (falls überhaupt).

---

Hier ist ein Ansatz, der sehr wenig Code verwendet, um zu überprüfen, ob ein Array Werte enthält:

Verwendung von array_filter():
Es durchläuft jeden Wert im Array und übergibt sie an die Rückruffunktion. Wenn die Rückruffunktion true zurückgibt, wird der aktuelle Wert aus dem Array in das Ergebnisarray zurückgegeben. Array-Schlüssel werden beibehalten.

$EmptyTestArray = array_filter($ArrayOne);

if (!empty($EmptyTestArray))
  {
    // Tests an den Werten in $ArrayOne durchführen
  }
else
  {
    // Wahrscheinlich kein else benötigt
    // könnte jedoch eine Nachricht an den Benutzer zurückgeben wie "du hast nichts eingegeben" usw.
  }

Wenn Sie array_filter() auf alle drei Beispielsarrays ausführen (die im ersten Codeblock dieser Antwort erstellt wurden), erhalten Sie Folgendes:

ARRAY EINS:
$arrayone ist nicht leer

ARRAY ZWEI:
$arraytwo ist nicht leer

ARRAY DREI:
$arraythree ist leer

Wenn es also keine Werte gibt, unabhängig davon, ob Schlüssel vorhanden sind oder nicht, zeigt die Verwendung von array_filter() zum Erstellen eines neuen Arrays und dann die Überprüfung, ob das neue Array leer ist, an, ob es Werte im Originalarray gab.
Es ist nicht ideal und etwas unübersichtlich, aber wenn Sie ein riesiges Array haben und es aus keinem anderen Grund durchlaufen müssen, dann ist dies in Bezug auf den benötigten Code am einfachsten.

---

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

Natürlich müssten Benchmarks auf verschiedenen Parametern durchgeführt werden, bei kleinen und großen Arrays und wenn Werte vorhanden sind oder nicht usw.

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