Zwei Methoden eines Objekts: PHP übergeht eine der beiden

[Forumsgast]

Hallohallo!

Für die Uni bastel ich im Moment an einer einfachen PHP-Seite. Die Aufgabenstellung ist die folgende: Wir sollen mithilfe objektorientierter Programmierung Daten sortieren, die in einem Formular eingegeben wurden. Zuletzt hatten wir das schon ohne Klasse gemacht; es geht halt nicht um sinnvolle Implementierung, sondern darum, das mal gemacht zu haben

Hier ist mein Code:

<?php                                
    class sortierdieelemente
    {
        /*Sortiert werden sollen die fünf
         eingegebenen Namen. Darum müssen dafür
         fünf Variablen und eine für das Array
         vorab eingeführt werden.*/
        
        public $name1;
        public $name2;
        public $name3;
        public $name4;
        public $name5;
        
        public $namen = array();
        
        /*In der Funktion sortieren() wird die
         PHP-eigene Funktion sort() aufgerufen,
         mit der die Werte des Arrays auf-
         steigend sortiert werden.*/
        
        public function sortieren($array)
        {
            sort($array);
        }
        
        /*Die Funktion ausgeben() gibt per
         foreach() jedes Element des sortierten
         Arrays aus und wird später im dann
         initialisierten Objekt der Klasse
         aufgerufen.*/
        
        public function ausgeben($array)
        {
            foreach ($array as $element)
            {
                echo "<tr><td>$element</td></tr>";
            }
        }
    }
    
    /*Das Objekt wird initalisiert.*/
    
    $arraysortierung = new sortierdieelemente;   
    
    /*Die Variablen $a bis $e dienen dazu, den
     Code übersichtlicher zu gestalten. Da sie
     in der Definition des $namen-Arrays benutzt
     werden, bietet es sich an, sie abzukürzen
     und nicht die Verweise mit ...->name zu
     verwenden.*/
    
    $a = $arraysortierung->name1=$_POST["tn1"];
    $b = $arraysortierung->name2=$_POST["tn2"];
    $c = $arraysortierung->name3=$_POST["tn3"];
    $d = $arraysortierung->name4=$_POST["tn4"];
    $e = $arraysortierung->name5=$_POST["tn5"];
    
    /*Jetzt wird das Array $namen mit Werten
     aus dem Formular gefüllt.*/
    
    $namen = $arraysortierung->namen=array($a,$b,$c,$d,$e);
    
    /*Hier sollte eigentlich sortiert werden,
     die Sortierung wird aber im Moment noch
     übergangen - warum auch immer!*/
    
    $arraysortierung->sortieren($namen);
    
    /*Die Funktion zur Ausgabe des Arrays wird
     aufgerufen.*/
    
    $arraysortierung->ausgeben($namen);
?>

Die eingegebenen Daten sind übrigens fünf Namen, die man in einem HTML-Formular vorher eingegeben hat und die mit tn1 bis tn5 benannt sind.

Das Problem ist (in den Kommentaren im Quellcode wird das ja schon deutlich), dass die Sortiermethode einfach übergangen wird. Wenn ich nur die Sortiermethode aufrufe und darin z. B. eine Überprüfung mit if implementiere, wird die Sortierung allerdings durchgeführt. Das heißt, dass irgendwie die Ausgabe die Sortierung stört offenbar.

Bei

sort($namen);
$arraysortierung->ausgeben($namen); 

funktioniert die Sortierung dann übrigens auch. Aber so wie ich die Aufgabenstellung verstanden habe, sollen das Sortieren und das Ausgeben eben zwei verschiedene Methoden sein...

Es wäre klasse, wenn mir jemand helfen könnte! Ich denke, ich hab das Problem ausführlich dargestellt und hoffe, ich hab nix vergessen. Bitte habt Nachsicht, falls es n doofer Fehler ist - ich bin noch Anfänger

Schöne Grüße,
Daniel

[Forumsgast]

das Hauptproblem is das Klassendesign. dein Code hat mit OOP überhaupt nichts zu tun. du benutzt lediglich Properties als Variablen und Methoden als Funktionen ohne auf den Sinn von Objekten (z.B. Datenkapselung) einzugehen. ich vermute mal daß das Problem mit dem Scope zusammenhängt, da die Sortierung in der Methode ja funktioniert.

nur mal ein Beispiel für eine sinnvolle Änderung:

        public function sortieren()
        {
            sort($this->namen);
        } 

[Forumsgast]

[MAN]sort[/MAN]

Schau dir mal die Signatur der Funktion genauer an:

bool sort ( array &$array [, int $sort_flags = SORT_REGULAR ] )

$array wird als Referenz entgegengenommen. (durch das &). In deiner Variante wird aber eben keine Referenz verwendet. Du sortierst damit eine lokale Kopie von $array.

public function sortieren($array)
        {
            sort($array); // <-- Hier ist $array nicht DAS $array, was du mal übergeben hast, sondern "nur" eine Kopie dessen.
        } 

[Forumsgast]

Ich weiß nicht genau was du da gemacht hast, aber OOP ist das nicht. Deine Names-Arrays haben keinerlei Bezug zu einander. Du übergibst das Array an die Funktion in der Klasse zum sortieren und arbeitest anschließend mit dem Ursprungsarray wieder, natürlich funktioniert das dann nicht.
Entweder du arbeitest mit der Referenz, dass ist der "Brezeloperator" (&) oder du setzt das Array in eine Klassenvariable.

Name1, name2, name3, usw.
Was machst du wenn du mal 100Name oder gar 1000 Namen sortieren musst? Legst du dann dem entsprechend viele Klassenvariablen an?

So was könntest du zum Beispiel machen, gut ist anders, ist aber schon mal ein Anfang:

class SortTheElements
{
    protected $_elementsIWantToSort = array();

    public function __construct(array $elements = array())
    {
        $this->setElements($elements);
    }
    
    public function setElements(array $elements = array()) {
        $this->_elementsIWantToSort = $elements;
        return $this;
    }
    
    public function sort()
    {
        sort($this->_elementsIWantToSort);
        return $this;
    }
    
    public function printItems()
    {
        foreach ($this->_elementsIWantToSort as $element)
        {
            echo "<tr><td>$element</td></tr>";
        }
    }
} 

und der Aufruf der Klasse:

$names = array();
$names[] = $_POST["tn1"];
$names[] = $_POST["tn5"];
$names[] = $_POST["tn3"];
$names[] = $_POST["tn4"];
$names[] = $_POST["tn2"];


$sortingClass = new SortTheElements();
$sortingClass->setElements($names)
    ->sort()
    ->printItems();

/*oder sowas
$sortingClass = new SortTheElements($names);
$sortingClass->sort()
    ->printItems();
*/ 

[Forumsgast]

Hallo,

herzlichen Dank für eure Hilfe. Das Beste daran: Ich hab jetzt nicht nur die Lösung, sondern vor allem auch ne Menge mehr verstanden.

Die wesentlichen Unterschiede zu meinem falschen Ansatz sind ja die Selbstreferenzierung per $this und die Sichtbarkeitsbeschränkung des Arrays in der Klasse. Sind das die Punkte, durch die sich hier das OOP auszeichnet?

Gruß,
Daniel

[Forumsgast]

Die wesentlichen Unterschiede zu meinem falschen Ansatz sind ja die Selbstreferenzierung per $this und die Sichtbarkeitsbeschränkung des Arrays in der Klasse. Sind das die Punkte, durch die sich hier das OOP auszeichnet?

1. ja (unter anderem)
2. nein, das kann dir auch bei Funktionen passieren.