Comment définir un objet vide dans PHP
avec un nouveau tableau je fais ceci:
$aVal = array();
$aVal[key1][var1] = "something";
$aVal[key1][var2] = "something else";
Existe-t-il une syntaxe similaire pour un objet
(object)$oVal = "";
$oVal->key1->var1 = "something";
$oVal->key1->var2 = "something else";
$x = new stdClass();
A commentaire dans le manuel résume bien:
stdClass est l'objet PHP par défaut. stdClass n'a pas de propriétés, méthodes ou parent. Il ne supporte pas les méthodes magiques et n'implémente aucune interface.
Lorsque vous convertissez un scalaire ou un tableau en objet, vous obtenez une instance de stdClass. Vous pouvez utiliser stdClass chaque fois que vous avez besoin d'une instance d'objet générique.
La méthode standard pour créer un objet "vide" est la suivante:
$oVal = new stdClass();
Mais, avec PHP> = 5.4, je préfère personnellement :
$oVal = (object)[];
C'est plus court et personnellement, je le considère plus clair parce que stdClass pourrait être trompeur pour les programmeurs débutants (c'est-à-dire "Hey, je veux un objet, pas une classe!" ...).
La même chose avec PHP <5.4 est:
$oVal = (object) array();
(object)[] est équivalent à new stdClass().
Voir le manuel PHP ( ici ):
stdClass : créé par conversion de texte en objet.
et ( ici ):
Si un objet est converti en objet, il n'est pas modifié. Si une valeur d'un autre type est convertie en objet, , une nouvelle instance de la classe intégrée stdClass est créée .
Cependant, rappelez-vous que vide ($ oVal) renvoie false , comme @PaulP l’a dit:
Les objets sans propriétés ne sont plus considérés comme vides.
En ce qui concerne votre exemple, si vous écrivez:
$oVal = new stdClass();
$oVal->key1->var1 = "something"; // PHP creates a Warning here
$oVal->key1->var2 = "something else";
PHP crée l'avertissement suivant, créant implicitement la propriété key1 (un objet lui-même)
Avertissement: Création d'un objet par défaut à partir d'une valeur vide
Cela pourrait poser problème si votre configuration (voir niveau de signalisation d'erreur ) affiche cet avertissement au navigateur. Ceci est un autre sujet entier, mais une approche rapide et sale pourrait utiliser le opérateur de contrôle d'erreur (@) pour ignorer l'avertissement:
$oVal = new stdClass();
@$oVal->key1->var1 = "something"; // the warning is ignored thanks to @
$oVal->key1->var2 = "something else";
Je tiens à souligner que, dans PHP, l'objet vide n'a pas de sens:
$obj = new stdClass();
var_dump(empty($obj)); // bool(false)
mais bien sûr, $ obj sera vide.
D'autre part, tableau vide signifie vide dans les deux cas
$arr = array();
var_dump(empty($arr));
Citation de la fonction changelog vide
Les objets sans propriétés ne sont plus considérés comme vides.
php.net a déclaré qu'il est préférable de:
$new_empty_object = new stdClass();
J'aime combien il est facile de créer des objets de type anonyme en JavaScript:
//JavaScript
var myObj = {
foo: "Foo value",
bar: "Bar value"
};
console.log(myObj.foo); //Output: Foo value
Donc, j'essaie toujours d'écrire ce genre d'objets dans PHP comme le fait 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
Mais comme il s’agit d’un tableau, vous ne pouvez pas assigner des fonctions anonymes à une propriété comme le fait 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)"
Eh bien, vous pouvez le faire, mais l’OMI n’est pas pratique/propre:
$barFunc = $myObj->bar;
echo $barFunc("Hello"); //Output: Hello bar
En outre, en utilisant ce synthax, vous pouvez trouver quelques surprises amusantes , mais cela fonctionne très bien dans la plupart des cas.
En plus de la réponse de zombat si vous continuez à oublier stdClass
function object(){
return new stdClass();
}
Maintenant vous pouvez faire:
$str='';
$array=array();
$object=object();
Vous pouvez utiliser new stdClass() (ce qui est recommandé):
$obj_a = new stdClass();
$obj_a->name = "John";
print_r($obj_a);
// outputs:
// stdClass Object ( [name] => John )
Vous pouvez également convertir un tableau vide en un objet produisant une nouvelle instance vide de la classe intégrée stdClass:
$obj_b = (object) [];
$obj_b->name = "John";
print_r($obj_b);
// outputs:
// stdClass Object ( [name] => John )
Vous pouvez également convertir la valeur null en un objet produisant une nouvelle instance vide de la classe intégrée stdClass:
$obj_c = (object) null;
$obj_c->name = "John";
print($obj_c);
// outputs:
// stdClass Object ( [name] => John )
pour accéder aux données dans une classe std de la même manière que vous utilisez un tableau associatif, utilisez simplement la syntaxe {$ 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};
Vous pouvez essayer de cette façon aussi.
<?php
$obj = json_decode("{}");
var_dump($obj);
?>
Sortie:
object(stdClass)#1 (0) { }
Comme d'autres l'ont fait remarquer, vous pouvez utiliser stdClass. Cependant, je pense que c'est plus propre sans le (), comme ceci:
$obj = new stdClass;
Cependant, si on se base sur la question, il semble que vous souhaitiez réellement pouvoir ajouter des propriétés à un objet à la volée. Vous n'avez pas besoin d'utiliser stdClass pour cela, bien que vous puissiez le faire. Vraiment, vous pouvez utiliser n'importe quelle classe. Créez simplement une instance d'objet de n'importe quelle classe et commencez à définir les propriétés. J'aime créer ma propre classe dont le nom est simplement o, avec quelques fonctionnalités étendues de base que j'aime utiliser dans ces cas et agréable à utiliser pour étendre d'autres classes. Fondamentalement, c'est ma propre classe d'objet de base. J'aime aussi avoir une fonction simplement nommée o (). Ainsi:
class o {
// some custom shared magic, constructor, properties, or methods here
}
function o() {
return new o;
}
Si vous n'aimez pas avoir votre propre type d'objet de base, vous pouvez simplement faire en sorte que o() renvoie une nouvelle classe stdClass. Un avantage est que o est plus facile à retenir que stdClass et est plus court, que vous l'utilisiez comme nom de classe, nom de fonction ou les deux. Même si vous n'avez aucun code dans votre classe o, il est toujours plus facile à mémoriser que la classe mal capitalisée et nommée stdClass (qui peut invoquer l'idée d'une "classe de maladies sexuellement transmissibles"). Si vous personnalisez la classe o, vous pouvez trouver une utilisation de la fonction o() à la place de la syntaxe du constructeur. C'est une fonction normale qui renvoie une valeur moins limitée qu'un constructeur. Par exemple, un nom de fonction peut être transmis sous forme de chaîne à une fonction qui accepte un paramètre appelable. Une fonction prend également en charge le chaînage. Ainsi, vous pouvez faire quelque chose comme: $ result = o ($ internal_value) -> some_operation_or_conversion_on_this_value ();
C'est un bon début pour un "langage" de base sur lequel construire d'autres couches de langage, la couche supérieure étant écrite dans des DSL internes complets. Ceci est similaire au style de développement LISP, et PHP le supporte bien mieux que la plupart des gens ne le réalisent. Je me rends compte que c’est un peu une tangente pour la question, mais la question touche ce que je pense est la base pour utiliser pleinement la puissance de PHP.
Si vous souhaitez créer un objet (comme en javascript) avec des propriétés dynamiques, sans recevoir d'avertissement de propriété non définie.
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
Utilisez un objet générique et mappez-y les paires clé-valeur.
$oVal = new stdClass();
$oVal->key = $value
Ou jette un tableau dans un objet
$aVal = array( 'key'=>'value' );
$oVal = (object) $aVal;
Si vous ne voulez pas faire ceci:
$myObj = new stdClass();
$myObj->key_1 = 'Hello';
$myObj->key_2 = 'Dolly';
Vous pouvez utiliser l'un des éléments suivants:
PHP> = 5.4
$myObj = (object) [
'key_1' => 'Hello',
'key_3' => 'Dolly',
];
PHP <5.4
$myObj = (object) array(
'key_1' => 'Hello',
'key_3' => 'Dolly',
);
Voici un exemple avec l'itération:
<?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; ?>
Vous avez cette technique mauvaise mais utile:
$var = json_decode(json_encode([]), FALSE);