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

위의 배열에 대한 배열 키와 값을 반향하면 다음과 같은 결과가 나타납니다.

배열 하나 :
[UserKeyA] => [UserValueA]
[UserKeyB] => [UserValueB]

배열 2 :
[0] => [UserValue01]
[1] => [UserValue02]

배열 3 :
[0] => []
[1] => []

위의 배열을 테스트하면 empty()다음 결과 가 반환됩니다.

배열 하나 :
$ ArrayOne이 비어 있지 않습니다

배열 2 :
$ ArrayTwo가 비어 있지 않습니다

배열 3 :
$ ArrayThree가 비어 있지 않습니다

배열을 할당 할 때 배열은 항상 비어 있지만 이후와 같이 사용하지 마십시오.

$ArrayFour = array();

이것은 비어 있습니다. 즉 empty(), 위의 if 를 사용할 때 PHP는 TRUE를 반환합니다 .

따라서 배열에 키가있는 경우 (예 : 양식의 입력 이름 또는 수동으로 지정하는 경우 (예 : 데이터베이스 열 이름을 키로 사용하지만 데이터베이스의 값 / 데이터는없는 배열을 생성)) 배열은 없습니다 empty().

이 경우 foreach에서 배열을 반복하여 각 키에 값이 있는지 테스트 할 수 있습니다. 어쨌든 키를 확인하거나 데이터를 삭제하는 등 배열을 통해 실행해야하는 경우이 방법이 좋습니다.

그러나 "값이 존재하는 경우"를 알아야 TRUE 또는 FALSE를 반환하는 것이 가장 좋은 방법은 아닙니다 . 배열에 키가 있다는 것을 알 때 배열에 값이 있는지 확인하는 다양한 방법이 있습니다. 함수 나 클래스가 최선의 접근 방법 일 수 있지만 항상 그렇듯이 항상 환경과 정확한 요구 사항은 물론 현재 배열에서 수행하는 작업 (있는 경우)과 같은 다른 작업에 따라 달라집니다.

다음은 매우 작은 코드를 사용하여 배열에 값이 있는지 확인하는 방법입니다.

사용 array_filter():
배열의 각 값을 반복하여 콜백 함수에 전달합니다. 콜백 함수가 true를 반환하면 배열의 현재 값이 결과 배열로 반환됩니다. 배열 키가 유지됩니다.

$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()이 답변의 첫 번째 코드 블록에서 작성된 세 가지 예제 배열에서 모두 실행 하면 다음과 같은 결과가 발생합니다.

배열 하나 :
$ arrayone이 비어 있지 않습니다

배열 2 개 :
$ arraytwo가 비어 있지 않습니다

배열 3 :
$ 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 값 ( 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...  
    }

은 '가'배열에 조건을 평가하는 것입니다 배열이 비어 있지 않은 경우는 true 와 배열이 비어있는 경우는 false . 입니다 하지 연관 배열에 적용.

이 코드를 사용합니다

$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. 문자열 값에 0true / valid / non-empty로 간주하려는 값이 포함될 수 있습니까? 그렇다면 열 값의 길이 만 확인하면됩니다.

   다음 은를 사용 하는 데모strlen() 입니다. 이것은 문자열이 폭발 할 경우 의미있는 배열 요소를 만들지 여부를 나타냅니다.

4. 나는 무조건적으로 폭발함으로써 당신은 비어 있지 않은 배열을 생성하도록 보장 받는다는 것을 언급하는 것이 중요하다고 생각합니다. 증거는 다음과 같습니다. Demo 즉, 배열이 비어 있는지 확인하는 것은 완전히 쓸모가 없습니다. 매번 비어 있지 않습니다.

5. 문자열에 아마도 0 값이 포함되지 않으면 (예를 들어, 이것은 시작부터 1증가 하는 ID로 구성된 csv이기 때문에 ) if ($gamerow['players']) {이야기의 끝입니다.

6. ...이 값의 공허함을 결정한 후에는 무엇을하고 있습니까? 다운 스크립트가 필요 $playerlist하지만 조건부로 해당 변수를 선언하는 경우 이전 행의 값을 사용하거나 다시 통지를 생성 할 위험이 있습니다. 그래서 당신은 무조건 선언해야합니까 $playerlist으로 무엇인가 ? 문자열에 정확한 값이 없으면 빈 배열을 선언하면 응용 프로그램에 도움이됩니까? 아마도 대답은 '그렇다'입니다. 이 경우 빈 배열로 되돌아가 변수가 배열 유형인지 확인할 수 있습니다. 이렇게하면 해당 변수를 루프에 공급해도 문제가되지 않습니다. 다음 조건부 선언은 모두 동일합니다.

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

이 기본적인 과제를 설명하기 위해 왜 그런 길이로 갔습니까?

1. 나는이 페이지에서 거의 모든 답변을 호루라기로 불렀으며,이 답변은 복수 투표를 이끌어 낼 가능성이 높습니다.
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 = 배열 ​​();
(empty (is_array ($ DepartmentPerSchool)))? $ DepartmentPerSchool // 또는 echo가 비어 있지 않습니다 : array ( 'not set'=> 'Not set. Contact Admin'); // 또는 에코가 비어 있습니다