Comment vérifier qu'un objet est vide en PHP?

Comment savoir si un objet est vide ou non en PHP.

Voici le code dans lequel $objse trouvent les données XML. Comment puis-je vérifier s'il est vide ou non?

Mon code:

$obj = simplexml_load_file($url);

Vous pouvez effectuer un cast en un tableau puis vérifier s'il est vide ou non

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

Edit : Je ne savais pas qu'ils voulaient spécifiquement vérifier si un objet SimpleXMLElement est vide. J'ai laissé l'ancienne réponse ci-dessous

Réponse mise à jour (SimpleXMLElement) :

Pour SimpleXMLElement:

Si par vide vous voulez dire n'a pas de propriétés:

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

OU

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

Si SimpleXMLElement a un niveau de profondeur et que vide, vous voulez dire qu'il n'a que des propriétés que PHP considère comme fausses (ou aucune propriété):

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

Si SimpleXMLElement a plus d'un niveau de profondeur, vous pouvez commencer par le convertir en un tableau pur:

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

Ancienne réponse (objet simple) :

Si vous voulez vérifier si un objet simple (type stdClass) est complètement vide (pas de clés / valeurs), vous pouvez faire ce qui suit:

// $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";
}

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

Edit : exemple ajouté

$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

Vous pouvez convertir votre objet dans un tableau et tester son nombre comme ceci:

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

Imaginez si l'objet n'est pas vide et d'une manière assez grand, pourquoi gaspilleriez-vous les ressources pour le convertir en tableau ou le sérialiser ...

C'est une solution très simple que j'utilise en JavaScript. Contrairement à la solution mentionnée qui convertit un objet en tableau et vérifie s'il est vide, ou pour l'encoder en JSON, cette fonction simple est très efficace concernant les ressources utilisées pour effectuer une tâche simple.

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

    return TRUE;
}

La solution fonctionne de manière très simple: elle n'entrera pas du tout dans une boucle foreach si l'objet est vide et il reviendra true. S'il n'est pas vide, il entrera dans la foreachboucle et reviendra falsetout de suite, sans passer par l'ensemble.

L'utilisation empty()ne fonctionnera pas comme d'habitude lors de son utilisation sur un objet, car la __isset()méthode de surcharge sera appelée à la place, si elle est déclarée.

Par conséquent, vous pouvez utiliser count()(si l'objet est dénombrable ).

Ou en utilisant get_object_vars(), par exemple

get_object_vars($obj) ? TRUE : FALSE;

Une autre solution possible qui n'a pas besoin d'être castée pour 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 ) );

il n'y a pas de moyen sûr unique de vérifier si un objet est vide

php's count () effectue d'abord un cast en tableau, mais le cast peut produire un tableau vide, dépend de la façon dont l'objet est implémenté (les objets des extensions sont souvent affectés par ces problèmes)

dans votre cas, vous devez utiliser $ obj-> count ();

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

(ce n'est pas le décompte de php http://www.php.net/count )

Si vous transtypez quelque chose en PHP comme un (booléen), il vous dira tout de suite si l'élément est un objet, un type primitif ou nul. Utilisez le code suivant:

$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!";
}

Si un objet est "vide" ou non est une question de définition, et parce que cela dépend de la nature de l'objet que la classe représente, c'est à la classe de le définir.

PHP lui-même considère chaque instance d'une classe comme non vide.

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

// results in bool(false)

Il ne peut pas y avoir de définition générique pour un objet "vide". Vous pourriez argumenter dans l'exemple ci-dessus que le résultat de empty()devrait être true, car l'objet ne représente aucun contenu. Mais comment PHP doit-il savoir? Certains objets ne sont jamais destinés à représenter du contenu (pensez aux usines par exemple), d'autres représentent toujours une valeur significative (pensez new DateTime()).

En bref, vous devrez trouver vos propres critères pour un objet spécifique, et les tester en conséquence, soit de l'extérieur de l'objet, soit à partir d'une isEmpty()méthode auto-écrite dans l'objet.

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

ou

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

J'utilisais un json_decode d'une chaîne dans la demande de publication. Rien de ce qui précède n'a fonctionné pour moi, à la fin j'ai utilisé ceci:

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

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