• Jetzt anmelden. Es dauert nur 2 Minuten und ist kostenlos!

Instanzen zählen

A

achtelpetit

Neues Mitglied
Guten Morgen zusammen,
vielleicht hat jemand die Geduld mir zu erläutern, wie PHP Klasseninstanzen zählt. Beispiel:
PHP: 
$shopdb = new DB ();
var_dump($shopdb); // ergibt: object(DB)#1 (1) {   ["shopdb":"DB":private]=>   object(PDO)#2 (0) {   } } 

$shopdb = new DB ();
var_dump($shopdb); //ergibt: object(DB)#3 (1) {   ["shopdb":"DB":private]=>   object(PDO)#4 (0) {   } }
Es wird also 2 x hintereinander derselbe Variablenname vergeben.
Ich versuche nun die Logik zu ergründen, mit der die Objekte numeriert werden. Aber erst Object 1, dann Object 3? Ich nix verstehen.
 
achtelpetit schrieb:
Es wird also 2 x hintereinander derselbe Variablenname vergeben.
Ich versuche nun die Logik zu ergründen, mit der die Objekte numeriert werden. Aber erst Object 1, dann Object 3? Ich nix verstehen.
Zum Vergrößern anklicken....
Ich auch nicht. du musst uns schon zeigen was du wirklich machst:
PHP: 
Class DB {
}

$shopdb = new DB ();
var_dump($shopdb); 
// ergibt: object(DB)#1 (0) { } 

$shopdb = new DB ();
var_dump($shopdb); 
//ergibt: object(DB)#2 (0) { }
Es wird also ganz normal durchgezählt.
 
Well, Du hast recht, war ein bisserl knapp, die Frage.
Meine Klasse sieht so aus:
PHP: 
class DB {
    private $shopdb;
    public function __construct() 
    {
        /* 
         * ATTR_PERSISTENT                    = Verbindung offen halten
         * MYSQL_ATTR_USE_BUFFERED_QUERY     = wenn mehrere Abfragen hinereinander dann puffern
         * ATTR_ERRMODE                     = jeder Fehler wirft eine Exception
         * ATTR_DEFAULT_FETCH_MODE             = Abfragen geben ein assoziatives Array zurück
         * query('SET NAMES utf8')             = Abfragen geben UTF8 zurück
         */
        $options = array 
        (
        PDO::ATTR_PERSISTENT                  => true,
        PDO::MYSQL_ATTR_USE_BUFFERED_QUERY    => true,
        PDO::ATTR_ERRMODE                     => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE          => PDO::FETCH_ASSOC,
        );
    
        $this->shopdb = new PDO('mysql:host=localhost;dbname=' . CON_DBNAME, CON_DBUSER, CON_DBPASS, $options);
        $this->shopdb->query('SET NAMES utf8');
        // var_dump($this->db);
    }
    
    public function getDB()
    {
        return $this->shopdb;    
    }
};
Jetzt mache ich mir Gedanken, was wohl passiert, wenn ich mehrere DB-Objekte erzeuge. Vermutlich ist das ja mindestens Speicherverschwendung, vielleicht hat's sogar Nebenwirkungen, die ich nicht kenne.
Um diesbezüglich Erleuchtung zu finden (om mani padme hum) hab' ich mal ein bissserl experimentiert und bin gleich über die Zählung gestolpert.
 
Ich bin kein Fachmann für PHP, aber es fällt auf, dass diese Nummerierung, einfach in der Reihenfolge erfolgt, er der das Objekt erzeugt wurde.

#1 DB => erzeugt #2 PDO
#3 DB => erzeugt #4 PDO

Eiegntlich nicht ungewöhnlich.
 
Meine Experimente gingen ja noch weiter:

$x = new DB ();
var_dump($x); // object(DB)#3 (1) { ["shopdb":"DB":private]=> object(PDO)#4 (0) { } }

$x = new DB ();
var_dump($x); // object(DB)#5 (1) { ["shopdb":"DB":private]=> object(PDO)#6 (0) { } }

$y = new DB ();
var_dump($y); // object(DB)#3 (1) { ["shopdb":"DB":private]=> object(PDO)#4 (0) { } }

$y = new DB ();
var_dump($y); // object(DB)#7 (1) { ["shopdb":"DB":private]=> object(PDO)#8 (0) { } }
 
Garbage Collection!

Dadurch, dass du $x überschriebst, wird ja die erste Instanz wieder frei.
 
Na ja, das erklärt nicht die Lücken in der Zählung und vor allem ist nicht erklärt, wie ich feststellen kann, wieviele Objekte jetzt noch leben.
 
achtelpetit schrieb:
Na ja, das erklärt nicht die Lücken in der Zählung und vor allem ist nicht erklärt, wie ich feststellen kann, wieviele Objekte jetzt noch leben.
Zum Vergrößern anklicken....
Welche Lücken?
Das bei dir 1,2,3 fehlen muss an etwas anderem liegen, nicht an dem Code, den du uns gezeigt hast.
Und ob PHP eine Debuggingmöglichkeit bietet, die Objekte zu zählen weiß ich nicht. Dazu müßtest du die Dokumentation danach durchsuchen. Aber sowas braucht man i.d.R. auch nicht.
 
Naja, deshalb schrieb ich ja i.d.R. (in der Regel) - Ausnahmen gibt es immer. Ich programmiere überwiegend in Perl, da geht alles.
 
Ich bin nicht sicher, ob meine Idee sinnvoll ist. Aber wie ich schon sagte: ich möchte vermeiden, daß z. B. ein DB-Connect per new erzeugt wird, wenn es noch einen gibt.
 
Du könntest die Instanz als Singleton deklarieren oder in einer Registry ablegen. Finde ich aber beides unschön. Ich würde Dependency Injection vorziehen, also einer Klasse, die die DB-Verbindung braucht, im Konstruktor eine Instanz übergeben.
 
Instanzen koennte man auch folgendermassen zaehlen:

PHP: 
<?php
  class Test {
    
    public static $count = 0;
    
    function __construct() {
      self::$count++;
    }
    
    function __destruct() {
      self::$count--;
    }
    
  }
  
  $test1 = new Test();
  $test2 = new Test();
  var_dump(Test::$count);
  $test1 = new Test();
  var_dump(Test::$count);
  $test2 = null;
  var_dump(Test::$count);
?>

Ich bin mir jetzt aber nicht sicher, ob du sowas gesucht hast...
 
Danke für eure Antworten. Ich glaube, die Anregung von mermshaus "Dependancy Injection" ist der richtige Weg.
Es macht micht trotzdem neugierig, ob es nicht eine Möglichkeit gibt Objekte zu zählen; ich meine jenseits der Idee von Anusha, die Dingers schon beim Entstehen zu numerieren.
 
Naja bei meinem Code werden ja nicht die Objekte numeriert, sondern einfach per Klassenvariable die Anzahl der Instanzen gezaehlt ;)
Also die $count Variable sagt nichts anderes, als wie Die momentane Anzahl der erzeugten Instanzen.
 
Du musst dich einloggen oder registrieren, um hier zu antworten.

Neueste Beiträge

Zurück
Oben