Como verificar se uma matriz está vazia usando PHP?

playersestará vazio ou uma lista separada por vírgula (ou um valor único). Qual é a maneira mais fácil de verificar se está vazia? Estou assumindo que posso fazê-lo assim que buscar a $gameresultmatriz $gamerow? Nesse caso, provavelmente seria mais eficiente pular a explosão $playerlistse ela estiver vazia, mas por uma questão de argumento, como eu verificaria se uma matriz também está vazia?

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

Se você só precisa verificar se há QUALQUER elemento na matriz

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

Se você precisar limpar valores vazios antes de verificar (geralmente feito para evitar explodeseqüências de caracteres estranhas):

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

Uma matriz vazia é falsey no PHP, então você nem precisa usar empty()como outros sugeriram.

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

PHP da empty()determina se uma variável não existe ou tem um valor Falsey (como array(), 0, null, false, etc).

Na maioria dos casos, você apenas deseja verificar !$emptyVar. Use empty($emptyVar)se a variável pode não ter sido definida E você não costuma acionar um E_NOTICE; OMI geralmente é uma má idéia.

Algumas respostas decentes, mas pensei em expandir um pouco para explicar mais claramente quando o PHP determinar se um array está vazio.

Notas principais:

Uma matriz com uma chave (ou chaves) será determinada como NÃO vazia pelo PHP.

Como os valores da matriz precisam de chaves para existir, ter valores ou não em uma matriz não determina se está vazio, apenas se não houver chaves (E, portanto, sem valores).

Portanto, verificar um array com empty()simplesmente não informa se você tem valores ou não, ele informa se o array está vazio e as chaves fazem parte de um array.

Portanto, considere como você está produzindo sua matriz antes de decidir qual método de verificação usar.
EG Uma matriz terá chaves quando um usuário enviar seu formulário HTML quando cada campo de formulário tiver um nome de matriz (ou seja name="array[]").
Uma matriz não vazia será produzida para cada campo, pois haverá valores de chave incrementados automaticamente para a matriz de cada campo de formulário.

Veja estas matrizes, por exemplo:

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

Se você repetir as chaves e os valores das matrizes acima, obtém o seguinte:

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

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

ARRAY TRÊS:
[0] => []
[1] => []

E testar as matrizes acima com empty()retorna os seguintes resultados:

ARRAY ONE:
$ ArrayOne não está vazio

ARRAY
DOWO : $ ArrayTwo não está vazio

ARRAY THREE:
$ ArrayThree não está vazio

Uma matriz sempre estará vazia quando você atribui uma matriz, mas não a usa posteriormente, como:

$ArrayFour = array();

Isso ficará vazio, ou seja, o PHP retornará TRUE quando usado se estiver empty()acima.

Portanto, se a sua matriz tiver chaves - seja por exemplo, os nomes de entrada de um formulário ou se você as atribuir manualmente (por exemplo, crie uma matriz com os nomes das colunas do banco de dados como as chaves, mas sem valores / dados do banco de dados), a matriz NÃO será empty().

Nesse caso, você pode fazer um loop na matriz em um foreach, testando se cada chave possui um valor. Esse é um bom método se você precisar executar a matriz de qualquer maneira, talvez verificando as chaves ou limpando os dados.

No entanto, não é o melhor método se você simplesmente precisar "se os valores existirem" retorna VERDADEIRO ou FALSO . Existem vários métodos para determinar se uma matriz possui algum valor quando sabe que terá chaves. Uma função ou classe pode ser a melhor abordagem, mas, como sempre, depende do seu ambiente e dos requisitos exatos, além de outras coisas, como o que você faz atualmente com a matriz (se houver).

Aqui está uma abordagem que usa muito pouco código para verificar se uma matriz possui valores:

Usando array_filter():
itera sobre cada valor na matriz, passando-os para a função de retorno de chamada. Se a função de retorno de chamada retornar true, o valor atual da matriz será retornado para a matriz de resultados. As chaves da matriz são preservadas.

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

A execução array_filter()nas três matrizes de exemplo (criadas no primeiro bloco de código nesta resposta) resulta no seguinte:

ARRAY ONE:
$ arrayone não está vazio

ARRAY DOIS:
$ arraytwo não está vazio

ARRAY TRÊS:
$ arraythree está vazio

Portanto, quando não há valores, sejam chaves ou não, use array_filter()para criar uma nova matriz e verifique se a nova matriz está vazia mostra se havia algum valor na matriz original.
Não é o ideal e é um pouco confuso, mas se você tem uma matriz enorme e não precisa fazer uma repetição por qualquer outro motivo, esse é o mais simples em termos de código necessário.

Não tenho experiência em verificar despesas gerais, mas seria bom saber as diferenças entre usar array_filter()e foreachverificar se um valor foi encontrado.

Obviamente, o benchmark precisaria estar em vários parâmetros, em matrizes pequenas e grandes e quando houver valores e não etc.

count($gamerow['players']) será 0.

Se você deseja verificar se a variável que você está testando é realmente uma matriz vazia, você pode usar algo como isto:

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

Se você deseja excluir as linhas falsas ou vazias (como 0 => ''), onde o uso empty()falhará, tente:

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

array_filter(): Se nenhum retorno de chamada for fornecido, todas as entradas da matriz iguais a FALSE (consulte a conversão para booleano) serão removidas.

Se você deseja remover todas as cadeias NULL, FALSE e vazias ( ''), mas deixar valores zero ( 0), pode usar strlencomo retorno de chamada, por exemplo:

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

Por que ninguém disse esta resposta:

$array = [];

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

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

is_array

Corri o benchmark incluído no final do post. Para comparar os métodos:

• count($arr) == 0 : contagem
• empty($arr) : vazio
• $arr == [] : comp
• (bool) $arr : fundida

e obteve os seguintes resultados

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

A diferença entre vazio e conversão para um booleano é insignificante. Eu executei esse teste várias vezes e eles parecem ser essencialmente equivalentes. O conteúdo das matrizes não parece desempenhar um papel significativo. Os dois produzem resultados opostos, mas a negação lógica mal é suficiente para levar o elenco à vitória na maioria das vezes, então eu pessoalmente prefiro vazio por razões de legibilidade em ambos os casos.

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

se você quiser verificar o conteúdo da matriz, poderá usar:

$arr = array();

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

veja aqui: http://codepad.org/EORE4k7v

Na minha opinião, a maneira mais simples para uma matriz indexada seria simplesmente:

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

Uma condição 'if' na matriz seria avaliada como true se a matriz não estiver vazia e false se a matriz estiver vazia . Isso não é aplicável a matrizes associativas.

Eu uso esse código

$variable = array();

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

Mas observe que, se a matriz tiver um grande número de chaves, esse código passará muito tempo contando-as, em comparação com as outras respostas aqui.

Você pode usar o array_filter()que funciona muito bem para todas as situações:

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

Eu acho que a melhor maneira de determinar se a matriz está vazia ou não é usar count () assim:

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

Tomar a decisão mais apropriada requer conhecer a qualidade dos seus dados e quais processos devem ser seguidos.

1. Se você vai desqualificar / desconsiderar / remover esta linha, o primeiro ponto de filtragem deve estar na consulta mysql.

   • WHERE players IS NOT NULL
   • WHERE players != ''
   • WHERE COALESCE(players, '') != ''
   • WHERE players IS NOT NULL AND players != ''
   • ... depende dos dados da sua loja e haverá outras maneiras, vou parar por aqui.

2. Se você não tiver 100% de certeza se a coluna existirá no conjunto de resultados, verifique se a coluna está declarada. Isto significa chamar array_key_exists(), isset()ou empty()na coluna. Não vou me incomodar em delinear as diferenças aqui (existem outras páginas de SO para esse detalhamento, aqui está um começo: 1 , 2 , 3 ). Dito isto, se você não estiver no controle total do conjunto de resultados, talvez tenha uma "flexibilidade" excessiva da aplicação e deva repensar se vale a pena o problema de acessar potencialmente dados inexistentes da coluna. Efetivamente, estou dizendo que você nunca deve verificar se uma coluna é declarada - portanto, você nunca precisará empty()dessa tarefa. Se alguém está argumentando queempty()é mais apropriado, eles estão expondo sua própria opinião pessoal sobre a expressividade dos scripts. Se você achar que a condição no 5 abaixo é ambígua, adicione um comentário embutido ao seu código - mas não o faria. A conclusão é que não há vantagem programática em fazer a chamada de função.

3. O valor da string pode conter um valor 0que você deseja considerar verdadeiro / válido / não vazio? Nesse caso, você só precisa verificar se o valor da coluna tem comprimento.

   Aqui está uma demonstração usando strlen(). Isso indicará se a sequência criará ou não elementos significativos da matriz se explodida.

4. Eu acho que é importante mencionar que, ao explodir incondicionalmente, você está GARANTIDO para gerar uma matriz não vazia. Aqui está a prova: Demonstração Em outras palavras, verificar se a matriz está vazia é completamente inútil - ela estará sempre vazia.

5. Se sua string NÃO POSSIVELMENTE conter um valor zero (porque, digamos, este é um csv que consiste em IDs que iniciam 1e apenas incrementam), if ($gamerow['players']) {é tudo o que você precisa - fim da história.

6. ... mas espere, o que você está fazendo depois de determinar o vazio desse valor? Se você tem algo em espera $playerlist, mas está declarando condicionalmente essa variável, corre o risco de usar o valor da linha anterior ou gerar novamente Avisos. Então, você precisa declarar incondicionalmente $playerlistcomo algo ? Se não houver valores reais na cadeia, seu aplicativo se beneficia ao declarar uma matriz vazia? As chances são de que a resposta seja sim. Nesse caso, você pode garantir que a variável seja do tipo matriz, retornando a uma matriz vazia - dessa forma, não importará se você alimentar essa variável em um loop. As seguintes declarações condicionais são todas equivalentes.

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

Por que fui tão longe para explicar essa tarefa muito básica?

1. Eu denunciei quase todas as respostas desta página e é provável que essa resposta receba votos de vingança (isso acontece frequentemente com os denunciantes que defendem este site - se uma resposta tiver votos negativos e nenhum comentário, sempre seja cético).
2. Eu acho que é importante que o Stackoverflow seja um recurso confiável que não envenene os pesquisadores com desinformação e técnicas abaixo do ideal.
3. É assim que eu mostro o quanto me importo com os desenvolvedores futuros, para que eles aprendam o como e o porquê, em vez de apenas alimentar uma geração de programadores de copiar e colar.
4. Costumo usar páginas antigas para fechar novas páginas duplicadas - essa é responsabilidade de voluntários veteranos que sabem como encontrar rapidamente duplicatas. Não posso usar uma página antiga com informações ruins / falsas / subótimas / enganosas como referência, porque então estou prestando um desserviço a um novo pesquisador.

empty($gamerow['players'])

Resolvi esse problema com o seguinte código.

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

Isso parece funcionar para todos os casos

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

E se:

DepartmentPerSchool = array ();
(vazio (is_array ($ DepartmentPerSchool)))? $ DepartmentPerSchool // ou o eco não está vazio: array ('not set' => 'Not set. Entre em contato com o administrador'); // ou o eco está vazio