Funktion in der viele Variablen definiert werden

[Mr. R341]

Hi..

Ich stehe vor einer großen Frage..

auch wenn mein derzeitiges Projekt aus PHP besteht und (leider) nicht aus Python, ist dieses "Problem" auf alle Programmiersprachen anwendbar.

Man will ja schön Strukturiert Coden... Mit Funktionen, Classen, main() (@Sirius3, € __blackjack__ ), uvm.

Jetzt stehe ich vor dem Problem, dass ich ca. 32 Variablen allein in der ersten Funktion vergebe... Und mit verlaub, ich kann nicht bei jeder neuen Funktion alle Variablen erneut weitergeben... dann würde das ganze so aussehen:

function(variable1, variable2, variable3, .. , .., variable30, variable31, variable32):

Und dann kommen mit weiteren Funktionen noch mehr variablen dazu... Also klar, brauch ich nicht jede Variable in jeder Funktion, aber dennoch wären es einfach zu viele..

Wie löse ich das also schlauer? Soll ich diese Variablen einfach global setzen? Ausserhalb von Funktionen (Viele Variablen werden erst durch eine Benutzereingabe gesetzt...)?

Hier die erste Funktion die aufgerufen werden soll:

Code: Alles auswählen

function Wertermittlung(){
$DateiName = (readline("Name der neuen Datei: ") . ".svg");
$Kugelradius = (int)readline("Kugelradius: ");
$Spitzenradius = (int)readline("Radius der Spitze: ");
$VBB = 0; // viewBoxBreite 
$VBH = 0; // viewBoxHoehe
$Hoehe = (int)($Kugelradius * sqrt (3));
$AnzahlKugeln = 2;
$AnzahlZacken =  ((int)readline("Anzahl der Zacken: ") + 1);
$AnzahlZeilen = 6;
$Zeilennummer = 1;
$startx = $VBB / 2;
$starty = 0-$Hoehe+$Spitzenradius;
$OffsetLinks = (int)readline("Offset links: ");
$OffsetRechts = (int)readline("Offset rechts: ");
$arrayKugeln = array();
$AbzugX = 0;
$StammZeilen = 5;
$StammKugeln = 0;
$arrayFarben = array("38648b","2077a2","518288","991228","004a81", "768692");
$TextFarbe = readline("Farbe des Texts in Hex: ");
$Textgroesse = 0;
$animationsdauer = readline("Dauer der Animation: ");
$Pausierung = readline("Dauer der Pause: ");
$verschiebedauer = readline("Dauer der Verschiebung: ");
$Schriftart = readline("Schriftart: ");
$Text_1 = readline("Oberer Text: ");
$Text_2 = readline("Unterer Text: ");
$Spitzenfarbe = readline("Farbe der Spitze in Hex: ");
$artif = "228C41";
$Stammfarbe = readline("Farbe des Stamms in Hex: ");
$SpitzenHoehe = (int)(sqrt((($Kugelradius + $Spitzenradius) ** 2) - (($Kugelradius) ** 2)));
$x = $startx;
$y = $starty;
}

[__blackjack__]

@Mr. R341: Wenn man immer alle Variablen weitergibt ist das ja nichts anderes als globale Variablen. Man gibt natürlich nur das weiter/zurück was gebraucht wird. Und bei vielen Variablen wird man die doch sicher sinnvoll in Datenstrukturen und Objekten organisieren können.

[nezzcarth]

Man muss da verschiedene Dingen unterscheiden: Namen, die den gesamten Programmverlauf über an dasselbe Objekt gebunden bleiben, sind Konstanten. Diese Namen werden per Konvention komplett groß geschrieben und sind im Grunde der einzige allgemeien Fall, in dem es in Python üblich ist, Namen global zu definieren. Globale Namen, die an wechselnde Objekte gebunden werden ("Variablen"), gelten hingegen fast immer als extrem schlechter Stil.

Ansonsten ist ein Trick" in deinem Fall, die Daten zu gruppieren, in dem du sie nach Möglichkeit sinnvoll in geeigneten Datenstrukturen ablegst (Listen, Tupel, Dictionaries, Named-Tuple). Wenn man auf gruppierten Werten zusätzlich Operationen definieren kann, können auch Klassen ein geeignetes Instrument zur Strukturierung sein. So voluminöse Funktionssignaturen, wie du sie gezeigt hast, mahnt dir jeder Linter an; und sie sind häufig auch nicht nötig. Weiterhin sollte man auch immer nur das weitergeben, was benötigt wird. Wenn du Funktionen hast, die extrem viele Argumente haben, sind diese Funktionen häufig auch zu Anwendungs-spezifisch gestaltet und kaum allgemein wiederverwendbar.

[snafu]

So ist das nun mal beim Programmieren: Bei zunehmender Komplexität kommt man mit Spaghetti-Code nicht mehr weiter, sofern es denn übersichtlich bleiben soll.

Im ersten Schritt könnte man die Erzeugung der Variablen mit Benutzerabfragen in eine eigene Funktion stecken, sodass diese getrennt sind von den Variablen, die ohne Nutzerinteraktion erstellt werden. Dinge wie links / rechts, oben / unten, x /y lassen sich als Pärchen zusammenfassen. Berechnungen wie für $SpitzenHoehe würde man besser an späterer Stelle vornehmen.

Bei der Rückgabe wäre eine Hilfsklasse wie z.B. ein Options-Objekt denkbar, das als einfacher Namensraum dient. Dann kann man sich kleine Funktionen bauen, an die man immer nur einen Teil aus dem Options-Objekt übergibt und die jeweils einen logischen Schritt für den weiteren Ablauf übernehmen.

Das hängt natürlich alles davon ab, was genau im Anschluss passieren soll. Und warum man für die ganzen Abfragen überhaupt PHP nehmen muss, anstatt z.B. über eine entsprechende JSON-Schnittstelle zu gehen, frage ich mal besser nicht.