[PHP] OOP und Funktionen einer Vererbten Klasse

[flaschenkind]

Ich hab eine MySQL Klasse. Die hat public $_debug = FALSE oben drüber stehen, um das debugging auszuschalten.
Da ich der Person, die das Script betreibt, es leicht machen will, den debugging Mode einzuschalten, hab ich in der __construct Funktion eine Stelle, wo ich das dann auf true setzen kann.
Das klappt auch, und wenn das an ist und ich ne Fehlerhafte Query ausführe, dann kommt auch schon mein Fehler.

Aber jetzt zu meinem Problem. Ich hab eine Klasse foo, die die MySQL Klasse vererbt (extends MySQL).
Wenn ich dort jetzt die Query Funktion ausführe (MySQL::query('SELECT `foo` FROM `bar`'); geht das auch. Aber wenn ich dann eine Fehlerhafte Query habe kommt nur ein Hinweis auf einen Fehler, aber nicht die Fehlermeldung.

if(!$this->_debug) echo 'bla';

Schreibe ich dies an die Stelle, wird auch schön bla ausgegeben. Also kommt es wohl nicht so ganz in der foo Klasse an, dass $_debug auf true gesetzt worden ist.
Schreibe ich das da in die Query Funktion, gibt der mir auch bla aus.

Wenn ich jetzt über die Stelle, wo ich die Query Funktion aufrufe, $this->_debug = ture schreibe, dann kommt auch der Fehler.

Aber wieso wird die festgelegte Variable in der MySQL Klasse ignoriert? Gibt es möglichkeiten, dass es trotzdem als true erkannt wird?

 

[Johnson]

Wenn du $_debug in Foo nicht neu gesetzt hast, dann ist es exakt das gleiche $_debug wie in Mysql.

Falls es das nicht ist: Ein bisschen Code wäre hilfreich.

edit: Wenn du Mysql::Query() von außerhalb aufrufst, dann weiß Foo natürlich nichts davon.

 

[flaschenkind]

Wenn du $_debug in Foo nicht neu gesetzt hast, dann ist es exakt das gleiche $_debug wie in Mysql.

Falls es das nicht ist: Ein bisschen Code wäre hilfreich.

edit: Wenn du Mysql::Query() von außerhalb aufrufst, dann weiß Foo natürlich nichts davon.

Ist dort nicht neu gesetzt, nur mal zum testen, ob es dann geht.

Gibts dann wohl, ich habe gehofft, ich krieg das ohne auf die Reihe

Ich ruf das in Foo auf, das is ja auch egal. Es geht ja darum, dass dann der Debug Mode nicht erkannt wird und das Script die Fehler für sich behällt.

Klasse Foo:

<?php
class Sites extends MySQL{
	function __construct(){
		MySQL::query('SELECT `foo` FROM `bar`'); //Gibt Fehler, da es die Tabelle nicht gibt
	}
[...]	
}
?>

MySQL Klasse:

<?php
class MySQL{
	[...]
	public $_debug = FALSE;
	
	
	function __construct($host, $user, $pw, $db, $prefix='', $debug=FALSE){
		[...]
		$this->_debug = $debug;
	}

	function connect(){
		$connection = mysql_connect($this->_host, $this->_user, $this->_pw, $this->_db) or die(mysql_error());
		mysql_select_db($this->_db, $connection) or die(mysql_error());
	}

	function query($query){
    	$mysql = mysql_query($query);
    	$mysql_error = mysql_error();
		if($this->_debug AND !empty($mysql_error)){
			die('Es ist ein Fehler aufgetreten:<br>'.mysql_error().' (Errno: '.mysql_errno().')<br>SQL-Code: '.$query);
		}
		elseif(!empty($mysql_error)){
			die('Es ist ein Fehler in einer MySQL Query aufgetreten.');
		}
    	return $mysql;
	}
    [...]
}
?>

Und wenn ich jetzt über Foo ne Fehlerhafte Query ausführe, kommt nur Es ist ein Fehler in einer MySQL Query aufgetreten.
Wenn ich allerdings ne Fehlerhafte Query irgentwo im Script ausserhalb einer Klasse ausführe, kommt der Fehler so wie er soll.

 

[theHacker]

PHP überschreibt seine vererbten Variablen grundsätzlich anders wie z.B. von C++ erwartet.

Zieh dir mal die Kommentare im Manual rein:
https://de.php.net/manual/de/keyword.parent.php#33724
Ne konkrete Lösung ist aber auch nicht zu finden.

Ich hab selber mal probiert, mit einer Get-Methode, aber auch das funktioniert nicht:

<?php

class A
{
  var $a;
  
  function get()
  {
    return $this->a;
  }
  
  function set1()
  {
    $this->a=1;
  }
}


class B extends A
{
  var $a;
  
  function getp()
  {
    return parent::get();
  }
  
  function set2()
  {
    $this->a=2;
  }
}

$foo=new B;
$foo->set1();
echo $foo->get(); 

$foo->set2();
echo $foo->getp();

?>

 

[flaschenkind]

Hmm, mist. Dann muss ich mir was anderes einfallen lassen, wie ich das löse

 

[tleilax]

Es ist doch eh vollkommen wurscht, was in Instanzen von Foo oder MySQL passiert, solange Du die query-Funktion der Hauptklasse statisch aufrufst. Da wirste halt auch auf keine nicht-statischen Variablen zugreifen oder diese verändern können...

 

[flaschenkind]

Es ist doch eh vollkommen wurscht, was in Instanzen von Foo oder MySQL passiert, solange Du die query-Funktion der Hauptklasse statisch aufrufst. Da wirste halt auch auf keine nicht-statischen Variablen zugreifen oder diese verändern können...

Also würde das funktionieren, wenn ich die statisch mache?

 

[tleilax]

Ja, Du kannst die Debugfunktion entweder statisch realisieren oder Du baust Deine Klassenhierarchie halt so auf, dass wirklich auf den erzeugten Instanzen gearbeitet wird, sprich: Jede Klasse, die von MySQL erbt, hat eine eigene Debugeinstellung, die benutzt werden kann.

 

[flaschenkind]

Hmm, wenn ich das Statisch mache, kann ich nich die globale Einstellung eintragen. Und nachträglich auf statisch stellen geht afaik nicht, oder?
Dann muss ich wohl das Debuggen an jede Klasse übertragen.

 

[tleilax]

Ich hab's nicht getestet, aber eigentlich müsste das hier doch funktionieren:

class MySQL
{
  public static $_debug = false;
  
  # ...

  public static function toggleDebug($state = null)
  {
    if ($state===null)
    {
      $state = !MySQL::_debug;
    }
    MySQL::_debug = $state;
  }

  public function query($sql)
  {
    $result = mysql_query($sql);
    if (MySQL::_debug and !empty(mysql_error())
    {
      printf('[MySQL] Error in SQL: %s', mysql_error);
    }
    return $result;
  }
}