Si prega di definire ciò che stdClassè.

stdClassè la classe vuota generica di PHP, un po 'come Objectin Java o objectin Python ( Modifica: ma in realtà non viene utilizzata come classe base universale; grazie @Ciaran per averlo sottolineato ).

È utile per oggetti anonimi, proprietà dinamiche, ecc.

Un modo semplice di considerare la StdClass è un'alternativa alla matrice associativa. Vedi questo esempio di seguito che mostra come json_decode()consente di ottenere un'istanza StdClass o un array associativo. Inoltre, ma non mostrato in questo esempio, SoapClient::__soapCallrestituisce un'istanza StdClass.

<?php
//Example with StdClass
$json = '{ "foo": "bar", "number": 42 }';
$stdInstance = json_decode($json);
echo $stdInstance->foo . PHP_EOL; //"bar"
echo $stdInstance->number . PHP_EOL; //42
//Example with associative array
$array = json_decode($json, true);
echo $array['foo'] . PHP_EOL; //"bar"
echo $array['number'] . PHP_EOL; //42

Vedi Proprietà dinamiche in PHP e StdClass per altri esempi.

stdClassè solo una classe "vuota" generica che viene utilizzata durante il cast di altri tipi su oggetti. Nonostante ciò che dicono le altre due risposte, nonstdClass è la classe base per gli oggetti in PHP. Questo può essere dimostrato abbastanza facilmente:

class Foo{}
$foo = new Foo();
echo ($foo instanceof stdClass)?'Y':'N';
// outputs 'N'

Non credo ci sia un concetto di oggetto base in PHP

stdClass è un'altra fantastica funzionalità di PHP. Puoi creare una classe PHP anonima. Facciamo un esempio.

$page=new stdClass();
$page->name='Home';
$page->status=1;

ora pensi di avere un'altra classe che verrà inizializzata con un oggetto pagina ed eseguirà la base su di esso.

<?php
class PageShow {

    public $currentpage;

    public function __construct($pageobj)
    {
        $this->currentpage = $pageobj;
    }

    public function show()
    {
        echo $this->currentpage->name;
        $state = ($this->currentpage->status == 1) ? 'Active' : 'Inactive';
        echo 'This is ' . $state . ' page';
    }
}

Ora devi creare un nuovo oggetto PageShow con un oggetto pagina.

Qui non è necessario scrivere un nuovo modello di classe per questo, puoi semplicemente usare stdClass per creare una classe al volo.

    $pageview=new PageShow($page);
    $pageview->show();

Vale anche la pena notare che un stdClassoggetto può essere creato anche dall'uso di json_decode().

Usando stdClass puoi creare un nuovo oggetto con le sue proprietà. Considera il seguente esempio che rappresenta i dettagli di un utente come un array associativo.

$array_user = array();
$array_user["name"] = "smith john";
$array_user["username"] = "smith";
$array_user["id"] = "1002";
$array_user["email"] = "smith@nomail.com";

Se devi rappresentare gli stessi dettagli delle proprietà di un oggetto, puoi usare stdClass come di seguito.

$obj_user = new stdClass;
$obj_user->name = "smith john";
$obj_user->username = "smith";
$obj_user->id = "1002";
$obj_user->email = "smith@nomail.com";

Se sei uno sviluppatore di Joomla, consulta questo esempio nei documenti di Joomla per ulteriore comprensione.

Allo stesso modo,

$myNewObj->setNewVar = 'newVal'; 

produce un oggetto stdClass - cast automatico

L'ho scoperto oggi scrivendo erroneamente:

$GLOBASLS['myObj']->myPropertyObj->myProperty = 'myVal';

Freddo!

stdClass non è una classe anonima o un oggetto anonimo

Le risposte qui includono espressioni che stdClasssono una classe anonima o addirittura un oggetto anonimo. Non è vero.

stdClassè solo una normale classe predefinita. Puoi verificarlo usando l' instanceofoperatore o la funzione get_class. Niente di speciale va qui. PHP usa questa classe per trasmettere altri valori all'oggetto.

In molti casi in cui stdClassviene utilizzato dai programmatori l'array è l'opzione migliore, a causa delle funzioni utili e del fatto che questa base utente rappresenta la struttura dei dati non un oggetto reale.

Vale anche la pena notare che utilizzando Casting in realtà non è necessario creare un oggetto come nella risposta data da @Bandula. Invece puoi semplicemente trasmettere il tuo array a un oggetto e la stdClass viene restituita. Per esempio:

$array = array(
    'Property1'=>'hello',
    'Property2'=>'world',
    'Property3'=>'again',
);

$obj = (object) $array;
echo $obj->Property3;

Output: again

In realtà ho provato a creare stdClass vuota e ho confrontato la velocità con la classe vuota.

class emp{}

poi ha continuato a creare 1000 stdClass ed emps ... classi vuote sono state fatte in circa 1100 microsecondi mentre stdClasses ha impiegato oltre 1700 microsecondi. Quindi immagino sia meglio creare la propria classe fittizia per l'archiviazione dei dati se si desidera utilizzare gli oggetti in modo così grave (gli array sono molto più veloci sia per la scrittura che per la lettura).

oggetti stdClass in uso

StdClass ti consente di creare classi anonime e con il cast di oggetti puoi anche accedere alle chiavi di un array associativo in stile OOP. Proprio come accederesti alla normale proprietà dell'oggetto.

Esempio

class Example {

  private $options;

  public function __construct(Array $setup)
  {
    // casting Array to stdClass object
    $this->options = (object) $setup;

    // access stdClass object in oop style - here transform data in OOP style using some custom method or something...
    echo $this->options->{'name'}; // ->{'key'}
    echo $this->options->surname;  // ->key
  }

}

$ob1 = new Example(["name" => "John", "surname" => "Doe"]);

farà eco

John Doe

Se si desidera creare rapidamente un nuovo oggetto per contenere alcuni dati su un libro. Faresti qualcosa del genere:

$book = new stdClass;
$book->title = "Harry Potter and the Prisoner of Azkaban";
$book->author = "J. K. Rowling";
$book->publisher = "Arthur A. Levine Books";
$book->amazon_link = "http://www.amazon.com/dp/0439136369/";

Si prega di controllare il sito - http://www.webmaster-source.com/2009/08/20/php-stdclass-storing-data-object-instead-array/ per maggiori dettagli.

Tieni presente che 2 bicchieri std vuoti non sono strettamente uguali. Questo è molto importante quando si scrivono aspettative beffardo.

php > $a = new stdClass();
php > $b = new stdClass();
php > var_dump($a === $b);
bool(false)
php > var_dump($a == $b);
bool(true)
php > var_dump($a);
object(stdClass)#1 (0) {
}
php > var_dump($b);
object(stdClass)#2 (0) {
}
php >

Il manuale di php.net ha alcune solide spiegazioni ed esempi forniti dagli utenti di cosa sia stdClass, mi piace particolarmente questo http://php.net/manual/en/language.oop5.basic.php#92123 , https: // stackoverflow.com/a/1434375/2352773 .

stdClass è l'oggetto PHP predefinito. stdClass non ha proprietà, metodi o parent. Non supporta metodi magici e non implementa interfacce.

Quando si esegue il cast di uno scalare o un array come Object, si ottiene un'istanza di stdClass. È possibile utilizzare stdClass ogni volta che è necessaria un'istanza di oggetto generica.

stdClass NON è una classe base! Le classi PHP non ereditano automaticamente da nessuna classe. Tutte le classi sono autonome, a meno che non estendano esplicitamente un'altra classe. PHP differisce da molti linguaggi orientati agli oggetti in questo senso.

Potresti definire una classe che estende stdClass, ma non otterrai alcun vantaggio, poiché stdClass non fa nulla.

stdClass è un modo in cui il file php evitare di interrompere l'interpretazione dello script quando ci sono alcuni dati che devono essere inseriti in una classe, ma sfortunatamente questa classe non è stata definita

Esempio :

 return $statement->fetchAll(PDO::FETCH_CLASS  , 'Tasks');

Qui i dati verranno inseriti nelle "Attività" predefinite. Ma, se abbiamo fatto il codice come questo:

 return $statement->fetchAll(PDO::FETCH_CLASS );

poi il php inserirà i risultati stdClass .

semplicemente phpdice questo: guarda, abbiamo un buon BAMBINO [Oggetti] Qui ma senza i genitori. Quindi, li invieremo a una casa di cura per bambini piccolistdClass :)

Puoi anche usare objectper lanciare matrici su un oggetto a tua scelta:

Class Example
{
   public $name;
   public $age;
}

Ora per creare un oggetto di tipo Examplee inizializzarlo puoi fare uno di questi:

$example = new Example();
$example->name = "some name";
$example->age = 22;

O

$example = new Example();
$example = (object) ['name' => "some name", 'age' => 22];

Il secondo metodo è utile soprattutto per inizializzare oggetti con molte proprietà.

stClass è una classe vuota creata da php stesso e dovrebbe essere utilizzata solo da php, poiché non è solo una classe "vuota", php usa stdClass per convertire le matrici in stile oggetto se è necessario utilizzare stdClass, consiglio due opzioni migliori : 1- usa le matrici (molto più velocemente delle classi) 2- crea la tua classe vuota e usala

//example 1
$data=array('k1'=>'v1' , 'k2'=>'v2',....);

//example 2
//creating an empty class is faster than instances an stdClass
class data={}
$data=new data();
$data->k1='v1';
$data->k2='v2';

cosa induce qualcuno a pensare di usare lo stile dell'oggetto invece dello stile dell'array ???

Il motivo per cui abbiamo stdClass è perché in PHP non c'è modo di distinguere un array normale da un array associato (come in Javascript hai {}per oggetto e []per array per distinguerli).

Quindi questo crea un problema per gli oggetti vuoti. Prendi questo per esempio.

PHP:

$a = [1, 2, 3]; // this is an array
$b = ['one' => 1, 'two' => 2]; // this is an associate array (aka hash)
$c = ['a' => $a, 'b' => $b]; // this is also an associate array (aka hash)

Supponiamo che tu voglia codificare JSON nella variabile $ c

echo json_encode($c);
// outputs => {'a': [1,2,3], 'b': {one: 1, two: 2}}

Ora supponiamo che tu abbia eliminato tutte le chiavi dal $brenderlo vuoto. Dato che $bora è vuoto (hai eliminato tutte le chiavi ricordi?), Sembra []che possa essere un array o un oggetto se lo guardi.

Quindi, se si esegue nuovamente un codice json, l'output sarà diverso

echo json_encode($c);
// outputs => {'a': [1,2,3], 'b': []}

Questo è un problema perché sappiamo bche doveva essere un array associato ma PHP (o qualsiasi funzione come json_encode) no.

Quindi stdClass viene in soccorso. Riprendendo lo stesso esempio

$a = [1, 2, 3]; // this is an array
$b = (object) ['one' => 1, 'two' => 2]; // this makes it an stdClass
$c = ['a' => $a, 'b' => $b]; // this is also an associate array (aka hash)

Quindi ora anche se elimini tutte le chiavi da $be lo rendi vuoto, poiché è una stdClass non importa e quando json_encode lo otterrai:

echo json_encode($c);
// outputs => {'a': [1,2,3], 'b': {}}

Questo è anche il motivo per cui json_encodee json_decodedi default restituisce stdClass.

 $c = json_decode('{"a": [1,2,3], "b": {}}', true); //true to deocde as array
 // $c is now ['a' => [1,2,3], 'b' => []] in PHP
 // if you json_encode($c) again your data is now corrupted