Creazione di oggetti anonimi in php
https://stackoverflow.com/questions/6384431
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Come sappiamo, creare oggetti anonimi in JavaScript è facile, come il codice seguente:
var object = {
p : "value",
p1 : [ "john", "johnny" ] } ;
alert(object.p1[1]) ;
Risultato:
an alert is raised with value "johnny"
Questa stessa tecnica può essere applicata in caso di PHP?Possiamo creare oggetti anonimi in PHP?
Soluzione
Sono passati alcuni anni, ma penso di dover mantenere le informazioni aggiornate!
In PHP-7 è possibile creare classi anonime, quindi sei in grado di fare cose come questa:
<?php
class Foo {}
$child = new class extends Foo {};
var_dump($child instanceof Foo); // true
?>
Puoi leggere di più su questo in RFC (è accettato): https://wiki.php.net/rfc/anonymous_classes
Ma non so quanto sia simile è implementato a Javscript, quindi le loro possono essere alcune differenze tra le classi anonime in JavaScript e PHP.
Modifica:
A partire dai commenti pubblicati, ecco il link al manuale ora: http:// php.rete / manuale / en / lingua.oop5.anonymous.php
Altri suggerimenti
"Anonimo" non è la terminologia corretta quando si parla di oggetti. Sarebbe meglio dire "oggetto di tipo anonimo", ma questo non si applica a PHP.
Tutti gli oggetti in PHP hanno una classe. La classe "predefinita" è stdClass e puoi crearne oggetti in questo modo :
$obj = new stdClass;
$obj->aProperty = 'value';
Puoi anche usufruire di trasmettere un array a un oggetto per una sintassi più conveniente:
$obj = (object)array('aProperty' => 'value');
print_r($obj);
Tuttavia, tieni presente che è probabile che il casting di un array su un oggetto produca risultati "interessanti" per quelle chiavi di array che non sono nomi di variabili PHP validi, ad esempio ecco una mia risposta che mostra cosa succede quando le chiavi iniziano con cifre.
Sì, è possibile!Utilizzando questa semplice classe PHP Anonymous Object .Come funziona:
// define by passing in constructor
$anonim_obj = new AnObj(array(
"foo" => function() { echo "foo"; },
"bar" => function($bar) { echo $bar; }
));
$anonim_obj->foo(); // prints "foo"
$anonim_obj->bar("hello, world"); // prints "hello, world"
// define at runtime
$anonim_obj->zoo = function() { echo "zoo"; };
$anonim_obj->zoo(); // prints "zoo"
// mimic self
$anonim_obj->prop = "abc";
$anonim_obj->propMethod = function() use($anonim_obj) {
echo $anonim_obj->prop;
};
$anonim_obj->propMethod(); // prints "abc"
Ovviamente questo oggetto è un'istanza della classe AnObj, quindi non è realmente anonimo, ma rende possibile definire metodi al volo, come fa JavaScript.
Fino a poco tempo fa questo è il modo in cui creavo oggetti al volo.
$someObj = json_decode("{}");
Quindi:
$someObj->someProperty = someValue;
Ma ora vado con:
$someObj = (object)[];
Quindi come prima:
$someObj->someProperty = someValue;
Ovviamente se conosci già le proprietà e i valori puoi impostarli all'interno come è stato detto:
$someObj = (object)['prop1' => 'value1','prop2' => 'value2'];
NB: Non so su quali versioni di PHP funzioni, quindi dovresti tenerlo presente.Ma penso che il primo approccio (che è anche breve se non ci sono proprietà da impostare in costruzione) dovrebbe funzionare per tutte le versioni che hanno json_encode / json_decode
Se desideri imitare JavaScript, puoi creare una classe Object e quindi ottenere lo stesso comportamento.Ovviamente non è più anonimo, ma funzionerà.
<?php
class Object {
function __construct( ) {
$n = func_num_args( ) ;
for ( $i = 0 ; $i < $n ; $i += 2 ) {
$this->{func_get_arg($i)} = func_get_arg($i + 1) ;
}
}
}
$o = new Object(
'aProperty', 'value',
'anotherProperty', array('element 1', 'element 2')) ;
echo $o->anotherProperty[1];
?>
Questo produrrà elemento 2 .Questo è stato rubato da un commento su PHP: Classi e oggetti .
Converti array in oggetto:
$obj = (object) ['myProp' => 'myVal'];
Se vuoi creare un oggetto (come in javascript) con proprietà dinamiche, senza ricevere un avviso di proprietà non definita, quando non hai impostato un valore su proprietà
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
Questa stessa tecnica può essere applicata in caso di PHP?
No, poiché javascript utilizza prototipi / dichiarazioni dirette di oggetti - in PHP (e molti altri linguaggi OO) un oggetto può essere creato solo da una classe.
Quindi la domanda diventa: puoi creare una classe anonima.
Anche in questo caso la risposta è no: come istanzeresti la classe senza poterla fare riferimento?
Per chi desidera un oggetto ricorsivo:
$o = (object) array(
'foo' => (object) array(
'sub' => '...'
)
);
echo $o->foo->sub;
Dalla documentazione di PHP, alcuni altri esempi:
<?php
$obj1 = new \stdClass; // Instantiate stdClass object
$obj2 = new class{}; // Instantiate anonymous class
$obj3 = (object)[]; // Cast empty array to object
var_dump($obj1); // object(stdClass)#1 (0) {}
var_dump($obj2); // object(class@anonymous)#2 (0) {}
var_dump($obj3); // object(stdClass)#3 (0) {}
?>
$ obj1 e $ obj3 sono dello stesso tipo, ma $ obj1!== $ obj3.Inoltre, tutti e tre json_encode () in un semplice oggetto JS {}:
<?php
echo json_encode([
new \stdClass,
new class{},
(object)[],
]);
?>
Risultati:
[{},{},{}]
