Bagaimana cara memeriksa apakah array kosong menggunakan PHP?

playersakan berupa daftar kosong atau koma (atau nilai tunggal). Apa cara termudah untuk memeriksa apakah itu kosong? Saya berasumsi saya bisa melakukannya segera setelah saya mengambil $gameresultarray $gamerow? Dalam hal ini mungkin akan lebih efisien untuk melewatkan meledak $playerlistjika itu kosong, tetapi demi argumen, bagaimana saya akan memeriksa apakah sebuah array kosong juga?

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

Jika Anda hanya perlu memeriksa apakah ada elemen APAPUN dalam array

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

Jika Anda perlu membersihkan nilai kosong sebelum memeriksa (umumnya dilakukan untuk mencegah explodestring aneh):

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

Array kosong adalah falsey dalam PHP, jadi Anda bahkan tidak perlu menggunakan empty()seperti yang disarankan orang lain.

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

PHP empty()menentukan apakah variabel tidak ada atau memiliki nilai falsey (seperti array(), 0, null, false, dll).

Dalam kebanyakan kasus, Anda hanya ingin memeriksa !$emptyVar. Gunakan empty($emptyVar)jika variabel mungkin belum disetel DAN Anda tidak ingin memicu E_NOTICE; IMO ini umumnya merupakan ide yang buruk.

Beberapa jawaban yang layak, tetapi hanya berpikir saya akan memperluas sedikit untuk menjelaskan lebih jelas ketika PHP menentukan apakah array kosong.

Catatan Utama:

Array dengan kunci (atau kunci) akan ditentukan sebagai TIDAK kosong oleh PHP.

Karena nilai array memerlukan kunci untuk ada, memiliki nilai atau tidak dalam array tidak menentukan apakah itu kosong, hanya jika tidak ada kunci (DAN karenanya tidak ada nilai).

Jadi memeriksa array dengan empty()tidak hanya memberi tahu Anda apakah Anda memiliki nilai atau tidak, itu memberi tahu Anda jika array kosong, dan kunci adalah bagian dari array.

Jadi pertimbangkan bagaimana Anda menghasilkan array Anda sebelum memutuskan metode pemeriksaan mana yang akan digunakan.
EG Sebuah array akan memiliki kunci ketika pengguna mengirimkan formulir HTML Anda ketika setiap bidang formulir memiliki nama array (yaitu name="array[]").
Sebuah non kosong array akan diproduksi untuk setiap bidang karena akan ada otomatis bertambah nilai-nilai kunci untuk array setiap form lapangan.

Ambil contoh array ini:

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

Jika Anda mengulangi kunci dan nilai array untuk array di atas, Anda mendapatkan yang berikut:

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

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

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

Dan menguji array di atas dengan empty()mengembalikan hasil berikut:

SATU ARRAY:
$ ArrayOne tidak kosong

ARRAY DUA:
$ ArrayTwo tidak kosong

ARRAY THREE:
$ ArrayThree tidak kosong

Array akan selalu kosong ketika Anda menetapkan array tetapi tidak menggunakannya setelah itu, seperti:

$ArrayFour = array();

Ini akan kosong, yaitu PHP akan mengembalikan BENAR saat menggunakan jika empty()di atas.

Jadi jika array Anda memiliki kunci - baik dengan misalnya nama input formulir atau jika Anda menetapkannya secara manual (yaitu membuat array dengan nama kolom basis data sebagai kunci tetapi tidak ada nilai / data dari database), maka array tersebut TIDAK akan empty().

Dalam hal ini, Anda bisa mengulang array dalam foreach, menguji apakah setiap kunci memiliki nilai. Ini adalah metode yang baik jika Anda perlu menjalankan array, mungkin memeriksa kunci atau membersihkan data.

Namun itu bukan metode terbaik jika Anda hanya perlu tahu "jika ada nilai" mengembalikan BENAR atau SALAH . Ada berbagai metode untuk menentukan apakah sebuah array memiliki nilai ketika ia tahu itu akan memiliki kunci. Fungsi atau kelas mungkin merupakan pendekatan terbaik, tetapi seperti biasa itu tergantung pada lingkungan Anda dan persyaratan yang tepat, serta hal-hal lain seperti apa yang saat ini Anda lakukan dengan array (jika ada).

Berikut ini pendekatan yang menggunakan kode sangat sedikit untuk memeriksa apakah array memiliki nilai:

Menggunakan array_filter():
Iterasikan setiap nilai dalam array yang meneruskannya ke fungsi panggilan balik. Jika fungsi panggilan balik kembali benar, nilai saat ini dari array dikembalikan ke array hasil. Kunci array dipertahankan.

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

Menjalankan array_filter()ketiga contoh array (dibuat di blok kode pertama dalam jawaban ini) menghasilkan sebagai berikut:

ARRAY ONE:
$ arrayone tidak kosong

ARRAY DUA:
$ arraytwo tidak kosong

ARRAY THREE:
$ arraythree kosong

Jadi ketika tidak ada nilai, apakah ada kunci atau tidak, gunakan array_filter()untuk membuat array baru dan kemudian periksa apakah array baru kosong menunjukkan apakah ada nilai dalam array asli.
Ini tidak ideal dan sedikit berantakan, tetapi jika Anda memiliki array yang besar dan tidak perlu mengulanginya karena alasan lain, maka ini adalah yang paling sederhana dalam hal kode yang diperlukan.

Saya tidak berpengalaman dalam memeriksa overhead, tetapi akan lebih baik untuk mengetahui perbedaan antara menggunakan array_filter()dan foreachmemeriksa jika nilai ditemukan.

Tentunya tolok ukur harus pada berbagai parameter, pada array kecil dan besar dan ketika ada nilai dan tidak dll.

count($gamerow['players']) akan menjadi 0.

Jika Anda ingin memastikan apakah variabel yang Anda uji sebenarnya adalah array kosong, Anda bisa menggunakan sesuatu seperti ini:

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

Jika Anda ingin mengecualikan baris palsu atau kosong (seperti 0 => ''), di mana penggunaan empty()akan gagal, Anda dapat mencoba:

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

array_filter(): Jika tidak ada callback yang diberikan, semua entri array yang sama dengan FALSE (lihat konversi ke boolean) akan dihapus.

Jika Anda ingin menghapus semua NULL, FALSE dan string kosong ( ''), tetapi meninggalkan nilai nol ( 0), Anda dapat menggunakan strlensebagai panggilan balik, misalnya:

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

Mengapa tidak ada yang mengatakan jawaban ini:

$array = [];

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

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

is_array

Saya menjalankan patokan yang disertakan pada akhir posting. Untuk membandingkan metode:

• count($arr) == 0 : hitung
• empty($arr) : kosong
• $arr == [] : comp
• (bool) $arr : Pemeran

dan mendapat hasil sebagai berikut

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

Perbedaan antara kosong dan casting ke boolean tidak signifikan. Saya telah menjalankan tes ini beberapa kali dan tampaknya pada dasarnya setara. Isi array tampaknya tidak memainkan peran penting. Keduanya menghasilkan hasil yang berlawanan tetapi negasi logis hampir tidak cukup untuk mendorong casting untuk memenangkan sebagian besar waktu jadi saya pribadi lebih suka kosong demi keterbacaan dalam kedua kasus.

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

jika Anda ingin memeriksa konten array yang dapat Anda gunakan:

$arr = array();

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

lihat di sini: http://codepad.org/EORE4k7v

Menurut pendapat saya, cara paling sederhana untuk array yang diindeks adalah:

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

Kondisi 'jika' pada array akan bernilai true jika array tidak kosong dan salah jika array kosong . Ini tidak berlaku untuk array asosiatif.

Saya menggunakan kode ini

$variable = array();

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

Tetapi perhatikan bahwa jika array memiliki sejumlah besar kunci, kode ini akan menghabiskan banyak waktu untuk menghitungnya, dibandingkan dengan jawaban lain di sini.

Anda dapat menggunakan array_filter()yang berfungsi baik untuk semua situasi:

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

Saya pikir cara terbaik untuk menentukan apakah array kosong atau tidak adalah dengan menggunakan count () seperti:

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

Membuat keputusan yang paling tepat membutuhkan mengetahui kualitas data Anda dan proses apa yang harus diikuti.

1. Jika Anda akan mendiskualifikasi / mengabaikan / menghapus baris ini, maka titik penyaringan paling awal harus ada dalam permintaan mysql.

   • WHERE players IS NOT NULL
   • WHERE players != ''
   • WHERE COALESCE(players, '') != ''
   • WHERE players IS NOT NULL AND players != ''
   • ... itu tergantung pada data toko Anda dan akan ada cara lain, saya akan berhenti di sini.

2. Jika Anda tidak 100% yakin apakah kolom akan ada di set hasil, maka Anda harus memeriksa bahwa kolom tersebut dinyatakan. Ini berarti memanggil array_key_exists(), isset()atau empty()pada kolom. Saya tidak akan repot-repot menggambarkan perbedaan di sini (ada halaman SO lainnya untuk gangguan itu, ini awal: 1 , 2 , 3 ). Yang mengatakan, jika Anda tidak sepenuhnya mengendalikan set hasil, maka mungkin Anda memiliki "fleksibilitas" aplikasi yang berlebihan dan harus memikirkan kembali jika masalah yang berpotensi mengakses data kolom yang tidak ada sepadan. Secara efektif, saya mengatakan bahwa Anda tidak perlu memeriksa apakah kolom dinyatakan - ergo Anda seharusnya tidak perlu empty()untuk tugas ini. Jika ada yang memperdebatkan ituempty()lebih tepat, maka mereka mendorong pendapat pribadi mereka sendiri tentang ekspresifitas scripting. Jika Anda menemukan kondisi di # 5 di bawah ini ambigu, tambahkan komentar inline ke kode Anda - tetapi saya tidak akan melakukannya. Intinya adalah bahwa tidak ada keuntungan pemrograman untuk membuat pemanggilan fungsi.

3. Mungkinkah nilai string Anda mengandung nilai 0yang ingin Anda anggap benar / valid / tidak kosong? Jika demikian, maka Anda hanya perlu memeriksa apakah nilai kolom memiliki panjang.

   Ini Demo yang digunakan strlen(). Ini akan menunjukkan apakah string akan membuat elemen array yang bermakna jika meledak.

4. Saya pikir penting untuk menyebutkan bahwa dengan meledak tanpa syarat, Anda DIJAMIN untuk menghasilkan array yang tidak kosong. Ini buktinya: Demo Dengan kata lain, memeriksa apakah array kosong sama sekali tidak berguna - itu akan kosong setiap saat.

5. Jika string Anda TIDAK MUNGKIN mengandung nilai nol (karena, katakanlah, ini adalah csv yang terdiri dari id yang dimulai dari 1dan hanya kenaikan), maka hanya if ($gamerow['players']) {itu yang Anda butuhkan - akhir cerita.

6. ... tapi tunggu, apa yang Anda lakukan setelah menentukan kekosongan nilai ini? Jika Anda memiliki skrip down yang menunggu $playerlist, tetapi Anda menyatakan variabel secara kondisional, maka Anda berisiko menggunakan nilai baris sebelumnya atau sekali lagi menghasilkan Pemberitahuan. Jadi, apakah Anda perlu mendeklarasikan tanpa syarat $playerlistsebagai sesuatu ? Jika tidak ada nilai kebenaran dalam string, apakah aplikasi Anda mendapat manfaat dari mendeklarasikan array kosong? Kemungkinannya adalah, jawabannya adalah ya. Dalam hal ini, Anda dapat memastikan bahwa variabel adalah tipe array dengan kembali ke array kosong - dengan cara ini tidak masalah jika Anda memasukkan variabel tersebut ke dalam sebuah loop. Deklarasi bersyarat berikut semuanya setara.

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

Mengapa saya harus berusaha keras untuk menjelaskan tugas yang sangat mendasar ini?

1. Saya memiliki whistleblown hampir setiap jawaban pada halaman ini dan jawaban ini kemungkinan akan memberikan suara balas dendam (ini sering terjadi pada whistleblower yang membela situs ini - jika sebuah jawaban memiliki downvotes dan tidak ada komentar, selalu bersikap skeptis).
2. Saya pikir penting bahwa Stackoverflow adalah sumber daya tepercaya yang tidak meracuni para peneliti dengan informasi yang salah dan teknik suboptimal.
3. Ini adalah bagaimana saya menunjukkan betapa saya sangat peduli dengan pengembang yang akan datang sehingga mereka belajar bagaimana dan mengapa alih-alih memberi makan generasi programmer copy-paste.
4. Saya sering menggunakan halaman lama untuk menutup halaman duplikat baru - ini adalah tanggung jawab sukarelawan veteran yang tahu cara cepat menemukan duplikat. Saya tidak dapat menggunakan halaman lama dengan informasi yang buruk / salah / suboptimal / menyesatkan sebagai referensi karena dengan demikian saya secara aktif melakukan tindakan merugikan kepada peneliti baru.

empty($gamerow['players'])

Saya telah memecahkan masalah ini dengan kode berikut.

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

Ini sepertinya berfungsi untuk semua kasus

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

Bagaimana tentang:

DepartmentPerSchool = array ();
(kosong (is_array ($ DepartmentPerSchool)))? $ DepartmentPerSchool // atau gema tidak kosong: array ('not set' => 'Not set. Contact Admin'); // atau gema kosong