Wie überprüfe ich mit PHP, ob ein Array leer ist?

471

playersist entweder leer oder eine durch Kommas getrennte Liste (oder ein einzelner Wert). Was ist der einfachste Weg, um zu überprüfen, ob es leer ist? Ich gehe davon aus, dass ich dies tun kann, sobald ich das $gameresultArray $gamerowabrufe. In diesem Fall wäre es wahrscheinlich effizienter, das Explodieren zu überspringen, $playerlistwenn es leer ist. Wie würde ich aus Gründen der Argumentation prüfen, ob ein Array ebenfalls leer ist?

$gamerow = mysql_fetch_array($gameresult);
$playerlist = explode(",", $gamerow['players']);
ein Slum
quelle
2
Verwenden Sie nicht count (), sizeof (), empty (). Leeres Array return false: if ($ array) {
Limitrof

Antworten:

774

Wenn Sie nur überprüfen müssen, ob das Array ALLE Elemente enthält

if (empty($playerlist)) {
     // list is empty.
}

Wenn Sie leere Werte vor dem Überprüfen bereinigen müssen (im Allgemeinen, um explodeseltsame Zeichenfolgen zu vermeiden ):

foreach ($playerlist as $key => $value) {
    if (empty($value)) {
       unset($playerlist[$key]);
    }
}
if (empty($playerlist)) {
   //empty array
}
Tyler Carter
quelle
2
Solltest du nicht einfach leer verwenden? Bei großen Arrays dauert die Ausführung länger.
Dan McGrath
1
Erledigt. Ich habe es auch geändert, weil Sie isset und so nicht verwenden müssen.
Tyler Carter
5
In Anbetracht seines Codebeispiels wird die Variable so festgelegt, dass Sie sie nicht verwenden müssen empty().
Cobby
4
VORSICHTIG! if(!isset($emptyarray))ist falseaber if(empty($emptyarray))zurück true. Das hat mich gerade genagelt
Kolob Canyon
161

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

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

PHP stellt empty()fest , ob eine Variable existiert nicht mehr oder hat einen Falsey Wert (wie array(), 0, null, false, etc.).

In den meisten Fällen möchten Sie nur überprüfen !$emptyVar. Verwenden empty($emptyVar)Sie diese Option, wenn die Variable möglicherweise nicht festgelegt wurde UND Sie keine E_NOTICE; IMO ist dies im Allgemeinen eine schlechte Idee.

Cobby
quelle
2
Ich hoffe, dass sich dies in einigen Standards nicht ändert ... es wird schmerzhaft sein
David Constantine
79

Einige anständige Antworten, aber ich dachte nur, ich würde etwas erweitern, um klarer zu erklären, wann PHP feststellt, ob ein Array leer ist.


Hauptnotizen:

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

Da für Array-Werte Schlüssel erforderlich sind, wird durch das Vorhandensein von Werten in einem Array nicht bestimmt, ob es leer ist oder nicht, nur wenn keine Schlüssel vorhanden sind (UND daher keine Werte).

empty()Wenn Sie also ein Array mit überprüfen, erfahren Sie nicht nur, ob Sie Werte haben oder nicht, sondern auch, ob das Array leer ist und Schlüssel Teil eines Arrays sind.


Überlegen Sie sich also, wie Sie Ihr Array erstellen, bevor Sie entscheiden, welche Überprüfungsmethode verwendet werden soll.
EG Ein Array wird Tasten haben , wenn ein Benutzer Ihres HTML - Formular sendet , wenn jedes Formularfeld einen Array - Namen (dh hat name="array[]"). Für jedes Feld wird
ein nicht leeres Array erstellt, da für das Array jedes Formularfelds automatisch inkrementierte Schlüsselwerte vorhanden sind.

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 wiedergeben, erhalten Sie Folgendes:

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

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

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

Wenn Sie die obigen Arrays mit testen, erhalten Sie empty()die folgenden Ergebnisse:

ARRAY ONE:
$ ArrayOne ist nicht leer

ARRAY TWO:
$ ArrayTwo ist nicht leer

ARRAY THREE:
$ ArrayThree ist nicht leer

Ein Array ist immer leer, wenn Sie ein Array zuweisen, es danach jedoch nicht mehr verwenden, z. B.:

$ArrayFour = array();

Dies ist leer, dh PHP gibt TRUE zurück, wenn es empty()oben verwendet wird.

Wenn Ihr Array also Schlüssel hat - entweder durch die Eingabenamen eines Formulars oder wenn Sie diese manuell zuweisen (dh ein Array mit Datenbankspaltennamen als Schlüssel, aber ohne Werte / Daten aus der Datenbank erstellen), ist das Array NICHT empty().

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

Es ist jedoch nicht die beste Methode, wenn Sie nur wissen müssen, ob Werte vorhanden sind, die TRUE oder FALSE zurückgeben . Es gibt verschiedene Methoden, um festzustellen, ob ein Array Werte hat, wenn bekannt ist, dass es Schlüssel hat. Eine Funktion oder Klasse ist möglicherweise der beste Ansatz, hängt jedoch wie immer von Ihrer Umgebung und den genauen Anforderungen sowie von anderen Faktoren ab, z. B. davon, was Sie derzeit mit dem Array tun (falls vorhanden).


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

Verwenden von array_filter():
Iteriert über jeden Wert im Array und übergibt ihn 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 bleiben erhalten.

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

Das Ausführen array_filter()auf allen drei Beispielarrays (die im ersten Codeblock dieser Antwort erstellt wurden) führt zu folgenden Ergebnissen:

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 Schlüssel vorhanden sind oder nicht, wird array_filter()durch Erstellen eines neuen Arrays und Überprüfen, ob das neue Array leer ist, angezeigt, ob das ursprüngliche Array Werte enthält.
Es ist nicht ideal und ein bisschen chaotisch, aber wenn Sie ein riesiges Array haben und es aus keinem anderen Grund durchlaufen müssen, ist dies der einfachste Code.


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

Offensichtlich müsste der Benchmark auf verschiedenen Parametern liegen, auf kleinen und großen Arrays und wenn es Werte gibt und nicht usw.

James
quelle
2
Vielen Dank dafür. Es war wirklich informativ und konnte mein Problem mitarray_filter()
Brian Powell
leer (array ()) wird immer zu FALSE ausgewertet, also wird durch Hinzufügen von count (array ()) == 0 true
timmz
1
@mboullouz count(array())==0ist falsch, wenn Schlüssel und keine Werte vorhanden sind. Dies hilft also nicht, nur nach Werten zu suchen . Ihre Aussage ist korrekt, aber Sie erzwingen einen Test mit, count(array())da das Array natürlich leer ist. Wir müssen überprüfen, wann das Array von einem Formular oder einem anderen Ort zurückgekehrt ist, um zu wissen, ob es leer ist (Schlüssel / Werte) oder nur Werte hat oder nicht
James
Diese Lösung ist perfekt für diese Art von Arrays, zum Beispiel hilft sie, wenn Sie eine Eingabedatei validieren möchten array_filter($_FILES["documento"]['name'])
Gendrith
20

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

Ignacio Vazquez-Abrams
quelle
old school da am besten wie immer, überprüfen Sie einfach den Index des Arrays.
Dänisch
Dies ist ein Funktionsaufruf zu viel.
Mickmackusa
12

Wenn Sie feststellen möchten, ob die zu testende Variable tatsächlich explizit ein leeres Array ist, können Sie Folgendes verwenden:

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

Wenn Sie die falschen oder leeren Zeilen (z. B. 0 => '') ausschließen möchten , bei denen die Verwendung empty()fehlschlägt, können Sie Folgendes versuchen:

if (array_filter($playerlist) == []) {
  // Array is empty!
}

array_filter(): Wenn kein Rückruf angegeben wird, werden alle Einträge des Arrays gleich FALSE (siehe Konvertieren in Boolesche Werte) entfernt.

Wenn Sie alle NULL-, FALSE- und leeren Zeichenfolgen ( '') entfernen möchten, aber Nullwerte ( 0) belassen möchten , können Sie dies strlenals Rückruf verwenden, z.

$is_empty = array_filter($playerlist, 'strlen') == [];
Kenorb
quelle
Dies ist die richtige Antwort auf eine andere Frage. Durch die Verwendung des Array-Filters werden vorhandene Elemente mit Falsey-Werten zerstört. Dies ist nicht das, was das OP verlangt.
Mickmackusa
8

Warum hat niemand diese Antwort gesagt:

$array = [];

if($array == []) {
    // array is empty
}
rauben
quelle
1
Ihre Aussage ist nicht korrekt. Jemand hat diese Antwort - Tim Ogilvy - ein Jahr zuvor gesagt. Die Verwendung von eckigen Klammern anstelle von array()ist das Gleiche.
Mickmackusa
Unter der Haube ist es die gleiche Antwort ... technisch. Ich habe die eckigen Klammern anstelle der veralteten Array-Funktion verwendet.
Rob
7
is_array($detect) && empty($detect);

is_array

zloctb
quelle
Dies sind unnötige Überprüfungen. Das OP ruft auf explode()- es gibt Daten vom Array-Typ zurück. Das Überprüfen empty()ist ein nicht benötigter Funktionsaufruf. Wie von Cobby im Jahr 2012 angegeben, if($detect)ist alles, was erforderlich ist. Diese Lösung sollte nicht für diese oder andere Aufgaben implementiert werden. Man könnte argumentieren , dass man Situationen jenseits dieser Frage des Umfangs bedecken, na ja, es gibt nie eine Notwendigkeit, rufen empty()NACH is_array()weil , wenn die Variable nicht „gesetzt“ ist, dann is_array()erzeugt wird „Hinweis: Nicht definierte Variable“, wenn isset()dann empty()viel des Guten ist, gerade Einsatz Cobbys Antwort.
Mickmackusa
6

Ich habe den am Ende des Beitrags enthaltenen Benchmark ausgeführt. So vergleichen Sie die Methoden:

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

und bekam 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 leer und Casting in einen Booleschen Wert ist unbedeutend. Ich habe diesen Test mehrmals durchgeführt und sie scheinen im Wesentlichen gleichwertig zu sein. Der Inhalt der Arrays scheint keine wesentliche Rolle zu spielen. Die beiden führen zu den entgegengesetzten Ergebnissen, aber die logische Negation reicht kaum aus, um das Casting die meiste Zeit zum Gewinnen zu bringen. Ich persönlich bevorzuge es aus Gründen der Lesbarkeit in beiden Fällen, leer zu sein.

#!/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";
kaan_a
quelle
Guter Benchmark, aber Sie haben vergessen, sizeofwelcher [nicht?] Alias ​​von empty... stackoverflow.com/a/51986794/1429432
Yousha Aleayoub
5

Wenn Sie den Array-Inhalt überprüfen möchten, können Sie Folgendes verwenden:

$arr = array();

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

siehe hier: http://codepad.org/EORE4k7v

nothingchen01
quelle
Wie Cobby 2012 gezeigt hat, muss keine Funktion aufgerufen werden, um zu überprüfen, ob ein deklariertes Array leer ist oder nicht.
Mickmackusa
5

Meiner Meinung nach wäre der einfachste Weg für ein indiziertes Array einfach:

    if ($array) {
      //Array is not empty...  
    }

Eine 'if'-Bedingung für das Array würde als wahr ausgewertet, wenn das Array nicht leer ist, und als falsch, wenn das Array leer ist . Dies gilt nicht für assoziative Arrays.

PJately
quelle
Cobby hat diese Technik bereits 2012 effektiv erklärt. Seine Antwort hat derzeit 133 positive Stimmen.
Mickmackusa
Dies ist aus Sicht der Meinung nicht "am einfachsten" - es ist am einfachsten, da es keine Syntax gibt, die präziser sein kann, und dies hat keinen Funktionsaufruf-Overhead. Es gibt ABSOLUT KEINEN UNTERSCHIED beim Zugriff auf ein Array mit indizierten Schlüsseln gegenüber assoziativen Schlüsseln. Diese Antwort führt Forscher in die Irre. Diese Antwort ist redundant und wird dann übernommen . 3v4l.org/DSLha
mickmackusa
3

Ich benutze diesen Code

$variable = array();

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

Beachten Sie jedoch, dass dieser Code, wenn das Array eine große Anzahl von Schlüsseln enthält, im Vergleich zu den anderen Antworten hier viel Zeit damit verbringt, diese zu zählen.

Joseph Asir Raja
quelle
Wie Cobby 2012 gezeigt hat, muss keine Funktion aufgerufen werden, um zu überprüfen, ob ein deklariertes Array leer ist oder nicht.
Mickmackusa
3

Sie können verwenden, array_filter()was für alle Situationen gut funktioniert:

$ray_state = array_filter($myarray);

if (empty($ray_state)) {
    echo 'array is empty';
} else {
    echo 'array is not empty';
}
user889030
quelle
1
Diese Antwort erfordert unnötige Überprüfungen. Erstens ist das OP nicht daran interessiert, Falsey-Werte aus dem Array zu filtern, bevor die Leere überprüft wird. Sie sind also von der gestellten Frage abgewichen. Zweitens ist es, wie Cobby 2012 gezeigt hat, nicht erforderlich, eine Funktion aufzurufen, um zu überprüfen, ob ein deklariertes Array leer ist oder nicht.
Mickmackusa
2
 $gamerow = mysql_fetch_array($gameresult);

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

  // do stuf if array is empty
}
Anish Rai
quelle
2

Ich denke, der beste Weg, um festzustellen, ob das Array leer ist oder nicht, ist die Verwendung von count () wie folgt:

if(count($array)) {
    return 'anything true goes here';
}else {
    return 'anything false'; 
}
Anas Red
quelle
Der count()Anruf kann vollständig entfernt werden - siehe die Antwort von Cobby.
Mickmackusa
2

Um die am besten geeignete Entscheidung zu treffen, müssen Sie die Qualität Ihrer Daten kennen und wissen, welche Prozesse zu befolgen sind.

  1. Wenn Sie diese Zeile disqualifizieren / ignorieren / entfernen möchten, sollte der früheste Filterpunkt in der MySQL-Abfrage liegen.

    • WHERE players IS NOT NULL
    • WHERE players != ''
    • WHERE COALESCE(players, '') != ''
    • WHERE players IS NOT NULL AND players != ''
    • ... es hängt irgendwie von Ihren Geschäftsdaten ab und es wird andere Möglichkeiten geben, ich werde hier aufhören.
  2. Wenn Sie nicht 100% sicher sind, ob die Spalte in der Ergebnismenge vorhanden ist, sollten Sie überprüfen, ob die Spalte deklariert ist. Dies bedeutet , ruft array_key_exists(), isset()oder empty()auf der Säule. Ich werde mich nicht darum kümmern, die Unterschiede hier zu beschreiben (es gibt andere SO-Seiten für diese Aufschlüsselung, hier ist ein Anfang: 1 , 2 , 3 ). Wenn Sie jedoch nicht die vollständige Kontrolle über die Ergebnismenge haben, haben Sie möglicherweise zu viel Flexibilität bei der Anwendung und sollten überdenken, ob sich die Mühe lohnt, möglicherweise auf nicht vorhandene Spaltendaten zuzugreifen. Eigentlich sage ich, dass Sie niemals überprüfen müssen, ob eine Spalte deklariert ist - also sollten Sie niemals brauchenempty() diese Aufgabe . Wenn jemand das argumentiertempty()ist angemessener, dann drängen sie ihre eigene persönliche Meinung über die Ausdruckskraft von Skripten. Wenn Sie feststellen, dass die Bedingung in # 5 unten nicht eindeutig ist, fügen Sie Ihrem Code einen Inline-Kommentar hinzu - aber das würde ich nicht. Das Fazit ist, dass der Funktionsaufruf keinen programmatischen Vorteil hat.

  3. Könnte Ihr Zeichenfolgenwert einen Wert enthalten 0, den Sie für wahr / gültig / nicht leer halten möchten? Wenn ja, müssen Sie nur prüfen, ob der Spaltenwert eine Länge hat.

    Hier ist eine Demo mit strlen(). Dies zeigt an, ob die Zeichenfolge bei Explosion sinnvolle Array-Elemente erstellt.

  4. Ich denke, es ist wichtig zu erwähnen, dass Sie durch bedingungsloses Explodieren GARANTIERT sind, ein nicht leeres Array zu generieren. Hier ist der Beweis: Demo Mit anderen Worten, die Überprüfung, ob das Array leer ist, ist völlig nutzlos - es ist jedes Mal nicht leer.

  5. Wenn Ihre Zeichenfolge möglicherweise keinen Nullwert enthält (weil dies beispielsweise eine CSV ist, die aus IDs besteht, die von 1und nur inkrementieren), if ($gamerow['players']) {ist alles, was Sie brauchen - Ende der Geschichte.

  6. ... aber warte, was machst du, nachdem du die Leere dieses Wertes festgestellt hast? Wenn Sie ein Down-Script haben, das Sie erwartet $playerlist, diese Variable jedoch bedingt deklarieren, besteht die Gefahr, dass Sie den Wert der vorherigen Zeile verwenden oder erneut Benachrichtigungen generieren. Müssen Sie sich also bedingungslos $playerlistals etwas deklarieren ? Wenn die Zeichenfolge keine wahrheitsgemäßen Werte enthält, profitiert Ihre Anwendung davon, ein leeres Array zu deklarieren? Die Antwort lautet wahrscheinlich Ja. In diesem Fall können Sie sicherstellen, dass die Variable vom Typ Array ist, indem Sie auf ein leeres Array zurückgreifen. Auf diese Weise spielt es keine Rolle, ob Sie diese Variable in eine Schleife einspeisen. Die folgenden bedingten Erklärungen sind alle gleichwertig.

    • `if ($ gamerow ['Spieler']) {$ playerlist = explode (',', $ gamerow ['Spieler']); } else {$ playerlist = []; }}
    • $playerlist = $gamerow['players'] ? explode(',', $gamerow['players']) : [];

Warum habe ich mich so lange bemüht, diese grundlegende Aufgabe zu erklären?

  1. Ich habe fast jede Antwort auf dieser Seite gepfiffen und diese Antwort wird wahrscheinlich Rachestimmen ziehen (dies passiert oft Whistleblowern, die diese Seite verteidigen - wenn eine Antwort Downvotes und keine Kommentare enthält, seien Sie immer skeptisch).
  2. Ich denke, es ist wichtig, dass Stackoverflow eine vertrauenswürdige Ressource ist, die Forscher nicht mit Fehlinformationen und suboptimalen Techniken vergiftet.
  3. Auf diese Weise zeige ich, wie sehr mir aufstrebende Entwickler am Herzen liegen, damit sie das Wie und Warum lernen, anstatt nur eine Generation von Programmierern zum Kopieren und Einfügen mit dem Löffel zu füttern.
  4. Ich verwende häufig alte Seiten, um neue doppelte Seiten zu schließen - dies liegt in der Verantwortung von freiwilligen Veteranen, die wissen, wie man schnell doppelte Seiten findet. Ich kann mich nicht dazu bringen, eine alte Seite mit schlechten / falschen / suboptimalen / irreführenden Informationen als Referenz zu verwenden, da ich dann einem neuen Forscher aktiv einen schlechten Dienst leiste.
mickmackusa
quelle
@ptr es ist hier.
Mickmackusa
1
empty($gamerow['players'])
Dan McGrath
quelle
Manchmal konnte man den Wert des Elementarray-Schlüssels nicht kennen $matches = preg_grep ( "/^$text (\w+)/i" , $array ) ; , um ihn zu überprüfen. Ich benutze ihnif ( count ( $matches ) > 0 )
Salem,
Es wird davon ausgegangen, dass die Spalte in der Ergebnismenge vorhanden ist und daher empty()zu viel Arbeit leistet.
Mickmackusa
-1

Ich habe dieses Problem mit folgendem Code gelöst.

$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);
}
Suraj Kumar
quelle
1
Willkommen bei Stack Overflow! Vielen Dank für das Code-Snippet, das möglicherweise nur begrenzte, sofortige Hilfe bietet. Eine richtige Erklärung würde ihren langfristigen Wert erheblich verbessern, indem sie beschreibt, warum dies eine gute Lösung für das Problem ist, und es für zukünftige Leser mit anderen ähnlichen Fragen nützlicher machen. Bitte bearbeiten Sie Ihre Antwort, um eine Erklärung hinzuzufügen, einschließlich der von Ihnen getroffenen Annahmen.
September
-3

Dies scheint in allen Fällen zu funktionieren

if(!empty(sizeof($array)))
Madhu Nair
quelle
3
Dies hat zu viel Aufwand. Diese Lösung sollte von keinem Entwickler aus irgendeinem Grund implementiert werden.
Mickmackusa
@mickmackusa Toller Punkt, aber wie lernt ein Anfänger zu erkennen, welche Operationen zu viel Overhead verursachen? Was ist das Werbegeschenk oder was sind die Nennwertkriterien für zu viel Overhead, ohne Leistungstests durchzuführen?
ptrcao
1
@ptr Für jeden Funktionsaufruf fallen "Kosten" an. Wenn eine Aufgabe ohne Funktionsaufruf ausgeführt werden kann, übertrifft sie eine Technik, die einen Funktionsaufruf verwendet.
Mickmackusa
@ptr Ich habe eine umfassende Antwort auf diese Frage gepostet. Ich hoffe, es klärt alle Bedenken, die Sie bezüglich dieser bestimmten Seite haben.
Mickmackusa
@mickmackusa Wolltest du einen Link zu einem anderen Beitrag einfügen?
ptrcao
-4

Wie wäre es mit:

DepartmentPerSchool = array ();
(leer (is_array ($ DepartmentPerSchool)))? $ DepartmentPerSchool // oder echo ist nicht leer: array ('not set' => 'Not set. Contact Admin'); // oder Echo ist leer
Ngatia Frankline
quelle