PHP'de bir nesnenin boş olup olmadığı nasıl kontrol edilir?

PHP'de bir nesnenin boş olup olmadığı nasıl anlaşılır?

$objXML verilerini tutan kod aşağıdadır. Boş olup olmadığını nasıl kontrol edebilirim?

Kodum:

$obj = simplexml_load_file($url);

Bir diziye çevirebilir ve ardından boş olup olmadığını kontrol edebilirsiniz.

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

Düzenleme : Bir SimpleXMLElement nesnesinin boş olup olmadığını özellikle kontrol etmek istediklerini fark etmemiştim. Eski cevabı aşağıda bıraktım

Güncellenmiş Cevap (SimpleXMLElement) :

SimpleXMLElement için:

Boş derken hiçbir özelliği olmadığını kastediyorsunuz:

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

VEYA

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

SimpleXMLElement bir seviye derinse ve boş derken aslında sadece PHP'nin falsey olarak kabul ettiği özelliklere sahip olduğunu kastediyorsunuz (veya hiçbir özelliği yok):

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

SimpleXMLElement birden fazla düzeydeyse, onu saf bir diziye dönüştürerek başlayabilirsiniz:

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

Eski Cevap (basit nesne) :

Basit bir nesnenin (tür stdClass) tamamen boş olup olmadığını kontrol etmek istiyorsanız (anahtar / değer yok), aşağıdakileri yapabilirsiniz:

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

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

Düzenleme : eklenmiş örnek

$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

Nesnenizi bir diziye çevirebilir ve sayısını şu şekilde test edebilirsiniz:

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

Nesne boş değilse ve bir bakıma oldukça büyükse, onu diziye dönüştürmek ya da serileştirmek için kaynakları neden boşa harcayasınız ki ...

Bu, JavaScript'te kullandığım çok kolay bir çözüm. Bir nesneyi diziye dönüştüren ve boş olup olmadığını kontrol eden veya JSON olarak kodlayan söz konusu çözümün aksine, bu basit işlev, basit bir görevi gerçekleştirmek için kullanılan kaynaklar açısından çok etkilidir.

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

    return TRUE;
}

Çözüm çok basit bir şekilde çalışıyor: Nesne boşsa ve geri dönecekse foreach döngüsüne hiç girmeyecek true. Boş değilse, tüm setten geçmeden foreachdöngüye girecek ve falsehemen geri dönecektir .

Kullanılması empty()çünkü bir nesne üzerinde kullanırken her zamanki gibi işe yaramaz __isset()ilan takdirde aşırı yöntem yerine çağrılacak.

Bu nedenle kullanabilirsiniz count()(nesne Sayılabilir ise ).

Veya get_object_vars()örneğin kullanarak

get_object_vars($obj) ? TRUE : FALSE;

Yayınlamaya ihtiyaç duymayan başka bir olası çözüm 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 ) );

bir nesnenin boş olup olmadığını kontrol etmenin benzersiz güvenli bir yolu yoktur

php's count () diziye ilk çevirir, ancak çevrim boş bir dizi üretebilir, nesnenin nasıl uygulandığına bağlıdır (uzantıların nesneleri genellikle bu sorunlardan etkilenir)

sizin durumunuzda $ obj-> count () kullanmanız gerekir;

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

(bu php'nin sayısı değil http://www.php.net/count )

PHP'de herhangi bir şeyi (bool) olarak çevirirseniz, öğenin bir nesne mi, ilkel tür mü yoksa boş mu olduğunu hemen söyleyecektir. Aşağıdaki kodu kullanın:

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

Bir nesnenin "boş" olması veya olmaması bir tanım meselesiyse ve sınıfın temsil ettiği nesnenin doğasına bağlı olduğu için, tanımlaması sınıfın kendisine aittir.

PHP, bir sınıfın her örneğini boş değil olarak görür.

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

// results in bool(false)

"Boş" bir nesne için genel bir tanım olamaz. Yukarıdaki örnekte sonucunun empty()olması gerektiğini true, çünkü nesnenin herhangi bir içeriği temsil etmediğini iddia edebilirsiniz . Fakat PHP nasıl bilinmeli? Bazı nesneler asla içeriği temsil etme amacını taşımaz (örneğin fabrikaları düşünün), diğerleri her zaman anlamlı bir değeri temsil eder (düşünün new DateTime()).

Kısacası, belirli bir nesne için kendi kriterlerinizi bulmanız ve bunları nesnenin dışından veya nesnede kendi kendine yazılan bir isEmpty()yöntemle buna göre test etmeniz gerekecektir .

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

veya

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

Gönderi isteğinde bir dizenin json_decode'unu kullanıyordum. Yukarıdakilerin hiçbiri benim için işe yaramadı, sonunda şunu kullandım:

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

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