Jak zdefiniować pusty obiekt w PHP

Z nową tablicą robię to:

$aVal = array();

$aVal[key1][var1] = "something";
$aVal[key1][var2] = "something else";

Czy istnieje podobna składnia dla obiektu

(object)$oVal = "";

$oVal->key1->var1 = "something";
$oVal->key1->var2 = "something else";

$x = new stdClass();

Komentarz w podręczniku podsumowuje to najlepiej:

stdClass jest domyślnym obiektem PHP. stdClass nie ma właściwości, metod ani elementu nadrzędnego. Nie obsługuje magicznych metod i nie implementuje interfejsów.

Kiedy rzutujesz skalar lub tablicę jako Object, dostajesz instancję stdClass. Możesz użyć stdClass, ilekroć potrzebujesz ogólnej instancji obiektu.

Standardowym sposobem utworzenia „pustego” obiektu jest:

$oVal = new stdClass();

Ale przy PHP> = 5.4 osobiście wolę używać:

$oVal = (object)[];

Jest krótszy i osobiście uważam, że jest bardziej przejrzysty, ponieważ stdClass może wprowadzać w błąd początkujących programistów (tj. „Hej, chcę obiekt, a nie klasę!” ...).

To samo z PHP <5.4 to:

$oVal = (object) array();

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

Zobacz instrukcję PHP ( tutaj ):

stdClass : Utworzony przez rzut rzutowy na obiekt.

i ( tutaj ):

Jeśli obiekt zostanie przekonwertowany na obiekt, nie zostanie zmodyfikowany. Jeśli wartość dowolnego innego typu zostanie przekonwertowana na obiekt, zostanie utworzone nowe wystąpienie wbudowanej klasy stdClass .

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

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

Jeśli chodzi o twój przykład, jeśli piszesz:

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

Ostrzeżenie: tworzenie domyślnego obiektu z pustej wartości

Może to stanowić problem, jeśli Twoja konfiguracja (patrz poziom zgłaszania błędów ) wyświetla to ostrzeżenie w przeglądarce. To kolejny cały temat, ale szybkim i nieprzyzwoitym podejściem może być użycie operatora kontroli błędów (@) w celu zignorowania ostrzeżenia:

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

Chcę podkreślić, ż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 pusty.

Z drugiej strony pusta tablica oznacza pustą w obu przypadkach

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

Cytat z funkcji dziennika zmian pusty

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

php.net powiedział, że najlepiej:

$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

Dlatego zawsze staram się pisać tego rodzaju 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żna wykonywać takich czynności, jak przypisywanie anonimowych funkcji do właściwości, takich jak 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)"

Cóż, możesz to zrobić, ale IMO nie jest praktyczne / czyste:

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

Ponadto, korzystając z tej składni, możesz znaleźć zabawne niespodzianki , ale działa dobrze w większości przypadków.

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

   function object(){

        return new stdClass();

    }

Teraz możesz zrobić:

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

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 ) 

Lub możesz 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ć nullwartość 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 ) 

aby uzyskać dostęp do danych w stdClass w podobny sposób, jak 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};

Jak zauważyli inni, możesz użyć stdClass. Jednak myślę, że jest czystszy bez (), tak:

$obj = new stdClass;

Jednak na podstawie tego pytania wydaje się, że naprawdę chcesz dodawać właściwości do obiektu w locie. Nie musisz do tego używać stdClass, chociaż możesz. Naprawdę możesz użyć dowolnej klasy. Wystarczy utworzyć instancję obiektu dowolnej klasy i rozpocząć ustawianie właściwości. Lubię tworzyć własną klasę, której nazwa to po prostu podstawowa rozbudowana funkcjonalność, którą lubię w takich przypadkach i jest miła do rozszerzenia z innych klas. Zasadniczo jest to moja własna podstawowa klasa obiektów. Lubię też mieć funkcję o nazwie o (). Tak jak:

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

function o() {
  return new o;
}

Jeśli nie chcesz mieć własnego podstawowego typu obiektu, możesz po prostu poprosić o () o zwrócenie nowej klasy stdClass. Jedną z zalet jest to, że o jest łatwiejsze do zapamiętania niż stdClass i jest krótszy, niezależnie od tego, czy użyjesz go jako nazwy klasy, nazwy funkcji, czy obu. Nawet jeśli nie masz żadnego kodu w swojej klasie, łatwiej jest zapamiętać niż niezgrabnie pisane wielką literą i nazwane stdClass (co może wywoływać 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 nazwę funkcji można przekazać jako ciąg do funkcji, która akceptuje parametr na żądanie. Funkcja obsługuje również tworzenie łańcuchów. Możesz więc zrobić coś takiego:

To świetny początek dla podstawowego „języka”, na którym można budować inne warstwy językowe, przy czym górna warstwa jest zapisywana w pełni wewnętrznych DSL. Jest to podobne do stylu seplenienia, a PHP obsługuje go znacznie lepiej niż większość ludzi zdaje sobie sprawę. Zdaję sobie sprawę, że jest to trochę styczna do pytania, ale pytanie dotyczy tego, co moim zdaniem jest podstawą do pełnego wykorzystania mocy PHP.

Jeśli chcesz utworzyć 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żesz także spróbować w ten sposób.

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

Wynik:

object(stdClass)#1 (0) { }

Użyj ogólnego obiektu i odwzoruj na nim pary wartości klucza.

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

Lub rzuć tablicę na obiekt

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

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 <5.4

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

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 przydatną technikę:

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

stdClass jest domyślnym obiektem PHP. stdClass nie ma właściwości, metod ani elementu nadrzędnego. Nie obsługuje magicznych metod i nie implementuje interfejsów.

Kiedy rzutujesz skalar lub tablicę jako Object, dostajesz instancję stdClass. Możesz użyć stdClass, ilekroć potrzebujesz ogólnej instancji obiektu.

<?php
// ways of creating stdClass instances
$x = new stdClass;
$y = (object) null;        // same as above
$z = (object) 'a';         // creates property 'scalar' = 'a'
$a = (object) array('property1' => 1, 'property2' => 'b');
?>

stdClass NIE jest klasą podstawową! Klasy PHP nie dziedziczą automatycznie po żadnej klasie. Wszystkie klasy są samodzielne, chyba że jawnie rozszerzają inną klasę. Pod tym względem PHP różni się od wielu języków obiektowych.

<?php
// CTest does not derive from stdClass
class CTest {
    public $property1;
}
$t = new CTest;
var_dump($t instanceof stdClass);            // false
var_dump(is_subclass_of($t, 'stdClass'));    // false
echo get_class($t) . "\n";                   // 'CTest'
echo get_parent_class($t) . "\n";            // false (no parent)
?>

W kodzie nie można zdefiniować klasy o nazwie „stdClass”. Ta nazwa jest już używana przez system. Możesz zdefiniować klasę o nazwie „Obiekt”.

Możesz zdefiniować klasę rozszerzającą stdClass, ale nie uzyskałbyś żadnej korzyści, ponieważ stdClass nic nie robi.

(testowany na PHP 5.2.8)