Können Sie Instanzeneigenschaften dynamisch in PHP erstellen?

Gibt es eine Möglichkeit zu schaffen, alle Instanz-Eigenschaften dynamisch? Zum Beispiel, ich möchte in der Lage sein zu generieren, werden alle Attribute im Konstruktor und noch in der Lage sein, um Ihnen den Zugang nach der Klasse instanziiert wird, wie diese: $object->property. Beachten Sie, dass ich für den Zugriff auf die Eigenschaften separat, und nicht mit einem array; hier ein Beispiel von dem, was ich nicht wollen:

class Thing {
    public $properties;
    function __construct(array $props=array()) {
        $this->properties = $props;
    }
}
$foo = new Thing(array('bar' => 'baz');
# I don't want to have to do this:
$foo->properties['bar'];
# I want to do this:
//$foo->bar;

Um genauer zu sein, wenn ich den Umgang mit Klassen, die eine große Anzahl von Eigenschaften, ich würde gerne in der Lage, wählen Sie alle Spalten in einer Datenbank (das sind die "Eigenschaften") und erstellen Sie eine Instanz Eigenschaften von Ihnen. Jeder Spaltenwert gespeichert werden soll, in einer separaten Instanz-Eigenschaft.

Kommentar zu dem Problem

Das array und die __set und __get-Methoden sollten ausreichend sein, für normale Zwecke. Haben Sie Besondere Anliegen-stick "one property=eine variable" Lösung? BTW, das Prinzip der Kapselung bestimmt kein anderes Objekt sollte wissen, wenn die variable ist ein echtes oder ein Wert in einem array? Nicht einmal Gegenstände durch die Erweiterung dieser Datenbank. Kommentarautor: Csaba Kétszeri

php.net/manual/en/language.oop5.overloading.php Kommentarautor: Keyne Viana

InformationsquelleAutor der Frage Brayn | 2009-05-06

60

Art. Es sind Magische Methoden, mit denen Sie Haken Sie Ihren eigenen code für die Umsetzung Klasse Verhalten zur Laufzeit:
```
class foo {
  public function __get($name) {
    return('dynamic!');
  }
  public function __set($name, $value) {
    $this->internalData[$name] = $value;
  }
}
```
Dies ist ein Beispiel für die dynamische getter-und setter-Methoden, es ermöglicht die Ausführung von Verhalten, wenn eine Objekt-Eigenschaft zugegriffen wird. Zum Beispiel
```
print(new foo()->someProperty);
```
drucken würde, in diesem Fall "dynamischer!" und Sie können auch einen Wert zuweisen, um eine beliebig benannte Eigenschaft, in dem Fall die __set () - Methode wird automatisch aufgerufen. Die __call($name, $params) - Methode macht das gleiche für die Objekt-Methode aufruft. Sehr nützlich in besonderen Fällen. Aber die meisten der Zeit, erhalten Sie, indem Sie mit:
```
class foo {
  public function __construct() {
    foreach(getSomeDataArray() as $k => $value)
      $this->{$k} = $value;
  }
}
```
...weil meistens alles, was Sie brauchen, ist, um dump-den Inhalt eines Arrays in entsprechend benannte Klasse Felder einmal, oder zumindest sehr explizite Punkte in der Ausführung Weg. Also, wenn Sie wirklich brauchen, das dynamische Verhalten, verwenden das Letzte Beispiel, füllen Sie Ihre Objekte mit Daten.

Dies nennt man überladen
http://php.net/manual/en/language.oop5.overloading.php

InformationsquelleAutor der Antwort Udo
23

Es hängt davon ab, was genau Sie wollen. Können Sie ändern die Klasse dynamisch? Nicht wirklich. Aber können Sie erstellen Objekt Eigenschaften dynamisch, wie in einer konkreten Instanz der Klasse? Ja.
```
class Test
{
    public function __construct($x)
    {
        $this->{$x} = "dynamic";
    }
}

$a = new Test("bar");
print $a->bar;
```
Ausgänge:

dynamische

So eine Objekt-Eigenschaft mit dem Namen "bar" geschaffen wurde, dynamisch in den Konstruktor.

InformationsquelleAutor der Antwort Chad Birch

Ja, Sie können.

class test
{
    public function __construct()
    {
        $arr = array
        (
            'column1',
            'column2',
            'column3'
        );

        foreach ($arr as $key => $value)
        {
            $this->$value = '';
        }   
    }

    public function __set($key, $value)
    {
        $this->$key = $value;
    }

    public function __get($value)
    {
        return 'This is __get magic '.$value;
    }
}

$test = new test;

//Results from our constructor test.
var_dump($test);

//Using __set
$test->new = 'variable';
var_dump($test);

//Using __get
print $test->hello;

Ausgabe

object(test)#1 (3) {
  ["column1"]=>
  string(0) ""
  ["column2"]=>
  string(0) ""
  ["column3"]=>
  string(0) ""
}
object(test)#1 (4) {
  ["column1"]=>
  string(0) ""
  ["column2"]=>
  string(0) ""
  ["column3"]=>
  string(0) ""
  ["new"]=>
  string(8) "variable"
}
This is __get magic hello

Dieser code wird gesetzt dynamischen Eigenschaften im Konstruktor, die dann zugegriffen werden, mit $this->Spalte. Es ist auch eine gute übung zur Verwendung der __get und __set magic-Methoden im Umgang mit Eigenschaften, die nicht definiert sind, die innerhalb der Klasse. Mehr Informationen finden Sie hier.

http://www.tuxradar.com/practicalphp/6/14/2

http://www.tuxradar.com/practicalphp/6/14/3

InformationsquelleAutor der Antwort The Pixel Developer

Können Sie über eine Instanz-variable zu handeln als ein Platzhalter für beliebige Werte, und verwenden Sie dann die __get magic-Methode abrufen, die Sie als reguläre Eigenschaften:

class My_Class
{
    private $_properties = array();

    public function __construct(Array $hash)
    {
         $this->_properties = $hash;
    }

    public function __get($name)
    {
         if (array_key_exists($name, $this->_properties)) {
             return $this->_properties[$name];
         }
         return null;
    }
}

InformationsquelleAutor der Antwort Carlton Gibson

Warum ist alle so kompliziert?

<?php namespace example;

error_reporting(E_ALL | E_STRICT); 

class Foo
{
    //class completely empty
}

$testcase = new Foo();
$testcase->example = 'Dynamic property';
echo $testcase->example;

InformationsquelleAutor der Antwort srcspider

Hier ist einfache Funktion zum Auffüllen Objekt-member, ohne dass die Schüler der öffentlichkeit.
Es hinterlässt auch Konstruktor für Ihre eigenen Nutzung, die Schaffung neuer Instanz-Objekt ohne Konstruktor aufrufen! So, Ihr domain-Objekts hängt nicht von der Datenbank!

/**
 * Create new instance of a specified class and populate it with given data.
 *
 * @param string $className
 * @param array $data  e.g. array(columnName => value, ..)
 * @param array $mappings  Map column name to class field name, e.g. array(columnName => fieldName)
 * @return object  Populated instance of $className
 */
function createEntity($className, array $data, $mappings = array())
{
    $reflClass = new ReflectionClass($className);
    //Creates a new instance of a given class, without invoking the constructor.
    $entity = unserialize(sprintf('O:%d:"%s":0:{}', strlen($className), $className));
    foreach ($data as $column => $value)
    {
        //translate column name to an entity field name
        $field = isset($mappings[$column]) ? $mappings[$column] : $column;
        if ($reflClass->hasProperty($field))
        {
            $reflProp = $reflClass->getProperty($field);
            $reflProp->setAccessible(true);
            $reflProp->setValue($entity, $value);
        }
    }
    return $entity;
}

/******** And here is example ********/

/**
 * Your domain class without any database specific code!
 */
class Employee
{
    //Class members are not accessible for outside world
    protected $id;
    protected $name;
    protected $email;

    //Constructor will not be called by createEntity, it yours!
    public function  __construct($name, $email)
    {
        $this->name = $name;
        $this->emai = $email;
    }

    public function getId()
    {
        return $this->id;
    }

    public function getName()
    {
        return $this->name;
    }

    public function getEmail()
    {
        return $this->email;
    }
}


$row = array('employee_id' => '1', 'name' => 'John Galt', 'email' => '[email protected]');
$mappings = array('employee_id' => 'id'); //Employee has id field, so we add translation for it
$john = createEntity('Employee', $row, $mappings);

print $john->getName(); //John Galt
print $john->getEmail(); //[email protected]
//...

P. S. das Abrufen von Daten aus dem Objekt ähnlich ist, z.B. $reflProp->setValue($entity, $Wert);
P. P. S. Diese Funktion ist stark inspiriert von Doctrine2 ORM, die ist genial!

InformationsquelleAutor der Antwort Serg

class DataStore //Automatically extends stdClass
{
  public function __construct($Data) //$Data can be array or stdClass
  {
    foreach($Data AS $key => $value)  
    {
        $this->$key = $value;    
    }  
  }
}

$arr = array('year_start' => 1995, 'year_end' => 2003);
$ds = new DataStore($arr);

$gap = $ds->year_end - $ds->year_start;
echo "Year gap = " . $gap; //Outputs 8

InformationsquelleAutor der Antwort Anthony

1

Können Sie:
```
$variable = 'foo';
$this->$variable = 'bar';
```
Würde, setzen Sie das Attribut foo des Objekts, es heißt auf bar.

Können Sie auch Funktionen verwenden:
```
$this->{strtolower('FOO')} = 'bar';
```
Dies würde auch set foo (nicht FOO)bar.

InformationsquelleAutor der Antwort Koraktor

Erweitern stdClass.

class MyClass extends stdClass
{
    public function __construct()
    {
        $this->prop=1;
    }
}

Ich hoffe das ist das, was Sie brauchen.

InformationsquelleAutor der Antwort Anthony

0

Dies ist wirklich kompliziert zu handhaben für diese rasante Entwicklung. Ich mag Antworten und Magische Methoden, aber meiner Meinung nach es besser ist die Verwendung von code-Generatoren wie CodeSmith.

Habe ich gemacht-Vorlage, die an eine Datenbank anschließen, Lesen Sie alle Spalten und deren Datentypen und erzeugen ganze Klasse entsprechend.

Diese Weise habe ich fehlerfrei (kein Tippfehler) lesbaren code. Und wenn dein Datenbank-Modell änderungen laufen generator wieder... es funktioniert für mich.

InformationsquelleAutor der Antwort zidane

Wenn Sie wirklich müssen es tun, der beste Weg ist, um eine überlastung ein ArrayObject ist, die es erlaubt zu pflegen iteration Unterstützung (foreach), das wird noch eine Schleife durch alle Ihre Eigenschaften.

Ich beachten Sie, dass Sie sagte: "ohne ein array verwenden", und ich möchte Ihnen versichern, dass während technisch ein array verwendet wird, in den hintergrund, die Sie NIE HABEN, um ES ZU SEHEN. Haben Sie Zugriff auf alle Eigenschaften über ->properyname oder foreach ($class in $Namen => $Wert).

Hier ist ein Beispiel, an dem ich arbeitete gestern, Hinweis: dies ist auch STARK TYPISIERT. Also Eigenschaften, die markiert sind, "integer" wirft einen Fehler, wenn Sie versuchen, und geben Sie einen "string".

Können Sie entfernen, natürlich.

Gibt es auch eine AddProperty () - member-Funktion, obwohl es nicht in dem Beispiel demonstriert. Das wird Ihnen erlauben, um Eigenschaften hinzuzufügen später.

Beispiel für die Nutzung:

    $Action = new StronglyTypedDynamicObject("Action",
            new StrongProperty("Player", "ActionPlayer"),   //ActionPlayer
            new StrongProperty("pos", "integer"),
            new StrongProperty("type", "integer"),
            new StrongProperty("amount", "double"),
            new StrongProperty("toCall", "double"));

    $ActionPlayer = new StronglyTypedDynamicObject("ActionPlayer",
            new StrongProperty("Seat", "integer"),
            new StrongProperty("BankRoll", "double"),
            new StrongProperty("Name", "string"));

    $ActionPlayer->Seat = 1;
    $ActionPlayer->Name = "Doctor Phil";

    $Action->pos = 2;
    $Action->type = 1;
    $Action->amount = 7.0;
    $Action->Player = $ActionPlayer;

    $newAction = $Action->factory();
    $newAction->pos = 4;

    print_r($Action);
    print_r($newAction);


    class StrongProperty {
            var $value;
            var $type;
            function __construct($name, $type) {
                    $this->name = $name;
                    $this->type = $type;
            }

    }

    class StronglyTypedDynamicObject extends ModifiedStrictArrayObject {

            static $basic_types = array(
                    "boolean",
                    "integer",
                    "double",
                    "string",
                    "array",
                    "object",
                    "resource",
            );

            var $properties = array(
                    "__objectName" => "string"
            );

            function __construct($objectName /*, [ new StrongProperty("name", "string"), [ new StrongProperty("name", "string"), [ ... ]]] */) {
                    $this->__objectName = $objectName;
                    $args = func_get_args();
                    array_shift($args);
                    foreach ($args as $arg) {
                            if ($arg instanceof StrongProperty) {
                                    $this->AddProperty($arg->name, $arg->type);
                            } else {
                                    throw new Exception("Invalid Argument");
                            }
                    }
            }

            function factory() {
                    $new = clone $this;
                    foreach ($new as $key => $value) {
                            if ($key != "__objectName") {
                                    unset($new[$key]);
                            }
                    }

                    //$new->__objectName = $this->__objectName;
                    return $new;
            }

            function AddProperty($name, $type) {
                    $this->properties[$name] = $type;
                    return;

                    if (in_array($short_type, self::$basic_types)) {
                            $this->properties[$name] = $type;
                    } else {
                            throw new Exception("Invalid Type: $type");
                    }
            }

            public function __set($name, $value) {
                    self::sdprintf("%s(%s)\n", __FUNCTION__, $name);
                    $this->check($name, $value);
                    $this->offsetSet($name, $value);
            }

            public function __get($name) {
                    self::sdprintf("%s(%s)\n", __FUNCTION__, $name);
                    $this->check($name);
                    return $this->offsetGet($name);
            }

            protected function check($name, $value = "r4nd0m") {
                    if (!array_key_exists($name, $this->properties)) {
                            throw new Exception("Attempt to access non-existent property '$name'");
                    }

                    $value__objectName = "";
                    if ($value != "r4nd0m") {
                            if ($value instanceof StronglyTypedDynamicObject) {
                                    $value__objectName = $value->__objectName;
                            }
                            if (gettype($value) != $this->properties[$name] && $value__objectName != $this->properties[$name]) { 
                                    throw new Exception("Attempt to set {$name} ({$this->properties[$name]}) with type " . gettype($value) . ".$value__objectName");
                            }
                    }
            }
    }

    class ModifiedStrictArrayObject extends ArrayObject {
            static $debugLevel = 0;

            /* Some example properties */

            static public function StaticDebug($message) {
                    if (static::$debugLevel > 1) {
                            fprintf(STDERR, "%s\n", trim($message));
                    }
            }

            static public function sdprintf() {
                    $args = func_get_args();
                    $string = call_user_func_array("sprintf", $args);
                    self::StaticDebug("D            " . trim($string));
            }

            protected function check($name) {
                    if (!array_key_exists($name, $this->properties)) {
                            throw new Exception("Attempt to access non-existent property '$name'");
                    }
            }

            //static public function sget($name, $default = NULL) {
            /******/ public function get ($name, $default = NULL) {
                    self::sdprintf("%s(%s)\n", __FUNCTION__, $name);
                    $this->check($name);
                    if (array_key_exists($name, $this->storage)) {
                            return $this->storage[$name];
                    }
                    return $default;
            }

            public function offsetGet($name) { 
                    self::sdprintf("%s(%s)\n", __FUNCTION__, implode(",", func_get_args()));
                    $this->check($name);
                    return call_user_func_array(array(parent, __FUNCTION__), func_get_args());
            }
            public function offsetSet($name, $value) { 
                    self::sdprintf("%s(%s)\n", __FUNCTION__, implode(",", func_get_args()));
                    $this->check($name);
                    return call_user_func_array(array(parent, __FUNCTION__), func_get_args());
            }
            public function offsetExists($name) { 
                    self::sdprintf("%s(%s)\n", __FUNCTION__, implode(",", func_get_args()));
                    $this->check($name);
                    return call_user_func_array(array(parent, __FUNCTION__), func_get_args());
            }
            public function offsetUnset($name) { 
                    self::sdprintf("%s(%s)\n", __FUNCTION__, implode(",", func_get_args()));
                    $this->check($name);
                    return call_user_func_array(array(parent, __FUNCTION__), func_get_args());
            }

            public function __toString() {
                    self::sdprintf("%s(%s)\n", __FUNCTION__, $name);
                    foreach ($this as $key => $value) {
                            $output .= "$key: $value\n";
                    }
                    return $output;
            }

            function __construct($array = false, $flags = 0, $iterator_class = "ArrayIterator") { 
                    self::sdprintf("%s(%s)\n", __FUNCTION__, implode(",", func_get_args()));
                    parent::setFlags(parent::ARRAY_AS_PROPS);
            }
    }

InformationsquelleAutor der Antwort Orwellophile

Nach dem Lesen @Udo 's Antwort. Ich habe das folgende Muster, das nicht aufblasen eine Instanz der Klasse mit was auch immer Elemente, die in Ihrem Konstruktor die array-argument, aber immer noch lassen Sie weniger Tippen und einfach fügen Sie neue Eigenschaften der Klasse.

class DBModelConfig
{
    public $host;
    public $username;
    public $password;
    public $db;
    public $port = '3306';
    public $charset = 'utf8';
    public $collation = 'utf8_unicode_ci';

    public function __construct($config)
    {
        foreach ($config as $key => $value) {
            if (property_exists($this, $key)) {
                $this->{$key} = $value;
            }
        }
    }
}

Dann können Sie das übergeben von arrays wie:

[
    'host'      => 'localhost',
    'driver'    => 'mysql',
    'username'  => 'myuser',
    'password'  => '1234',
    'charset'   => 'utf8',
    'collation' => 'utf8_unicode_ci',
    'db'        => 'key not used in receiving class'
]

InformationsquelleAutor der Antwort

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.