$globals - Seite 4

21.01.2012, 16:01

Zitat:

Zitat von mermshaus

Es gibt nichts, was davon abhält, test einfach so beliebig oft zu instanziieren.

Doch, wenn die Instanz über die instance Klasse erfolgt.

http://mod.php.developer.vc/instance-2/

PHP-Code:

  <?php

 
require __dir__ . '/instance.class.php';

 
$new = new instance;

 
$a1 = $new->test;

 
# Klasse test nutzt __get() und __set()

$a1->var = 123;

echo '$a1->var = 123;', BR;

 
$a2 = $new->test;

echo '$a2 = $new->test;', BR;

echo $a2->var, BR;

 
highlight_file('./instance.class.php');

highlight_file('./test.class.php');

 
?>

btw: ich behaupte nicht, daß mein Beispiel "der Weisheit letzter Schuß" wäre. Den Kram habe ich deshalb getippert habe, weil mir andere Verfahren als zu umständlich erscheinen.

nikosch · 21.01.2012, 16:20

Zitat:

Doch, wenn die Instanz über die instance Klasse erfolgt.

Ja aber wenn nicht? Das ist doch der Witz am Singleton. Und deshalb gibt es eben private Konstruktoren. Weil das Pattern dann auch sicherstellen muss, dass es nur eine Instanz geben kann. Sonst kannste Dir den ganzen Schmu auch sparen und ST per Konvention benutzen.

Umständlich finde ich eher Deine Variante.

21.01.2012, 17:39

Zitat:

Zitat von nikosch

Ja aber wenn nicht?

Klar "wenn der Topf aber nun ein Loch hat..."
Es gibt hinreichend genug Möglichkeiten, semantische Fehler in die Scripte einzubauen.

Zitat:

Umständlich finde ich eher Deine Variante.

Geschmacksache.

Versteh mich nicht falsch: ich will mein Zeuch doch nicht verkaufen. Grundsätzlich isses für mich gut, weil es mir nutzt. Mein Ego steht und fällt nicht damit, ob es auch andere nutzen.

mermshaus · 21.01.2012, 17:41

Ja, die Klasse selbst müsste das Singleton sein, damit es was bringt.

Dein Ansatz unterscheidet sich nicht so sehr von einer „normalen“ Registry. Er ist gewissermaßen ein Vorbau (siehe RegistrySimple), um auf eine andere Art auf den Inhalt der Registry zugreifen zu können.

PHP-Code:

  <?php

 
final class Registry

{

    private static $instance = null;

 
    private $data = array();

 
    private function __construct() {}

 
    public function __clone()

    {

        throw new Exception('Clone is not allowed.');

    }

 
    public function __wakeup()

    {

        throw new Exception('Unserializing is not allowed.');

    }

 
    public static function getInstance()

    {

        if (self::$instance === null) {

            $className = __CLASS__;

            self::$instance = new $className;

        }

 
        return self::$instance;

    }

 
    public function set($key, $value)

    {

        $this->data[$key] = $value;

    }

 
    public function has($key)

    {

        return (isset($this->data[$key]));

    }

 
    public function get($key)

    {

        if (!is_string($key)) {

            throw new InvalidArgumentException('$key must be of type string.');

        }

 
        if (!$this->has($key)) {

            throw new Exception('Key "' . $key . '" is not set.');

        }

 
        return $this->data[$key];

    }

}

 
class RegistrySimple

{

    public function __get($className)

    {

        $r = Registry::getInstance();

 
        if (!$r->has($className)) {

            $r->set($className, new $className());

        }

 
        return $r->get($className);

    }

}

 
class Foo

{

    public $test = '';

}

 
$r  = new RegistrySimple();

$r2 = new RegistrySimple();

 
$foo = $r->Foo;

$foo->test = 'Hello World!';

unset($foo);

 
$foo = $r2->Foo;

var_dump($foo->test);

Den Autoloader würde ich übrigens davon trennen.

nikosch · 21.01.2012, 17:48

Zitat:

Es gibt hinreichend genug Möglichkeiten, semantische Fehler in die Scripte einzubauen.

Also ein privater Konstruktor verhindert wirkungsvoll Zweitinstanziierung. Von daher finde ich Deine Argumentation sehr seltsam.

Zitat:

Da gibts bessere Lösungen, als eine Klasseninstanz über den Lieferanteneingang abzuholen.

Das war Dein „Versprechen“, aber Dein Code hält das doch gar nicht ein.

Zitat:

Manche Scripte sehen so aus, als erwartet der Autor seinen privaten Alzheimer und kann sich später nicht mehr daran erinnern, für was das gut war.

21.01.2012, 18:02

<eod>

mermshaus · 22.01.2012, 12:05

Halb zum Thema:

Zitat:

Zitat von php.de

Also ich fände es schöner, wenn gewisse superglobale Arrays read-only wären.

Ich hatte vor ein paar Tagen beim Suchen diesen Thread gefunden: http://www.sitepoint.com/forums/show...ead-Only-Array

Den Code dort habe ich leicht verändert. Vielleicht interessiert es noch wen. Ich weiß gerade nicht, wohin damit.

(Das Anwendungsbeispiel ist als phpunit-Test geschrieben.)

PHP-Code:

  <?php

 
/**

 *

 * @see http://www.sitepoint.com/forums/showthread.php?708740-Read-Only-Array

 */

class ReadOnlyArray implements Iterator, ArrayAccess

{

    protected $index;

 
    protected $storage;

 
    public function __construct(array $data)

    {

        $this->storage = array();

 
        // Converting arrays to ReadOnlyArray instances makes for nicer error

        // messages

        foreach ($data as $key => $value) {

            if (is_array($value)) {

                $value = new self($value);

            }

 
            $this->storage[$key] = $value;

        }

 
        reset($this->storage);

        $this->index = key($this->storage);

    }

 
    public function rewind()

    {

        reset($this->storage);

    }

 
    public function current()

    {

        return $this->storage[ $this->index ];

    }

 
    public function key()

    {

        return $this->index;

    }

 
    public function next()

    {

         next($this->storage);

         $this->index = key($this->storage);

    }

 
    public function valid()

    {

        return isset($this->storage[$this->index]);

    }

 
    public function offsetSet($offset, $value)

    {

        throw new Exception('You cannot write values to a Read Only Array after it is created.');

    }

 
    public function offsetExists($offset)

    {

        return isset($this->storage[$offset]);

    }

 
    public function offsetUnset($offset)

    {

        throw new Exception('You cannot delete values from a Read Only Array after it is created.');

    }

 
    public function offsetGet($offset)

    {

        if (!isset($this->storage[$offset])) {

            throw new Exception($offset . ' does not exist');

        }

 
        return $this->storage[$offset];

    }

}

 
 
 
class ReadOnlyArrayTest extends PHPUnit_Framework_TestCase

{

    public function test()

    {

        $data = array();

        $data['foo']['bar'] = 'baz';

 
        $roa = new ReadOnlyArray($data);

 
        $this->assertEquals('baz', $roa['foo']['bar']);

 
        $ex = false;

        try {

            $roa['foo']['bar'] = 'boz';

        } catch (Exception $e) {

            $ex = true;

        }

        $this->assertEquals(true, $ex);

 
        $ex = false;

        try {

            unset($roa['foo']['bar']);

        } catch (Exception $e) {

            $ex = true;

        }

        $this->assertEquals(true, $ex);

 
        $this->assertEquals('baz', $roa['foo']['bar']);

    }

}

Themen-Optionen
Druckbare Version zeigen Jemanden per E-Mail auf dieses Thema hinweisen
Thema bewerten
Thema bewerten:

Ähnliche Themen
Thema	Autor	Forum	Antworten	Letzter Beitrag
Arraynamen ausgeben lassen in Foreach	dreamcatcher	PHP Einsteiger	4	09.04.2011 10:45
$GLOBALS, welche in DB gespeichert ist, als Variabel ausgeben und nicht als String	beta02	PHP Tipps 2009	29	01.04.2009 22:08
Verwendung von $GLOBALS	DutziMan	PHP-Fortgeschrittene	16	01.09.2004 10:00
[Erledigt] Unterschiede in Sessions		PHP-Fortgeschrittene	39	19.08.2004 23:52
static vs global vs $GLOBALS	Chance	PHP-Fortgeschrittene	19	10.08.2004 00:03


Mister Ad PHP Code Flüsterer Registriert seit: 21.08.2005 Beiträge: 4682 PHP-Kenntnisse: Fortgeschritten

21.01.2012, 17:41
mermshaus Erfahrener Benutzer Registriert seit: 14.06.2009 Beiträge: 1.731 PHP-Kenntnisse: Fortgeschritten	Ja, die Klasse selbst müsste das Singleton sein, damit es was bringt. Dein Ansatz unterscheidet sich nicht so sehr von einer „normalen“ Registry. Er ist gewissermaßen ein Vorbau (siehe RegistrySimple), um auf eine andere Art auf den Inhalt der Registry zugreifen zu können. PHP-Code: <?php final class Registry { private static $instance = null; private $data = array(); private function __construct() {} public function __clone() { throw new Exception('Clone is not allowed.'); } public function __wakeup() { throw new Exception('Unserializing is not allowed.'); } public static function getInstance() { if (self::$instance === null) { $className = __CLASS__; self::$instance = new $className; } return self::$instance; } public function set($key, $value) { $this->data[$key] = $value; } public function has($key) { return (isset($this->data[$key])); } public function get($key) { if (!is_string($key)) { throw new InvalidArgumentException('$key must be of type string.'); } if (!$this->has($key)) { throw new Exception('Key "' . $key . '" is not set.'); } return $this->data[$key]; } } class RegistrySimple { public function __get($className) { $r = Registry::getInstance(); if (!$r->has($className)) { $r->set($className, new $className()); } return $r->get($className); } } class Foo { public $test = ''; } $r = new RegistrySimple(); $r2 = new RegistrySimple(); $foo = $r->Foo; $foo->test = 'Hello World!'; unset($foo); $foo = $r2->Foo; var_dump($foo->test); Den Autoloader würde ich übrigens davon trennen. __________________ Blog \| Buch \| Kaloa

21.01.2012, 18:02
meikel Gast Beiträge: n/a	<eod>