Hoe controleer je met PHP of een array leeg is?

playerszijn ofwel leeg, ofwel een door komma’s gescheiden lijst (of een enkele waarde). Wat is de gemakkelijkste manier om te controleren of deze leeg is? Ik neem aan dat ik dit kan doen zodra ik de array $gameresultin $gamerowheb opgehaald? In dit geval zou het waarschijnlijk efficiënter zijn om het exploderen van de $playerlistover te slaan als deze leeg is, maar ter wille van het argument, hoe kan ik controleren of een array ook leeg is?

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

Antwoord 1, autoriteit 100%

Als u alleen wilt controleren of er ENIGE elementen in de array staan

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

Als je lege waarden moet opschonen voordat je gaat controleren (meestal gedaan om te voorkomen dat exploderare strings worden):

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

Antwoord 2, autoriteit 21%

Een lege array is falsey in PHP, dus je hoeft niet eens empty()te gebruiken zoals anderen hebben gesuggereerd.

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

PHP’s empty()bepaalt of een variabele bestaat niet of heeft een falsey-waarde (zoals array(), 0, null, false, enzovoort).

In de meeste gevallen wil je gewoon !$emptyVarcontroleren. Gebruik empty($emptyVar)als de variabele mogelijk niet is ingesteld EN u niet een E_NOTICEwilt activeren; IMO is dit over het algemeen een slecht idee.


Antwoord 3, autoriteit 11%

Enkele fatsoenlijke antwoorden, maar ik dacht dat ik een beetje zou uitbreiden om het duidelijker uit te leggen wanneer PHP bepaalt of een array leeg is.


Belangrijkste opmerkingen:

Een array met een sleutel (of sleutels) wordt door PHP bepaald als NIET leeg.

Omdat arraywaarden sleutels nodig hebben om te bestaan, bepaalt het al dan niet hebben van waarden in een array niet of deze leeg is, alleen als er geen sleutels zijn (EN dus geen waarden).

Dus het controleren van een array met empty()vertelt je niet alleen of je waarden hebt of niet, het vertelt je of de array leeg is en of sleutels deel uitmaken van een array.


Overweeg dus hoe u uw array produceert voordat u beslist welke controlemethode u gaat gebruiken.
EG Een array heeftsleutels wanneer een gebruiker uw HTML-formulier indient wanneer elk formulierveld een arraynaam heeft (dwz name="array[]").
Er wordt een niet-legearray geproduceerd voor elk veld, aangezien er automatisch verhoogde sleutelwaarden zijn voor de array van elk formulierveld.

Neem bijvoorbeeld deze 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[] = '';

Als je de array-sleutels en -waarden voor de bovenstaande arrays weergeeft, krijg je het volgende:

ARRAY EEN:
[GebruikerssleutelA] => [UserValueA]
[GebruikerssleutelB] => [GebruikerswaardeB]

ARRAY TWEE:
[0] => [Gebruikerswaarde01]
[1] => [UserValue02]

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

En het testen van de bovenstaande arrays met empty()geeft de volgende resultaten:

ARRAY EEN:
$ArrayOne is niet leeg

ARRAY TWEE:
$ArrayTwo is niet leeg

ARRAY DRIE:
$ArrayThree is niet leeg

Een array zal altijd leeg zijn wanneer u een array toewijst, maar deze daarna niet meer gebruikt, zoals:

$ArrayFour = array();

Dit zal leeg zijn, dwz PHP zal TRUE teruggeven bij gebruik van if empty()in het bovenstaande.

Dus als uw array sleutels heeft – hetzij door bijvoorbeeld de invoernamen van een formulier of als u ze handmatig toewijst (dwz een array maakt met databasekolomnamen als sleutels maar geen waarden/gegevens uit de database), dan zal de array NIET wees empty().

In dit geval kunt u de array in een foreach herhalen, waarbij u test of elke sleutel een waarde heeft. Dit is een goede methode als u de array toch moet doorlopen, misschien de sleutels controleren of gegevens opschonen.

Het is echter niet de beste methode als u alleen maar wilt weten dat “als waarden bestaan” TRUEof FALSEretourneert.
Er zijn verschillende methoden om te bepalen of een array waarden heeft wanneer het weet dat het sleutels heeft. Een functie of klasse is misschien de beste aanpak, maar zoals altijd afhangt van uw omgeving en exacte vereisten, evenals andere dingen, zoals wat u momenteel met de array (indien iets) doet.


Hier is een benadering die heel weinig code gebruikt om te controleren of een array waarden heeft:

met array_filter():
Itereert over elke waarde in de array die ze doorgeven aan de callback-functie. Als de callback-functie true retourneert, wordt de huidige waarde van de array geretourneerd in de resultaatarray. Array-toetsen worden bewaard.

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

RUIMTE array_filter()Op alle drie de reeksen (in het eerste codeblok in dit antwoord) resulteert in het volgende:

array one:
$ arrayon is niet leeg

array twee:
$ arraytwo is niet leeg

array drie:
$ arraydrie is leeg

Dus wanneer er geen waarden zijn, of er sleutels zijn of niet, met behulp van array_filter()om een ​​nieuwe array te maken en vervolgens te controleren of de nieuwe array leeg is, toont u als er waarden in de Originele array.
Het is niet ideaal en een beetje rommelig, maar als je een enorme array hebt en het niet om een ​​andere reden doorsnijdt, dan is dit de eenvoudigste in termen van code die nodig is.


Ik heb geen ervaring met het controleren van overheadkosten, maar het zou goed zijn om de verschillen te kennen tussen het gebruik van array_filter()en foreachom te controleren of een waarde is gevonden.

Het is duidelijk dat de benchmark op verschillende parameters moet zijn, op kleine en grote arrays en wanneer er waarden zijn en niet enz.


Antwoord 4, autoriteit 3%

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


Antwoord 5, autoriteit 2%

Als u de valse of lege rijen (zoals 0 => '') wilt uitsluiten, waarbij het gebruik van empty()niet werkt, kunt u probeer:

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

array_filter(): als er geen callback is opgegeven, worden alle vermeldingen van array gelijk aan FALSE (zie converteren naar boolean) wordt verwijderd.

Als u alle NULL, FALSE en lege tekenreeksen ('') wilt verwijderen, maar nulwaarden wilt laten (0), kunt u strlenals terugroepactie, bijv.:

$is_empty = array_filter($playerlist, 'strlen') == [];

Antwoord 6, autoriteit 2%

Als je wilt weten of de variabele die je aan het testen bent, daadwerkelijk een lege array is, kun je zoiets als dit gebruiken:

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

Antwoord 7

Ik heb de benchmark uitgevoerd die aan het einde van de post is opgenomen. Om de methoden te vergelijken:

  • count($arr) == 0: count
  • empty($arr): leeg
  • $arr == []: comp
  • (bool) $arr: cast

en kreeg de volgende resultaten

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 */|

Het verschil tussen leeg en casten naar een boolean is onbeduidend. Ik heb deze test meerdere keren uitgevoerd en ze lijken in wezen gelijkwaardig te zijn. De inhoud van de arrays lijkt geen significante rol te spelen. De twee produceren de tegenovergestelde resultaten, maar de logische ontkenning is nauwelijks genoeg om het gieten meestal te laten winnen, dus ik geef persoonlijk in beide gevallen de voorkeur aan leeg omwille van de leesbaarheid.

#!/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";

Antwoord 8

Waarom zei niemand dit antwoord:

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

Antwoord 9

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

is_array


Antwoord 10

Als u de array-inhoud wilt controleren, kunt u gebruiken:

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

Zie hier:
http://codepad.org/EORE4K7V


Antwoord 11

Naar mijn mening zou de eenvoudigste manier voor een geïndexeerde array eenvoudig zijn:

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

Een ‘als’ Conditie op de array zou evalueren naar waar als de array niet leeg is en false als de array leeg is . Dit is niet van toepassing op associatieve arrays.


Antwoord 12

Ik gebruik deze code

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

Merk op dat als de array een groot aantal sleutels heeft, deze code veel tijd besteedt, in vergelijking met de andere antwoorden hier.


Antwoord 13

U kunt array_filter()gebruiken die goed werkt voor alle situaties:

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

Antwoord 14

Het meest geschikte beslissing nemen vereist kennen van de kwaliteit van uw gegevens en welke processen moeten volgen.

  1. Als u deze rij gaat diskwalificeren / negeren / verwijderen, moet het vroegste punt van filtratie in de MySQL-query zijn.
  • WHERE players IS NOT NULL
  • zijn

  • WHERE players != ''
  • WHERE COALESCE(players, '') != ''
  • WHERE players IS NOT NULL AND players != ''
  • … het is af van uw winkelgegevens en er zullen andere manieren zijn, ik stop hier.
  1. Als u niet 100% zeker bent of de kolom bestaat in de resultatenset, moet u controleren of de kolom wordt gedeclareerd. Dit betekent bellen met array_key_exists(), isset()of empty()OP DE KOLOM. Ik ga niet de moeite nemen om de verschillen hier te zorgen (er zijn andere zo-pagina’s voor die pech, hier is een start: 1 , 2 , 3 ). Dat gezegd hebbende, als u niet in totale controle over de resultaatreeks bevindt, dan heeft u misschien een overgegeven applicatie “flexibiliteit” en moet het opnieuw heroverwikkelen of de moeite van de toegang tot niet-bestaande kolomgegevens waard is. Effectief, ik zeg dat je nooit hoeft te controleren of een kolom wordt gedeclareerd – Ergo moet je nooit empty()voor deze taak nodig hebben. Als iemand dat doet empty()is meer geschikt, dan duwen ze hun eigen persoonlijke mening over expressiviteit van scripting. Als u de conditie in # 5 hieronder vindt om dubbelzinnig te zijn, voegt u een inline-commentaar toe aan uw code – maar dat zou ik niet doen. De onderste regel is dat er geen programmatisch voordeel is om de functie-oproep te doen.

  2. Kan uw stringwaarde een 0bevatten die u echt / geldig / niet leeg wilt geven? Zo ja, dan hoeft u alleen te controleren of de kolomwaarde lengte heeft.

Hier is een Demo met strlen(). Dit zal aangegeven of de tekenreeks een zinvolle array-elementen zal maken als deze wordt geëxploeld.

  1. Ik denk dat het belangrijk is om te vermelden dat door onvoorwaardelijk te exploderen, je GEGARANDEERD bent om een niet-lege array te genereren.Hier is het bewijs: DemoMet andere woorden, controleren of de array leeg is, is volkomen nutteloos — hij zal elke keer niet leeg zijn.

  2. Als je string MOGELIJK GEEN nulwaarde zal bevatten (omdat dit bijvoorbeeld een csv is dat bestaat uit id’s die beginnen bij 1en alleen toenemen), dan if ($gamerow['players']) {is alles wat je nodig hebt — einde verhaal.

  3. …maar wacht, wat doe je nadat je de leegte van deze waarde hebt bepaald? Als je iets down-script hebt dat $playerlistverwacht, maar je die variabele voorwaardelijk declareert, dan riskeer je de waarde van de vorige rij te gebruiken of opnieuw mededelingen te genereren. Dus moet je $playerlistonvoorwaardelijk verklaren als iets? Als de tekenreeks geen waarheidswaarden bevat, heeft uw toepassing dan baat bij het declareren van een lege array? De kans is groot dat het antwoord ja is. In dit geval kunt u ervoor zorgen dat de variabele van het array-type is door terug te vallen op een lege array – op deze manier maakt het niet uit of u die variabele in een lus invoert. De volgende voorwaardelijke verklaringen zijn allemaal gelijkwaardig.

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

Waarom heb ik zoveel moeite gedaan om deze zeer basale taak uit te leggen?

  1. Ik heb een klootzak op deze pagina en dit antwoord zal waarschijnlijk wraakvrije stemmen trekken (dit gebeurt vaak met klokkenluiders die deze site verdedigen – als een antwoord deuntvinden en geen opmerkingen hebben, wees altijd sceptisch).
  2. Ik denk dat het belangrijk is dat Stackoverflow een vertrouwde hulpbron is die onderzoekers niet vergiftigt met verkeerde informatie en suboptimale technieken.
  3. Dit is hoe ik laat zien hoeveel ik om aanstaande ontwikkelaars geef, zodat ze leren hoe en het waarom in plaats van gewoon een generatie kopie-plakken programmeurs te geven.
  4. Ik gebruik vaak oude pagina’s om nieuwe dubbele pagina’s te sluiten – dit is de verantwoordelijkheid van veteraanvrijwilligers die weten hoe ze snel duplicaten kunnen vinden. Ik kan mezelf niet brengen om een ​​oude pagina te gebruiken met slechte / false / suboptimale / misleidende informatie als referentie, want dan doe ik actief een slechte dienst aan een nieuwe onderzoeker.

Antwoord 15

$gamerow = mysql_fetch_array($gameresult);
if (!empty(($gamerow['players'])) {
   $playerlist = explode(",", $gamerow['players']);
}else{
  // do stuf if array is empty
}

Antwoord 16

Ik denk dat de beste manier om te bepalen of de array leeg is of niet is om count () zoals SO te gebruiken:

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

Antwoord 17

empty($gamerow['players'])

Antwoord 18

$status = "";
$new_array = array();
if(!empty($new_array)){
  $status = "1";   // not a blank array
}
else{
  $status = "0";   // blank array
}

Antwoord 19

Er zijn al veel opties besproken om te controleren of een array leegis of geen waarde bevat, zoals er wel zijn

if ($playerlist) {}

if (!empty($playerlist)) {}

if (count($playerlist) > 0) {}

Ze hebben allemaal hun voor- en nadelen.

Maarer is nog een andere optie, die haalbaar kan zijn als je zeker weet dat je array alleen numerieke toetsen heeft, beginnend bij nul (dit gebeurt als je explode()een tekenreeks):

if (isset($playerlist[0])) {
  // do something
}

Dit is zelfs een beetje sneller dan de andere oplossingen.


Antwoord 20

Ik heb dit probleem opgelost met de volgende code.

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

Antwoord 21

Dit lijkt in alle gevallen te werken

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

Other episodes