Como verificar se um objeto está vazio no PHP?

Como descobrir se um objeto está vazio ou não no PHP.

A seguir está o código no qual $objestá mantendo os dados XML. Como posso verificar se está vazio ou não?

Meu código:

$obj = simplexml_load_file($url);

Você pode lançar para uma matriz e, em seguida, verificar se ela está vazia ou não

$arr = (array)$obj;
if (!$arr) {
    // do stuff
}

Edit : Eu não percebi que eles queriam verificar especificamente se um objeto SimpleXMLElement está vazio. Eu deixei a velha resposta abaixo

Resposta atualizada (SimpleXMLElement) :

Para SimpleXMLElement:

Se por vazio você quer dizer não tem propriedades:

$obj = simplexml_load_file($url);
if ( !$obj->count() )
{
    // no properties
}

OU

$obj = simplexml_load_file($url);
if ( !(array)$obj )
{
    // empty array
}

Se SimpleXMLElement tiver um nível de profundidade e por vazio, você realmente quer dizer que ele só possui propriedades que o PHP considera falsey (ou nenhuma propriedade):

$obj = simplexml_load_file($url);
if ( !array_filter((array)$obj) )
{
    // all properties falsey or no properties at all
}

Se SimpleXMLElement tiver mais de um nível de profundidade, você pode começar convertendo-o em uma matriz pura:

$obj = simplexml_load_file($url);
// `json_decode(json_encode($obj), TRUE)` can be slow because
// you're converting to and from a JSON string.
// I don't know another simple way to do a deep conversion from object to array
$array = json_decode(json_encode($obj), TRUE);
if ( !array_filter($array) )
{
    // empty or all properties falsey
}

Resposta Antiga (objeto simples) :

Se você deseja verificar se um objeto simples (tipo stdClass) está completamente vazio (sem chaves / valores), você pode fazer o seguinte:

// $obj is type stdClass and we want to check if it's empty
if ( $obj == new stdClass() )
{
    echo "Object is empty"; // JSON: {}
}
else
{
    echo "Object has properties";
}

Fonte: http://php.net/manual/en/language.oop5.object-comparison.php

Editar : exemplo adicionado

$one = new stdClass();
$two = (object)array();

var_dump($one == new stdClass()); // TRUE
var_dump($two == new stdClass()); // TRUE
var_dump($one == $two); // TRUE

$two->test = TRUE;
var_dump($two == new stdClass()); // FALSE
var_dump($one == $two); // FALSE

$two->test = FALSE;
var_dump($one == $two); // FALSE

$two->test = NULL;
var_dump($one == $two); // FALSE

$two->test = TRUE;
$one->test = TRUE;
var_dump($one == $two); // TRUE

unset($one->test, $two->test);
var_dump($one == $two); // TRUE

Você pode lançar seu objeto em uma matriz e testar sua contagem assim:

if(count((array)$obj)) {
   // doStuff
}

Imagine se o objeto não está vazio e de uma forma bastante grande, por que você desperdiçaria recursos para convertê-lo em um array ou serializá-lo ...

Esta é uma solução muito fácil que uso em JavaScript. Ao contrário da solução mencionada que converte um objeto em array e verifica se está vazio, ou para codificá-lo em JSON, esta função simples é muito eficiente em relação aos recursos usados ​​para realizar uma tarefa simples.

function emptyObj( $obj ) {
    foreach ( $obj AS $prop ) {
        return FALSE;
    }

    return TRUE;
}

A solução funciona de uma maneira muito simples: ele não entrará em um loop foreach se o objeto estiver vazio e ele retornará true. Se não estiver vazio, ele entrará no foreachloop e retornará falseimediatamente, não passando por todo o conjunto.

O uso empty()não funcionará normalmente ao usá-lo em um objeto, porque o __isset()método de sobrecarga será chamado, se declarado.

Portanto, você pode usar count()(se o objeto for Contável ).

Ou usando get_object_vars(), por exemplo

get_object_vars($obj) ? TRUE : FALSE;

Outra solução possível que não precisa de vazamento para array:

// test setup
class X { private $p = 1; } // private fields only => empty
$obj = new X;
// $obj->x = 1;


// test wrapped into a function
function object_empty( $obj ){
  foreach( $obj as $x ) return false;
  return true;
}


// inline test
$object_empty = true;
foreach( $obj as $object_empty ){ // value ignored ... 
  $object_empty = false; // ... because we set it false
  break;
}


// test    
var_dump( $object_empty, object_empty( $obj ) );

não há uma maneira única e segura de verificar se um objeto está vazio

O count () do php converte primeiro em array, mas o casting pode produzir um array vazio, depende de como o objeto é implementado (objetos de extensões são freqüentemente afetados por esses problemas)

no seu caso, você deve usar $ obj-> count ();

http://it.php.net/manual/en/simplexmlelement.count.php

(isso não é a contagem de php http://www.php.net/count )

Se você converter qualquer coisa no PHP como um (bool), ele dirá imediatamente se o item é um objeto, tipo primitivo ou nulo. Use o seguinte código:

$obj = simplexml_load_file($url);

if (!(bool)$obj) {
    print "This variable is null, 0 or empty";
} else {
    print "Variable is an object or a primitive type!";
}

Se um objeto está "vazio" ou não, é uma questão de definição, e porque depende da natureza do objeto que a classe representa, cabe à classe definir.

O próprio PHP considera cada instância de uma classe como não vazia.

class Test { }
$t = new Test();
var_dump(empty($t));

// results in bool(false)

Não pode haver uma definição genérica para um objeto "vazio". Você pode argumentar no exemplo acima que o resultado de empty()deveria ser true, porque o objeto não representa nenhum conteúdo. Mas como o PHP deve saber? Alguns objetos nunca têm o objetivo de representar conteúdo (pense em fábricas, por exemplo), outros sempre representam um valor significativo (pense new DateTime()).

Em suma, você terá que criar seus próprios critérios para um objeto específico e testá-los de acordo, seja de fora do objeto ou de um isEmpty()método autoescrito no objeto.

$array = array_filter($array);
if(!empty($array)) {
    echo "not empty";
}

ou

if(count($array) > 0) {
    echo 'Error';
} else {
    echo 'No Error';
}

Eu estava usando um json_decode de uma string na solicitação de postagem. Nenhuma das opções acima funcionou para mim, no final eu usei isto:

$post_vals = json_decode($_POST['stuff']);

if(json_encode($post_vals->object) != '{}')
{
    // its not empty
}