Hallo allerseits

Ich habe vor 2 Wochen mit der Objektorientierten Programmierung angefangen,
und wollte nun meine SQL-Daten damit auslesen.

Ohne OOP würde ich das so machen:

PHP-Code:

$code = mysql_query("select * from example where Name='Test';");
while($zeile = mysql_fetch_array($code))
{
    $ID = $zeile["ID"];
    $Name = $zeile["Name"];
} 


Mein Ansatz mit OOP:

PHP-Code:

class sql{
    static $sql;
    
    function sql_code($code){
        $this->sql = $code;
    }
    function sql_auslesen($row){
        $code = mysql_query($this->sql);
        while($zeile = mysql_fetch_array($code))
        {
            return $zeile[$row];
        }
    }
}

$sql = new sql;
$sql->sql_code("select * from example where Name='Test';");
$ID = $sql->sql_auslesen("ID");
$Name = $sql->sql_auslesen("Name"); 


Allerdings wird bei meiner OOP-Variante ja jedes mal eine neue While-Schleife ausgeführt.
Kann man das irgendwie umgehen?
Vielen Dank im Vorraus.
--
Mit freundlichen Grüßen
Daniel K.

Einfach den Output der Schleife in eine globale Variable packen und dann könnte man mit einer neuen Funktion die einfach auslesen.
Halt fast genauso wie bei $sql.

Wie genau meinst du das?
So?

PHP-Code:

class sql{
    static $sql;
    public $werte;
    
    function sql_code($code){
        $this->sql = $code;
    }
    function sql_auslesen($row){
        $code = mysql_query($this->sql);
        while($zeile = mysql_fetch_array($code))
        {
            $werte = $werte . "|" . $zeile[$row];
        }
        $this->werte = explode("|", $this->werte);
    }
    function sql_werte($row){
        $arrnum = array_search($row, $this->werte);
        return $this->werte[$arrnum];
    }
} 


Aber dann hab ich doch auch die ganzen schleifen...

...
[Ca. 10 Minuten später]
...

Juhuu!! :P
Es klappt
Du hast mich auf ne Idee gebracht
Ich führ jetz ne while schleife in der while schleife aus, die -- ach guckt einfach selber

PHP-Code:

class sql{
    static $sql;
    public $rows;
    public $werte;
    
    function sql_code($code){
        $this->sql = $code;
    }
    function sql_auslesen($rows){
        $this->rows = explode("|", $rows);
        $rows_num = count($this->rows);
        
        $code = mysql_query($this->sql);
        while($zeile = mysql_fetch_array($code))
        {
            $i = 0;
            while($i < $rows_num){
                $this->werte = $this->werte . $zeile[$this->rows[$i]] . "|";
                $i++;
            }
        }
        $this->werte = explode("|", $this->werte);
    }
    function sql_werte($row){
        $arrnum = array_search($row, $this->rows);
        return $this->werte[$arrnum];
    }
}

$sql = new sql;
$sql->sql_code("select * from example where name='Test';");
$sql->sql_auslesen("ID|name");
$ID = $sql->sql_werte("ID");
$Name = $sql->sql_werte("name");

echo $ID . $Name; 


Viiiiieelen Danke
--
MfG Daniel

So ähnlich wie das 2.te meinte ich es.
Mit 2 Schleifen verkomplizierst du das doch nur unnötig.
Vielleicht kann ich dir morgen nochmal ein codebeispiel bringen, wie ich es genau meinte.

Das wäre sehr nett
Vielen Dank schonmal im Vorraus.

Kurze Zwischenfrage: Warum nimmst du nicht PDO wenn du es mit OOP machen willst?

O.o hab grad mal gegooglet um zu gicken was das is...
Ich versteh nur Bahnhof

Die Klasse ist also schon standartmäßig bei PHP5 drinne,
muss also nur nen Objekt anlegen, und dann?

Nutz doch einfach mysqli - ist MySQL nur halt oop.
Tutorial:
http://www.tutorials.de/content/1168...-absetzen.html

Du legst ein PDO-Objekt an und darüber kannst du dann so tolle Sachen machen wie Prepared Statements. Beispiel anhand deines Codes:

Code php:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// Verbindung aufbauen $db = new PDO('mysql:dbname=testdb;host=127.0.0.1', 'benutzername', 'passwort'); if(!$db) {   die('Verbindung zur Datenbank fehlgeschlagen'); } // Exceptions einschalten; sobald ein Fehler auftritt wird eine Exception geworfen $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);   // Prepared Statement vorbereiten $statement = $db->prepare('SELECT * FROM example WHERE Name = ?');   // Variable Werte ins Statement einfügen $statement->bindValue(1, 'Test');   // Statement ausführen $statement->execute();   // Resultate abholen $result = $statement->fetchObject();   // Resultat anzeigen echo $result->Name; // Zu Debugging-Zwecken noch mal ein var_dump   var_dump($result);

Ist schon ein Unterschied, wenn man das über PDO macht, ich rate allerdings dazu, denn man weiß nie, warum es sich lohnt, es einzusetzen. Ich zähle mal ein paar Gründe auf:

- Übersichtlichkeit im Code (ist für mich persönlich das wichtigste)
- Einigermaßen Sicherheit, was SQL-Injections angeht (wegen Prepared Statements)
- Sehr flexibel, was das Backend angeht; Man kann relativ einfach die Datenbank austauschen (z.B. von MySQL zu PostgreSQL)
- Performance-Gewinne bei Statements innerhalb von Schleifen (wenn man mal mehrere Datensätzen abholen will)

Jede vernünftige Programmiersprache bietet heutzutage Prepared Statements an, und das ist auch gut so.

Wenn du zu den Punkten oder allgemein Fragen hast, kannst du sie gerne stellen. Wenn du dafür (noch) nicht bereit bist, kannst du meine Versuche, dich zu etwas professionelleren Code zu bewegen, ignorieren

Zitat von saftmeister

Code php:

1 2 3 4 5

// Resultate abholen $result = $statement->fetchObject();   // Resultat anzeigen echo $result->Name;

Aber wenn ich das richtig verstehe kann man hier doch nur 1 Zeile auslesen,
also wenn ich SELECT * FROM test WHERE Ort='Hannover' mache und es mehrer Benutzer
aus diesem Ort gibt, zeigt er mir doch nur einen an, oder?
Ich müsste dann doch ne while-schleife machen, oder?

Außerdem sieht mir persönlich mysqli auf den ersten Blick übersichtlicher aus..

Und wo ist das Problem um fetch_object() eine Schleife zumachen?

Das ist kein Problem
Wollte nur nachfragen, ob meine überlegung mit der Schleife richtig ist :P

Deine Überlegung ist richtig. Warum denkst du, das MySQLi übersichtlicher aussieht? Prinzipiell ist es genauso aufgebaut wie PDO nur das man bei MySQLi noch prozedural arbeiten könnte, wenn man das wöllte. Da du aber OOP machen willst, kannst du auch gleich PHP Data Objects nehmen und machst damit sogar unabhängig von der Datenbank.

Vorausgesetzt du optimierst dein Code für alle Datenbanksysteme

Wieso optimieren? ANSI-SQL verwenden und gut ist

EDIT: Hersteller-spezifische Statements kann man auch in Stored Procedures oder Functions implementieren. Der SQL-Server ist in den meisten Fällen ohnehin damit beschäftigt, Däumchen zu drehen.