Problem mit Php Klasse

Entweder verwendest du es sop wie Nico oder du arbeitest mit global: http://php.net/manual/de/language.variables.scope.php

Von globalen Variablen raten wir mal besser ab, wenn nicht unumgänglich, also bitte nach vorgegebener Methode lösen.

Zitat von LeijaT

unumgänglich

Warum davon abraten?

Zitat von Slash™

Warum davon abraten?

Weil auf globale Variablen alles und jeder zugreifen kann, ganz gleich wer und aus welchem Grund. Unkontrollierter Zugang ist immer ein Manko, dass es zu vermeiden gilt.

Zitat von LeijaT

Weil auf globale Variablen alles und jeder zugreifen kann, ganz gleich wer und aus welchem Grund. Unkontrollierter Zugang ist immer ein Manko, dass es zu vermeiden gilt.

Wofür baut man Klassen, wenn man alles eh Global deklariert?

Edit: Whoops falscher markiert

Slash™:

Bitte nicht so.
Klassen haben aus gutem Grund einen Konstruktor, dem Parameter übergeben werden können.

Der Konstruktor einer Klasse wird immer ausgeführt wenn ansatzweisse die Klasse aufgerufen wird.

Aber ich empfehle mit PDO zu arbeiten. Ich habe dazu mir auch eine PDO-Klasse geschrieben die du gerne verwenden darfst.

<?php


class Database
{
	private $host 	= 'localhost';
	private $user 	= '';
	private $pass 	= '';
	private $dbname = '';
	private $synup;
	private $error;
	private $stmt;
	protected $dsn;

	public function viewDB()
	{
		return $this->dbname;
	}
	public function __construct()
	{
		$this->dsn = 'mysql:host='.$this->host.';dbname='.$this->dbname;

		$optionen = array(
				PDO::ATTR_PERSISTENT => true,
				PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION);

		try{
			$this->synup = new PDO($this->dsn, $this->user, $this->pass, $optionen);
		} catch(PDOException $e)
		{
			$this->error = $e->getMessage();
		}

	}

	public function Query($sql)
	{
		$this->stmt = $this->synup->prepare($sql);
	}

	public function errorInfo()
	{
		$this->stmt = $this->synup->errorInfo();
	}

	public function errorCode()
	{
		$this->stmt = $this->synup->errorCode();
	}

	public function getAttribute($att)
	{
		$this->stmt = $this->synup->getAttribute($att);
	}

	public function setAttribute($att, $value)
	{
		$this->stmt = $this->synup->setAttribute($att, $value);
	}


	public function bind($param, $value, $type = NULL)
	{
		if(is_null($type))
		{
			switch(true)
			{
				case is_int($value):
					$type = PDO::PARAM_INT;
					break;
				case is_null($value):
					$type = PDO::PARAM_BOOL;
					break;
				default:
					$type = PDO::PARAM_STR;
			}
		}

		$this->stmt->bindValue($param, $value, $type);
	}

	public function execute()
	{
		return $this->stmt->execute();
	}

	public function fetchAll()
	{
		return $this->stmt->fetchAll();	
	}

	public function debug()
	{
		return $this->stmt->debugDumpParams();
	}

	public function nextRowset()
	{
		return $this->stmt->nextRowset();
	}
	public function resultset()
	{
		$this->execute();
		return $this->stmt->fetchAll(PDO::FETCH_ASSOC);
	}

	public function fetch($typ = PDO::FETCH_OBJ)
	{
		$this->execute();
		return $this->stmt->fetch($typ);
	}

	public function rowCount()
	{
		return $this->stmt->rowCount();
	}

	public function lastInsertId()
	{
		return $this->synup->lastInsertId();
	}

	public function columnCount()
	{
		return $this->stmt->columnCount();
	}

	public function getColumnMeta($c = 0)
	{
		return $this->stmt->getColumnMeta($c);
	}

	public function beginnTransaktion()
	{
		return $this->synup->beginTransaction();
	}

	public function commit()
	{
		return $this->synup->commit();
	}

	public function rollBack()
	{
		return $this->synup->rollBack();
	}

	/*public function debug()
	{
		return $this->stmt->debugDumpParams();
	}*/
}
?>

Ich verwende allgemein meine DB-Klasse nur in anderen Datenbank Klassen. Allerdings kann man es auch in prozenduale Programmierung verwenden.

$db = new Database; 


$db->Query(SQLBEFEHL);
$db->execute(); //Gibt True zurück wenn SQL Befehl erfolgreich ausgeführt ansonsten false

Aber wenn man einen SQL Befehl in einen derzeit ausgeführten SQL Befehl ausführen möchte. Dann muss man eine neue Datenbank Distanz erstellen sonst funktioert es nicht.

$db1 = new Database;
$db2  = new Database;
$db1->Query("SELECT * FROM person WHERE vorname = 'Manfred'");
$db1->execute();
$fetch = $db1->fetch(); //Fetch wird als Objekt ausgegeben, nicht als Array


if($fetch->hatPersonalAkte == 0) {
$db2->Query("INSERT INTO personalakte(vorname) VALUES (`Manfred`)");
$db2->execute();
}

"Dann muss man eine neue Datenbank Distanz erstellen sonst funktioert es nicht." - alleine schon das ist grausam. Man stelle sich nur mal Relationen vor - das sind dann gerne mal 4, 5 oder auch mehr Verbindungen zur Datenbank.
Deine Klasse ist im übrigen auch sonst wenig sinnvoll - enschuldige, dass ich das so direkt sage. Auch hier gilt: Konstruktor sinnvoll einsetzen.

Ihr braucht nicht immer das Rad neu erfinden.

Nein das ist ganz praktisch trotz allem.

Ist doch wohl logisch das wenn man in eine Distanze arbeitet diese nicht überschreiben kannst. Das musst du auch nur wenn du in einer Distanze einen anderen SQL Befehl ausführen willst.

Wenn du ein SQL Befehl ausgeführt hast und ihn nicht weiter behandeln möchtest dann kannst du mit der gleichen Variable einen neuemn SQL Befehl ausführen.

Zitat von palwal

Nein das ist ganz praktisch trotz allem.

Ist doch wohl logisch das wenn man in eine Distanze arbeitet diese nicht überschreiben kannst. Das musst du auch nur wenn du in einer Distanze einen anderen SQL Befehl ausführen willst.

Wenn du ein SQL Befehl ausgeführt hast und ihn nicht weiter behandeln möchtest dann kannst du mit der gleichen Variable einen neuemn SQL Befehl ausführen.

Wenn man davon noch nicht so die Ahnung hat wie der @TA: sollte man lieber bei mysqli bleiben, deine Klasse ist mit unnötigen Variablen bestückt und sieht auch nicht gerade schön verwendbar aus.

Also ich sage dazu immer nur entweder man arbeitet sich da komplett von alleine rein oder lässt es bleiben. Deine Klasse hat nichtmal Erklärungen, "Beginner" in PDO wüssten somit nichtmal was du da machst

Nicowiss ich mag deine Art, seit ich dich kenne kritisierst du alles irgendwie.

mysql_connect() Function ist nicht MySQLi! Das ist die standartbassierte function um eine Db Connection aufzubauen.

Ich hab nur eine Empfehlung ausgesprochen. Abgesehen davon kannst du es auch verwenden, wie du magst. Vielleicht stelle ich meine Klasse ins Showroom mit einer Dokumentation.

Auch von der Schreibweise her ist meines leicht handlebar. Ich habe Bekannten von mir die Klasse gegeben die auch etwas in der Webprogrammierung sind (Aber keine Profis) und von denen habe ich auch nur gutes Feedback gehört. In der Theorie sieht es komplizerter aus als es eigentlich ist.

Ausserdem bietet PDO mehr Security. Einfach mit mysql_real_escape_string() ein String zu maskieren ist es nicht getan und hilft auch oftmals nicht. Einfache SQL-Injections können nicht ausgeführt werden aber erweiterte schon. Arbeite erstmal mit meiner Klasse in der Praxis und gebe bitte dann erst ein Feedback ab.

naja die MySQL Extension ist immernoch veraltet. Ich empfehle dir mal deine PDO Klasse zu verbessern, die ist ja schrecklich, da kannste lieber direkt die Originale PDO Klasse bzw. deren Abwandlungen nutzen...

Außerdem für Privat Anwender ist MySQLi vollkommen in Ordnung? Wozu braucht ein Privatanwender Transactions usw? Und Prepared Statements kriegst man ebenso easy auch mit mysqli hin...