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

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

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
}

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.

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.

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

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

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

Warum hat niemand diese Antwort gesagt:

$array = [];

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

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

is_array

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

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

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.

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.

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

 $gamerow = mysql_fetch_array($gameresult);

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

  // do stuf if array is empty
}

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

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.

empty($gamerow['players'])

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

Dies scheint in allen Fällen zu funktionieren

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

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