Come verificare che un oggetto sia vuoto in PHP?

Come scoprire se un oggetto è vuoto o meno in PHP.

Di seguito è riportato il codice in cui $objsono contenuti i dati XML. Come posso verificare se è vuoto o no?

Il mio codice:

$obj = simplexml_load_file($url);

Puoi eseguire il cast su un array e quindi verificare se è vuoto o meno

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

Modifica : non mi ero reso conto che volessero controllare specificamente se un oggetto SimpleXMLElement è vuoto. Ho lasciato la vecchia risposta qui sotto

Risposta aggiornata (SimpleXMLElement) :

Per SimpleXMLElement:

Se per vuoto intendi non ha proprietà:

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

O

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

Se SimpleXMLElement è profondo un livello e con vuoto in realtà significa che ha solo proprietà che PHP considera false (o nessuna proprietà):

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

Se SimpleXMLElement è profondo più di un livello, puoi iniziare convertendolo in un array puro:

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

Vecchia risposta (oggetto semplice) :

Se vuoi controllare se un oggetto semplice (tipo stdClass) è completamente vuoto (nessuna chiave / valore), puoi fare quanto segue:

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

Modifica : aggiunto esempio

$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

Puoi lanciare il tuo oggetto in un array e testarne il conteggio in questo modo:

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

Immagina se l'oggetto non è vuoto e in un certo senso abbastanza grande, perché sprecheresti le risorse per lanciarlo in array o serializzarlo ...

Questa è una soluzione molto semplice che utilizzo in JavaScript. A differenza della soluzione menzionata che esegue il cast di un oggetto in un array e controlla se è vuoto, o per codificarlo in JSON, questa semplice funzione è molto efficiente per quanto riguarda le risorse utilizzate per eseguire un'attività semplice.

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

    return TRUE;
}

La soluzione funziona in un modo molto semplice: non entrerà affatto in un ciclo foreach se l'oggetto è vuoto e tornerà true. Se non è vuoto, entrerà nel foreachciclo e tornerà falsesubito, senza passare attraverso l'intero set.

L'utilizzo empty()non funzionerà come al solito quando lo si utilizza su un oggetto, perché il __isset()metodo di sovraccarico verrà invece chiamato, se dichiarato.

Quindi puoi usare count()(se l'oggetto è numerabile ).

O utilizzando get_object_vars(), ad es

get_object_vars($obj) ? TRUE : FALSE;

Un'altra possibile soluzione che non necessita di casting per 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 ) );

non esiste un modo unico e sicuro per verificare se un oggetto è vuoto

count () di php esegue prima il cast su array, ma il casting può produrre un array vuoto, dipende da come l'oggetto è implementato (gli oggetti delle estensioni sono spesso influenzati da questi problemi)

nel tuo caso devi usare $ obj-> count ();

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

(questo non è il conteggio di php http://www.php.net/count )

Se esegui il cast di qualcosa in PHP come (bool), ti dirà subito se l'elemento è un oggetto, un tipo primitivo o nullo. Usa il codice seguente:

$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 un oggetto è "vuoto" o meno è una questione di definizione e poiché dipende dalla natura dell'oggetto rappresentato dalla classe, spetta alla classe definirlo.

PHP stesso considera ogni istanza di una classe come non vuota.

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

// results in bool(false)

Non può esserci una definizione generica per un oggetto "vuoto". Si potrebbe sostenere nell'esempio precedente il risultato di empty()dovrebbe essere true, perché l'oggetto non rappresenta alcun contenuto. Ma come deve saperlo PHP? Alcuni oggetti non sono mai intesi per rappresentare il contenuto (pensa alle fabbriche per esempio), altri rappresentano sempre un valore significativo (pensa new DateTime()).

In breve, dovrai elaborare i tuoi criteri per un oggetto specifico e testarli di conseguenza, dall'esterno dell'oggetto o da un isEmpty()metodo auto-scritto nell'oggetto.

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

o

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

Stavo usando un json_decode di una stringa nella richiesta di post. Nessuno dei precedenti ha funzionato per me, alla fine ho usato questo:

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

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