So definieren Sie ein leeres Objekt in PHP

mit einem neuen Array mache ich das:

$aVal = array();

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

Gibt es eine ähnliche Syntax für ein Objekt?

(object)$oVal = "";

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

$x = new stdClass();

Ein Kommentar im Handbuch fasst es am besten zusammen:

stdClass ist das Standard-PHP-Objekt. stdClass hat keine Eigenschaften, Methoden oder Eltern. Es unterstützt keine magischen Methoden und implementiert keine Schnittstellen.

Wenn Sie einen Skalar oder ein Array als Objekt umwandeln, erhalten Sie eine Instanz von stdClass. Sie können stdClass verwenden, wenn Sie eine generische Objektinstanz benötigen.

Die Standardmethode zum Erstellen eines "leeren" Objekts ist:

$oVal = new stdClass();

Aber mit PHP> = 5.4 bevorzuge ich persönlich :

$oVal = (object)[];

Es ist kürzer und ich persönlich halte es für klarer, weil stdClass für unerfahrene Programmierer irreführend sein könnte (dh "Hey, ich möchte ein Objekt, keine Klasse!" ...).

Das gleiche mit PHP <5.4 ist:

$oVal = (object) array();

(object)[]ist äquivalent zu new stdClass().

Siehe das PHP-Handbuch ( hier ):

stdClass : Erstellt durch Typumwandlung in ein Objekt.

und ( hier ):

Wenn ein Objekt in ein Objekt konvertiert wird, wird es nicht geändert. Wenn ein Wert eines anderen Typs in ein Objekt konvertiert wird, wird eine neue Instanz der integrierten Klasse stdClass erstellt .

Denken Sie jedoch daran, dass leer ($ oVal) false zurückgibt , wie @PaulP sagte:

Objekte ohne Eigenschaften werden nicht mehr als leer betrachtet.

In Bezug auf Ihr Beispiel, wenn Sie schreiben:

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

PHP erstellt die folgende Warnung und erstellt implizit die Eigenschaft key1(ein Objekt selbst).

Warnung: Standardobjekt aus leerem Wert erstellen

Dies kann ein Problem sein, wenn Ihre Konfiguration (siehe Fehlerberichterstattungsstufe ) diese Warnung dem Browser anzeigt. Dies ist ein weiteres ganzes Thema, aber ein schneller und schmutziger Ansatz könnte darin bestehen, den Fehlerkontrolloperator (@) zu verwenden, um die Warnung zu ignorieren:

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

Ich möchte darauf hinweisen, dass es in PHP kein leeres Objekt im Sinne gibt:

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

aber natürlich wird $ obj leer sein.

Andererseits bedeutet leeres Array in beiden Fällen leer

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

Zitat aus Changelog-Funktion leer

Objekte ohne Eigenschaften werden nicht mehr als leer betrachtet.

php.net sagte, es sei am besten:

$new_empty_object = new stdClass();

Ich finde es toll, wie einfach es ist, Objekte anonymen Typs in JavaScript zu erstellen:

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

Deshalb versuche ich immer, diese Art von Objekten in PHP zu schreiben, wie es Javascript tut :

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

Da es sich jedoch im Grunde genommen um ein Array handelt, können Sie einer Eigenschaft keine anonymen Funktionen zuweisen, wie dies bei js der Fall ist:

//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)"

Nun, Sie können es tun, aber IMO ist nicht praktisch / sauber:

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

Mit dieser Synthax können Sie auch einige lustige Überraschungen finden , die jedoch in den meisten Fällen gut funktionieren.

Zusätzlich zu Zombats Antwort, wenn Sie immer wieder vergessen stdClass

   function object(){

        return new stdClass();

    }

Jetzt können Sie Folgendes tun:

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

Sie können verwenden new stdClass()(was empfohlen wird):

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

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

Oder Sie können ein leeres Array in ein Objekt konvertieren, das eine neue leere Instanz der integrierten Klasse stdClass erzeugt:

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

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

Sie können den nullWert auch in ein Objekt konvertieren, das eine neue leere Instanz der integrierten Klasse stdClass erzeugt:

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

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

Um auf Daten in einer stdClass auf ähnliche Weise zuzugreifen, wie Sie es mit einem asoziativen Array tun, verwenden Sie einfach die Syntax {$ 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};

Wie andere bereits betont haben, können Sie stdClass verwenden. Ich denke jedoch, dass es ohne () sauberer ist, wie folgt:

$obj = new stdClass;

Basierend auf der Frage scheint es jedoch so, als ob Sie wirklich in der Lage sein möchten, einem Objekt im laufenden Betrieb Eigenschaften hinzuzufügen. Sie müssen dafür keine stdClass verwenden, obwohl Sie dies können. Sie können wirklich jede Klasse verwenden. Erstellen Sie einfach eine Objektinstanz einer beliebigen Klasse und legen Sie die Eigenschaften fest. Ich mag es, meine eigene Klasse zu erstellen, deren Name einfach o ist, mit einigen grundlegenden erweiterten Funktionen, die ich in diesen Fällen gerne verwende, und die sich gut für die Erweiterung von anderen Klassen eignen. Im Grunde ist es meine eigene Basisobjektklasse. Ich möchte auch eine Funktion namens o () haben. Wie so:

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

function o() {
  return new o;
}

Wenn Sie keinen eigenen Basisobjekttyp haben möchten, können Sie einfach o () eine neue stdClass zurückgeben lassen. Ein Vorteil ist, dass o leichter zu merken ist als stdClass und kürzer ist, unabhängig davon, ob Sie es als Klassennamen, Funktionsnamen oder beides verwenden. Selbst wenn Sie keinen Code in Ihrer o-Klasse haben, ist es immer noch einfacher, sich diesen zu merken als die umständlich großgeschriebene und benannte stdClass (die möglicherweise die Idee einer "sexuell übertragbaren Krankheitsklasse" hervorruft). Wenn Sie die Klasse o anpassen, finden Sie möglicherweise eine Verwendung für die Funktion o () anstelle der Konstruktorsyntax. Es ist eine normale Funktion, die einen Wert zurückgibt, der weniger begrenzt ist als ein Konstruktor. Beispielsweise kann ein Funktionsname als Zeichenfolge an eine Funktion übergeben werden, die einen aufrufbaren Parameter akzeptiert. Eine Funktion unterstützt auch die Verkettung. Sie können also Folgendes tun:

Dies ist ein guter Anfang für eine Basis- "Sprache", auf der andere Sprachebenen aufbauen können, wobei die oberste Ebene in vollständig internen DSLs geschrieben wird. Dies ähnelt dem Lisp-Stil der Entwicklung, und PHP unterstützt ihn viel besser, als die meisten Leute glauben. Mir ist klar, dass dies ein bisschen tangential für die Frage ist, aber die Frage berührt, was meiner Meinung nach die Basis für die vollständige Nutzung der Leistung von PHP ist.

Wenn Sie ein Objekt (wie in Javascript) mit dynamischen Eigenschaften erstellen möchten, ohne eine Warnung vor undefinierten Eigenschaften zu erhalten.

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

Sie können dies auch versuchen.

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

Ausgabe:

object(stdClass)#1 (0) { }

Verwenden Sie ein generisches Objekt und ordnen Sie ihm Schlüsselwertpaare zu.

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

Oder wandeln Sie ein Array in ein Objekt

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

Wenn Sie dies nicht tun möchten:

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

Sie können eine der folgenden Optionen verwenden:

PHP> = 5,4

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

PHP <5,4

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

Hier ein Beispiel mit der Iteration:

<?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; ?>

Sie haben diese schlechte, aber nützliche Technik:

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

stdClass ist das Standard-PHP-Objekt. stdClass hat keine Eigenschaften, Methoden oder Eltern. Es unterstützt keine magischen Methoden und implementiert keine Schnittstellen.

Wenn Sie einen Skalar oder ein Array als Objekt umwandeln, erhalten Sie eine Instanz von stdClass. Sie können stdClass verwenden, wenn Sie eine generische Objektinstanz benötigen.

<?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 ist KEINE Basisklasse! PHP-Klassen erben nicht automatisch von einer Klasse. Alle Klassen sind eigenständig, es sei denn, sie erweitern explizit eine andere Klasse. PHP unterscheidet sich in dieser Hinsicht von vielen objektorientierten Sprachen.

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

Sie können in Ihrem Code keine Klasse mit dem Namen 'stdClass' definieren. Dieser Name wird bereits vom System verwendet. Sie können eine Klasse mit dem Namen 'Objekt' definieren.

Sie könnten eine Klasse definieren, die stdClass erweitert, aber Sie würden keinen Vorteil erhalten, da stdClass nichts tut.

(getestet auf PHP 5.2.8)