Как проверить, является ли массив пустым с помощью PHP?


471

playersбудет либо пустым, либо разделенным запятыми списком (или одним значением). Какой самый простой способ проверить, пусто ли оно? Я предполагаю, что смогу сделать это, как только я получу $gameresultмассив в $gamerow? В этом случае, вероятно, было бы более эффективно пропустить взрыв, $playerlistесли он пуст, но ради аргумента, как бы я проверил, если массив также пуст?

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

2
Не используйте count (), sizeof (), empty (). Пустой массив возвращает false: if ($ array) {
Limitrof

Ответы:


774

Если вам просто нужно проверить, есть ли какие-либо элементы в массиве

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

Если вам нужно очистить пустые значения перед проверкой (обычно это делается для предотвращения появления explodeстранных строк):

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

2
Разве вы не должны просто использовать пустой? подсчет займет больше времени для больших массивов.
Дэн МакГрат

1
Выполнено. Я также изменил это из-за того, что вам не нужно использовать isset и все такое.
Тайлер Картер

5
Учитывая его пример кода, переменная будет установлена, поэтому вам не нужно использовать empty().
Кобби

4
ОСТОРОЖНЫЙ! if(!isset($emptyarray))есть falseно if(empty($emptyarray))возвращается true. Это меня просто прибило
Каньон Колоб

161

Пустой массив в 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; ИМО это вообще плохая идея.


2
Я надеюсь, что это не изменится в каком-то стандарте ... это будет больно
Дэвид Константин

79

Некоторые приличные ответы, но я подумал, что я бы немного расширил их, чтобы объяснить более четко, когда 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 проверкой, найдено ли значение.

Очевидно, что эталонный тест должен быть по различным параметрам, по маленьким и большим массивам, и когда есть значения, а не и т.д.


2
Большое спасибо за это. Это было действительно информативным и смог решить мою проблему, используяarray_filter()
Брайан Пауэлл

empty (array ()) всегда будет равнозначно FALSE, поэтому при добавлении count (array ()) == 0 будет
получено значение

1
@mboullouz count(array())==0имеет значение false, когда есть ключи и нет значений, поэтому это не помогает проверять только значения. Ваше утверждение верно, но вы вынуждены выполнить тест, count(array())поскольку массив, конечно, пуст. Нам нужно проверить, вернулся ли массив из формы или куда-то еще, чтобы узнать, пустой ли он (ключи / значения) или просто имеет значения или нет
Джеймс

Это решение идеально подходит для такого типа массивов, например, оно помогает, когда вы хотите проверить входной файл array_filter($_FILES["documento"]['name'])
Gendrith


12

Если вы хотите выяснить, является ли тестируемая переменная явно пустым массивом, вы можете использовать что-то вроде этого:

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

11

Если вы хотите исключить ложные или пустые строки (например, 0 => ''), где использование empty()не удастся, вы можете попробовать:

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

array_filter(): Если обратный вызов не предоставлен, все записи массива, равные FALSE (см. Преобразование в логическое значение), будут удалены.

Если вы хотите удалить все NULL, FALSE и пустые строки ( ''), но оставить нулевые значения ( 0), вы можете использовать strlenв качестве обратного вызова, например:

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

Это правильный ответ на другой вопрос. Использование фильтра массива уничтожит существующие элементы со значениями Falsey. Это не то, о чем просит ОП.
mickmackusa

8

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

$array = [];

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

1
Ваше утверждение неверно. Кто-то ДЕЙСТВИТЕЛЬНО сказал этот ответ - Тим Огилви - годом ранее. Использование квадратных скобок вместо того array()же самого.
mickmackusa

Пока под капотом это тот же ответ ... технически. Я использовал квадратные скобки вместо устаревшей функции массива.
Роб

Если вы используете этот подход, вы должны также использовать ===вместо ==, так как это быстрее.
Mind

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

is_array


Это ненужные проверки. OP вызывает explode()- он возвращает данные типа массива. Проверка empty()является ненужным вызовом функции. Как заявил Кобби в 2012 году, if($detect)это все, что требуется. Это решение не должно быть реализовано для этой или других задач. Можно возразить , что вы охватывает ситуации , выходит за рамки данного Вопроса в, ну, там никогда не нужно вызывать empty()ПОСЛЕ is_array()потому что , если переменная не «набор», то is_array()будет генерировать «Примечание: Undefined переменной», если isset()тогда empty()это перебор, просто использовать Кобби ответ.
mickmackusa

6

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

  • 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";

Хороший тест, но вы забыли, sizeofкакой [не?] Псевдоним empty... stackoverflow.com/a/51986794/1429432
Юша Алеауб

К вашему сведению: Когда я запустил этот тест с использованием PHP 7.4, я получил разные результаты, которые показали, что сравнение было самым быстрым.
Ник Меррилл

Вы должны действительно использовать ===вместо ==.
Mind

5

если вы хотите проверить содержимое массива, вы можете использовать:

$arr = array();

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

смотрите здесь: http://codepad.org/EORE4k7v


Как показал Cobby в 2012 году, нет необходимости вызывать функцию, чтобы проверить, является ли объявленный массив пустым или нет.
mickmackusa

5

На мой взгляд, самый простой способ для индексированного массива будет просто:

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

Условие if в массиве будет иметь значение true, если массив не пустой, и false, если массив пустой . Это не относится к ассоциативным массивам.


Коби эффективно изложил эту технику еще в 2012 году. В его ответе 133 отзыва.
mickmackusa

С точки зрения мнения, это не «самое простое» - это самое простое, потому что нет синтаксиса, который мог бы быть более кратким, и в нем нет накладных расходов на вызов функции. Абсолютно нет различий в доступе к массиву с индексированными ключами по сравнению с ассоциативными ключами. Этот ответ вводит в заблуждение исследователей. Этот ответ излишний , а затем неверный . 3v4l.org/DSLha
mickmackusa

3

Я использую этот код

$variable = array();

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

Но учтите, что если массив содержит большое количество ключей, этот код потратит много времени на их подсчет по сравнению с другими ответами здесь.


Как показал Cobby в 2012 году, нет необходимости вызывать функцию, чтобы проверить, является ли объявленный массив пустым или нет.
mickmackusa

3

Вы можете использовать, array_filter()который отлично подходит для всех ситуаций:

$ray_state = array_filter($myarray);

if (empty($ray_state)) {
    echo 'array is empty';
} else {
    echo 'array is not empty';
}

1
Этот ответ использует ненужные проверки. Прежде всего, OP не заинтересован в фильтрации каких-либо ложных значений из массива перед проверкой его пустоты, поэтому вы отклонились от заданного вопроса. Во-вторых, как показал Cobby в 2012 году, нет необходимости вызывать функцию, чтобы проверить, является ли объявленный массив пустым или нет.
mickmackusa

2
 $gamerow = mysql_fetch_array($gameresult);

if (!empty(($gamerow['players'])) {
   $playerlist = explode(",", $gamerow['players']);
}else{

  // do stuf if array is empty
}

2

Я думаю, что лучший способ определить, является ли массив пустым или нет, это использовать count () следующим образом:

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

count()Вызов может быть полностью удален - см ответ Cobby в.
mickmackusa

2

Принятие наиболее подходящего решения требует знания качества ваших данных и того, какими процессами следует следовать.

  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. Я часто использую старые страницы, чтобы закрыть новые дубликаты страниц - это ответственность опытных добровольцев, которые знают, как быстро найти дубликаты. Я не могу заставить себя использовать старую страницу с неверной / ложной / неоптимальной / вводящей в заблуждение информацией в качестве справки, потому что тогда я активно оказываю плохую услугу новому исследователю.

@ptr это здесь.
mickmackusa

1
empty($gamerow['players'])

иногда вы не могли узнать значение ключа массива элементов, $matches = preg_grep ( "/^$text (\w+)/i" , $array ) ; чтобы проверить это, я используюif ( count ( $matches ) > 0 )
Салем

Предполагается, что столбец существует в наборе результатов, поэтому empty()выполняет слишком много работы.
mickmackusa

-1

Я решил эту проблему с помощью следующего кода.

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

1
Добро пожаловать в переполнение стека! Спасибо за фрагмент кода, который может оказать некоторую ограниченную, немедленную помощь. Правильное объяснение значительно улучшило бы его долгосрочную ценность , описав, почему это хорошее решение проблемы, и сделало бы его более полезным для будущих читателей с другими подобными вопросами. Пожалуйста, измените свой ответ, чтобы добавить некоторые объяснения, в том числе предположения, которые вы сделали.
сентября

-3

Кажется, это работает для всех случаев

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

3
Это слишком много накладных расходов. Это решение не должно быть реализовано ни одним разработчиком по любой причине.
mickmackusa

@mickmackusa Замечательно, но как новичку научиться определять, какие операции требуют слишком много накладных расходов? Что такое дешевая распродажа или каковы критерии номинальной стоимости слишком больших накладных расходов без проведения тестов производительности?
ptrcao

1
@ptr есть «стоимость» для каждого вызова функции. Если задача может быть выполнена без вызова функции, она превзойдет метод, использующий вызов функции.
mickmackusa

@ptr Я опубликовал исчерпывающий ответ на этот вопрос. Я надеюсь, что это прояснит все ваши опасения по поводу этой конкретной страницы.
mickmackusa

@mickmackusa Вы хотели включить ссылку на другой пост?
ptrcao
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.