duli hat geschrieben:(oder Mädels?).
... Treffer, ... versenkt.
:
duli hat geschrieben:Auf jeden Fall habe ich echt noch nicht verstanden was ihr hier diskutiert.
Deswegen finde ich solche Diskussionen zwischen zwei Parteien innerhalb eines Threads ja auch so sinnlos. Sie gehen am eigentlichen Problem bzw. der Fragestellung meist komplett vorbei und dem Fragenden helfen solche Diskussionen in keinster Weise. Aber vielleicht kriegen wir das ja jetzt mal hin.
duli hat geschrieben:Ehrlich gesagt habe ich noch nicht mal ganz verstanden wie eine Prozedur so unabhänig läuft. Theoretisch weiss ich das die Werte inerhalb einer Prozedur isolliert bleiben, aber wieso der #True wert Z.B. gefühlt ist, keine Ahnung. Oder wieso inerhalb einer Prozedur Oberflächenelemente angesprochen werden können Zeitlich unabgänig von anderen Vorgängen, verstehe ich noch nicht.
Also das mit dem "zeitlich unabhähigen" Ablaufen ist natürlich keine Grundeigenschaft aller Prozeduren.
Ein solcher unabhängiger Ablauf betrifft im Grunde nur Sonderfälle wie z.B. CallBacks oder Threads.
Aber erst mal zu den etwas einfacheren Teilen Deiner Frage:
- Sinn und Zweck von Prozeduren sowie deren Gültigkeitsbereichen:
Stell Dir vor, Du entwickeltst ein Programm. Nun könntest Du ja alle benötigten Befehle einfach untereinander schreiben (und noch mit ein paar Sprungmarken versehen um im Code auch noch vor und zurück springen zu können).
Bei größeren Projekten hat man dann aber häufig den Fall, dass man ein und dieselbe Funktion oder Berechnung an verschiedenen Stellen ausführen müsste.
Im Grunde ja kein Problem - denn die Routine mit der gewünschten Berechnung könnte man ja einfach kopieren - was wohl auch funktionieren würde.
Komplizierter wird es dann, wenn Du nachher zu dem Schluß kommst, dass Du eben in diese Berechnung eine Änderung durchführen musst. Denn dann musst Du jede einzelne Stelle in Deinem Programm wiederfinden, wo Du diese Änderung durchführen musst.
Und genau da liegt dann das Problem, da schleichen sich dann leicht Fehler ein.
Wenn Du nun jedoch statt des Duplizierens diese Berechnung in eine Prozedur packst, welche Du dann eben einfach nur x-mal aus Deinem Programm aufrufst, so hast Du später nur eine einige Stelle (eben die Prozedur), die Du ändern müsstest und alle Aufrufe greifen dann automatisch auf diese veränderte Prozedur zu. Soweit einläuchtend, oder?
- Gültigkeitsbereiche von Variablen:
Der Gültigkeitsbereich - oder wie Du es nanntest, das "isoliert bleiben" von Werten (Variablen) - wurde mal eingeführt um Programme u.A. besser modular aufbauen zu können.
Stell Dir mal vor, Du und Dein Sohn würden zusammen ein Programm entwickeln. Du würdest (sagen wir mal) den Hauptteil davon schreiben und Dein Sohn einige Prozeduren dazu, welche Du dann aus Deinem großen Hauptteil aus aufrufst. (Hauptteil ist evtl. etwas unglücklich formiliert, aber ich hoffe Du weisst was ich damit meine.)
Du benutzt dann z.B. in dem von Dir entwickelten Teil ein paar der von Anfängern so beliebten Variablen x,y,z,n oder auch m. Genausogerne benutzt Dein Sohn aber eben auch genau diese Variablen in seinem Teil des Codes - nur eben für vollkommen unterschiedliche Zwecke.
Wenn man Eure beiden Teile dann also letztendlich zusammenführen würde, so wäre die Wahrscheinlichkeit groß, dass sich Variablen gleichen Namens in die Quere kommen können und es zu unvorhersehbaren Problemen kommen kann.
Aus diesem Grunde wurden mal die äusserst geniale Geschichte mit den Gültigkeitsbereichen von Variablen eingeführt.
So kann also der Gültigkeitsbereich einer Variable z.B. nur lokal (für das Hauptprogram oder eben NUR innerhalb einer Prozedur) oder eben auch global (verfügbar im gesamten Code) sein.
Im oben beschriebenen Fall wäre also eine von Dir ein Deinem Hauptteil benutzten Variable "X" nicht im gleichen Gültigkeitsbereich wie eine von Deinem Sohn in seiner Prozedur benutzte Variable "X" und würden sich somit auch nicht "beisses".
Für weitere Feinheiten zu Gültigkeitsbereichen schaust Du am Besten mal in der PB-Hilfe nach (z.B. unter Define, Global, Protected oder auch Shared) .
Bei dem von Dir angesprochene "Wert" #True handelt es sich nicht um eine "Variable" die ja wie gerade beschrieben einen Gültigkeitsbereich haben kann, sondern eine "Konstanten".
Konstanten sind im Grunde Platzhalter, die einen bestimmten Wert representieren. Konstanten werden beim Compilieren vom Compiler durch den jeweils dafür definierten Wert ersetzt werden.
Du kannst es Dir im Grunde wie bei einer Textverarbeitung vorstellen, bei der dann z.B. alle "#True" durch eine "1" ersetzt werden.
Somit ist es also im Grunde exakt das gleiche, ob Du nun "X = #True" oder "X = 1" schreibst.
Statt einer festen Zahl solche Konstanten zu nehmen hat z.B. den Vorteil, dass der Name einer Konstante viel aussagekräftiger ist als einfach nur eine Zahl.
Stell Dir vor, Dein Sohn hätte eine Prozedur für Euer Projekt geschrieben, bei der der Benutzer 3 Antwortmöglichkeiten hat: "Ja, Nein, Abbruch".
Seine Prozedur würde Dir dann als Wert die Zahlen 1,2 und 3 für die entsprechenden Antworten zurück liefern.
Nun würdest Du in Deinem Code dann also die Zahlen 1,2, und 3 auswerten:
Wenn RückgabeWert = 1 dann mach das, ...
wenn RückgabeWert = 2 dann mach das, ...
wenn RückgabeWert = 3 dann mach das ...
Die Chanche ist groß, dass Du in einigen Wochen nicht mehr auf Anhieb weisst, wofür die Zahlen 1,2,3 standen.
Wenn Ihr aber nun ein paar Konstanten diese Wert 1,2,3 zuweist und eben dann diese Konstanten in Eurem Code benutzt, so wird die Abfrage gleich viel leichter lesbar:
=> zuerst die Definition der Konstanten:
#Antwort_Ja = 1
#Antwort_Nein = 2
#Antwort_Abbruch = 3
Auswertung:
Wenn RückgabeWert = #Antwort_Ja dann mach das, ...
wenn RückgabeWert = #Antwort_Nein dann mach das, ...
wenn RückgabeWert = #Antwort_Abbruch dann mach das ...
Sieht doch schon mal etwas mehr selbsterklärend aus, oder?
Die Verwendung von Konstanten hat aber auch noch weitere, viel essentiellere Vorteile. Deren Erläuterung würde aber momentan wohl noch etwas zu weit gehen.
Wichtig für das Verständniss ist im Grunde, dass Konstanten Platzhalter für irgend etwas (Zahlen, Zeichen, Buchstaben) sind, und diese dann vom Compiler auch durch exakt diese Zahlen, Zeichen, Buchstaben ersetzt werden - egal wo sie stehen. Konstanten sind also global und representieren überall im Code den selben Wert.
Auch kann einer Konstante nur ein einziges Mal ein Wert zugewiesen werden, der dann eben konstant bleibt. Im Gegensatz zu einer Variable, deren Inhalt ja verändert werden kann - also variabel ist.
Ich schätze das war jetzt erst mal genug Tobak um Deine Gehirnwindungen zum Qualmen zu bringen.
Ich nehme mal an, dass es klar ist dass weder dieser Beitrag noch das gesamte Forum eine umfangreiche Einführung in die Programmiereung bieten kann und auch nicht alle Aspekte bis ins Detail behandelt werden können. Von daher wäre ein gutes Buch zum Thema "Einstieg in die Programmierung mit Basic" mit Sicherheit sehr hilfreich.
Wenn Du aber das o.g. mal verdaut hast und dann noch weitere Fragen zu "unabhängig laufenden" Prozeduren oder eben "Oberflächenelementen" hast, dann kann ich Dich da ja gerne nochmal mit einigen weiteren Ausführungen quälen.
So long und gutes Gelingen .... PL.
