Nebenbei: Warum eigentlich $this???

[TobiaZ]

Hi!

Hab grade gesehen, dass ein paar Profis hier sind. Will mir jetzt doch langsam mal die Klassen vor nehmen. Hab aber ehrlich gesagt mein Buch noch nicht geholt, sondern schaue mir ne fertige Classe von Op@ an.

Warum heißt das da immer $this? Ist das Vorgegeben oder egal?

[TBT]

die Klasse kann Membervariablen haben.
Diese sind automatisch in allen Methoden der Klasse vorhanden.
Damit er die von lokalen unterscheiden kann heissen die $this->... (diese Klasse!)

class X {
   var $member1;
   var $member2;
   function X($_x,$_y) {
      $this->member1=$_x;
      $this->member2=$_y;
   }
   function show() {
      echo "member1 ist: ".$this->member1." und member2 ist: ".$this->member2;
   }
}

$test=new X("Hallo","Test");
$test->show(); 

PS: wenn du in einer Klassenmethode eine andere Methode dieser Klasse aufrufen willst, mußt du auch $this-> benutzen

[TobiaZ]

Methoden = Funktionen ?!?

[TBT]

Methoden nennt man die Funktionen, die einer Klasse gehören

[Coragon Rivito]

oh, weil ichs grad seh ..
was bringt die namensgebung ..

function &yx() {}
function _yx() {}

var $_xy;

gibts da noch mehr sondernamen ?

danke

[TobiaZ]

Habs mir in der Richtung schon gedacht.

Hab mir grad noch was ausgedruckt. Eigentlich, um nicht mein Buch zu holen, obwohl das genauso wie der Drucker im Keller ist. Naja.

Deinen Code verstehe ich soweit. D.h. ich kann nachvollziehen, was er macht, bin aber nicht in der Lage selbst was zu schreiben.

Wollte eigentlich noch weiterschreiben, hab aber jetzt ein paar erklärungen auf php.net gefunden.

Aber keine Sorge, melde mich wieder...

[TobiaZ]

Uh, was ist das denn?

Man, ich war grade dabei den Stoff zu rallen, und dann kommst du mit so nem Schei* daher.

[EDIT]
PS: Ich glaub ich überlege mir das mit dem sympathisch noch mal

[TBT]

Variablen in der Form

$_xyz sind normalerweise (hat sich irgendwie als Standard
entwickelt) als Parameter übergebene Variablen

Variablen der Art &$xyz sind Referenzen, dh.

von oben

function bla($_x) {
   $_x->member1="neu gesetzt";
   $_x->show();
}

function bla1(&$_x) {
   $_x->member1="nochmal neu gesetzt";
   $_x->show();
}


$x= new X("Hallo","Test");
$x->show()
bla($x);
$x->show();
bla1($x);
$x->show(); 

bei der normalen Übergabe per $xyz wird von dem Objekt (auch bei Arrays, ...) ein KOPIE gemacht,
dadurch wirken sich Änderungen NICHT auf das Original aus.

Übergibt man per &$xyz, wird nur ein Verweis auf das Objekt übergeben,
und man arbeitet innerhalb der Funktion auch mit dem Original.

Zweiteres ist von Vorteil, wenn man große Arrays,Objekte etc übergibt,
da durch das nichtkopieren des Obbjektes Arbeitspeicher gespart wird.
Außerdem dauert der Kopiervorgang auch seine Zeit.

Fein ist es auch, wenn in der Funktion vieles geändert wird. Man hat ja
nur einen Rückgabewert, und will manchmal am besten mehrere Variablen
aus der Funktion zurückbekommen.

das geht dann so:

function foo(&$_x,&$_x1,&$_x2) {
   $_x="Hallo";
   $_x1="du";
   $_x2=145;
   return "OK";
}

$x=$x1=$x2=$x3='';

echo $x3=foo($x,$x1,$x2);

echo $x.$x1.$x2; 

EDIT:

---

nu ist ganz vorbei mit sympathisch

---

[Coragon Rivito]

@ tobi

seit froh dass ich __sleep und __wake noch ned ausgepackt und angefangen hab vom serialisieren und deserialisieren zu reden .. *lal*

[TBT]

Funktionen der Art

&foo()

geben ihrerseits eine Referenz auf das Objelt zurück, sind aber
mit Vorsicht zu geniesen, da diese Objekte manchmal ungewollt
an anderer Stelle geändert werden.

[Coragon Rivito]

ist also vom prinzip das selbe wenn bei den argumenten mit & sagst die funktion erwartet eine referenz ?

function foo(&$bar) {}

muss ich dann eigentl mit

foo(&$bar)

aufrufen oder kann ich das dann bleiben lassen ?

[TobiaZ]

denke, das & beim Aufruf kann weg.

[TBT]

aufruf per

foo(&$bar) gibt es nichtmehr, dafür mußt du ja die function als

function foo(&$bar) {} definieren.

ein Aufruf von foo('Konstante') ist bei einer Referenz auch nicht möglich !
Das muß in diesem Falle

foo($x='Konstante'); heißen.

willst du den Rückgabewert als Referenz haben, muß die Funktion entsprechend
deklariert sein.
Ein

return &$returnwwert;

bringt da wieder nur nen Fehler

[TBT]

ein böses, meist ungewolltes Beispiel für Referenzen:

class foo{
    var $bar;
    function foo(&$_param){
        $this->bar=&$_param;
    }
    function set(&$_param){
        $this->bar=&$_param;
    }
    function &get(){
        return $this->bar;
    }
}
$foo = new foo($x="test");
$test = &$foo->get();
echo $test;
$foo->set($x="blabla");
$test1 = &$foo->get();
echo $test1;
echo $test; 

bringt:

test
blabla
blabla

$test wurde durch den Aufruf von set mit Referenz überschrieben !!!

[Op@ U.]

Was man noch unbedingt wissen sollte ist folgender Spezialfall:

Wenn du eine klasse mit dem Namen "klasse" hast, kannst du diese per Konstruktor initialisieren (die klasse anlegen, und den Variablen Werte zuweisen).
Das funktioniert einfach, indem du eine Methode schreibst, die genauso heisst, wie die eigentliche klassen.