Come definire un oggetto vuoto in PHP

con un nuovo array faccio questo:

$aVal = array();

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

Esiste una sintassi simile per un oggetto

(object)$oVal = "";

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

$x = new stdClass();

Un commento nel manuale riassume al meglio:

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.

Il modo standard per creare un oggetto "vuoto" è:

$oVal = new stdClass();

Ma, con PHP> = 5.4, personalmente preferisco usare:

$oVal = (object)[];

È più breve e personalmente lo considero più chiaro perché stdClass potrebbe essere fuorviante per i programmatori alle prime armi (cioè "Ehi, voglio un oggetto, non una classe!" ...).

Lo stesso con PHP <5.4 è:

$oVal = (object) array();

(object)[]è equivalente a new stdClass().

Vedi il manuale di PHP ( qui ):

stdClass : creato digitando sull'oggetto.

e ( qui ):

Se un oggetto viene convertito in un oggetto, non viene modificato. Se un valore di qualsiasi altro tipo viene convertito in un oggetto, viene creata una nuova istanza della classe integrata stdClass .

Tuttavia, ricorda che vuoto ($ oVal) restituisce falso , come diceva @PaulP:

Gli oggetti senza proprietà non sono più considerati vuoti.

Per quanto riguarda il tuo esempio, se scrivi:

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

PHP crea il seguente avviso, creando implicitamente la proprietà key1(un oggetto stesso)

Avvertenza: creazione di un oggetto predefinito da un valore vuoto

Questo potrebbe essere un problema se la tua configurazione (vedi livello di segnalazione errori ) mostra questo avviso al browser. Questo è un altro intero argomento, ma un approccio rapido e sporco potrebbe essere l'utilizzo dell'operatore di controllo degli errori (@) per ignorare l'avviso:

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

Voglio sottolineare che in PHP non esiste qualcosa come l'oggetto vuoto in senso:

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

ma ovviamente $ obj sarà vuoto.

D'altra parte array vuoto significa vuoto in entrambi i casi

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

Citazione dalla funzione log delle modifiche vuota

Gli oggetti senza proprietà non sono più considerati vuoti.

php.net ha detto che è meglio:

$new_empty_object = new stdClass();

Adoro quanto sia facile creare oggetti di tipo anonimo in JavaScript:

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

Quindi cerco sempre di scrivere questo tipo di oggetti in PHP come fa 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

Ma poiché questo è fondamentalmente un array, non puoi fare cose come assegnare funzioni anonime a una proprietà come fa 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)"

Bene, puoi farlo, ma IMO non è pratico / pulito:

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

Inoltre, usando questa sintassi puoi trovare alcune sorprese divertenti , ma funziona bene nella maggior parte dei casi.

Oltre alla risposta di zombat se continui a dimenticare stdClass

   function object(){

        return new stdClass();

    }

Ora puoi fare:

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

Puoi usare new stdClass()(che è raccomandato):

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

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

Oppure puoi convertire un array vuoto in un oggetto che produce una nuova istanza vuota della classe integrata stdClass:

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

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

Oppure puoi convertire il nullvalore in un oggetto che produce una nuova istanza vuota della classe integrata stdClass:

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

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

per accedere ai dati in una stdClass in modo simile a un array asociativo basta usare la sintassi {$ 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};

Come altri hanno sottolineato, è possibile utilizzare stdClass. Comunque penso che sia più pulito senza il (), in questo modo:

$obj = new stdClass;

Tuttavia, in base alla domanda, sembra che quello che vuoi davvero sia poter aggiungere proprietà a un oggetto al volo. Non è necessario utilizzare stdClass per questo, anche se è possibile. Davvero puoi usare qualsiasi classe. Basta creare un'istanza di oggetto di qualsiasi classe e iniziare a impostare le proprietà. Mi piace creare la mia classe il cui nome è semplicemente o con alcune funzionalità estese di base che mi piace usare in questi casi ed è bello estenderlo da altre classi. Fondamentalmente è la mia classe di oggetti base. Mi piace anche avere una funzione chiamata semplicemente o (). Così:

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

function o() {
  return new o;
}

Se non ti piace avere il tuo tipo di oggetto base, puoi semplicemente avere o () restituire una nuova stdClass. Uno dei vantaggi è che o è più facile da ricordare rispetto a stdClass ed è più breve, indipendentemente dal fatto che lo si usi come nome di classe, nome di funzione o entrambi. Anche se non hai alcun codice all'interno della tua classe o, è ancora più facile da memorizzare rispetto allo stdClass goffamente capitalizzato e chiamato (che può invocare l'idea di una "classe di malattie a trasmissione sessuale"). Se personalizzi la classe o, potresti trovare un uso per la funzione o () invece della sintassi del costruttore. È una funzione normale che restituisce un valore, che è meno limitato di un costruttore. Ad esempio, un nome di funzione può essere passato come stringa a una funzione che accetta un parametro richiamabile. Una funzione supporta anche il concatenamento. Quindi puoi fare qualcosa del tipo:

Questo è un ottimo inizio per un "linguaggio" di base su cui costruire altri livelli linguistici con il livello superiore scritto in DSL interni completi. Questo è simile allo stile di sviluppo fluido e PHP lo supporta molto meglio di quanto la maggior parte delle persone realizzi. Mi rendo conto che questo è un po 'tangente per la domanda, ma la domanda tocca ciò che penso sia la base per sfruttare appieno il potere di PHP.

Se si desidera creare un oggetto (come in JavaScript) con proprietà dinamiche, senza ricevere un avviso di proprietà non definita.

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

Puoi provare anche in questo modo.

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

Produzione:

object(stdClass)#1 (0) { }

Utilizzare un oggetto generico e mappare coppie di valori chiave su di esso.

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

O lanciare un array in un oggetto

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

Se non vuoi farlo:

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

Puoi usare uno dei seguenti:

PHP> = 5.4

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

PHP <5.4

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

Ecco un esempio con l'iterazione:

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

Hai questa tecnica cattiva ma utile:

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

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.

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

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

Non è possibile definire una classe denominata "stdClass" nel codice. Quel nome è già utilizzato dal sistema. È possibile definire una classe denominata "Oggetto".

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

(testato su PHP 5.2.8)