PHP kullanarak bir dizinin boş olup olmadığı nasıl kontrol edilir?

playersboş veya virgülle ayrılmış bir liste (veya tek bir değer) olur. Boş olup olmadığını kontrol etmenin en kolay yolu nedir? Ben $gameresultdizi içine getirilir getirmez bunu yapabilirim varsayıyorum $gamerow? Bu durumda $playerlist, boşsa patlamayı atlamak daha verimli olur , ancak tartışma amacıyla, bir dizinin de boş olup olmadığını nasıl kontrol edebilirim?

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

Dizide HERHANGİ bir öğe olup olmadığını kontrol etmeniz gerekiyorsa

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

Kontrol etmeden önce boş değerleri temizlemeniz gerekiyorsa (genellikle explodegarip dizeleri önlemek için yapılır ):

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

Boş bir dizi PHP'de falsey olduğundan empty(), başkalarının önerdiği gibi kullanmanıza bile gerek yoktur .

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

PHP en empty()değişken yok veya (böyle bir Falsey değeri vardır değilse belirler array(), 0, null, false, vs).

Çoğu durumda kontrol etmek istersiniz !$emptyVar. Kullanım empty($emptyVar)değişken seti edilmiş olmayabilir VE Bir tetiklemek için alışkanlık yoksa E_NOTICE; IMO bu genellikle kötü bir fikirdir.

Bazı iyi cevaplar, ama sadece PHP bir dizi boş olup olmadığını belirlediğinde daha net açıklamak için biraz genişletmek düşündüm.

Ana Notlar:

Anahtarlı (veya anahtarlı) bir dizi PHP tarafından boş DEĞİL olarak belirlenir .

Dizi değerleri anahtarlara ihtiyaç duyduğundan, bir dizide değerlere sahip olmak ya da olmamak, yalnızca anahtar yoksa (VE dolayısıyla değer yoksa) boş olup olmadığını belirlemez.

Bu nedenle, bir diziyi kontrol etmek empty()size değerleriniz olup olmadığını söylemez, dizinin boş olup olmadığını ve anahtarların bir dizinin parçası olup olmadığını söyler.

Hangi kontrol yöntemini kullanacağınıza karar vermeden önce dizinizi nasıl ürettiğinizi düşünün.
EG Her form alanı bir dizi adına (ör. ) Sahip olduğunda, kullanıcı HTML formunuzu gönderdiğinde bir dizi anahtarlara sahip olacaktırname="array[]" .
Bir boş olmayan bir otomatik her form alanının dizisi için anahtar değerleri artırılır olacak şekilde dizisi, her bir alan için üretilecektir.

Örneğin bu dizileri ele alalım:

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

Yukarıdaki diziler için dizi anahtarlarını ve değerleri yankılarsanız, aşağıdakileri elde edersiniz:

BİR ARRAY:
[UserKeyA] => [UserValueA]
[UserKeyB] => [UserValueB]

İKİNCİ
Dizi : [0] => [UserValue01]
[1] => [UserValue02]

ÜÇÜNCÜ Dizi:
[0] => []
[1] => []

Ve yukarıdaki dizileri test etmek empty()aşağıdaki sonuçları döndürür:

BİR
DÜZEN : $ ArrayOne boş değil

İKİ İKİ:
$ ArrayTwo boş değil

ÜÇÜNCÜ
DÜZEN : $ ArrayThree boş değil

Bir dizi atadığınızda bir dizi her zaman boş olur, ancak bundan sonra onu kullanmazsınız, örneğin:

$ArrayFour = array();

Bu boş olacak, yani empty()yukarıdaki durumlarda kullanılırken PHP TRUE döndürecektir .

Dolayısıyla dizinizde anahtarlar varsa - örneğin bir formun giriş adlarıyla veya bunları manuel olarak atarsanız (örn. Anahtar olarak veritabanı sütun adlarıyla bir dizi oluşturun ancak veritabanından değer / veri yok), dizi DEĞİLDİR empty().

Bu durumda, dizinin bir foreach içinde döngüye girip her anahtarın bir değeri olup olmadığını test edebilirsiniz. Yine de dizi üzerinden çalışmanız, belki de anahtarları kontrol etmeniz veya verileri sterilize etmeniz gerekiyorsa, bu iyi bir yöntemdir.

Ancak, "değerlerin olup olmadığını" DOĞRU veya YANLIŞ döndürdüğünü bilmeniz gerekiyorsa en iyi yöntem değildir . Bir dizinin anahtarları olacağını bildiğinde herhangi bir değere sahip olup olmadığını belirlemek için çeşitli yöntemler vardır. Bir işlev veya sınıf en iyi yaklaşım olabilir, ancak her zaman olduğu gibi ortamınıza ve kesin gereksinimlerin yanı sıra şu anda dizi ile ne yaptığınız gibi başka şeylere (herhangi bir şey varsa) bağlıdır.

İşte bir dizinin değerleri olup olmadığını kontrol etmek için çok az kod kullanan bir yaklaşım:

Kullanım array_filter():
Dizideki her bir değeri geri arama işlevine geçirerek yineler. Geri arama işlevi true değerini döndürürse, dizideki geçerli değer sonuç dizisine döndürülür. Dizi anahtarları korunur.

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

Koşu array_filter()(bu yanıtında ilk kod bloğu oluşturulan) aşağıda sonuçları her üç örnek diziler üzerinde:

BİR
DÜZEN : $ arrayone boş değil

İKİ İKİ:
$ arraytwo boş değil

ÜÇÜNCÜ
Dizi : $ arraythree boş

Bu nedenle, herhangi bir değer olmadığında, anahtarlar olsun veya olmasın, array_filter()yeni bir dizi oluşturmak için kullanın ve sonra yeni dizinin boş olup olmadığını kontrol edin, orijinal dizide herhangi bir değer olup olmadığını gösterir.
İdeal ve biraz dağınık değil, ancak büyük bir diziniz varsa ve başka bir nedenden dolayı döngü yapmanıza gerek yoksa, bu gerekli kod açısından en basit olanıdır.

Genel giderlerin kontrolünde deneyimli değilim, ancak bir değerin bulunup bulunmadığını kontrol etmek array_filter()ve kullanmak arasındaki farkları bilmek iyi olurdu foreach.

Açıkçası, karşılaştırmanın çeşitli parametrelerde, küçük ve büyük dizilerde ve değerler olduğunda vb.

count($gamerow['players']) 0 olacaktır.

Test ettiğiniz değişkenin gerçekten boş bir dizi olup olmadığını öğrenmek istiyorsanız, şöyle bir şey kullanabilirsiniz:

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

Yanlış veya boş satırları (örneğin 0 => '') hariç tutmak empty()istiyorsanız, kullanımın başarısız olacağı yerde deneyebilirsiniz:

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

array_filter(): Herhangi bir geri arama sağlanmazsa, FALSE öğesine eşit olan tüm dizi girişleri (bkz. Boole'ye dönüştürme) kaldırılacaktır.

Tüm NULL, FALSE ve boş dizeleri ( '') kaldırmak , ancak sıfır değer ( 0) bırakmak isterseniz, strlengeri arama olarak kullanabilirsiniz , örneğin:

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

Neden kimse bu cevabı söylemedi:

$array = [];

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

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

is_array

Gönderinin sonunda yer alan karşılaştırmalı değerlendirmeyi yaptım. Yöntemleri karşılaştırmak için:

• count($arr) == 0 : Miktar
• empty($arr) : boş
• $arr == [] : comp
• (bool) $arr : oyuncular

ve aşağıdaki sonuçları aldı

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

Boş ve bir boole dökümü arasındaki fark önemsizdir. Bu testi birkaç kez çalıştırdım ve aslında eşdeğer görünüyorlar. Dizilerin içeriği önemli bir rol oynamıyor gibi görünüyor. İkisi tam tersi sonuçlar doğurur, ancak mantıksal olumsuzlama, dökümleri çoğu zaman kazanmaya itmek için yeterli değildir, bu yüzden her iki durumda da okunaklılık uğruna şahsen boş olmayı tercih ederim.

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

Kullanabileceğiniz dizi içeriğini kontrol edecekseniz:

$arr = array();

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

buraya bakın: http://codepad.org/EORE4k7v

Bence bir endeksli dizi için en basit yolu basit olurdu:

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

Bir 'eğer' dizisinde koşulu ile değerlendirirsiniz dizi boş değilse, gerçek ve dizi boşsa yanlış . Bu ilişkisel diziler için geçerli değildir .

Bu kodu kullanıyorum

$variable = array();

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

Ancak, dizinin çok sayıda anahtarı varsa, bu kodun buradaki diğer cevaplara kıyasla onları saymak için çok zaman harcayacağını unutmayın.

array_filter()Hangisinin tüm durumlar için harika olduğunu kullanabilirsiniz :

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

Dizi boş olup olmadığını belirlemek için en iyi yolu düşünüyorum count () gibi kullanmaktır:

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

En uygun kararı vermek için verilerinizin kalitesini ve hangi süreçlerin izleneceğini bilmek gerekir.

1. Bu satırı diskalifiye edecek / dikkate almayacak / kaldıracaksanız, filtrasyonun en erken noktası mysql sorgusunda olmalıdır.

   • WHERE players IS NOT NULL
   • WHERE players != ''
   • WHERE COALESCE(players, '') != ''
   • WHERE players IS NOT NULL AND players != ''
   • ... mağaza verilerinize bağlıdır ve başka yollar da olacaktır, burada duracağım.

2. Sütunun sonuç kümesinde bulunup bulunmayacağından% 100 emin değilseniz, sütunun bildirildiğinden emin olmalısınız. Bu çağırarak anlamına gelecektir array_key_exists(), isset()veya empty()sütun üzerinde. Buradaki farklılıkları tanımlamak için uğraşmayacağım (bu arıza için başka SO sayfaları var, işte bir başlangıç: 1 , 2 , 3 ). Bununla birlikte, sonuç kümesinin tam kontrolünde değilseniz, o zaman belki de aşırı indüklenmiş uygulama "esnekliğine" sahipsiniz ve mevcut olmayan sütun verilerine erişme sorununun buna değip değmediğini yeniden düşünmelisiniz. Etkili bir şekilde, bir sütunun bildirilip bildirilmediğini asla kontrol etmeniz gerekmediğini söylüyorum - ergo empty()bu görev için asla ihtiyacınız olmamalıdır . Eğer biri bunu tartışıyorsaempty()daha uygunsa, senaryo anlatımının dışavurumculuğu hakkında kendi kişisel görüşlerini itiyorlar. Aşağıdaki # 5 koşulunu belirsiz bulursanız, kodunuza satır içi bir yorum ekleyin - ama yapmazdım. Sonuç olarak, fonksiyon çağrısı yapmanın programlı bir avantajı yoktur.

3. Dize değeriniz bir 0 doğru / geçerli / boş olmayan mi? Öyleyse, yalnızca sütun değerinin uzunluğuna sahip olup olmadığını kontrol etmeniz gerekir.

   İşte bir Demo kullanıyor strlen(). Bu, dizenin patladığında anlamlı dizi öğeleri oluşturup oluşturmayacağını gösterecektir.

4. Koşulsuz patlayarak, boş olmayan bir dizi oluşturmak için GARANTİLİ olduğunuzu belirtmek önemlidir. Kanıt: Demo Başka bir deyişle, dizinin boş olup olmadığını kontrol etmek tamamen işe yaramaz - her seferinde boş olmayacaktır.

5. Dizeniz OLASI OLMAYAN bir sıfır değeri içermiyorsa (diyelim ki, bu, 1yalnızca başlangıçtan başlayan ve yalnızca artışlı kimliklerden oluşan bir csv'dir ), o if ($gamerow['players']) {zaman ihtiyacınız olan tek şey - hikayenin sonu.

6. ... ama bekle, bu değerin boşluğunu belirledikten sonra ne yapıyorsun? Bekleyen bir komut dosyanız varsa $playerlist, ancak bu değişkeni koşullu olarak bildiriyorsanız, önceki satırın değerini kullanma veya yeniden Bildirimler oluşturma riskiyle karşı karşıya kalırsınız. Peki koşulsuz $playerlistolarak bir şey olarak ilan etmeniz gerekiyor mu? Dizede doğruluk değerleri yoksa, uygulamanız boş bir dizi bildirmekten yararlanır mı? Şansı var, cevap evet. Bu durumda, boş bir diziye geri dönerek değişkenin dizi türü olduğundan emin olabilirsiniz; bu şekilde, bu değişkeni bir döngüye beslemeniz önemli değildir. Aşağıdaki koşullu bildirimlerin hepsi eşdeğerdir.

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

Bu çok temel görevi açıklamak için neden bu kadar uzun sürdüm?

1. Bu sayfadaki hemen hemen her cevabı düdük çalıyorum ve bu cevabın intikam oyu çizmesi muhtemeldir (bu genellikle bu siteyi savunan muhbirlere olur - eğer bir cevabın downvotes ve yorumları yoksa, her zaman şüpheci olur).
2. Stackoverflow'un araştırmacıları yanlış bilgi ve yetersiz tekniklerle zehirlemeyen güvenilir bir kaynak olması önemli olduğunu düşünüyorum.
3. Bu, gelecek geliştiricilere ne kadar önem verdiğimi göstereceğim, böylece bir nesil kopyala yapıştır programcılarını sadece kaşıkla beslemek yerine nasıl ve nedenini öğrenecekler.
4. Sıklıkla yeni yinelenen sayfaları kapatmak için eski sayfaları kullanıyorum - bu, yinelenenleri hızlı bir şekilde nasıl bulacağını bilen kıdemli gönüllülerin sorumluluğundadır. Kendimi kötü / yanlış / yetersiz / yanıltıcı bilgi içeren eski bir sayfayı referans olarak kullanamıyorum çünkü o zaman aktif olarak yeni bir araştırmacıya kötülük yapıyorum.

empty($gamerow['players'])

Bu kodu aşağıdaki kodla çözdüm.

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

Bu tüm durumlar için işe yarıyor gibi görünüyor

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

Nasıl olur:

DepartmentPerSchool = array ();
(boş (is_array ($ DepartmentPerSchool)))? $ DepartmentPerSchool // veya echo boş değil: array ('not set' => 'Not set. Admin'e başvurun'); // veya yankı boş