Globale Variablen vs. Parameter-Übergabe vs. neu ermitteln

[Deus Figendi]

Guten Abend,
ich habe eine recht grundsätzliche Frage dazu, wie ich bestimmte Werte in eine Funktion hinein kriege.
In meinem Fall geht es um ein recht lineares TCL-Script (naja ein paar Schleifen sind drin aber...).
Ich habe einige Variablen, die direkt von anderen abhängen ums mal einfach zu schreiben:
Wenn $X == 1 dann $Y:='a'; $Z:='b';
Wenn $X == 2 dann $Y:='c'; $Z:='d';
Wenn $X == 3 dann $Y:='e'; $Z:='f';
(denkt euch Klammern oder "begin end" oder was auch immer einfach)
Diese Zuweisung ändert sich über die gesamte Laufzeit des Programms nicht, sie wird recht früh ermittelt ($X ist btw. ein vom Nutzer übergebener Parameter) und bleibt dann immer gleich.
Nun brauche ich die Werte von Y und Z in einer Funktion und Funktionen haben die Angewohnheit in ihrem eigenen kleinen Sandkasten zu spielen, sprich ich komme an Y und Z so erstmal nicht dran.
Nun sehe ich ein paar Möglichkeiten die Dinger in die Funktion zu bringen.
Eine Variante: globale Variablen:
Funktion meineFunktion ()
 mach mir Y global
 mach mir Z global
 /* Arbeite was mit Y und Z
Ende Funktion

oder Parameter übergeben:
Funktion meineFunktion (Y Z)
 /* Arbeite was mit Y und Z */
Ende Funktion

oder eines von beiden oben und die Berechnung von Y und Z in der Funktion erledigen:
Funktion meineFunktion (X)
 Wenn $X == 1 dann $Y:='a'; $Z:='b';
 Wenn $X == 2 dann $Y:='c'; $Z:='d';
 Wenn $X == 3 dann $Y:='e'; $Z:='f';
 /* Arbeite was mit Y und Z */
Ende Funktion

Außerdem wären so Varianten möglich wie ein Gesamt-Array zu erstellen anstatt mit drei Variablen zu arbeiten, z.B. so:
Array:
Key val val
[1] 'a';'b'
[2] 'c';'d'
[3] 'e';'f'
aber auch dann stellt sich die Frage: Globalisieren oder übergeben.
(Vorteil ist, dass die Werte nicht berechnet/ermittelt werden müssen, sondern einfach festgelegt werden. Nachteil ist natürlich dass da jede Menge Daten im Array sind, die ich für die Laufzeit nicht brauche, dennoch aber Speicher belegen.)

Welches ist die sinnvollste (performanteste/geschickteste/stylishste/sauberste/whatever) Methode?

[mrjerk]

Hallo,

aber auch dann stellt sich die Frage: Globalisieren oder übergeben.

Grundsätzlich solltest Du (meiner Ansicht nach) auf globale Variablen nach Möglichkeit so gut es geht verzichten.

Der Grund ist schlichtweg Wartbarkeit und Übersichtlichkeit - in einem komplexeren Projekt ist nicht mehr überschaubar, woher plötzlich irgendwelche Werte kommen, wenn deren Variablen global sind. Plötzlich werden die Variablen an irgendeiner Stelle (möglicherweise oder besser gesagt sogar meistens versehentlich :)) geändert - die Fehlersuche kann dann ziemlich nerven-aufreibend sein.

Wenn die Variablen in irgendeiner Form fachlich zusammengehören, solltest Du sie in einer Datenstruktur kappseln (einem Array, einem Objekt, einem Hash...was auch immer TCL Dir so anbietet, dafür kenne ich mich zu wenig damit aus) - dann musst Du jeweils immer nur diese Datenstruktur übergeben.

Hope that helps,
Jörg

[dedlfix]

Hi!

ich habe eine recht grundsätzliche Frage dazu, wie ich bestimmte Werte in eine Funktion hinein kriege.

Wie fändest du es, wenn du jemandem einen Auftrag gibst, etwas zu erledigen, und der sich dazu Dinge aus deinem Umfeld nimmt und sie gegebenenfalls verändert? Du hast kein Problem damit, wirst du sagen, denn du hast ihn ja so instruiert, genau so vorzugehen. Nun kommt aber jemand anderes daher, der nicht weiß, wie diese Vorgänge bei dir so ablaufen und dass er, wenn er an diesen Jemand einen Auftrag geben will, ab bestimmte Stellen in seinem Umfeld Dinge bereitzustellen hat, damit dieser Auftrag erledigt werden kann.

Eine Funktion sollte im Idealfall autark funktionieren können. Nun ist es mitunter aufwendig, neben den eigentlichen Parametern noch allgemeine Konfigurationsparameter zu übergeben. Hier kann man zwar der Praktikabilität wegen Zugriff auf globale Dinge gewähren. Der Nachteil ist dann aber auch die Abhängigkeit, und der müssen sich alle Beteiligten Anwender der Funktion im Klaren sein.

Lo!

[hotti]

hi,

Welches ist die sinnvollste (performanteste/geschickteste/stylishste/sauberste/whatever) Methode?

Wie mrjerk schon schrieb: Globale Vars möglichst sparsam verwenden und wenns die Language hergibt, zusammenfassen (Object, struct...). Kleine Ergänzung meinerseits:

Bei Übergabe/Rückgabe in Unterfunktionen möglichst mit Referenzen arbeiten, das ist auch Hauptspeicherfreundlich gegenüber dem Anlegen von Kopien. Referenzen also auf jeden Fall bei größeren Datenmengen und Letztere auch nicht in Unterfunktionen verdoppeln. Übergaben/Rückgaben möglichst nicht von Funktion zu Funktion über mehrere Funktionen schleifen sondern die Wege kurz halten.

Tipp: Lies Dir mal die Kapitel Speicherverwaltung Deiner Programmiersprache durch (Stichworte: garbage collection). Perler habens in dieser Hinsicht relativ einfach ;-)

Viele Grüße
Horst Ramberger

[Deus Figendi]

Gut gut,
darüber welche Methode die geeignetste ist scheint ja Einigkeit zu herrschen, ich werde also jedes Mal wenn ich die Funktion aufrufe die entsprechende(n) Variable(n) mitgeben. (Hmm es sei denn ich kann im Kopf der Deklaration eine Zuweisung machen... mal probieren).
Am Meisten überzeugt hat micht

Eine Funktion sollte im Idealfall autark funktionieren können.

Ich werde es ja quelloffen publizieren bzw. habe ich schon und vielleicht recycle ich die Funktion eines Tages. Da wäre es praktisch wenn sie ohne das Programm rings herum liefe :)

[Novi]

Hallo,

nur mal so als alternative Idee. Was wäre, wenn du Methoden für die Berechnung der Werte schreibst, die du dann entsprechend Aufrufst:

  
class YZ {  
 private static X  
 private static Y  
 private static Z  
 static function setX() {  
   // Berechne Y bzw. Z und speichere sie als Eigenschaften  
 }  
 static function getY() {  
   return Y  
 }  
 static function getZ() {  
   return Z  
 }  
}  

Dann kann man zumindest den Wert für Y nicht aus Versehen ändern. Die Funktionen wären halt auf ein Objekt angewiesen, aber so etwas lässt sich wohl eh selten vermeiden.

Viele Grüße Novi