1. Vesuch OOP - Klassen

A

Arndtinho

Erfahrenes Mitglied
Hallo,

ich bin gerade dabei die Verwendung von Klassen in PHP zu verstehen und möchte eine Login-Klasse erstellen. Bis jetzt habe ich es nur zum DB_connect geschafft.

PHP: 
class login {
	var $connect, $db;
	//var $host, $database, $db_uname, $db_upass;
	
	function db_connect() {
		global $host, $database, $db_uname, $db_upass;
		
		$this->connect = @mysql_connect($host, $db_uname, $db_upass);
		if(!$this->connect) {
			die (mysql_error());
		}
		else {
			echo "Connect erfolgreich";
		}
			$this->db = mysql_select_db($database, $this->connect) or die (mysql_error());
	}
}

Ich möchte mir nun anzeigen lassen, ob die Connection zur DB erfolgreich war oder nicht. Also erzeuge ich eine Instanz:

PHP: 
if(isset($_POST['txtUName']) AND isset($_POST['txtUPass'])) {
	$login = new login();
	echo $login;
}

Bei der Ausgabe wird 'Object' angezeigt. Was mache ich falsch?

Gruß Arndtinho
 
Habe es soeben rausgefunden. Es muss heißen:

PHP: 
echo $login->db_connect();

Oder? Zumindest wird jetzt bei mir angezeigt 'Connect erfolgreich'.


Gruß Arndtinho
 
Auch wenn es dein erster Versuch mit Klassen in PHP ist: Der Sinn von Klassen/Kapselung ist die Trennung von Code. Deine Funktion db_connect() gehört eigentlich nicht in die Klasse login sondern in eine eigene z.B: myDB. Ind der Klasse login wird dann eine Instanz von myDB verwendet.
 
Hey,

ja das ist richtig. Wenn du eine Instanz erzeugst hast du ja ein Objekt. Davon kannst du beliebig viele verschiedene instanzieren.

Auf jedem Objekt kannst du dann operieren, soll heißen di kannst auf dem Objekt deine Methoden aus der Klasse aufrufen, oder deine Klassen Variablen jedem Objekt unterschiedlich zuweisen.

wenn du mit new nen Objekt instanziert hast, arbeitest du eigentlich nur noch mit Methoden auf dem Objekt, auch wenn du den Wert eines Variablen Wertes wissen willst.

Normal gibt es für jede Variable in einer Klasse eine get und eine set Methode, mit der get holst du dir den Wert, mit der set veränderst du deinen Wert.

Bei dir also zum Beispiel:

function getConnect() {
return $this->connect;
}

dann kannst du du einfach schauen ob für das Objekt eine Verbindung steht

if(isset($object->getConnect)) { .....

oder wie du möchtest.

also schon ganz OK so was du machst, schau dir wenn du das gerade lernst mal vielleicht gleich an wie man das in PHP5 macht, da ist das mit OO weiter ausgearbeitet schon.
 
Wenn du OOP Verstehen willst solltest du noch ein bischen über die OOP Grundlagen lesen.

Da geht es u.a darum nur Dinge in Klassen zu kapseln die auch unweigerlich zusammengehören.

Ein Login Object hat keine Datenbank verbindung.

Das ist unlogisch.

Ein Login Object hat:

Einen Loginnamen
Ein Login Passwort
Einen Login Status
...
Und ein Login kann:
sich Validieren (Ohne Datenbank)


Also nur das was wirklich zu einem Login passt.

Also könnte dein Login vollgendermassen aussehen:

PHP: 
class Login  {
  var $name, $pass, $status = 0;
  var $VALID = 1;
  var $FAILED =  0;
  var $auth = 0;
  
  function Login($name,$pass) {
     $this->name = $name;
     $this->pass = $pass;
  }

  function isValid() {
     if($this->name=="") return false;
     if($this->pass=="") return false;
  }

  function setAuthenticated($authstatus) {
     $this->auth = $authstatus;
  }

  function getAuthenticated() {
     return $this->auth;
   }
}

Jetzt hast du ein Login Object das sich selber einen ´Valid Status verpasst.
Dieses kannst du dann an ein andere Klasse übergeben.

Reine Datenbank Klassen sind aber auch nicht die Lösung sondern verpasse
dein Login einem LoginManager / SecurityManager der u.a mit der Persistenz
arbeiten kann (sprich entweder der Datenbank oder ähnlichem).

PHP: 
class SecurityManager {
   function check($login) {
        if(!$login->valid) return 0;
       // Datenbank operation mit $login->name und $login->password
        ...
       // nicht gefunden
         return 0;
       // gefunden 
         return 1;
   }
}

// aufruf des ganzen

$login =  new Login($name,$password);
$securityManager = new SecurityManager();
$login.setAuthenticate($securityManager->check($login));
....... .... // irgendwas und bei bedarf
if($login->checkAuthenticate()==$login->FAILED) 
         header('Location: loginerror.php');

Währe jetzt eben ein Quick and Dirty beispiel.

Die Wahre stärke von OOP zeigt sich dann wenn mann weiss welche Informationen am besten wie zu kapseln sind.

Ein einfacher Weg ist sich das Ding auch als Object vorzustellen und einfach mal beschreibend aufzuschreiben:

Ein (Object) hat ein ... und ein ... und eine ... und kann ...

Anderes Beispiel ein Logger der Dinge mitlogged
Ein Logger hat ein Logfile und hat eine Logstufe und hat ein Logzähler welcher jedesmal beim loggen eins hochgesetzt wird und kann Strings loggen und kann
.... usw
 
Hallo,

ok ich habe das mal getrennt. Habe jetzt eine Klasse 'db' und eine 'login'. In der login-Klasse hole ich mir die eingebenen Daten aus dem Formular:

PHP: 
class login {
	var $uname, $upass;
	
	function get_user($user, $pw) {
		$user = $_POST['txtUName'];
		$pw = $_POST['txtUPass'];
		
		$this->uname = $user;
		$this->upass = $pw;
	}
}

Um zu sehen ob es funktioniert, lasse ich mir die Daten ausgeben:

PHP: 
$curUser = new login($uname, $upass);
echo $curUser->uname." ".$curUser->upass;

Ich denke mal, das es eigentlich richtig ist, aber es werden keine Werte angezeigt.

Gruß Arndtinho
 
Hey,

also 1. schau mal ruhig was der Christian gesagt hat :-) der hatte da gute Anregungen für das allgemeine OO auch.

so das ist so wie du das gemacht hast net richtig.

Du brauchst (bzw. man macht es so) eine get Methode um einen Variablen Wert eines Objektes zu bekommen und eine set um einen Wert zu setzen. Schau mal in Christians Beispiel, da sieht man das auch sehr gut.

bei dir wäre das also so in der Klasse:

PHP: 
function getUname() {
     return $this->uname;
}

function getUpass() {
     return $this->upass;
}

und dann der Aufruf
PHP: 
echo $curUser->getUname()." ".$curUser->getUpass();


die beiden Methoden machen nix weiter, als dir den Wert dieses Objektes zurückzugeben.

Wie gesagt schau dir mal das Beispiel von Christian an, alles drinne.

P.S. deine Bezeichner solltest du mal überdenken.
 
Zuletzt bearbeitet:
Ja ist schonmal ein Anfang, aber hier machst du
noch einen Fehler:

Code: 
function get_user($user, $pw) {
        $user = $_POST['txtUName'];
        $pw = $_POST['txtUPass'];
        
        $this->uname = $user;
        $this->upass = $pw;

Einerseits gibst du $user und $pw als Parameter für deine Methode an, anderseits aber liest du diese aus $_POST aus.
Damit sind die Parameter ohne Sinn.

du solltest nicht in get_user die Daten aus den $_POST vars lesen, das macht keinen Sinn.
Ein Vorteil von OOP ist das du wiederverwendbaren Code schreibst. Wenn du deine Daten in der Klasse aus $_POST herausliest legst du dich in alle Zukunf fest das die Daten immer aus den POST vars kommen müssen.

In dem du aber die Parameter nutzt kannst du später die Klasse auch in anderen Projekten nutzen in denen du die Daten z.b aus einem Textfile holst oder anders generierst.

Modulare Programmierung ist das Stichwort.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück