Jak zdefiniować pusty obiekt w PHP

Standardowy sposób tworzenia "pustego" obiektu to:

$oVal = new stdClass();

Ale z PHP > = 5.4, ja osobiście wolę używać:

$oVal = (object)[];

Jest krótszy i osobiście uważam go za jaśniejszy, ponieważ stdClass może wprowadzać w błąd początkujących programistów (np."...).

To samo z PHP

$oVal = (object) array();

(object)[] jest równoważne new stdClass().

Zobacz Podręcznik PHP ( tutaj):

StdClass : Utworzony przez typecasting do obiektu.

I (tutaj):

Jeśli obiekt jest konwertowany na obiekt, nie jest modyfikowany. Jeśli wartość innego typu zostanie przekonwertowana na obiekt, zostanie utworzona nowa instancja wbudowanej klasy stdClass.

Pamiętaj jednak, że empty ($oVal) zwraca false , jak powiedział @PaulP:

Obiekty bez właściwości nie są już brane pod uwagę pusty.

Odnośnie Twojego przykładu, jeśli napiszesz:

$oVal = new stdClass();
$oVal->key1->var1 = "something"; // PHP creates  a Warning here
$oVal->key1->var2 = "something else";

PHP tworzy następujące ostrzeżenie, domyślnie tworząc właściwość key1 (sam obiekt)

Warning: Tworzenie domyślnego obiektu z pustej wartości

Może to być problem, jeśli konfiguracja (zobacz poziom raportowania błędów) wyświetla to Ostrzeżenie w przeglądarce. Jest to kolejny cały temat, ale szybkie i brudne podejście może być za pomocą operator kontroli błędów (@) aby zignorować ostrzeżenie:

$oVal = new stdClass();
@$oVal->key1->var1 = "something"; // the warning is ignored thanks to @
$oVal->key1->var2 = "something else";

Chcę zaznaczyć, że w PHP nie ma czegoś takiego jak pusty obiekt w sensie:

$obj = new stdClass();
var_dump(empty($obj)); // bool(false)

Ale oczywiście $obj będzie puste.

Z drugiej strony tablica pusta oznacza pustą w obu przypadkach

$arr = array();
var_dump(empty($arr));

Cytat z changelog function empty

Obiekty bez właściwości nie są już uważane za puste.

Php.net said it is best:

$new_empty_object = new stdClass();

Uwielbiam jak łatwo jest tworzyć obiekty anonimowego typu w JavaScript:

//JavaScript
var myObj = {
    foo: "Foo value",
    bar: "Bar value"
};
console.log(myObj.foo); //Output: Foo value

Więc zawsze staram się pisać tego typu obiekty w PHP tak jak robi to javascript :

//PHP >= 5.4
$myObj = (object) [
    "foo" => "Foo value",
    "bar" => "Bar value"
];

//PHP < 5.4
$myObj = (object) array(
    "foo" => "Foo value",
    "bar" => "Bar value"
);

echo $myObj->foo; //Output: Foo value

Ale ponieważ jest to w zasadzie tablica, nie możesz przypisać funkcji anonimowych do właściwości, takiej jak robi to js:

//JavaScript
var myObj = {
    foo: "Foo value",
    bar: function(greeting) {
        return greeting + " bar";
    }
};
console.log(myObj.bar("Hello")); //Output: Hello bar

//PHP >= 5.4
$myObj = (object) [
    "foo" => "Foo value",
    "bar" => function($greeting) {
        return $greeting . " bar";
    }
];
var_dump($myObj->bar("Hello")); //Throw 'undefined function' error
var_dump($myObj->bar); //Output: "object(Closure)"

$barFunc = $myObj->bar;
echo $barFunc("Hello"); //Output: Hello bar

Ponadto, za pomocą tego syntax można znaleźć kilka zabawne niespodzianki, ale działa dobrze dla większości sprawy.

Oprócz odpowiedzi zombata jeśli ciągle zapominasz stdClass

   function object(){

        return new stdClass();

    }

Teraz możesz zrobić:

$str='';
$array=array();
$object=object();

Aby uzyskać dostęp do danych w stdClass w podobny sposób, co robisz w tablicy asocjacyjnej wystarczy użyć składni {$var}.

$myObj = new stdClass;
$myObj->Prop1 = "Something";
$myObj->Prop2 = "Something else";

// then to acces it directly

echo $myObj->{'Prop1'};
echo $myObj->{'Prop2'};

// or what you may want

echo $myObj->{$myStringVar};

Możesz użyć new stdClass() (co jest zalecane):

$obj_a = new stdClass();
$obj_a->name = "John";
print_r($obj_a);

// outputs:
// stdClass Object ( [name] => John ) 

Można też przekonwertować pustą tablicę na obiekt, który tworzy nową pustą instancję wbudowanej klasy stdClass:

$obj_b = (object) [];
$obj_b->name = "John";
print_r($obj_b);

// outputs: 
// stdClass Object ( [name] => John )  

Lub możesz przekonwertować wartość null na obiekt, który tworzy nową pustą instancję wbudowanej klasy stdClass:

$obj_c = (object) null;
$obj_c->name = "John";
print($obj_c);

// outputs:
// stdClass Object ( [name] => John ) 

Możesz spróbować również w ten sposób.

<?php
     $obj = json_decode("{}"); 
     var_dump($obj);
?>

Wyjście:

object(stdClass)#1 (0) { }

Jak zauważyli inni, możesz użyć stdClass. Jednak myślę, że jest czystsze Bez (), jak TAK:

$obj = new stdClass;

Jednak w oparciu o to pytanie, wydaje się, że to, czego naprawdę chcesz, to możliwość dodawania właściwości do obiektu w locie. Nie musisz do tego używać stdClass, chociaż możesz. Naprawdę możesz użyć każdej klasy. Wystarczy utworzyć instancję obiektu dowolnej klasy i rozpocząć ustawienie właściwości. Lubię tworzyć własne klasy, których nazwa jest po prostu o z niektórych podstawowych rozszerzonych funkcjonalność, która lubię używać w tych przypadkach i jest miła dla rozszerzenia z innych klas. Zasadniczo jest to moja własna podstawowa klasa obiektu. Lubię też mieć funkcję o nazwie o (). TAK:

class o {
  // some custom shared magic, constructor, properties, or methods here
}

function o() {
  return new o;
}

Jeśli nie chcesz mieć własnego typu obiektu bazowego, możesz po prostu poprosić o () o zwrócenie nowej klasy stdClass. Zaletą jest to, że o jest łatwiejsze do zapamiętania niż stdClass i jest krótsze, niezależnie od tego, czy używasz go jako nazwy klasy, nazwy funkcji, czy obu. Nawet jeśli nie masz żadnego kodu w środku twoja klasa o jest jeszcze łatwiejsza do zapamiętania niż niezręcznie Pisana i nazwana stdClass (która może powoływać się na ideę "klasy chorób przenoszonych drogą płciową"). Jeśli dostosujesz klasę o, Możesz znaleźć zastosowanie dla funkcji o () zamiast składni konstruktora. Jest to normalna funkcja, która zwraca wartość, która jest mniej ograniczona niż konstruktor. Na przykład nazwa funkcji może być przekazana jako łańcuch znaków do funkcji, która akceptuje parametr wywołujący. Funkcja obsługuje również chaining. Więc możesz zrobić coś takiego jak: $result= o ($internal_value) - >some_operation_or_conversion_on_this_value ();

Jest to świetny początek dla "języka" bazowego do budowania innych warstw językowych, na których górna warstwa jest napisana w pełnych wewnętrznych DSL. Jest to podobne do stylu programowania Lispu, A PHP obsługuje go o wiele lepiej niż większość ludzi zdaje sobie sprawę. Zdaję sobie sprawę, że jest to trochę styczne do pytania, ale pytanie dotyka tego, co moim zdaniem jest podstawą do pełnego wykorzystania potęga PHP.

Jeżeli chcesz wytworzyć obiekt (jak w javascript) z właściwościami dynamicznymi, bez ostrzeżenia o niezdefiniowanej właściwości.

class stdClass {

public function __construct(array $arguments = array()) {
    if (!empty($arguments)) {
        foreach ($arguments as $property => $argument) {
            if(is_numeric($property)):
                $this->{$argument} = null;
            else:
                $this->{$property} = $argument;
            endif;
        }
    }
}

public function __call($method, $arguments) {
    $arguments = array_merge(array("stdObject" => $this), $arguments); // Note: method argument 0 will always referred to the main class ($this).
    if (isset($this->{$method}) && is_callable($this->{$method})) {
        return call_user_func_array($this->{$method}, $arguments);
    } else {
        throw new Exception("Fatal error: Call to undefined method stdObject::{$method}()");
    }
}

public function __get($name){
    if(property_exists($this, $name)):
        return $this->{$name};
    else:
        return $this->{$name} = null;
    endif;
}

public function __set($name, $value) {
    $this->{$name} = $value;
}

}

$obj1 = new stdClass(['property1','property2'=>'value']); //assign default property
echo $obj1->property1;//null
echo $obj1->property2;//value

$obj2 = new stdClass();//without properties set
echo $obj2->property1;//null

Możemy po prostu utworzyć pusty obiekt używając tej metody:

$object = new ObjectClass();

Na przykład:

class ObjectClass
{
    // Something goes here
}

$object = new ObjectClass();

Teraz mamy zmienną {[2] } która jest ObjectClass ale pustą. Uwaga jeśli zawiera funkcję __construct(), to może nie być pusta.

Jeśli nie chcesz tego robić:

$myObj = new stdClass();
$myObj->key_1 = 'Hello';
$myObj->key_2 = 'Dolly';

Możesz użyć jednej z następujących opcji:

PHP >=5.4

$myObj = (object) [
    'key_1' => 'Hello',
    'key_3' => 'Dolly',
];

PHP

$myObj = (object) array(
    'key_1' => 'Hello',
    'key_3' => 'Dolly',
);

Użyj obiektu ogólnego i Mapuj do niego pary wartości klucza.

$oVal = new stdClass();
$oVal->key = $value

Lub wrzucić tablicę do obiektu

$aVal = array( 'key'=>'value' );
$oVal = (object) $aVal;

Oto przykład z iteracją:

<?php
$colors = (object)[];
$colors->red = "#F00";
$colors->slateblue = "#6A5ACD";
$colors->orange = "#FFA500";

foreach ($colors as $key => $value) : ?>
    <p style="background-color:<?= $value ?>">
        <?= $key ?> -> <?= $value ?>
    </p>
<?php endforeach; ?>

Masz tą kiepską ale użyteczną technikę:

$var = json_decode(json_encode([]), FALSE);