Jak sprawdzić, czy tablica jest pusta za pomocą PHP?

playersbędzie albo pusta, albo rozdzielona przecinkami lista (lub pojedyncza wartość). Jak najłatwiej sprawdzić, czy jest pusty? Zakładam, że mogę to zrobić zaraz po pobraniu $gameresulttablicy $gamerow? W takim przypadku prawdopodobnie bardziej efektywne byłoby pominięcie eksplodowania, $playerlistjeśli jest puste, ale ze względu na argument, w jaki sposób sprawdziłbym, czy tablica jest pusta?

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

Jeśli musisz tylko sprawdzić, czy w tablicy są ŻADNE elementy

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

Jeśli musisz wyczyścić puste wartości przed sprawdzeniem (zazwyczaj robione w celu zapobiegania explodedziwnym ciągom znaków):

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

W PHP pusta tablica jest falsey, więc nie musisz jej używać, empty()jak sugerowali inni.

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

PHP empty()sprawdza, czy zmienna nie istnieje lub ma wartość falsey (jak array(), 0, null, false, etc).

W większości przypadków po prostu chcesz to sprawdzić !$emptyVar. Użyj, empty($emptyVar)jeśli zmienna mogła nie zostać ustawiona ORAZ nie będziesz wyzwalać E_NOTICE; IMO to ogólnie zły pomysł.

Kilka przyzwoitych odpowiedzi, ale pomyślałem, że rozwinę się nieco, aby wyjaśnić jaśniej, kiedy PHP określi, czy tablica jest pusta.

Główne uwagi:

Tablica z kluczem (lub kluczami) zostanie określona przez PHP jako NIE pusta .

Ponieważ wartości tablicowe wymagają istnienia kluczy, posiadanie wartości w tablicy lub nie, nie określa, czy jest ona pusta, tylko jeśli nie ma kluczy (ORAZ dlatego nie ma wartości).

Sprawdzanie tablicy za pomocą empty()nie tylko informuje, czy masz wartości, czy nie, ale informuje, czy tablica jest pusta, a klucze są częścią tablicy.

Zastanów się, w jaki sposób tworzysz tablicę, zanim zdecydujesz, której metody sprawdzania użyć.
EG Tablica będzie miała klucze, gdy użytkownik prześle formularz HTML, gdy każde pole formularza ma nazwę tablicy (tj name="array[]".).
Dla każdego pola zostanie utworzona niepusta tablica, ponieważ dla każdej tablicy pola formularza będą automatycznie zwiększane wartości klucza.

Weźmy na przykład te tablice:

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

Po wygenerowaniu echa kluczy tablicowych i wartości dla powyższych tablic otrzymujesz:

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

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

TREŚĆ TRZECIA:
[0] => []
[1] => []

I testowanie powyższych tablic za pomocą empty()zwraca następujące wyniki:

ARRAY ONE:
$ ArrayOne nie jest pusty

TABELA DRUGA: $ ArrayTwo nie jest puste

TABELA TRZECIA: $ ArrayThree nie jest pusty

Tablica zawsze będzie pusta po przypisaniu tablicy, ale nie będzie jej później używana, na przykład:

$ArrayFour = array();

To będzie puste, tzn. PHP zwróci PRAWDA, jeśli użyjesz empty()powyższego.

Więc jeśli twoja tablica ma klucze - albo przez np. Nazwy wejściowe formularza lub jeśli przypisujesz je ręcznie (tj. Utwórz tablicę z nazwami kolumn bazy danych jako kluczami, ale bez wartości / danych z bazy danych), to tablica NIE będzie empty().

W takim przypadku możesz zapętlić tablicę w foreach, sprawdzając, czy każdy klucz ma wartość. Jest to dobra metoda, jeśli mimo to musisz uruchomić tablicę, na przykład sprawdzając klucze lub odkażając dane.

Jednak nie jest to najlepsza metoda, jeśli po prostu trzeba wiedzieć „jeśli wartości istnieją” zwraca PRAWDA lub FAŁSZ . Istnieją różne metody określania, czy tablica ma jakieś wartości, gdy wiadomo, że będzie miała klucze. Funkcja lub klasa może być najlepszym podejściem, ale jak zawsze zależy od środowiska i dokładnych wymagań, a także innych rzeczy, takich jak to, co obecnie robisz z tablicą (jeśli w ogóle).

Oto podejście, które wykorzystuje bardzo mało kodu do sprawdzenia, czy tablica ma wartości:

Użycie array_filter():
Iteruje każdą wartość w tablicy, przekazując ją do funkcji zwrotnej. Jeśli funkcja zwrotna zwraca wartość true, bieżąca wartość z tablicy jest zwracana do tablicy wynikowej. Klucze tablicy są zachowane.

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

Uruchomienie array_filter()wszystkich trzech przykładowych tablic (utworzonych w pierwszym bloku kodu w tej odpowiedzi) powoduje:

Tablica pierwsza : $ arrayone nie jest pusty

TABELA DRUGA: $ arraytwo nie jest pusta

ARRAY TRZY:
$ arraythree jest pusty

Więc jeśli nie ma wartości, czy są klucze, czy nie, użycie array_filter()do utworzenia nowej tablicy, a następnie sprawdzenie, czy nowa tablica jest pusta, pokazuje, czy w oryginalnej tablicy były jakieś wartości.
Nie jest idealny i nieco niechlujny, ale jeśli masz ogromną tablicę i nie musisz z niej zapętlać z jakiegokolwiek innego powodu, jest to najprostszy pod względem wymaganego kodu.

Nie mam doświadczenia w sprawdzaniu kosztów ogólnych, ale dobrze byłoby znać różnice między używaniem array_filter()a foreachsprawdzaniem, czy wartość została znaleziona.

Oczywiście benchmark musiałby dotyczyć różnych parametrów, małych i dużych tablic oraz gdy istnieją wartości, a nie itd.

count($gamerow['players']) będzie 0.

Jeśli chcesz się upewnić, czy testowana zmienna jest jawnie pustą tablicą, możesz użyć czegoś takiego:

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

Jeśli chcesz wykluczyć fałszywe lub puste wiersze (np. 0 => ''), W których użycie empty()zakończy się niepowodzeniem, możesz spróbować:

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

array_filter(): Jeśli nie podano wywołania zwrotnego, wszystkie wpisy tablicy równe FAŁSZ (patrz konwersja na wartość logiczną) zostaną usunięte.

Jeśli chcesz usunąć wszystkie wartości NULL, FALSE i puste łańcuchy ( ''), ale pozostaw wartości zerowe ( 0), możesz użyć strlenjako wywołania zwrotnego, np .:

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

Dlaczego nikt nie powiedział tej odpowiedzi:

$array = [];

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

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

is_array

Przeprowadziłem test porównawczy zawarty na końcu wpisu. Aby porównać metody:

• count($arr) == 0 : count
• empty($arr) : pusty
• $arr == [] : comp
• (bool) $arr : obsada

i uzyskałem następujące wyniki

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

Różnica między pustym a rzutowaniem na wartość logiczną jest nieznaczna. Przeprowadziłem ten test wiele razy i wydają się one zasadniczo równoważne. Zawartość tablic nie wydaje się odgrywać znaczącej roli. Oba dają przeciwne wyniki, ale logiczna negacja ledwo wystarcza, aby rzucić casting do zwycięstwa przez większość czasu, więc osobiście wolę pustą ze względu na czytelność w obu przypadkach.

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

jeśli chcesz sprawdzić zawartość tablicy, której możesz użyć:

$arr = array();

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

patrz tutaj: http://codepad.org/EORE4k7v

Moim zdaniem najprostszym sposobem dla tablicy indeksowanej byłoby po prostu:

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

Warunek „if” w tablicy miałby wartość true, jeśli tablica nie jest pusta, i false, jeśli tablica jest pusta . To nie dotyczy tablic asocjacyjnych.

Używam tego kodu

$variable = array();

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

Należy jednak pamiętać, że jeśli tablica ma dużą liczbę kluczy, kod ten poświęci dużo czasu na ich liczenie, w porównaniu do innych odpowiedzi tutaj.

Możesz użyć, array_filter()który działa świetnie we wszystkich sytuacjach:

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

Myślę, że najlepszym sposobem ustalenia, czy tablica jest pusta, czy nie, jest użycie metody count () w następujący sposób:

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

Podjęcie najwłaściwszej decyzji wymaga znajomości jakości danych i procesów, które należy wykonać.

1. Jeśli zamierzasz zdyskwalifikować / zignorować / usunąć ten wiersz, najwcześniejszy punkt filtracji powinien znajdować się w zapytaniu mysql.

   • WHERE players IS NOT NULL
   • WHERE players != ''
   • WHERE COALESCE(players, '') != ''
   • WHERE players IS NOT NULL AND players != ''
   • ... to zależy od danych twojego sklepu i będą inne sposoby, zatrzymam się tutaj.

2. Jeśli nie jesteś w 100% pewien, czy kolumna będzie istnieć w zestawie wyników, powinieneś sprawdzić, czy kolumna jest zadeklarowana. Będzie to oznaczać wywołanie array_key_exists(), isset()lubempty() na kolumnie. Nie zamierzam zawracać sobie głowy opisywaniem różnic (istnieją inne strony SO dla tego podziału, oto początek: 1 , 2 , 3 ). To powiedziawszy, jeśli nie masz całkowitej kontroli nad zestawem wyników, być może masz nadmierną pobłażliwość „elastyczności” aplikacji i powinieneś przemyśleć, czy warto mieć problem z dostępem do nieistniejących danych w kolumnie. Mówiąc skutecznie, nigdy nie powinieneś sprawdzać, czy kolumna jest zadeklarowana - a więc nigdy nie powinieneś empty()tego robić. Jeśli ktoś to twierdziempty()jest bardziej odpowiednie, wtedy wypierają własną opinię o ekspresyjności skryptów. Jeśli uznasz, że warunek w punkcie 5 poniżej jest niejednoznaczny, dodaj komentarz wbudowany do swojego kodu - ale nie zrobiłbym tego. Najważniejsze jest to, że wywołanie funkcji nie ma programowej korzyści.

3. Może twoja wartość ciągu zawiera 0 , którą chcesz uznać za prawdziwą / prawidłową / niepustą? Jeśli tak, wystarczy sprawdzić, czy wartość kolumny ma długość.

   Tutaj jest użycie wersji demonstracyjnejstrlen() . To wskaże, czy ciąg utworzy znaczące elementy tablicy, jeśli zostanie rozbity.

4. Myślę, że ważne jest, aby wspomnieć, że poprzez bezwarunkowe wybuchanie, GWARANTOWANE jest wygenerowanie niepustej tablicy. Oto dowód: Demo Innymi słowy, sprawdzanie, czy tablica jest pusta, jest całkowicie bezużyteczne - za każdym razem będzie niepuste.

5. Jeśli Twój łańcuch NIE MOŻE zawierać wartości zerowej (ponieważ, powiedzmy, jest to plik csv składający się z identyfikatorów zaczynających się od 1 i tylko przyrostowo), if ($gamerow['players']) {to wszystko, czego potrzebujesz - koniec historii.

6. ... ale poczekaj, co robisz po określeniu pustki tej wartości? Jeśli masz coś, co się spodziewa $playerlist, ale warunkowo deklarujesz tę zmienną, ryzykujesz użycie wartości z poprzedniego wiersza lub ponowne wygenerowanie Powiadomień. Czy więc musisz bezwarunkowo zadeklarować $playerlistjako coś ? Jeśli w ciągu nie ma żadnych prawdziwych wartości, czy Twoja aplikacja korzysta z deklarowania pustej tablicy? Możliwe, że odpowiedź brzmi tak. W takim przypadku możesz upewnić się, że zmienna jest typu tablicowego, wracając do pustej tablicy - w ten sposób nie będzie miało znaczenia, jeśli wprowadzisz tę zmienną do pętli. Wszystkie poniższe deklaracje warunkowe są równoważne.

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

Dlaczego dołożyłem wszelkich starań, aby wyjaśnić to bardzo podstawowe zadanie?

1. Omówiłem prawie każdą odpowiedź na tej stronie i ta odpowiedź prawdopodobnie przyciągnie głosy zemsty (zdarza się to często demaskatorom, którzy bronią tej witryny - jeśli odpowiedź ma opinie negatywne i brak komentarzy, zawsze bądź sceptyczny).
2. Myślę, że ważne jest, aby Stackoverflow był zaufanym zasobem, który nie zatruwa badaczy błędnymi informacjami i nieoptymalnymi technikami.
3. W ten sposób pokazuję, jak bardzo dbam o przyszłych programistów, aby dowiedzieli się, jak i dlaczego zamiast po prostu karmić łyżką pokolenie programistów kopiujących i wklejających.
4. Często używam starych stron do zamykania nowych zduplikowanych stron - to obowiązek weteranów-wolontariuszy, którzy wiedzą, jak szybko znaleźć duplikaty. Nie mogę zmusić się do użycia starej strony ze złymi / fałszywymi / nieoptymalnymi / wprowadzającymi w błąd informacjami jako odniesieniem, ponieważ wtedy czynnie szkodzę nowemu badaczowi.

empty($gamerow['players'])

Rozwiązałem ten problem za pomocą następującego kodu.

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

Wydaje się, że działa to we wszystkich przypadkach

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

Co powiesz na:

DepartmentPerSchool = array ();
(pusty (is_array ($ DepartmentPerSchool)))? $ DepartmentPerSchool // lub echo nie jest puste: array ('not set' => 'Not set. Contact Admin'); // lub echo jest puste