จะตรวจสอบว่าอาร์เรย์นั้นว่างเปล่าโดยใช้ PHP ได้อย่างไร

playersจะว่างเปล่าหรือรายการที่คั่นด้วยเครื่องหมายจุลภาค (หรือค่าเดียว) วิธีที่ง่ายที่สุดในการตรวจสอบว่าว่างเปล่าคืออะไร? ฉันคิดว่าฉันสามารถทำได้ทันทีที่ฉันเรียก$gameresultอาเรย์เข้ามา$gamerow? ในกรณีนี้มันอาจจะมีประสิทธิภาพมากกว่าที่จะข้ามการระเบิด$playerlistถ้ามันว่างเปล่า แต่เพื่อการโต้แย้งฉันจะตรวจสอบได้อย่างไรว่าอาร์เรย์ว่างเปล่าเช่นกัน?

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

หากคุณเพียงแค่ต้องตรวจสอบว่ามีองค์ประกอบใด ๆ ในอาร์เรย์

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

หากคุณต้องการล้างค่าว่างก่อนทำการตรวจสอบ (โดยทั่วไปจะทำเพื่อป้องกันไม่ให้explodeสตริงแปลก ๆ ):

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

อาเรย์ที่ว่างเปล่านั้นเท็จใน PHP ดังนั้นคุณจึงไม่จำเป็นต้องใช้empty()ตามที่คนอื่น ๆ แนะนำไว้

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

ของ PHP empty()กำหนดว่าตัวแปรไม่มีอยู่หรือมีค่า falsey (เช่นarray(), 0, null, falseฯลฯ )

!$emptyVarในกรณีส่วนใหญ่คุณเพียงต้องการที่จะตรวจสอบ ใช้empty($emptyVar)ถ้าตัวแปรนั้นยังไม่ได้ตั้งค่าและคุณจะไม่เรียกE_NOTICE; IMO โดยทั่วไปนี่เป็นความคิดที่ไม่ดี

บางคำตอบที่ดี แต่แค่คิดว่าฉันจะขยายเล็กน้อยเพื่ออธิบายให้ชัดเจนยิ่งขึ้นเมื่อ PHP พิจารณาว่าอาร์เรย์ว่างเปล่าหรือไม่

หมายเหตุหลัก:

อาร์เรย์ที่มีคีย์ (หรือคีย์) จะถูกกำหนดเป็นค่าว่างโดย PHP

เนื่องจากค่าอาร์เรย์ต้องการคีย์ที่มีอยู่การมีค่าหรือไม่อยู่ในอาร์เรย์จะไม่พิจารณาว่าเป็นค่าว่างหรือไม่หากไม่มีคีย์ (และไม่มีค่า)

ดังนั้นการตรวจสอบอาเรย์ด้วยempty()ไม่เพียงแค่บอกคุณว่าคุณมีค่าหรือไม่มันจะบอกคุณว่าอาเรย์นั้นว่างเปล่าหรือไม่และกุญแจเป็นส่วนหนึ่งของอาเรย์

ดังนั้นให้พิจารณาว่าคุณผลิตอาเรย์ของคุณอย่างไรก่อนตัดสินใจเลือกวิธีการตรวจสอบที่จะใช้
EG อาร์เรย์จะมีคีย์เมื่อผู้ใช้ส่งแบบฟอร์ม HTML ของคุณเมื่อแต่ละเขตข้อมูลฟอร์มมีชื่ออาร์เรย์ (เช่นname="array[]")
อาเรย์ที่ไม่ว่างเปล่าจะถูกสร้างขึ้นสำหรับแต่ละฟิลด์เนื่องจากจะมีการเพิ่มค่าคีย์อัตโนมัติสำหรับอาเรย์ของแต่ละเขตข้อมูลฟอร์ม

ใช้อาร์เรย์เหล่านี้เช่น:

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

หากคุณสะท้อนคีย์และค่าของอาร์เรย์สำหรับอาร์เรย์ข้างต้นคุณจะได้รับสิ่งต่อไปนี้:

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

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

สาม ARRAY:
[0] => []
[1] => []

และการทดสอบอาร์เรย์ข้างต้นด้วยempty()ผลตอบแทนต่อไปนี้:

ARRAY ONE:
$ ArrayOne ไม่ว่างเปล่า

ARRAY TWO:
$ ArrayTwo ไม่ว่างเปล่า

สาม ARRAY:
$ ArrayThree ไม่ว่างเปล่า

อาเรย์จะว่างเปล่าเสมอเมื่อคุณกำหนดอาเรย์ แต่อย่าใช้อาเรย์นั้นหลังจากนั้นเช่น

$ArrayFour = array();

สิ่งนี้จะว่างเปล่าเช่น PHP จะส่งกลับค่า TRUE เมื่อใช้ถ้าempty()ด้านบน

ดังนั้นถ้าคุณมีอาร์เรย์กุญแจ - ทั้งโดยการเช่นรูปแบบของการป้อนข้อมูลชื่อหรือถ้าคุณกำหนดด้วยตนเอง (เช่นสร้างอาร์เรย์ที่มีชื่อคอลัมน์ฐานข้อมูลเป็นกุญแจ แต่ค่าที่ไม่มี / ข้อมูลจากฐานข้อมูล) empty()จากนั้นอาร์เรย์จะไม่ได้รับ

ในกรณีนี้คุณสามารถวนลูปอาร์เรย์ใน foreach โดยทดสอบว่าแต่ละคีย์มีค่าหรือไม่ นี่เป็นวิธีการที่ดีถ้าคุณต้องใช้อาเรย์ด้วยซ้ำบางทีตรวจสอบคีย์หรือฆ่าเชื้อข้อมูล

แต่มันไม่ได้เป็นวิธีที่ดีที่สุดถ้าคุณเพียงแค่ต้องรู้ว่า "ถ้าค่าอยู่" ผลตอบแทนจริงหรือเท็จ มีวิธีการต่าง ๆ เพื่อตรวจสอบว่าอาร์เรย์มีค่าใด ๆ เมื่อมันรู้ว่ามันจะมีคีย์ ฟังก์ชั่นหรือคลาสอาจเป็นวิธีที่ดีที่สุด แต่ขึ้นอยู่กับสภาพแวดล้อมและข้อกำหนดที่แน่นอนของคุณเช่นเดียวกับสิ่งอื่น ๆ เช่นสิ่งที่คุณทำกับอาเรย์ในปัจจุบัน (ถ้ามี)

นี่คือวิธีการที่ใช้รหัสน้อยมากเพื่อตรวจสอบว่าอาร์เรย์มีค่าหรือไม่:

การใช้array_filter():
วนซ้ำค่าแต่ละค่าในอาร์เรย์ที่ส่งไปยังฟังก์ชันการเรียกกลับ หากฟังก์ชันการเรียกกลับส่งคืนค่าจริงค่าปัจจุบันจากอาร์เรย์จะถูกส่งกลับไปยังอาร์เรย์ผลลัพธ์ คีย์อาร์เรย์ถูกเก็บรักษาไว้

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

วิ่ง array_filter()อาร์เรย์ตัวอย่างทั้งสาม (สร้างขึ้นในบล็อครหัสแรกในคำตอบนี้) จะส่งผลให้เกิดสิ่งต่อไปนี้:

อาเรย์ ONE:
$ arrayone ไม่ว่างเปล่า

อาเรย์สอง:
อาร์เรย์ $ arraytwo ไม่ว่างเปล่า

สาม ARRAY:
$ arraythree ว่างเปล่า

ดังนั้นเมื่อไม่มีค่าไม่ว่าจะมีคีย์หรือไม่ใช้array_filter()เพื่อสร้างอาร์เรย์ใหม่แล้วตรวจสอบว่าอาร์เรย์ใหม่ว่างเปล่าแสดงว่ามีค่าใด ๆ ในอาร์เรย์เดิมหรือไม่
มันไม่เหมาะและยุ่งเล็กน้อย แต่ถ้าคุณมีอาเรย์ขนาดใหญ่และไม่จำเป็นต้องวนซ้ำมันด้วยเหตุผลอื่นใดนี่เป็นวิธีที่ง่ายที่สุดในเรื่องของรหัสที่จำเป็น

ฉันไม่มีประสบการณ์ในการตรวจสอบค่าโสหุ้ย แต่จะเป็นการดีที่จะทราบความแตกต่างระหว่างการใช้งานarray_filter()และforeachตรวจสอบหากพบว่ามีค่า

มาตรฐานแน่นอนจะต้องอยู่ในพารามิเตอร์ต่าง ๆ ในอาร์เรย์ขนาดเล็กและขนาดใหญ่และเมื่อมีค่าและไม่เป็นต้น

count($gamerow['players']) จะเป็น 0

หากคุณต้องการตรวจสอบว่าตัวแปรที่คุณกำลังทดสอบนั้นเป็นอาร์เรย์ว่างเปล่าหรือไม่คุณสามารถใช้สิ่งนี้:

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

หากคุณต้องการยกเว้นแถวเท็จหรือแถวว่าง (เช่น0 => '') ซึ่งการใช้empty()จะล้มเหลวคุณสามารถลอง:

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

array_filter(): หากไม่มีการโทรกลับรายการทั้งหมดของอาร์เรย์จะเท่ากับ FALSE (ดูที่การแปลงเป็นบูลีน) จะถูกลบออก

หากคุณต้องการลบสตริง NULL, FALSE และว่างเปล่าทั้งหมด ( '') แต่ปล่อยให้เป็นศูนย์ค่า ( 0) คุณสามารถใช้strlenเป็นโทรกลับเช่น:

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

ทำไมไม่มีใครพูดคำตอบนี้:

$array = [];

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

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

is_array

ฉันวิ่งเกณฑ์มาตรฐานรวมอยู่ท้ายโพสต์ เพื่อเปรียบเทียบวิธีการ:

• count($arr) == 0 : นับ
• empty($arr) : ว่างเปล่า
• $arr == [] : comp
• (bool) $arr : นักแสดง

และได้ผลลัพธ์ดังต่อไปนี้

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

ความแตกต่างระหว่างที่ว่างเปล่าและการหล่อกับบูลีนนั้นไม่มีความสำคัญ ฉันใช้การทดสอบนี้หลายครั้งและพวกเขาดูเหมือนจะเทียบเท่า เนื้อหาของอาร์เรย์ดูเหมือนจะไม่ได้มีบทบาทสำคัญ ทั้งสองสร้างผลลัพธ์ที่ตรงกันข้าม แต่การปฏิเสธเชิงตรรกะนั้นแทบจะไม่เพียงพอที่จะผลักดันการคัดเลือกให้ชนะเกือบตลอดเวลาดังนั้นฉันจึงชอบที่จะว่างเปล่าเพื่อความชัดเจนในแต่ละกรณี

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

ถ้าคุณต้องการตรวจสอบเนื้อหาของอาเรย์คุณอาจใช้:

$arr = array();

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

ดูที่นี่: http://codepad.org/EORE4k7v

ในความคิดของฉันวิธีที่ง่ายที่สุดสำหรับอาร์เรย์ที่จัดทำดัชนีจะเป็นเพียง

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

ว่า 'ถ้า' เงื่อนไขในอาร์เรย์จะประเมินจริงถ้าอาร์เรย์ไม่ว่างเปล่าและเท็จถ้าอาร์เรย์เป็นที่ว่างเปล่า สิ่งนี้ไม่สามารถใช้ได้กับอาเรย์แบบเชื่อมโยง

ฉันใช้รหัสนี้

$variable = array();

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

แต่โปรดทราบว่าหากอาร์เรย์มีคีย์จำนวนมากรหัสนี้จะใช้เวลาในการนับนานเมื่อเทียบกับคำตอบอื่น ๆ ที่นี่

คุณสามารถใช้array_filter()งานได้ดีสำหรับทุกสถานการณ์:

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

ฉันคิดว่าวิธีที่ดีที่สุดในการตรวจสอบว่าอาร์เรย์ว่างเปล่าหรือไม่คือการใช้ count () เช่น:

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

การตัดสินใจที่เหมาะสมที่สุดนั้นจำเป็นต้องทราบถึงคุณภาพของข้อมูลของคุณและกระบวนการที่ต้องปฏิบัติตาม

1. หากคุณจะตัดสิทธิ์ / ไม่สนใจ / ลบแถวนี้ดังนั้นจุดกรองที่เร็วที่สุดควรอยู่ในแบบสอบถาม mysql

   • WHERE players IS NOT NULL
   • WHERE players != ''
   • WHERE COALESCE(players, '') != ''
   • WHERE players IS NOT NULL AND players != ''
   • ... มันขึ้นอยู่กับข้อมูลร้านค้าของคุณและจะมีวิธีอื่นฉันจะหยุดที่นี่

2. หากคุณไม่แน่ใจ 100% ว่าจะมีคอลัมน์อยู่ในชุดผลลัพธ์หรือไม่คุณควรตรวจสอบว่ามีการประกาศคอลัมน์นั้นหรือไม่ นี้จะหมายถึงการเรียกร้องarray_key_exists(), isset()หรือempty()ในคอลัมน์ ฉันจะไม่รบกวนการแยกแยะความแตกต่างที่นี่ (มีหน้า SO อื่น ๆ สำหรับการแจกแจงนั่นเริ่มต้น: 1 , 2 , 3 ) ที่กล่าวว่าหากคุณไม่ได้ควบคุมชุดผลลัพธ์อย่างสมบูรณ์บางทีคุณอาจมีแอพพลิเคชั่น "ยืดหยุ่น" ที่เกินควรและควรคิดใหม่หากปัญหาในการเข้าถึงข้อมูลคอลัมน์ที่ไม่มีอยู่นั้นคุ้มค่า อย่างมีประสิทธิภาพฉันกำลังบอกว่าคุณไม่จำเป็นต้องตรวจสอบว่ามีการประกาศคอลัมน์หรือไม่empty()งานนี้ หากใคร ๆ ก็เถียงกันว่าempty()มีความเหมาะสมมากกว่าจากนั้นพวกเขาก็ผลักดันความคิดเห็นส่วนตัวเกี่ยวกับการแสดงออกของสคริปต์ หากคุณพบว่าเงื่อนไขใน # 5 ด้านล่างไม่ชัดเจนให้เพิ่มความคิดเห็นแบบอินไลน์ในรหัสของคุณ - แต่ฉันจะไม่ทำ บรรทัดล่างคือไม่มีข้อได้เปรียบทางด้านโปรแกรมเพื่อการเรียกใช้ฟังก์ชัน

3. อาจมีค่าสตริงของคุณ 0ที่คุณต้องการถือว่าเป็นจริง / ถูกต้อง / ไม่ว่างเปล่าหรือไม่? ถ้าเป็นเช่นนั้นคุณจะต้องตรวจสอบว่าค่าคอลัมน์มีความยาว

   นี่คือการสาธิตstrlen()การใช้ สิ่งนี้จะระบุว่าสตริงจะสร้างองค์ประกอบอาร์เรย์ที่มีความหมายหรือไม่หากมีการระเบิด

4. ฉันคิดว่ามันเป็นสิ่งสำคัญที่จะกล่าวถึงว่าโดยการระเบิดอย่างไม่มีเงื่อนไขคุณจะได้รับการรับประกันเพื่อสร้างอาร์เรย์ที่ไม่ว่างเปล่า นี่คือข้อพิสูจน์: การสาธิต ในคำอื่น ๆ การตรวจสอบว่าอาร์เรย์ว่างเปล่าไม่มีประโยชน์อย่างสมบูรณ์หรือไม่นั้นจะว่างเปล่าทุกครั้ง

5. ถ้าสายอักขระของคุณจะไม่ POSSIBLY มีค่าเป็นศูนย์ (เพราะพูดว่านี่คือ csv ซึ่งประกอบด้วยรหัสที่เริ่มต้น1และเพิ่มขึ้นอย่างเดียว) if ($gamerow['players']) {นั่นคือทั้งหมดที่คุณต้องการ - จบเรื่อง

6. ... แต่เดี๋ยวก่อนคุณกำลังทำอะไรหลังจากพิจารณาความว่างเปล่าของค่านี้? หากคุณมีสคริปต์ดาวน์ที่คาดหวัง$playerlistแต่คุณกำลังประกาศตัวแปรนั้นอย่างมีเงื่อนไขคุณต้องเสี่ยงกับการใช้ค่าของแถวก่อนหน้าหรือสร้างประกาศอีกครั้ง ดังนั้นคุณต้องประกาศโดยไม่มีเงื่อนไข$playerlistเป็นอะไรหรือไม่? หากไม่มีค่าความจริงในสตริงแอปพลิเคชันของคุณจะได้รับประโยชน์จากการประกาศอาร์เรย์ว่างเปล่าหรือไม่? โอกาสที่คำตอบคือใช่ ในกรณีนี้คุณสามารถมั่นใจได้ว่าตัวแปรนั้นเป็นประเภทอาเรย์โดยการกลับไปที่อาเรย์ที่ว่างเปล่าด้วยวิธีนี้มันจะไม่สำคัญถ้าคุณป้อนตัวแปรนั้นลงในลูป การประกาศเงื่อนไขดังต่อไปนี้เทียบเท่ากันทั้งหมด

   • `if ($ gamerow ['players']) {$ playerlist = ระเบิด (',', $ gamerow ['players']); } else {$ playerlist = []; }
   • $playerlist = $gamerow['players'] ? explode(',', $gamerow['players']) : [];

ทำไมฉันถึงต้องใช้ความพยายามขนาดนี้เพื่ออธิบายภารกิจขั้นพื้นฐานนี้?

1. ฉันได้แจ้งเบาะแสเกือบทุกคำตอบในหน้านี้และคำตอบนี้น่าจะเป็นการลงคะแนนแก้แค้น (เกิดขึ้นบ่อยครั้งกับผู้แจ้งเบาะแสที่ปกป้องเว็บไซต์นี้ - ถ้าคำตอบมี downvotes และไม่แสดงความคิดเห็น
2. ฉันคิดว่ามันเป็นสิ่งสำคัญที่ Stackoverflow เป็นทรัพยากรที่เชื่อถือได้ซึ่งไม่ทำให้นักวิจัยพิษด้วยข้อมูลที่ผิดและเทคนิคที่ไม่เหมาะสม
3. นี่คือวิธีที่ฉันแสดงให้เห็นว่าฉันสนใจนักพัฒนาที่จะมาถึงเพื่อให้พวกเขาเรียนรู้วิธีการและเหตุผลแทนที่จะเป็นเพียงแค่การให้โปรแกรมโปรแกรมเมอร์คัดลอกวาง
4. ฉันมักจะใช้หน้าเก่าเพื่อปิดหน้าซ้ำที่ซ้ำกัน - นี่เป็นความรับผิดชอบของอาสาสมัครรุ่นเก๋าที่รู้วิธีหารายการซ้ำอย่างรวดเร็ว ฉันไม่สามารถพาตัวเองไปใช้หน้าเก่าที่มีข้อมูลไม่ดี / เท็จ / ไม่ดี / ไม่ดี / ทำให้เข้าใจผิดเป็นข้อมูลอ้างอิงได้เพราะจากนั้นฉันก็กำลังสร้างความเสียหายให้กับนักวิจัยคนใหม่

empty($gamerow['players'])

ฉันได้แก้ไขปัญหานี้ด้วยรหัสต่อไปนี้

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

ดูเหมือนว่าจะใช้ได้กับทุกกรณี

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

เกี่ยวกับ:

DepartmentPerSchool = array ();
(ว่าง (is_array ($ DepartmentPerSchool))) $ DepartmentPerSchool // หรือ echo ไม่ว่าง: array ('not set' => 'ไม่ได้ตั้งค่าติดต่อผู้ดูแลระบบ'); // หรือ echo ว่างเปล่า