Как проверить, является ли массив пустым с помощью 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

РНР empty()определяет , является ли переменная не существует или имеет значение falsey (например array(), 0, null, falseи т.д.).

В большинстве случаев вы просто хотите проверить !$emptyVar. Используйте, empty($emptyVar)если переменная может быть не установлена ​​И вы не будете вызывать E_NOTICE; ИМО это вообще плохая идея.

Некоторые приличные ответы, но я подумал, что я бы немного расширил их, чтобы объяснить более четко, когда PHP определяет, является ли массив пустым.

Основные примечания:

Массив с ключом (или ключами) будет определен как НЕ пустой в PHP.

Поскольку для значений массива необходимы ключи, наличие или отсутствие значений в массиве не определяет, является ли он пустым, только если нет ключей (И, следовательно, нет значений).

Так что проверка массива с помощью empty()не просто говорит вам, есть ли у вас значения или нет, она говорит вам, если массив пуст, и ключи являются частью массива.

Поэтому подумайте, как вы создаете свой массив, прежде чем решить, какой метод проверки использовать.
Например, массив будет иметь ключи, когда пользователь отправит вашу 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]

Массив третий:
[0] => []
[1] => []

И тестирование вышеупомянутых массивов с empty()возвращает следующие результаты:

ARRAY ONE:
$ ArrayOne не пусто

ARRAY TWO:
$ ArrayTwo не пусто

ARRAY THREE:
$ ArrayThree не пусто

Массив всегда будет пустым, когда вы назначаете массив, но не используете его после этого, например:

$ArrayFour = array();

Это будет пустым, то есть PHP вернет TRUE при использовании if empty()на вышеупомянутом.

Таким образом, если в вашем массиве есть ключи - например, с помощью входных имен формы или если вы назначаете их вручную (т.е. создаете массив с именами столбцов базы данных в качестве ключей, но без значений / данных из базы данных), то массив НЕ будет 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()всех трех примеров массивов (созданных в первом блоке кода в этом ответе) приводит к следующему:

ARRAY ONE:
$ arrayone не пуст

Массив второй : $ 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), вы можете использовать strlenв качестве обратного вызова, например:

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

Почему никто не сказал этот ответ:

$array = [];

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

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

is_array

Я провел тест, включенный в конце поста. Чтобы сравнить методы:

• count($arr) == 0 : count
• 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...  
    }

Условие if в массиве будет иметь значение 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. Может ли ваше строковое значение содержать значение, 0которое вы хотите считать истинным / действительным / непустым? Если это так, то вам нужно только проверить, имеет ли значение столбца длину.

   Вот демо с использованием strlen(). Это будет указывать, будет ли строка создавать значимые элементы массива в случае разнесения.

4. Я думаю, что важно упомянуть, что, взорвавшись безоговорочно, вы ГАРАНТИРУЕТЕ создать непустой массив. Вот доказательство: Демонстрация Другими словами, проверка, является ли массив пустым, абсолютно бесполезен - он будет непустым каждый раз.

5. Если ваша строка НЕ ​​МОЖЕТ содержать нулевое значение (потому что, скажем, это CSV, состоящий из идентификаторов, которые начинаются с 1и только увеличиваются), то if ($gamerow['players']) {это все, что вам нужно - конец истории.

6. ... но подождите, что вы делаете после определения пустоты этой величины? Если у вас есть что-то, что ожидает $playerlist, но вы условно объявляете эту переменную, тогда вы рискуете использовать значение предыдущей строки или снова генерировать Notices. Так нужно ли безоговорочно декларировать $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)))