¿Cómo comprobar que un objeto está vacío en PHP?

Cómo saber si un objeto está vacío o no en PHP.

A continuación se muestra el código en el que se $objencuentran los datos XML. ¿Cómo puedo comprobar si está vacío o no?

Mi código:

$obj = simplexml_load_file($url);

Puede convertir a una matriz y luego verificar si está vacía o no

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

Editar : No me di cuenta de que querían verificar específicamente si un objeto SimpleXMLElement está vacío. Dejé la vieja respuesta a continuación

Respuesta actualizada (SimpleXMLElement) :

Para SimpleXMLElement:

Si por vacío quiere decir que no tiene propiedades:

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

O

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

Si SimpleXMLElement tiene un nivel de profundidad, y por vacío, en realidad quiere decir que solo tiene propiedades que PHP considera falsey (o ninguna propiedad):

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

Si SimpleXMLElement tiene más de un nivel de profundidad, puede comenzar convirtiéndolo en una 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
}

Respuesta anterior (objeto simple) :

Si desea verificar si un objeto simple (tipo stdClass) está completamente vacío (sin claves / valores), puede hacer lo siguiente:

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

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

Editar : ejemplo agregado

$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

Puede convertir su objeto en una matriz y probar su recuento de esta manera:

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

Imagínese si el objeto no está vacío y de alguna manera es bastante grande, ¿por qué desperdiciaría los recursos para convertirlo en una matriz o serializarlo ...

Esta es una solución muy fácil que uso en JavaScript. A diferencia de la solución mencionada que lanza un objeto a una matriz y verifica si está vacío, o para codificarlo en JSON, esta función simple es muy eficiente con respecto a los recursos utilizados para realizar una tarea simple.

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

    return TRUE;
}

La solución funciona de una manera muy simple: no entrará en ningún bucle foreach si el objeto está vacío y volverá true. Si no está vacío, ingresará al foreachbucle y regresará de falseinmediato, sin pasar por todo el conjunto.

El uso empty()no funcionará como de costumbre cuando se usa en un objeto, porque en su __isset()lugar se llamará al método de sobrecarga, si se declara.

Por lo tanto, puede usar count()(si el objeto es contable ).

O usando get_object_vars(), por ejemplo

get_object_vars($obj) ? TRUE : FALSE;

Otra posible solución que no necesita fundición 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 ) );

no existe una forma segura única de comprobar si un objeto está vacío

count () de php se lanza primero a la matriz, pero la conversión puede producir una matriz vacía, depende de cómo se implemente el objeto (los objetos de las extensiones a menudo se ven afectados por esos problemas)

en su caso, debe usar $ obj-> count ();

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

(ese no es el recuento de php http://www.php.net/count )

Si lanza algo en PHP como (bool), le dirá de inmediato si el elemento es un objeto, tipo primitivo o nulo. Utilice el siguiente 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!";
}

Si un objeto está "vacío" o no es una cuestión de definición, y debido a que depende de la naturaleza del objeto que representa la clase, le corresponde a la clase definirlo.

PHP mismo considera que cada instancia de una clase no está vacía.

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

// results in bool(false)

No puede haber una definición genérica para un objeto "vacío". En el ejemplo anterior, podría argumentar que el resultado de empty()debería ser true, porque el objeto no representa ningún contenido. Pero, ¿cómo saber PHP? Algunos objetos nunca están destinados a representar contenido (piense en las fábricas, por ejemplo), otros siempre representan un valor significativo (piense new DateTime()).

En resumen, tendrá que crear sus propios criterios para un objeto específico y probarlos en consecuencia, ya sea desde fuera del objeto o desde un isEmpty()método autoescrito en el objeto.

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

o

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

Estaba usando un json_decode de una cadena en la solicitud de publicación. Nada de lo anterior funcionó para mí, al final usé esto:

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

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