Func innerhalb Func möglich?

  • Mal eine dumme Frage: Ist es bei AutoIT möglich, eine Funktion innerhalb einer Function zu deklarieren? Ich bekomme immer eine Fehlermeldung. Ich würde aber gerne auf die, innerhalb der Funktion deklarierten (lokalen) Variablen Zugriff haben, daher hatte ich vor eine Function innerhalb einer Function zu erzeugen.

  • Dafür gibts globale Variablen oder Rückgabewerte die du mit return an die aufrufende Funktion zurückgibst. Bei mehreren Variablen / Werten gibst du eben ein Array zurück.

    Achja und die Antwort lautet "Nein" geht nicht, was du vermutlich selbst schon festgestellt hast.

  • Danke, ich hab's befürchtet! In anderen Sprachen geht das ja durchaus.

    Hintergrund: Mit Aufruf eines Menue-Items starte eine Funktion, welche eine zweites Fenster öffnet und dort mittels GUI-create eine Fenster mit vielen Controls erzeugt.
    Die Controls sind nun alle nur lokal in der entsprechenden Funktion definiert. Von ausserhalb der Funktion habe ich keinen Zugriff darauf, möchte aber auch nicht den vollständigen Code für dieses Fenster in einer Funktion halten (ist einfach zu viel).
    Natürlich könnte ich alle Cotrols wieder als Global definieren, aber ich frage mich, ob es da nicht eine bessere Möglichkeit gibt, mit dieser GUI zu interagieren.
    Habe lange im Internet gesucht, aber kein Beispiel in dieser Richtung gefunden.

  • Die Frage ist doch warum du mit dieser GUI interagieren musst und was du genau damit tun willst.

    Eine Methode wäre von Anfang an alle GUI's und deren Controls global zu erzeugen und je nach Programmzustand sichtbar oder unsichtbar zu machen. Das ist die flexiblste Veriante, da du jederzeit auf alle Controls Zugriff hast.

    Eine andere Variante wäre, dass es sich um diese zweite GUI um keine besonders relevante GUI handelt. z.B. nur um einen Einstellungsdialog. Hier kannst du problemlos die GUI temporär in einer extra Funktion jedesmal neu erstellen und die betreffenden Werte die dort hinterlegt oder geändert werden sollen in eine Konfigurationsdatei scheiben bzw. aus dieser lesen.

    Aber vielleicht hilfts auch wenn du dein Programm näher beschreibst.

  • In welcher Sprache kann man denn eine Methode in der Methode deklarieren?
    Das ergibt doch keinen Sinn und würde dem Prinzip der Modularisierung hinter der Idee der Methode widersprechen.
    Wenn man in einer OOP programmiert kann man in Objekten zwar Methoden deklarieren. Aber Objekte sind, wie der Name schon sagt, keine Methoden.

    Je nach dem (ich kenne ja deinen Code nicht) lässt sich dein Problem evtl. auch durch geschickt geschachtelte Methoden mit richtig gesetzten Paramtern lösen als Alternative zu den globalen Variablen.

    Eine Funktion dient auch nicht dazu irgendwelche Werte selbst über ihre Laufzeit hinaus zu halten. Dein Vorhaben ist, wenn ich das so richtig verstehe, dann ein schlechter Programmieransatz.

    Wenn du genauere Hilfe möchtest kommst du nicht darum herum deinen Code zu zeigen. So können wir dir nur theoretische Tipps geben.

    LG Reiterfuchs

  • Ich kenne Programmiersprachen (prozedurale) bei denen Du Funktionen innerhalb von Funktionen definieren kannst. Deren Scope ist dann identisch mit dem Scope von lokalen Variablen d.h. Variablen können nur innerhalb der Funktion und geschachtelten Funktionen angesprochen werden. Dies gilt auch für Funktionen.

  • Okay, das ist mir neu. Naja, man kann nicht alles kennen. Trotzdem entspricht das nicht dem aktuellen Stand der Technik. Ein strikt modular aufgebautes Programm ist heutzutage ja nicht ohne Grund der Standard, ob prozedural oder objektorientiert ;)

    Dennoch sind Funktionen selbst kein geeigneter Speicher für Variablenwerte. Selbstverständlich enthalten viele Funktionen eigene lokale Variablen. Diese gelten allerdings nur für einen Funktionsaufruf. Sie sind aber nicht statisch und somit werden Änderungen an diesen Wert nach dem Beenden des Funktionsdurchlaufs verworfen.

    Wenn ich einen Wert habe, der auch außerhalb des Funktionsumfangs wichtig ist halte ich diesen sicherlich nict als Variable der Funktion fest sondern parametriere sie.
    Im Falle des TE's würde ich die Variablen nicht in der Funktion festhalten, die die Controls enthält sondern übergeordnet als Globale oder als Variable einer umschließenden Mainethode. (Das Ergebnis ist in etwa das gleiche.) Die Werte würde ich als Parameter in die Funktionen übergeben und nach Beendigung der Funktion wieder zurückgeben. Dann kann ich auf anderer Ebene anschließend problemlos mit den modifizierten Werten weiterarbeiten.

    Natürlich ist eine Mainfunktion auch eine Funktion. Allerdings ist deren Umfang ja die Steuerung der Funktionsaufrufe. Somit widerspricht die Hinterlegung der Werte hier nicht den Grundsätzen der Modularisierung.

    Aber wie gesagt, ja alles nur Theorie :D

    LG Reiterfuchs

  • Wenn es wirklich so viel ist, wie hier angedeutet wird, wäre eine Fragmentierung wohl der sinnigste Weg.

    Es gibt Tage, da trete ich nicht ins Fettnäpfchen. Ich falle in die Friteuse.

  • In welcher Sprache kann man denn eine Methode in der Methode deklarieren?
    Das ergibt doch keinen Sinn und würde dem Prinzip der Modularisierung hinter der Idee der Methode widersprechen.

    So ein Konstrukt nennt man Closure und das ist ein wunderschönes Programmierkonstrukt.
    Sinnvoll ist es eben gerade für solche Fälle bei denen z.B. mehreren Events eine Callback-Funktion zugewiesen werden muss die sich nur minimal in bestimmten Werten unterscheiden.
    Die erstellte Funktion greift auf den Kontext zu der zum Zeitpunkt ihrer Erstellung geherrscht hat (der aktuelle Variablenstand in der äußeren Funktion).
    Was man erhält sind dynamische Funktionsobjekte.

    Könnte man Event-Callbackfunktionen statische Parameter mitgeben könnte man den selben Effekt erreichen - das ist aber nicht der Fall - weswegen Closures dann diese Arbeit übernehmen können.

  • Vielen Dank für die vielen Antworten und Anregungen! :thumbup:

    Ich kenne "Closures" noch aus der Zeit von Turbo Pascal (ist ja schon 25 Jahre her) und habe diese gerne eingesetzt, wenn eine Funktion nur lokal benötigt wurde, um "Routine-Aufgaben" in einer Funktion zu lösen. Der Code ist dadurch einfach besser zu strukturieren und wird übersichtlicher.

    Ich habe es nun so gelöst, dass ich die Controls auf die ich zugreifen wollte, als Global deklariert habe, der Rest (Laufvariablen, etc.) wird im Funktionskopf übergeben, bzw. per return() zurückgegeben.
    Ich öffne nur ein Fenster, um verschiedene Einstellungen vorzunehmen und das ganze dann in einer Datei (ähnlich config) abzuspeichern. Dabei fallen eine paar wiederkehrende Abläufe an, die ich in Funktionen ausgelagert habe, die ich aber eben nur für dieses Fenster benötige.

    Mit Methoden habe ich mich im Zusammenhang mit AutoIT noch nicht beschäftigt. Vielleicht wäre das ja mal ein Grund, tiefer einzusteigen.

    • Offizieller Beitrag

    Okay, das ist mir neu. Naja, man kann nicht alles kennen. Trotzdem entspricht das nicht dem aktuellen Stand der Technik.

    Wer definiert denn den "aktuellen Stand"? :whistling: Ich programmiere viel in Lua (und Lua erlaubt Funktionsdeklarationen in Funktionen) und da ist das ein echter Segen. Nicht nur die Modularisierung ist ein wichtiges Merkmal, sondern immer auch die Speicherbelastung/Ausführungsgeschwindigkeit. Und da bieten im lokalen Funktionsspace deklarierte Funktionen nun mal ein Plus an Geschwindigkeit und Verringerung der Speicherlast (in Lua). Da es in AutoIt nur Global und Lokal gibt und keine Differenzierung von Lokal in Lokal möglich ist, haben wir keine solchen Möglichkeiten.

    Wenn ich Globale Variablen vermeiden möchte, nutze ich folgende Funktion zur Verwaltung:

  • Klassen sind schon was feines für sowas :P
    Aber dafür verwende ich nen "Ableger*" von AutoIt


    *Vorsicht.. Ban Grund im Main- (Eng) Forum alleine für die Erwähnung... haha :D
    (Beide haben ihre Vor- und Nachteile und ich benutze beide)

  • Stimmt, da gibt es ein eigenes Forum wo die gebannten User aufgeführt werden die AHK erwähnt haben.
    Shit ... jetzt habe ich es selber getan :D