Gambas: Druckversion: Codierung
Apostroph als Kommentarzeichen
[Bearbeiten]Ein gutes Programm enthält erklärende Kommentare. Diese sind für andere sehr hilfreich, um ein Programm zu verstehen. Die Kommentare werden bei der Interpretation oder Compilierung des Programmes nicht berücksichtigt. Man kann also in die Kommentare im Klartext alles hineinschreiben, was man will.
Wenn Sie in Gambas eine Zeile als Kommentar eingeben wollen, dann schreiben Sie ganz an den Anfang der Zeile ein Apostroph Zeichen.
'
Sie finden das Apostrophzeichen links neben der Returntaste. Sie müssen die Rautentaste # und die Hochtaste drücken, um das Apostrophzeichen zu erzeugen. Der Tastencode für das Apostrophzeichen ist Chr(39).
In Wikibooks und Wikipedia wird das Apostrophzeichen für Fettschrift oder Kursivschrift verwendet.
Bei der Programmierung in Gambas ist im Unterschied zu VB folgendes zu beachten:
- Apostroph funktioniert
- Rem funktioniert nicht
Beispiel:
'Das ist ein Kommentar und wird beim Programmablauf nicht berücksichtigt.
Programmtests mit Kommentaren
[Bearbeiten]Das Aus- und Einkommentieren von Befehlen ist eine gute Methode, um Programme zu testen und Fehler zu beseitigen.
Sie haben z.B. eine Programmzeile folgender Art geschrieben. (Formel für die Berechnung der Kreisfläche.)
F = Pi * r * r
Da ihr Programm hier noch einen Fehler macht, kommentieren Sie die Zeile aus und versuchen, den Fehler zu finden. Ihr Code bleibt aber erhalten und Sie müssen ihn später nicht noch einmal eingeben.
Im Codefenster kann man auch mit der rechten Maustaste kommentieren und mit den Abkürzungen Strg + K und Strg + U arbeiten.
Beispielprogramm mit der Kreisberechnung. Man braucht dazu auf der Form:
- 1 Commandbutton
- 2 Textboxen
- 1 Labelfeld
Die Erste und die neunte Zeile sind auskommentiert.
' Gambas class file PUBLIC SUB Form_Open() Textbox1.Text = "" Textbox2.Text = "" Button1.Text = "Kreisberechnung mit Radius:" Label1.Text = "Fläche:" Label1.Alignment = 66 'Textausrichtung Rechts END PUBLIC SUB Button1_Click() DIM r AS Float DIM F AS Float IF Textbox1.Text = "" THEN r = 0 Textbox1.Text = Str(0) ELSE r = Val(textbox1.text) ENDIF F = Pi*(r^2) Textbox2.Text = Str(Round(F,-2)) END
Verändern Sie das Programm so, dass Sie die Zeile
F = Pi*(r^2)
auskommentieren und dafür
F = (Pi*r)^2
eingeben.
Welche Version ist richtig? Kann man auf die Klammer in der Zeile verzichten oder nicht?
F = Pi*r^2
Was bedeutet der Befehl Round in dem Programm? Schauen Sie mit F1 im Alphabetischen Befehlsverzeichnis von Gambas nach. Der Befehl rundet eine Kommazahl auf eine gewünschte Zahl von Stellen ab.
Einfache Meldung
[Bearbeiten]Eine Meldung ist sehr einfach zu programmieren. Geben Sie folgenden Code in eine leere Form ein und starten Sie das Programm.
PUBLIC SUB Form_Open() Message("Dies ist eine Meldung", "ButtonText") END
Alternativ können Sie auch folgenden Code verwenden:
PUBLIC SUB Form_Open() Message.Info("Hallo, das ist die Info Meldung", "OK") END
Meldung mit mehreren Antwortmöglichkeiten
[Bearbeiten]Neben der einfachen Message.Info gibt es vier weitere Meldungsarten:
- Message.Delete (Löschen)
- Message.Error (Fehlermeldung)
- Message.Question (Frage)
- Message.Warning (Warnmeldung)
Bei diesen Meldungsboxen sind bis zu drei Antworten möglich. Außerdem kommt ein Icon zur Anzeige:
- Delete = "Mülltonne",
- Error = "Roter Punkt mit X",
- Question = "?" Fragezeichen,
- Warning = "Gelbes Dreieck mit Ausrufungszeichen"
Beispiel
[Bearbeiten]Wie diese Meldungsboxen funktionieren zeigt folgendes Beispiel. Sie brauchen einen Button und ein Labelsteuerelement auf Ihrer Form um das Programm in gang zu bringen. Beides finden Sie in der Werkzeugkiste mit F6.
Layout
[Bearbeiten]Code
[Bearbeiten]PUBLIC SUB Button1_Click() SELECT Message.Question("Hallo, das ist die Meldung mit einer Frage! Gefällt Sie Ihnen?", "Ja", "Nein", "Weiß nicht") CASE 1 Label1.Text = "Erfreulich!" CASE 2 Label1.Text = "Bedauerlich!" CASE 3 Label1.Text = "Sie werden sie bald mögen!" END SELECT END
Das Gleichheitszeichen in Basic wird anders verwendet als in der Mathematik. Es wird als Zuweisung für eine Variable verwendet.
Man sollte wenn ein Gleichheitszeichen im Programmcode auftaucht in Gedanken immer sagen:
Es wird gleichgesetzt. Oder man sagt Fülle den Speicherplatz der Variable mit, statt ist gleich. Dann vermeidet man unlogische Folgerungen.
Folgender Code ist z.B. in Basic korrekt. Probieren Sie es aus. Was ist das Ergebnis?
a = 5 a = a * 5
Wie das in einem Programm geht, zeigt folgendes Beispiel:
PUBLIC SUB Button1_Click() DIM a AS Integer a = 5 a = a * 5 PRINT a END
Einem Mathematiker würden sich die Haare sträuben. Logischer wäre hier die Verwendung von 2 verschiedenen Variablen.
PUBLIC SUB Button1_Click() DIM a AS Integer DIM b as integer a = 5 b = a * 5 PRINT b END
Theorie der Zuweisung (Assignment)
[Bearbeiten]Folgender Code
Variable = Expression
weist den Wert eines Ausdrucks einem der folgenden Elemente zu:
- Einer lokalen Variablen (A local variable)
- Einem Funktionsparameter (A function parameter)
- Einer Globalen Klassen Variable (A global (class) variable)
- Einem Array (An array slot)
- Einer Öffentlichen Objekt Variablen (An object public variable)
- Einer Objekt Eigenschaft (An object property)
Beispiele :
iVal = 1972
Name = "Gambas"
hObject.Property = iVal
cCollection[sKey] = Name
Einfache Datentypen
[Bearbeiten]In der folgenden Tabelle werden die einfachen Datentypen von Gambas aufgelistet. Die wichtigsten sind Boolean, Integer, Float und String.
Name | Beschreibung | Speicherbedarf | Voreingestellter Wert |
---|---|---|---|
Boolean | Wahr oder Falsch | 1 byte | False |
Byte | 0 ... 255 | 1 byte | 0 |
Short | -32768 ... +32767 | 2 bytes | 0 |
Integer | -2147483648 ... +2147483647 | 4 bytes | 0 |
Float | Wie der double Datatyp in C | 8 bytes | 0.0 |
Date | Datum und Zeit, gespeichert als integer | 8 bytes | Null |
String | Ein beliebige Folge von Buchstaben. | 4 bytes | Null |
Variant | Jede Art von Datatyp | 12 bytes | Null |
Object | Eine anonyme Referenz auf ein Objekt | 4 bytes | Null |
Zusammengesetzte Datentypen
[Bearbeiten]Klassen
[Bearbeiten]Objekte
[Bearbeiten]Arrays
[Bearbeiten]Siehe Gambas: Arrays
Collections
[Bearbeiten]Umwandlung von Datentypen
[Bearbeiten]Ganz einfach
[Bearbeiten]Da den meisten Programmierern die OOP beim ersten Kontakt erhebliche Probleme bereitet, sollte man ein ganz einfaches Beispiel zum Verständnis wählen:
Bei der Programmierung von Steuerelementen für eine grafische Bedienoberfläche werden beispielsweise die Schaltflächen (Befehlsknöpfe) als Objekte einer allgemeinen Klasse Schaltfläche gehandhabt.
- Klasse Button
- Objekte
- Button1
- Button2
- etc
- Objekte
Sie arbeiten also meist schon mit Klassen und Objekten, ohne daß sie es merken.
Links
[Bearbeiten]Gambas
[Bearbeiten]- Waybackmaschine anwählen und dann suchen unter www.madeasy.de/7/prgmini.htm#klasse
Allgemein
[Bearbeiten]
Variablen
[Bearbeiten]Was sind Variablen?
[Bearbeiten]Eine Variable ist eine Größe, die verschiedene Werte annehmen kann. Sie ist also in ihrer Größe veränderlich. Variablen werden auch Platzhalter oder Unbekannte genannt. Sie kommen in Formeln und Termen vor.
Das Gegenteil einer Variablen ist die Konstante, also ein fester, unveränderlicher Wert. Die Kreiszahl Pi = 3,14... ist beispielsweise keine Variable, sondern eine Konstante.
Beispiele für Variable:
- x,y,z im kartesischen Koordinatensystem
- y = x^2
- Temperatur t
- Satz B
Für den Programmierer ist eine Variable ein Speicherbereich, auf den er (unter Beachtung des Datentyps) über einen eindeutigen Bezeichner (Namen) zugreifen kann. Das Variablen-Konzept ist der Kern der Imperativen Programmierung. Eine Variable muss in Gambas ausdrücklich deklariert werden.
Deklaration (Dimensionierung, Zuweisung des Datentyps)
[Bearbeiten]Es gibt zwei Haupttypen von Information, die in einer Variablen gespeichert werden kann: Zahlen und Text. Bevor eine Variable benutzt werden kann, muß sie zuerst erstellt werden. Das erfolgt mit dem Befehl DIM AS .
Beispiele für die Deklaration von Variablen:
DIM x AS integer DIM y AS float DIM z AS String
Man kann in einem Unterprogramm nicht dieselbe Bezeichnung für 2 verschiedene Variablen heranziehen.
Man kann Dim auch einfach weglassen:
x AS integer y AS float z AS String
Es gibt bisher keine Möglichkeit mehr als eine Variable in einer Zeile zu deklarieren:
intA, intB, intC AS Integer
Ist leider nicht möglich. Außerdem erfolgen die Deklarationen immer am Anfang eines Unterprogammes und nicht irgendwo wild im Code. Benoit ist da ganz streng. Die korrekte Deklaration von Variablen zeigt folgendes Miniprogramm
PUBLIC SUB Button1_Click() 'Deklaration x AS integer y AS float z AS String 'Zuweisung von Werten x = 2 y = 2.378 z = "Das ist eine korrekte Deklaration" 'Benutzung der Variablen print x,y,z END
Folgendes Programm dagegen ergibt eine Fehlermeldung: x already declared
PUBLIC SUB Button1_Click() DIM x AS integer DIM x AS float DIM x AS String x = 2 x = 2.378 y = "Das ist keine korrekte Deklaration" print x,x,x END
Auch im folgenden Programm gibt es Ärger, da zwischen kleinen und großen Buchstaben nicht unterschieden wird:
PUBLIC SUB Button1_Click() DIM x AS integer DIM X AS float DIM x$ AS String x = 2 X = 2.378 x$ = "Das ist eine korrekte Deklaration" print x,X,x$ END
Die Deklaration von x$ ist korrekt.
Assignment (Wertzuweisung)
[Bearbeiten]Sobald eine neue Variable erstellt worden ist, kann ihr ein Wert zum Speichern zugewiesen werden. Um dies zu tun wird der Befehl = verwendet. Die Wertzuweisung wird im Englischen Assignment genannt.
Das Beispiel weist einer Variable die als Gewicht bezeichnet einen Wert zu.
Beispiel :
Gewicht = 80
Bei der Wertzuweisung muss man eine bestimmte Reihenfolge einhalten. Erst werden die Variablen deklariert, dann kann Ihnen ein Wert zugewiesen werden:
Variablen müssen am Anfang einer Klasse, Methode oder Funktion festgelegt werden.
Beispiel korrekt:
PUBLIC SUB bla() gewicht AS Integer groesse AS Integer gewicht = 75 groesse = 176 END
Beispiel FALSCH !! (falsche Reihenfolge)
PUBLIC SUB bla() gewicht AS Integer gewicht = 75 groesse AS Integer groesse = 176 END
Das letzte Beispiel ergibt die Fehlermeldung: Unknown identifier,groesse Zeile: xx in Form1.class
Wie kann man Variablen begrenzen
[Bearbeiten]Public, Private, Static
Globale Variablen soll es nicht geben. Optional wird nur bei der Methoden Deklaration verwendet.
Public - Private
[Bearbeiten]Geben Sie folgendes kleine Programm ein und schauen Sie zu, was passiert, wenn Sie auf den Button1 clicken:
PRIVATE SUB Button1_Click() DIM Zahl AS Integer 'Erstellen einer privaten lokalen Variable Zahl = Zahl + 1 Textbox1.Text = Textbox1.Text & Zahl END
Erstaunlicherweise wird in der Textbox kein Wert ausgegeben. Das liegt an der Kennzeichnung des Unterprogrammes mit PRIVATE. Tauschen Sie den Begriff PRIVATE mit PUBLIC aus und versuchen Sie Ihr Glück noch einmal:
PUBLIC SUB Button1_Click() DIM Zahl AS Integer 'Erstellen einer oeffentlichen lokalen Variable Zahl = Zahl + 1 Textbox1.Text = Textbox1.Text & Zahl END
Jetzt wird eine 1 in der Textbox ausgegeben. Wenn Sie mehrmals den Button anklicken, erscheint die 1 mehrfach.
Variablen allgemein definieren
[Bearbeiten]Variablen lassen sich auch außerhalb von Funktionen deklarieren, hier ein Beispiel:
PUBLIC meldung AS String PUBLIC SUB Form_Open() meldung = "Dies ist ein Test" END SUB PUBLIC SUB Button1_Click() Message.Info(meldung) END
Sie brauchen einen Commandbutton auf Ihrer Form, um das Beispiel in Gang zu bringen.
Form_Open ist ein Ereignis wie Button1_Click. Der Code zu diesem Ereignis wird bereits beim Programmstart aufgerufen, wenn die Form geladen und geöffnet wird. Hier wird die Variable mit Public außerhalb eines Unterprogrammes deklariert. Diese Variable ist also so lange verfügbar, wie die Formular geladen ist.
Ersetzen Sie den Begriff PUBLIC durch den Begriff PRIVATE und probieren Sie das Ergebnis aus.
PRIVATE meldung AS String PRIVATE SUB Form_Open() meldung = "Dies ist ein Test" END SUB PRIVATE SUB Button1_Click() Message.Info(meldung) END
Static (Statische Variable)
[Bearbeiten]Manchmal soll der Wert einer Variablen erhalten bleiben. Ruft man die Variable wieder auf, kann mit dem gemerkten Wert der Variablen weiter gearbeitet werden. Um dies zu ermöglichen gibt es den Deklarationsbefehl Static.
Wie er funktioniert zeigt folgendes Beispiel. Sie brauchen einen Befehlsknopf auf Ihrer Form um es in Gang zu bringen.
Static Public x As integer Public Sub Button1_Click() x = x + 1 print x End
Drückt man den Befehlsknopf wird erst x als 0 definiert. Dann wird in der Zeile x = x + 1 zur 0 die 1 dazugezählt. Mit Print x wird das Ganze im Direktfenster ausgegeben. Drückt man den Befehlsknopf mehrfach, dann erkennt man, daß das Programm sich den Wert für x gemerkt hat.
Ausgabe im Direktfenster:
1 2 3 4 5
Das Wort Static sorgt dafür, daß der Wert einer Variablen nicht einfach verschwindet. Wird sie ein zweites Mal aufgerufen, steht automatisch der alte Wert wieder zur Verfügung.
Versuchen Sie folgende Variante:
Public Sub Button1_Click() x As integer x = x + 1 print x End
Drücken Sie den Befehlsknopf mehrfach. Welche Ausgabe ergibt sich?
1 1 1 1
Die Unterfunktion setzt den Wert der Variablen immer wieder auf Null zurück. Beachten Sie das die statische Variable im Gegensatz zu Visual Basic außerhalb des Unterprogrammes definiert werden muß.
Wären Sie enttäuscht, wenn das ganze auch ohne Static und Public funktioniert? Probieren Sie folgenden Code aus:
x As integer Public Sub Button1_Click() x = x + 1 print x End
Globale Variablen in Gambas
[Bearbeiten]Benoit Minsini mag sie nicht. Aber sie sind möglich und m.E. auch ganz praktisch.
Siehe Gambas:_Form#Globale_Variablen_in_Gambas
Eine andere Möglichkeit über den Umgang mit globalen Variablen zeigen die nachstehenden Beispiele:
In einem umfangreichen Gambas Projekt werden mehrere Formen und Module verwendet. Globale Variablen, die für das gesamte Projekt gelten, gibt es in Gambas nicht. Es ist jedoch sinnvoll von Formen oder Modulen auf die Variablen anderer Formen oder Module zugreifen zu können. Wie das funktioniert wird nachstehend gezeigt. Wir benötigen eine Form mit einem Befehlsknopf und einem Textfeld als Ergebnisanzeige. Des weiteren benötigen wir ein Modul, in dem mit den Variablen aus der Form gerechnet wird.
Auslesen von öffentlichen Variablen in einer Form1 aus einer Prozedur in einem Modul.
Programmcode der Form1:
PUBLIC a AS Float PUBLIC b AS Float ' Die Variablen sind öffentlich und sind gültig in allen Prozeduren und Funktionen in der Form1. PUBLIC SUB Button1_Click() DIM c AS Float ME.Text ="Beispiele" a = 3.2 b = 7.4 c = Module1.RechnenVariable() textbox1.Text = Str(c) END
Programmcode von Module1:
PUBLIC FUNCTION RechnenVariable() AS Float DIM c AS Float c = form1.a + form1.b RETURN c END
Bei Betätigung der Befehlsschaltfläche werden zunächst den Variablen a und b Werte zugewiesen. Mit dem Aufruf der Function RechenVariable in Module1 werden die Werte der Variablen a und b der Form1 ausgelesen, dann addiert und als Rückgabewert der Function wieder an die aufrufende Prozedur Sub Button1 zurückgegeben. Das Ergebnis wird in der Textbox1 als Float-Variable ausgegeben.
Genau so einfach wie das Auslesen der Variablen ist das Zuweisen von Werten für die Variablen a und b der Form1 über eine Prozedur von Module1.
Programmcode der Form1:
PUBLIC a AS Float PUBLIC b AS Float PUBLIC SUB Button1_Click() ME.Text ="Beispiele" Module1.RechnenVariable() textbox1.Text = Str(a + b) END
Programmcode von Module1
PUBLIC SUB RechnenVariable() form1.a = 10.2 form1.b = 2.5 END
Etwas komplizierter ist das Auslesen von Variablen aus einem Array, da das Ansprechen der Arrayvariable aus dem Modul mit dem Code c = form1.a[5] nicht funktioniert. Daher wird in Form1 eine öffentliche Prozedur programmiert, die auf das Array zugreifen kann. Zum Auslesen des Array wird von dem Modul auf diese öffentliche Prozedur zugegriffen. Hier ist der Code für die Form1:
d[10] AS Float ' das Array wird ohne PUBLIC deklariert. Mit Public d[10] AS Float gibt Gambas eine Fehlermeldung aus. ' ein Array kann nur im Kopf von Formen deklariert werden. Bei der Deklaration im Kopf von 'Modulen gibt Gambas ebenfalls eine Fehlermeldung aus. ' Die Zählung für den Arrayinhalt beginnt bei 0 (d[0] = ..), während die Zählung für die Deklaration bei 1 beginnt ' Das Array ist öffentlich und ist gültig in allen Prozeduren und Funktionen der Form1. PUBLIC SUB Form_Open() DIM i AS Integer ME.Text ="Beispiele" FOR i = 0 TO 9 d[i] = i * 1.2 'Array wird mit willkürlichen Werten gefüllt. NEXT END PUBLIC FUNCTION d_aus (x AS Integer) AS Float DIM wert AS Float wert = d[x] RETURN wert END PUBLIC SUB Button1_Click() DIM c AS Float c = Module1.RechnenArray() textbox1.Text = Str(c) END
Programmcode von Module1:
PUBLIC FUNCTION RechnenArray() AS Float DIM c AS Float c = form1.d_aus(2) + form1.d_aus(5) RETURN c END
Zunächst wird in der Prozedur Open() das Array mit Werten gefüllt. Mit dem Aufruf der Function RechenArray in Module1 wird zweimal die Function d_aus in der Form 1 aufgerufen und die Inhalte von d[2] bzw. d[5] ermittelt und an die Funktion Rechenarray zurückgegeben. Dort werden sie dann adddiert und als Rückgabewert der Function Rechenarray wieder an die aufrufende Prozedur Sub Button1 zurückgegeben. Das Ergebnis wird in der Textbox1 als Float-Variable ausgegeben.
Das Zuweisen von Werten für das Array erfolgt ähnlich. Anstatt Funktionen werden in diesem Beispiel Prozeduren benötigt, da die Werte übergeben und nicht ausgelesen werden. Der dafür erforderliche Code für die Form1 lautet:
d[10] AS Float PUBLIC SUB Form_Open() DIM i AS Integer ME.Text ="Beispiele" FOR i = 0 TO 9 d[i] = i * 1.2 'Array wird mit willkürlichen Werten gefüllt. NEXT END PUBLIC SUB d_ein (wert AS Float, x AS Integer) d[x] = wert END PUBLIC SUB Button1_Click() DIM c AS Float Module1.RechnenArray() textbox1.Text = Str(d[5]) END
Programmcode von Module1:
PUBLIC SUB RechnenArray() DIM wert AS Float wert = 12.7 form1.d_ein (wert, 5) '5 ist willkürlich gewählt END
Bei einem zweidimensionalen Array lautet der Code der Form1 für das Auslesen von Werten:
d[10,5] AS Float PUBLIC SUB Form_Open() DIM i AS Integer DIM j AS Integer ME.Text ="Beispiele" FOR i = 0 TO 9 FOR j = 0 TO 4 d[i,j] = i * 1.2 + j 'Array wird mit willkürlichen Werten gefüllt. NEXT NEXT END PUBLIC FUNCTION d_aus (x AS Integer, y AS Integer) AS Float DIM wert AS Float wert = d[x,y] RETURN wert END PUBLIC SUB Button1_Click() DIM c AS Float c = Module1.RechnenArray() textbox1.Text = Str(c) END
Programmcode von Module1:
PUBLIC FUNCTION RechnenArray() AS Float DIM c AS Float c = form1.d_aus(5,2) + form1.d_aus(8,4) RETURN c END
Bei einem zweidimensionalen Array lautet der Code der Form1 für die Übergabe von Werten:
d[10,5] AS Float PUBLIC SUB Form_Open() DIM i AS Integer DIM j AS Integer ME.Text ="Beispiele" FOR i = 0 TO 9 FOR j = 0 TO 4 d[i,j] = i * 1.2 + j 'Array wird mit willkürlichen Werten gefüllt. NEXT NEXT END PUBLIC SUB d_ein (wert AS Float, x AS Integer, y AS Integer) d[x,y] = wert END PUBLIC SUB Button1_Click() Module1.RechnenArray() textbox1.Text = Str(d[5,2]) END
Programmcode von Module1:
PUBLIC SUB RechnenArray() DIM wert AS Float wert = 12.7 form1.d_ein (wert, 5,2) '5 und 2 sind willkürlich gewählt END
In allen Beispielen wurde mit Fließkommazahlen experimentiert. Durch geringfügige Änderungen der Prozeduren und Funktionen kann natürlich auch mit Integervariablen, mit Strings, mit Datevariablen oder auch mit Booleanvariablen gearbeitet werden. Es ist auch nicht kompliziert auf die Inhalte von Textboxen zuzugreifen, die Textboxen mit Inhalten zu füllen oder auch Labeltexte auszulesen oder zu ändern.
Im folgenden werden einige Befehle beschrieben, mit denen man Variablen von einer Formatierung in eine andere umwandeln kann. Wichtig sind vor allem die Befehle Val,Str,Chr,Asc und Int.
val
[Bearbeiten]Wie man Strings (Textfolgen) mit Val() umwandelt.
Der Befehl Val() wandelt einen String ( = Folge von Asciizeichen) in einen Datentyp um, der dem Inhalt des Strings entspricht.
Wenn der String ausschaut wie eine Fließkommazahl, dann macht Val() eine Fließkommazahl daraus. Val() benutzt die lokale Sprache ihrer Maschine ( hier also deutsch ), die in "locales" festgelegt wurde. Sie können Ihre Einstellung mit folgendem Konsolenbefehl überprüfen:
"locales" oder "echo $LANG".
Auf einer deutschen Maschine erhält man : de_DE@euro Vorsicht: Mit Kommazahlen und der Ländereinstellung !! Steht in einer Textbox1 6,6 mit deutscher Ländereinstellung, dann liefert
val(textbox1.text)
eine Floatvariable mit dem Wert 6.6
Steht in der Textbox 6.6 dann liefert val(textbox1.text) ein Datum 06.06.04 Wollen Sie die Zahl wieder in einen deutschen Text verwandeln, dann nutzen Sie str(zahl) zum umwandeln.
Das Programm
Wenn Sie einen string eingeben dann wandelt das Programm den String mit val um und die Art der umgewandelten Variable wird überprüft.
Das Ergebnis wird ausgegeben.
Um das Programm in Gang zu bringen brauchen Sie auf Ihrer Form:
- 1 Command Button
- 1 Textlabelfeld
- 1 Textbox
- 1 Labelfeld
Holen Sie sich diese mit F6 aus dem Werkzeugkasten und platzieren Sie diese auf der Form.
Der Code:
PUBLIC SUB _new() TextLabel1.Text="Tippen Sie etwas ein das wie eine Zahl oder eine Kommazahl oder eine Boolesche Variable ausschaut" END PUBLIC SUB Button1_Click() x AS Variant x = Val(TextBox1.Text) IF IsBoolean(x) THEN Label1.Text="Das ist eine Boolesche Variable!" ENDIF IF IsInteger(x) THEN Label1.Text="Das ist eine Zahl!" ENDIF IF IsFloat(x) THEN Label1.Text="Das ist eine Kommazahl!" ENDIF IF IsString(x) THEN Label1.Text="Das ist ein String!" ENDIF END
Theorie Expression = Val ( String ) Converts a string into a boolean, a number or a date, according to the content of the string. The current localization is used to convert numbers and dates. The conversion algorithm is the following : If the string can be interpreted as a date & time (with date or time separators), then the date & time is returned. Else, if the string can be interpreted as a floating point number, then this floating point number is returned. Else, if the string can be interpreted as a integer number, then this integer number is returned. Else, if the string is TRUE or FALSE , then the matching boolean value is returned. Otherwise, NULL is returned.
Beispiel
PRINT Val("09/06/72 01:00")
=> 09/06/72 01:00:00
PRINT Val("3.1415")
=> 3.1415 oder 31415 je nach Ländereinstellung
PRINT Val("6.6")
=> 6.6 oder 06.06.04 je nach Ländereinstellung !!
PRINT Val("-25")
=> -25
PRINT Val("True")
=> True
PRINT IsNull(Val("Gambas"))
=> True
str$
[Bearbeiten]Str ist das genaue Gegenteil des Val Befehles. Str wandelt also alles in einen String um. Wenn Sie zb eine Zahl errechnet haben zb die Wurzel aus 3 und sie möchten diese in einer Textbox ausgeben , dann können Sie den Str Befehl nutzen:
Textbox1.text = str$(sqr(3))
Vorsicht: Auch der Str Befehl nutzt wieder die lokalen Einstellungen ihres PCs , was Anlass für Fehler sein kann.
Schauen Sie sich das folgende einfache Beispiel an. Sie brauchen eine Textbox und einen Commandbutton auf Ihrer Form um es in Gang zu bringen:
PUBLIC SUB Button1_Click() textbox1.Text = Str(Sqr(3)) END
Der Befehl sqr zieht die Wurzel aus einer Zahl. Statt der 3 in der Klammer nach Sqr können Sie jede andere positive Zahl oder 0 eingeben. Wenn Sie eine negative Zahl eingeben , dann erscheint eine Fehlermeldung: Mathematic Error
Ein weiteres Beispiel:
PUBLIC SUB Button1_Click() textbox1.Text = Str( 8 * 37) END
Das Sternchen entspricht dem deutschen Zeichen für Malnehmen ( Multiplikation)
Oder probieren Sie einmal folgenden Code:
PUBLIC SUB Button1_Click() textbox1.Text = Str(Pi) END
In den Beispielen mit den Rechentrainern wird der Val und der Str Befehl mehrfach genutzt.
Siehe Gambas: Rechentrainer
Das Beispiel aus der Hilfefunktion von Gambas ist für Anfänger ziemlich unverständlich:
' Ausgabe in der Standard Ausgabe oder als Meldung PUBLIC CONST ON_STDOUT AS Integer = 1 PUBLIC CONST ON_MESSAGE AS Integer = 2 SUB PrintOn(Where AS Integer, What AS Variant) IF Where = ON_STDOUT THEN PRINT What ELSE IF Where = ON_MESSAGE THEN Message(Str$(What)) ENDIF END
asc
[Bearbeiten]Asc gibt den ASCII code eines Buchstabens oder Zeichens zurück. Wenn die Position nicht angegeben wird, dann wird der ASCII code des ersten Zeichens zurückgegeben.
Syntax = Asc ( String [ , Position ] )
Beispiel:
PRINT Asc("Gambas")
=> Ausgabe 71
PRINT Asc("Gambas", 3)
=> Ausgabe 109
Beispiel 2 Sie brauchen einen Befehlsbutton um es in Gang zu bringen. Die Ausgabe erfolgt mit Print im Direktfenster.
PUBLIC SUB Button1_Click() x as integer For x = 1 to 6 PRINT Asc("Messer", x) next END
Ein Beispiel im Terminalmodus :
STATIC PUBLIC SUB Main() test AS String x AS Integer test = "1234567 Dies ist ein Test" FOR x = 0 TO Len(test) PRINT Asc(test,x) NEXT END
chr$
[Bearbeiten]Dieser Befehl gibt das Ascii Zeichen zurück, welches der Zahl in Klammern entspricht.
Zeichen = Chr$ ( Zahl )
Vorsicht ! Gambas nutzt intern das UTF-8 charset, so daß Zahlen > 128 andere Zeichen zurückgeben wie mit dem ISO8859-1 charset zu erwarten sind.
Beispiel:
PRINT Chr$(65)
==> A
Weiteres Beispiel, Sie brauchen einen Befehlsbutton um es in gang zu bringen. Die Ausgabe erfolgt mit Print im Direktfenster.
PUBLIC SUB Button1_Click() X AS Integer FOR X = 32 TO 127 PRINT Chr$(X); NEXT END
Mit einer Schleife werden alle Zeichen zwischen 32 und 127 hintereinander in einer Zeile ausgegeben. Siehe http://www.madeasy.de/7/prgansi.htm
Im reinen Terminalmodus können Sie folgendes Programm als Beispiel ausprobieren:
STATIC PUBLIC SUB Main() x AS Integer FOR x = 30 TO 133 PRINT x,Chr(x) NEXT PRINT PRINT "Zeilenumbruch CHR(10)", Chr$(10) PRINT "Return CHR(13)", Chr$(13) PRINT "Leerzeichen Chr$(32)", "a";Chr$(32);"a" PRINT "0 CHR48", Chr$(48), Str(0) PRINT "9 CHR57", Chr$(57), Str(9) PRINT "@ CHR64", Chr$(64), Str("@") PRINT "A CHR65", Chr$(65), Str("A") PRINT "Z CHR90", Chr$(90), Str("Z") PRINT "a CHR97", Chr$(97), Str("a") PRINT "z CHR122", Chr$(122), Str("z") PRINT "A" + "A" PRINT "A" & "A" END
int
[Bearbeiten]Der Befehl Int ( Integer = ganze Zahl) gibt die ganze Zahl zurück, die unterhalb einer Kommazahl steht.
3,1 ==> 3
Vergleiche auch den Befehl Fix Der Befehl wird gerne beim Runden benutzt.
Beispiel
PRINT Int(Pi)
=> 3
PRINT Int(-Pi)
=> -4
Beispiel: Sie brauchen einen Commandbutton. Die Ausgabe erfolgt im Direktfenster
PUBLIC SUB Button1_Click() x AS Integer a AS Float a = -3.456 FOR x = 1 TO 10 a = a + 1 PRINT a, Int(a) NEXT END
Beachten Sie, daß die Kommazahl hier im Code in der englischen Notation mit einem Punkt eingegeben werden muß !
a = -3.456
Ergebnis :
-2,456 -3 -1,456 -2 -0,456 -1 0,544 0 1,544 1 2,544 2 3,544 3 4,544 4 5,544 5 6,544 6
fix
[Bearbeiten]Der Befehl fix liefert den Ganzezahlteil einer Kommazahl. Alles was vor dem Komma steht bleibt erhalten, was hinter dem Komma steht wird weggeschnitten. Vergleichen Sie auch den Befehl Int.
Syntax:
Value = Fix ( Number )
Einfache Beispiele :
PRINT Fix(Pi)
=> 3
PRINT Fix(-Pi)
=> -3
Programmbeispiel: Sie brauchen einen Commandbutton um es in Gang zu setzen.
PUBLIC SUB Button1_Click() x AS Integer a AS Float a = -3.456 FOR x = 1 TO 10 a = a + 1 PRINT a, Fix(a) NEXT END
Ergebnisausgabe im Direktfenster:
-2,456 -2 -1,456 -1 -0,456 0 0,544 0 1,544 1 2,544 2 3,544 3 4,544 4 5,544 5 6,544 6
sgn
[Bearbeiten]Die Signum Funktion liefert einen Wert, der für das Vorzeichen einer Zahl steht.
Syntax Sgn(Zahl)
Anmerkungen Das Argument Zahl kann ein beliebiger zulässiger numerischer Ausdruck sein. Dessen Vorzeichen bestimmt den von der Sgn-Funktion ausgegebenen Wert:
- Ist die Zahl > 0 liefert Sgn(Zahl) den Wert 1.
- Ist die Zahl = 0 liefert Sgn(Zahl) den Wert 0.
- Ist die Zahl < 0 liefert Sgn(Zahl) den Wert -1.
Beispiel: Sie brauchen dafür nur eine leere Form. Die Ergebnisausgabe erfolgt im Direktfenster.
PUBLIC SUB Form_Open() x AS Integer y AS Float FOR x = 1 TO 100 y = Rnd(-5, 5) SELECT CASE Sgn(y) ' ...auswerten. CASE 0 ' Wenn Zahl null. PRINT y &" " & Sgn(y) & " Signum = Null." CASE 1 ' Wenn Zahl positiv. PRINT y &" " & Sgn(y) & "Signum = positive Zahl." CASE -1 ' Wenn Zahl negativ. PRINT y & " " & Sgn(y) & "Signum = negative Zahl." END SELECT NEXT END
Beispiel 2
bst
[Bearbeiten]cbool
[Bearbeiten]Dieser Befehl wandelt einen Ausdruck in eine Boolesche Variabel ( wahr,falsch) um.
Syntax;
Boolean = CBool (Ausdruck)
Das Ergebnis wird falsch, falls der Ausdruck:
- eine Boolesche Variable mit dem Wert falsch ist.
- eine Null ist.
- ein Textstring mit Länge Null ist zb a = ""
- ein Null Objekt ist.
In allen anderen Fällen ist der Ausdruck wahr. Auch ein Leerzeichen als Textstring ergibt mit CBool umgewandelt den Wert True !
Beispiel :
PRINT CBool(0);" "; CBool(1)
=> False True " " funktioniert hier nur als Abstandshalter bei der Ergebnisausgabe.
PRINT CBool("Gambas"); " "; CBool("")," "; CBool(" ")
=> True False True
PRINT CBool(NULL)
=> False
cbyte
[Bearbeiten]cdate
[Bearbeiten]cfloat
[Bearbeiten]cstr
[Bearbeiten]cint
[Bearbeiten]Einfache Arrays
[Bearbeiten]Siehe auch: http://www.madeasy.de/7/prgmini.htm#arr
Arrays sind Listen oder Tabellen, in die man zusammengehörige Texte oder Werte vom selben Dateityp abspeichert. Jedes Element des Arrays ist einzeln ansprechbar.
Beispiel eines Arrays: Liste von 5 Vornamen
- Anna
- Anton
- Toni
- Max
- Klaus
Um Arrays zu definieren, reicht kein einfaches Ist-Gleich-Zeichen, sondern man braucht eine besondere Deklaration: Um eine Namensliste , wie die obige, in Gambas zu bekommen, nimmt man am besten einen Stringarray (Textarray):
Beispiel:
PUBLIC SUB Form_Open() a AS String[] x AS Integer a = NEW String[] FOR x = 0 TO 4 a.Add(Str(x)) NEXT a[0] = "Anna" a[1] = "Anton" a[2] = "Toni" a[3] = "Max" a[4] = "Klaus" FOR x = 0 TO 4 PRINT a[x] NEXT END
Um dieses Beispielprogramm in Gang zu bringen brauchen Sie nur eine leere Form. Das Programm gliedert sich in 4 Teile:
- 1. Ein Stringarray wird deklariert.
a AS String[]
- 2.Der Stringarry wird initialisiert.
DIM x AS Integer a = NEW String[] FOR x = 0 TO 4 a.Add(Str(x)) NEXT
- 3.Der Stringarray wird mit echten Elementen gefüllt:
a[0] = "Anna" a[1] = "Anton" a[2] = "Toni" a[3] = "Max" a[4] = "Klaus"
- 4.Um zu Überprüfen, ob die Elemente wirklich im Array gespeichert wurden, werden sie dann wieder mit einer Schleife und dem Printbefehl im Direktfenster ausgegeben.
FOR x = 0 TO 4 PRINT a[x] NEXT
Das erscheint reichlich kompliziert oder was meinen Sie ? Es geht auch etwas einfacher, wenn man den Array Befehl nutzt. Dies ist im nächsten Kapitel beschrieben.
Erstaunlicherweise funktioniert das obige Programm nur im Grafikmodus. Aber vielleicht fehlt mir auch nur ein Trick um es im Terminalmodus zu ermöglichen. Außerdem ist die Deklaration ziemlich umständlich. a = NEW String[5] funktioniert nicht.
Man kann die einzelnen Elemente über ihre Position im Array ansprechen, wobei das erste Element die Position 0 hat:
Benennung der Einträge
a[0] = "Anna" a[1] = "Anton" a[2] = "Toni" a[3] = "Max" a[4] = "Klaus"
Um den Namen Max ausgeben zu lassen, muß man dann schreiben:
print a[3]
Beachten Sie bitte das a kein Element von Gambas ist , sondern oben im Beispielprogramm als Array definiert wurde.
Die eckigen Klammern sind hier nicht wie üblich bei Computertexten optionale Angaben, sondern man muß bei Arrays wirklich eckige Klammern verwenden.
Der Index eines Arrays beginnt immer bei 0, somit ergeben sich die gültigen Indizes bei einem Array der Größe n: 0, 1, 2, ..., n-1.
Der Umgang mit Arrays ist für Anfänger sehr gewöhnungsbedürftig. Trotzdem lohnt es sich, sich mit den verschiedenen Arten und Programmiermöglichkeiten von Arrays vertraut zu machen, denn sie machen die Programme übersichtlicher und kürzer. Insbesondere bei der Programmierung von Datenbanken oder Tabellen sind Arrays unverzichtbar.
Neben dem hier gezeigten Stringarray kann man auch für jeden anderen Dateityp ein Array definieren. Es gibt also Binärarrays, Textarrays, Ganzzahlenarrays, Arrays für Fließkommazahlen etc etc. Sogar für zusammengesetzte Dateitypen wie zb Objekte kann man Arrays verwenden.
Die Elemente eines Arrays haben dabei alle denselben Dateityp. Will man auch noch den Dateityp in der Liste variieren, dann muß man statt eines Arrays eine Collection heranziehen.
Schneller füllen mit dem Arraybefehl
[Bearbeiten]Der Arraybefehl verkürzt das obige Programm enorm. Mit ihm kann man ein Array viel schneller füllen.
Wie das geht zeigt folgendes Beispiel. Sie brauchen nur eine leere Form um es in Gang zu bringen:
PUBLIC SUB Form_Open() x AS Integer a AS String[] a = Array("Anna","Anton","Toni","Max","Klaus") FOR x = 0 TO 4 print a[x] 'Ausgabe des Arrays im Direktfenster NEXT END
Wollen Sie die Ausgabe nicht in das Direktfenster umleiten, dann fügen Sie Ihrer Form eine Textarea hinzu und ändern den Code folgendermassen:
PUBLIC SUB Form_Open() x AS Integer a AS String[] a = Array("Anna","Anton","Toni","Max","Klaus") Textarea1.Text = "" FOR x = 0 TO 4 Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
Das Zeichen chr(10) fügt einen Zeilenwechsel zwischen die Namen. Mit Textarea1.Text = "" wird die Textarea am Start gelöscht.
Einfache Arrayroutinen
[Bearbeiten]Erzeugung
[Bearbeiten]Es soll ein Integer Array mit 20 Elementen erzeugt werden. Dazu nutzen sie folgende Zeile:
feld [20] AS Integer
Etwas umständlicher geht das auch so:
feld AS NEW Integer[] i AS Integer FOR i = 0 TO 19 feld.Add(i) NEXT
Zu beachten ist jedoch, das jeder Array mit [0] beginnt. So ist das letzte Element feld[19] (0 bis 19 = 20 Elemente). Laut der Deklaration feld [20] AS Integer wäre zu vermuten, das auch das Element feld[20] einen Wert hat. Das stimmt aber nicht, es liegt bereits außerhalb der Deklaration (out of Bound).
Operationen mit Elementen
[Bearbeiten]Mit Arrayelementen können alle Operationen wie gewohnt ausgeführt werden. Beispiel:
feld[2] = 77 feld[3] = feld[2] - 7
Die erste Zeile weist dem 3. (dritten!) Element des Arrays die Zahl 77 zu. Die zweite Zeile weist dem 4. (vierten!) Element des Arrays die Zahl 77 - 7 = 70 zu.
Index
[Bearbeiten]Als Index kann eine Variable oder Konstante angegeben werden:
n as integer n = 1 feld[n] = 25
Dieser Code weist dem n-ten Element (dem 2.) den Wert 25 zu.
Als Programm:
PUBLIC SUB Form_Open() feld[4] AS Integer n AS Integer feld[2] = 77 feld[3] = feld[2] - 7 n = 1 feld[n] = 25 FOR n = 0 TO 3 PRINT feld[n] NEXT END
Ausgabe im Direktfenster:
0 25 77 70
Wenn Sie print feld[4] eingeben, erscheint die Fehlermeldung: Out of bounds
Probieren sie noch einmal folgende Variante, dann wird es vielleicht klarer:
PUBLIC SUB Form_Open() feld[4] AS Integer 'Deklariert das Zahlenarry feld[0 bis 3] !!! n AS Integer feld[2] = 77 feld[3] = feld[2] - 7 n = 1 feld[n] = 25 FOR n = 0 TO 3 PRINT "feld[" & n & "] = " & feld[n] NEXT 'PRINT feld[4] ergibt einen Fehler !!! END
Mehrere Dimensionen
[Bearbeiten]Weiterhin können Arrays mit mehr als einer Dimension erzeugt werden.
schachbrett[10, 10] AS Integer
Erzeugt ein 2-Dimensionales Integer-Feld der Größe 10 x 10.
Als Programmbeispiel:
PUBLIC SUB Form_Open() i AS Integer n AS Integer schachbrett[10, 10] AS Integer FOR i = 0 TO 9 FOR n = 0 TO 9 PRINT i, n schachbrett[i, n] = i*10 + n PRINT schachbrett[i, n] NEXT NEXT END
Fehler mit Arrays
[Bearbeiten]Beispiel 2:
In diesem Beispiel wird ein Stringarray definiert und am Anfang mit fortlaufenden Zahlen gefüllt. Dabei entspricht die jeweilige Zahl der Position im Array. Bei der zweiten Füllung des Arrays ist das nicht mehr der Fall. Jetzt ist das Array mit Quadratzahlen gefüllt worden.
Um das Programm in Gang zu bringen , brauchen Sie 2 Befehlsbuttons und ein Textlabelfeld.
ar AS String[] 'Der array wir als String definiert PUBLIC SUB Button1_Click() ' Der Array wird ausgegeben i AS Integer txt AS String ar = NEW String[] FOR i = 0 TO 3 ar.Add(Str(i)) NEXT FOR i = 0 TO 3 txt = txt & ar[i] NEXT TextLabel1.Text = txt END PUBLIC SUB Button2_Click() 'Der array wird neu gefüllt a AS Integer i AS Integer txt AS String ar = NEW String[] FOR a = 0 TO 3 ar.Add(Str(a*a)) NEXT FOR i = 0 TO 3 txt = txt & ar[i] NEXT TextLabel1.Text = txt END
Auch diese Programm können Sie mit dem Arraybefehl verkürzen:
ar AS Integer[] 'Der array wir als Zahlenliste definiert PUBLIC SUB Button1_Click() 'Der Array wird gefüllt und ausgegeben i AS Integer txt AS String ar = Array(0,1,2,3) FOR i = 0 TO 3 txt = txt & ar[i] NEXT TextLabel1.Text = txt END PUBLIC SUB Button2_Click() 'Der array wird mit den Quadratzahlen der ersten Füllung erneut gefüllt a AS Integer i AS Integer txt AS String ar = Array(ar[0]^2,ar[1]^2,ar[2]^2,ar[3]^2) FOR i = 0 TO 3 txt = txt & ar[i] NEXT TextLabel1.Text = txt END
Vorsicht! Diese Programm funktioniert nur einmal richtig. Beim zweiten Programmlauf erfolgt eine Fehlermeldung.
Type mismatch: Wanted Integer[], got float[] instead.
Die Schachtelung des Arrays ist also fehlerträchtig:
ar = Array(ar[0]^2,ar[1]^2,ar[2]^2,ar[3]^2)
Als Übung können Sie ein Array aller kleinen Buchstaben des Alphabets aufstellen:
Beispiel 3: Ein 3-dimensionales Array
Um das Programm in Gang zu bringen brauchen Sie eine Form und einen Befehlsbutton.
PUBLIC SUB Button1_Click() DIM i AS Integer DIM ii AS Integer DIM iii AS Integer DIM Matrix[3, 3, 3] AS Integer FOR i = 0 TO 2 FOR ii = 0 TO 2 FOR iii = 0 TO 2 PRINT i, ii , iii Matrix[i, ii, iii] = i*9 + ii*3 + iii PRINT Matrix[i, ii, iii] NEXT NEXT NEXT END
Split >> Zerlegt einen Text in ein Stringarray mit lauter einzelnen Elementen
[Bearbeiten]Der Befehl Split zerlegt einen Textstring in kleine Textteile, die durch ein bestimmtes Trennzeichen abgegrenzt sind.
Die Syntax des Befehls lautet:
Array = Split ( Text [ , Trennzeichen , Nichttrennen ] )
Benutzt man den Befehl ganz einfach nur mit der Angabe für Text, dann wird als Trennzeichen das Komma verwendet.
Array = Split(Text)
Will man einen Satz beispielsweise in seine Wörter trennen, dann benutzt man folgende Variante:
Array = Split(Satz," ")
Wenn man mehrere verschiedene Trennzeichen verwenden will ( zb Komma und Punkt) dann muss man diese als zweiten Parameter übergeben zusammengefügt zu einem einzigen String.
Will man bestimmte Bereiche nicht trennen , dann kann man ein Nichttrennenzeichen angeben. Alles was zwischen zwei Nichttrennenzeichen steht ( zb in Anführungsstrichen ) wird nicht zerlegt.
Für das Nichttrennenzeichen gibt es keine Voreinstellung. Man muß es immer explizit eingeben.
Die Splitfunktion liefert einen Stringarray ( = eine Wörterliste) zurück, der jeweils mit den einzelnen zerlegten Elementen gefüllt wurde.
Beispiel: Sie brauchen einen Befehlsknopf, um das Beispiel in Gang zu bringen.
PUBLIC SUB Button1_Click() e AS String[] s AS String e = Split("Gambas Almost Means BASIC !", " ") FOR EACH s IN e PRINT s NEXT End
Ausgabe:
Gambas Almost Means BASIC !
Versuchen Sie einmal dasselbe Programm mit dem Trennzeichen a. Als Ausgabe erhalten Sie dann:
G mb s Almost Me ns BASIC !
Das Trennzeichen wird also nicht in die Elemente des Arrays mit aufgenommen.
Der Splitbefehl ist sehr praktisch und kann in einer Vielzahl von Programmen gut verwendet werden. Beispiel finden sich in Gambas: Statistik
Join Der Befehl zum zusammenfügen
[Bearbeiten]Der Befehl klebt eine Liste wieder zusammen. Er ist das Gegenteil des Splitbefehls.
For each
[Bearbeiten]Mit For each werden alle Einträge eines Arrays einer anderen Variable zugewiesen, die man dann ausgeben kann.
Beispiel: Sehr beliebt ist Addy der Summierer. Auch er nutzt einen Stringarray.
Sie brauchen eine Textarea, eine Textbox und einen Commandbutton um das Programm zu starten.
PUBLIC SUB Button1_Click() DIM text AS String DIM summe AS Float DIM liste AS String[] DIM posten AS String text = textarea1.Text liste = Split(text,Chr(10)) FOR EACH posten IN liste summe = summe + Val(posten) NEXT textbox1.Text = summe END
Geben Sie in die Textarea ein paar Zahlen und dazwischen Return ein. Dann drücken Sie auf die Befehlstaste. Die Zahlen werden zusammengezählt. Die Liste in der Textarea kann beliebig korrigiert werden. Auch negative Zahlen werden verarbeitet.
Vorsicht: Geben Sie keine Buchstaben oder Sonderzeichen ein. So robust ist Addy noch nicht.
Arrayroutinen Add,Remove,Resize,Revert,Clear, Sort
[Bearbeiten]Gambas bringt für alle seine Arrayarten eine Reihe von sehr nützlichen Routinen mit.
Arrayroutinen
[Bearbeiten]- Add
- ein Element am Ende hinzufügen oder an einer Position einfügen
- Remove
- ein Element am Ende wegnehmen oder an einer definierten Position wegnehmen
- Revert
- Reihenfolge umdrehen
- Resize
- Dem Array eine neue Größe geben
- Clear
- Alle Elemente weglöschen
- Sort
- In aufsteigender oder absteigender Reihenfolge sortieren
Wie die Arrayroutinen funktionieren, zeigt das folgende Programm.
Sie brauchen
[Bearbeiten]- 11 Buttons
- 4 Textboxen
- 1 Textarea
um das Programm in Gang zu bringen.
Layout
[Bearbeiten]Code
[Bearbeiten]PUBLIC a AS String[] PUBLIC SUB Form_Open() x AS Integer a = Array("Anna","Anton","Toni","Max","Klaus") Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT Textbox1.Text = "Franz" Button1.Text = "Hinzufügen" Button2.Text = "Einfügen" Textbox2.Text = "2" Textbox3.Text = "2" Textbox4.Text = "3" ME.Text = "Arraybefehle" END
PUBLIC SUB Button1_Click() x AS Integer a.Add(Textbox1.Text) Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) 'Die Länge des Array wird von 1 an gezählt, die Position von 0 an Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button2_Click() x AS Integer a.Add(Textbox1.Text,Val(Textbox2.Text)) Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button3_Click() x AS Integer a.Sort(0) Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button4_Click() x AS Integer a.Sort(16) Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button5_Click() x AS Integer a.clear Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button6_Click() x AS Integer a.resize(8) Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button7_Click() x AS Integer a.reverse Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button8_Click() x AS Integer a.remove(Val(textbox3.text),Val(textbox4.text)) Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button9_Click() ME.Close END
PUBLIC SUB Button10_Click() x AS Integer a = Array("Anna","Anton","Toni","Max","Klaus") Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT END
PUBLIC SUB Button11_Click() text AS String posten AS String text = textarea1.Text a = Split(text,Chr(10)) FOR EACH posten IN a NEXT END
Man kann dieses Programm vereinfachen, wenn man die Arrayausgabe in der Textarea in eine Subroutine packt, denn sie kommt immer wieder vor.
x as integer Textarea1.Text = "" FOR x = 0 TO (a.Length - 1) Textarea1.Text = Textarea1.Text & a[x] & Chr(10) NEXT
Übrigens: Für das Array Object[] funktiert das Sortieren noch nicht.
Array mit Zufallszahlen füllen
[Bearbeiten]Man kann ein Array auch mit Zufallszahlen füllen , um beispielsweise Algorithmen zum Sortieren zu testen.
Wie das geht zeigt folgendes Miniprogramm. Sie brauchen dazu eine Form und einen Befehlsbutton. Das Array wird bereits beim Laden der Form erzeugt und gefüllt. Drückt man auf den Befehlsknopf, wird das Array im Direktfenster ausgegeben.
Es werden 6 Zufallszahlen zwischen 1 und 10 erzeugt und in den Array eingelesen.
Einige Ungereimtheiten ergeben sich hier noch bei der Benennung der Arrays ( siehe Programmkommentare) Außerdem erkennt man jetzt auch den Vorteil, daß es 2 Methoden der Array Füllung gibt.
' Gambas class file ar AS Float[] 'warum gibt es eine Fehlermeldung , 'wenn man das Array mit Integer[] festlegt. PUBLIC SUB Form_Open() Randomize() ar = Array(Int(Rnd(1,10)) , Int(Rnd(1,10)) , Int(Rnd(1,10)) , Int(Rnd(1,10)) , Int(Rnd(1,10)) , Int(Rnd(1,10))) END PUBLIC SUB Button1_Click() element AS Integer FOR EACH element IN ar PRINT element NEXT END
Alternative:
ar AS Integer[] 'Obwohl der Array als Integerarray definiert ist, 'funktioniert er weiter unten als Stringarray Wieso ? PUBLIC SUB Form_Open() x AS Integer ar = NEW Integer[] FOR x = 0 TO 10 ar.Add(Str(x)) NEXT END PUBLIC SUB Button1_Click() x AS Integer Randomize() FOR x = 0 TO 10 ar[x] = Int(Rnd(1,10)) NEXT END PUBLIC SUB Button2_Click() element AS Integer FOR EACH element IN ar PRINT element; NEXT PRINT END
Wieviel Elemente hat der Array ? Warum so viele ? Probieren Sie das Programm einmal ohne den Randomize Befehl, dann erkennen Sie seine Notwendigkeit.
Lottozahlen ( 7 aus 49 )
[Bearbeiten]Das folgende Programm erzeugt sieben Lottozahlen , wirft Doppelgänger heraus und gibt die Zahlen sortiert aus: Genutzt wird dabei ein Array mit 49 Elementen.
Zunächst wird das Programm in seine Einzelteile zerlegt und auf 4 Comanndbuttons gelegt.
- Commandbutton1 >> Array mit 7 Zufallszahlen
- Commandbutton2 >> Kompletten Array über Print ausgeben
- Commandbutton3 >> Nur die Elemente ausgeben, die ungleich Null sind
- Commandbutton4 >> Kompletten Array wieder mit Nullen füllen.
ar AS Integer[] PUBLIC SUB Form_Open() 'schon beim Öffnen der Form wird der Array mit lauter Nullen gefüllt. x AS Integer ar = NEW Integer[] FOR x = 0 TO 48 ar.Add(Str(0)) NEXT END PUBLIC SUB Button1_Click() 'dann wird der Array mit 7 Zufallszahlen an den Stellen gefüllt, die mit der Zufallszahl übereinstimmen x AS Integer r AS Integer Randomize() FOR x = 0 TO 6 r = Int(Rnd(1,49)) IF r = ar[r] THEN x = x - 1 'Falls ein Doppelgänger auftritt gehe eins zurück ar[r] = r NEXT END PUBLIC SUB Button2_Click() 'zu Testzwecken wird das ganze Array ausgegeben element AS Integer FOR EACH element IN ar PRINT element NEXT END PUBLIC SUB Button3_Click() 'jetzt werden nur noch die Elemente ausgegeben , die ungleich 0 sind element AS Integer FOR EACH element IN ar IF element <> 0 THEN PRINT element NEXT END PUBLIC SUB Button4_Click() 'der Array wird wieder komplett auf Null gestellt x AS Integer FOR x = 0 TO 48 ar[x] = 0 NEXT END
Nachdem man das Programm in einzelne Schritte zerlegt hat, kann man es jetzt auf einen einzigen Button zusammenfassen. Und die Zusatzzahl fehlt natürlich noch.
' Gambas class file Lottozahlen ar AS Integer[] PUBLIC SUB Form_Open() 'schon beim Öffnen der Form wird der Array mit lauter Nullen gefüllt. x AS Integer ar = NEW Integer[] FOR x = 0 TO 48 ar.Add(Str(0)) NEXT END PUBLIC SUB Button1_Click() x AS Integer r AS Integer element AS Integer 'der Array wird komplett auf Null gestellt FOR x = 0 TO 48 ar[x] = 0 NEXT 'dann wird der Array mit 7 Zufallszahlen an den Stellen gefüllt, die mit der Zufallszahl übereinstimmen Randomize() FOR x = 0 TO 6 r = Int(Rnd(1,49)) IF r = ar[r] THEN x = x - 1 'Falls ein Doppelgänger auftritt gehe eins zurück ar[r] = r NEXT 'nur die Zahlen <> 0 werden ausgegeben FOR EACH element IN ar IF element <> 0 THEN PRINT element NEXT END
Überlegen Sie einmal warum die Elemente des Arrays zweimal auf Null gestellt wurden. Wenn Sie es nicht wissen, dann werfen Sie doch die eine Schleife heraus und probieren Sie das Programm ein paar Mal aus. Dann erkennen Sie die Notwendigkeit, wenn man mehrfach den Befhelsbutton drückt.
Doppelgänger aus dem Array herauswerfen
[Bearbeiten]Hierfür wir ein temporäres Array erstellt und die Elemente kopiert die im neuen temporären Array noch nicht vorhanden sind.
Beispiel als Funktion:
PUBLIC FUNCTION RemoveDuplicates(sArray AS String[]) AS String[] DIM s AS String DIM tempArray AS NEW String[] FOR EACH s IN sArray IF tempArray.Find(s) = -1 THEN tempArray.Add(s) NEXT RETURN tempArray END
Aufruf mit:
... RemoveDuplicates(Array) ...
Theorie
[Bearbeiten].Array Diese virtuelle Klasse ist die Eltern Klasse jedes anderen Gambas arrays.
Diese Klasse ist virtuell. Man kann sie nicht als Datentyp benutzen. Sie ist nicht erzeugbar (creatable. ).
Eigenschaften:
- Count (identisch mit Length)
- Length
Methoden
- Add
- Clear
- Remove
- Resize
- Reverse
- Sort
Arten von Arrays
[Bearbeiten]Arrays sind in Gambas meist an den eckigen Klammern zu erkennen: []
Mit der Schnellmethode über den Arraybefehl können Sie aber auch mit runden Klammern () definiert werden.
Wenn Sie nicht wissen, was für eine Art von Array sie definiert haben, dann lassen Sie sich die Art des Arrays im Direktfenster ausgeben. Wenn man sein Array mit dem Arraybefehl gefüllt hat, dann wird der Typ des Arrays durch das erste Element definiert. Die anderen Elemente werden automatisch zum selben Typ umgewandelt.
Mit Join kann man die Elemente des Arrays bei der Ausgabe trennen
Beispiel:
PUBLIC SUB Form_Open() ar AS Integer[] ar = Array(3,3,3) PRINT Object.Type(ar) END
Ausgabe: Integer[]
PRINT Object.Type(Array("2.4", 3, 3.2))
Ausgabe: String[]
PRINT [ "A", "B", "C" ].Join("/")
Ausgabe A/B/C
Zweidimensionales Array anlegen
[Bearbeiten]Siehe Gambas: Tabelle
Array Routinen
[Bearbeiten]- Zweidimensionale Felder anlegen
- Ein Boolean-Array
- Anzahl der Dimensionen eines Arrays bestimmen
- Arrays dynamisch vergrößern
- FAQ - Oft gestellte Fragen über Arrays
- Element in Array suchen
- Schnelles Einfügen und Löschen
- Arrayinhalte schnell mischen
- Schnelle Sortierung mit QuickSort und MinSort
Stoffsammlung und Fragen zu Arrays
[Bearbeiten]Will man die einzelnen Einträge durch ein Zeichen trennen, geht das normalerweise mit der Join Methode.
Hinzufügen von Einträgen
Wie kann man Einträge in ein Array hinzufügen ?
Zählen der Einträge
Wie erfolgt das Zählen der Einträge ? ( Length Eigenschaft )
PRINT a.Count
Einträge durchsuchen
Wenn man ein Array nach einem Eintrag durchsuchen will, geht das so:
Array.Find(SuchWert)
Sortieren der Einträge
Wie kann man Arrays sortieren ?
Array.Sort
Wie kann man nach den Namen der Werte sortieren lassen ? Wie kann man die Elemente in Ihrer Reihenfolge umdrehen ?
Array.Reverse
Lassen Sie sich am Anfang nicht von den vielen verschiedenen Befehlen verwirren. Suchen Sie sich am Anfang nur die wichtigsten heraus und arbeiten Sie mit Ihnen.
AS, Print, =, &, FOR TO, NEXT, ME.Close, IF THEN, TRUE, FALSE
Der Rahmen für ein Unterprogramm wird mit PUBLIC SUB
und END
am Ende von Gambas automatisch beim Klick z.B. auf einen Befehlsbutton vorgegeben.
Wenn Ihnen ein neuer Befehl über den Weg läuft, dann schauen Sie einfach mit F1 in der Hilfe nach, was er bedeutet.
Alphabetischer Befehlsindex
[Bearbeiten]Auf gambasdoc.org finden Sie eine stets aktuelle Übersicht zu allen Gambas-Befehlen.
Mathematische Operationen in Gambas
Zahl + Zahl | Addiert zwei Zahlen, zählt zusammen |
- Zahl | Rechnet die negative Zahl einer Zahl aus. Die negative Zahl von Null ist Null. N = 5 R = -8 PRINT N ; " " ; R ; " , " ; -N ; " " ; -R ==> 5 -8 , -5 8 |
Zahl - Zahl | Abziehen, zieht eine Zahl von einer anderen ab |
Zahl * Zahl | Multipliziert zwei Zahlen, malnehmen |
Zahl / Zahl | Bildet einen Bruch. Eine Zahl wird durch eine andere geteilt. Ein division by zero (= Division durch Null) Fehler erscheint, wenn der Teiler gleich Null ist. Das Ergebnis ist nicht immer eine ganze Zahl. Deswegen sollte das Ergebnis als eine float Variable deklariert werden. |
Zahl ^ Potenz | Eine Zahl wird potenziert. PRINT 4^3 ==> 64 |
Zahl \ Zahl | Berechnet den Quotienten von 2 Zahlen. Ein division by zero (= Division durch Null) Fehler tritt auf, wenn die Zahl rechts vom Backslash (Schrägstrich) gleich Null ist. A \ B ist dasselbe wie INT(A/B). PRINT 9\4 ; " , " ; 9 MOD 4 ==> 2 , 1 |
Zahl MOD Zahl | Berechnet den Rest eines Bruches zweier Zahlen. Ein division by zero (= Division durch Null) Fehler tritt auf, wenn die Zahl rechts vom MOD Befehl gleich Null ist. PRINT 9\4 ; " , " ; 9 MOD 4 ==> 2 , 1 |
Zahl AND Zahl | Berechnet das mathematische AND der Binärwerte zweier Zahlen. PRINT 5 AND 3 ==> 1 |
Zahl OR Zahl | Berechnet das mathematische OR (oder) der Binärwerte zweier Zahlen. PRINT 5 OR 3 ==> 7 |
Zahl XOR Zahl | Berechnet das mathematische ExOR (entweder oder) der Binärwerte zweier Zahlen. PRINT 5 XOR 3 ==> 6 |
AND (Und)
[Bearbeiten]Normalerweise wird der AND Befehl nicht sehr oft benutzt.
Er hat 2 Funktionen:
- Logische Verknüpfung von zwei Aussagen und Überprüfung Ihres Wahrheitswertes
- Vergleich von 2 Zahlen im binären Zahlensystem und Ausgabe von Übereinstimmungen
Beispiel für die Erste Funktion:
PRINT TRUE AND FALSE
Ausgabe: False
PRINT TRUE AND TRUE
Ausgabe: True
Eine Zusammenfassung steht in folgendem Programm:
PUBLIC SUB Form_Open() DIM a AS Boolean DIM b AS Boolean FOR a = 0 TO 1 FOR b = 0 TO 1 PRINT Str$(a) & " AND " & Str$(b) & " ==> " & Str$(a AND b) NEXT NEXT END
Wahrheitswerttabelle:
A | B | A AND B |
---|---|---|
False | False | False |
False | True | False |
True | False | False |
True | True | True |
Elektrische Schaltung: Die AND Verknüpfung entspricht einer elektrischen Serien- bzw. Reihenschaltung.
OR (Oder)
[Bearbeiten]Der Logikbefehl OR verknüpft zwei Aussagen und gibt für die Verknüpfung einen neuen Wahrheitswert aus.
OR = Oder = Das Eine oder das Andere oder Beide.
Es reicht aus, wenn eine der beiden Aussagen wahr ist. Auch dann ist die Oder Verknüpfung bereits wahr.
Eine Zusammenfassung steht in folgendem Programm:
PUBLIC SUB Form_Open() DIM a AS Boolean DIM b AS Boolean FOR a = 0 TO 1 FOR b = 0 TO 1 PRINT Str$(a) & " OR " & Str$(b) & " ==> " & Str$(a OR b) NEXT NEXT END
Wahrheitswerttabelle:
A | B | A OR B |
---|---|---|
False | False | False |
False | True | True |
True | False | True |
True | True | True |
Elektrische Schaltung: Die OR Verknüpfung entspricht einer elektrischen Parallelschaltung.
XOR
[Bearbeiten]XOR = Exclusive OR = Entweder das Eine oder das Andere
Die Funktion zeigt folgendes Programm
STATIC PUBLIC SUB Main() DIM a AS Boolean DIM b AS Boolean FOR a = 0 TO 1 FOR b = 0 TO 1 PRINT Str$(a) & " XOR " & Str$(b) & " ==> " & Str$(a XOR b) NEXT NEXT END
Wahrheitswerttabelle:
A | B | A XOR B |
---|---|---|
False | False | False |
False | True | True |
True | False | True |
True | True | False |
NOT
[Bearbeiten]NOT kehrt den Wahrheitswert um.
Die Funktion zeigt folgendes Programm
STATIC PUBLIC SUB Main() DIM a AS Boolean FOR a = 0 TO 1 PRINT Str$(a) & " ==> " & Str$(NOT a) NEXT END
Wahrheitswerttabelle:
A | NOT A |
---|---|
True | False |
False | True |
Bitweise Operatoren
[Bearbeiten]Bitweises AND
[Bearbeiten]Betrachten Sie dazu folgendes Programm:
PUBLIC SUB Form_Open() DIM x AS Integer DIM y AS Integer FOR x = 1 TO 15 FOR y = 1 TO 15 PRINT Bin$( x, 4 ), Bin$( y, 4 ), Bin$( x AND y, 4 ) NEXT NEXT END
Bitweises OR
[Bearbeiten]Betrachten Sie dazu folgendes Programm:
PUBLIC SUB Form_Open() DIM x AS Integer DIM y AS Integer FOR x = 1 TO 15 FOR y = 1 TO 15 PRINT Bin$( x, 4 ), Bin$( y, 4 ), Bin$( x OR y, 4 ) NEXT NEXT END
Bitweises XOR
[Bearbeiten]Betrachten Sie dazu folgendes Programm:
PUBLIC SUB Form_Open() DIM x AS Integer DIM y AS Integer FOR x = 1 TO 15 FOR y = 1 TO 15 PRINT Bin$( x, 4 ), Bin$( y, 4 ), Bin$( x XOR y, 4 ) NEXT NEXT END
Übersicht der Strukturen von Gambas
[Bearbeiten]Wie die meisten Programmiersprachen gibt es in Gambas verschiedene Möglichkeiten zur Ablaufsteuerung:
- Reihenfolge
- Auswahl
- Wiederholung
- Unterprogramme
Reihenfolge
[Bearbeiten]Normalerweise wird in einem Programm eine Befehlszeile nach der anderen abgearbeitet. Ausnahmen zu diesem Prinzip gibt es allerdings auch: Die Definition von Variablen mit dem DIM-Befehl erfolgt immer am Programmanfang oder am Anfang eines Unterprogrammes. Außerdem bietet der Befehl GOTO Möglichkeiten, die Reihenfolge des Programmes zu überspringen. Bei Unterprogrammen spielt die Reihenfolge im Codefenster keine Rolle, da sie über ihren Namen angesprungen werden. Trotzdem sollte man sich eine gewisse Reihenfolge angewöhnen. Beispielsweise gehört das Unterprogramm PUBLIC SUB Form_Open() an den Anfang des eigenen Codes.
<Anweisung> <Anweisung> <Anweisung> <...>
Auswahl
[Bearbeiten]Programmverzweigungen erfordern Bedingungen und Entscheidungen. Um dies zu ermöglichen gibt es verschiedene Befehle. Falls eine Bedingung nicht zutreffen sollte, wird die Zeile einfach übersprungen und das Programm macht bei der Zeile nach der Bedingungsabfrage weiter.
Einseitige Auswahl
IF <Bedingung> THEN <Anweisung>
Zweiseitige Auswahl
IF <Bedingung> THEN <Anweisung> ELSE <Anweisung> ENDIF
Fallunterscheidung
SELECT CASE TRUE CASE <Bedingung1> <Anweisung> CASE <Bedingung2> <Anweisung> CASE <Bedingung3> <Anweisung> CASE ELSE <Anweisung> END SELECT
Schleifen
[Bearbeiten]In Schleifen wird ein Befehl oder eine Befehlsfolge mehrfach wiederholt.
Zählschleife
FOR <Laufvariable> = <Startwert> TO <Endwert> <Anweisung> NEXT
Abweisende Schleife
WHILE <Wiederhol-Bedingung> DO <Anweisung>
Nicht abweisende Schleife
REPEAT <Anweisung> UNTIL <Abbruch-Bedingung>
Zählschleife für Arrays
FOR EACH <Element> IN <Liste> <Anweisung> NEXT
Die aufgezählten Strukturen kann man ineinander verschachteln. Dies führt aber oft zu unübersichtlichem Code und sollte vielleicht eher durch Funktionen in Unterprogrammen ersetzt werden.
Verzweigungen
[Bearbeiten]if - then
[Bearbeiten]Die einfachste Verzweigung eines Programmes erfolgt mit dem if - then Befehl
- If heißt auf Deutsch FALLS
- then heißt auf Deutsch DANN
Der If-Then-Befehl macht es möglich Programmverzweigungen zu programmieren, wenn eine bestimmte Bedingung erfüllt ist. Auf deutsch heißt der Befehl Falls die Bedingung wahr ist, dann mache folgendes.
Am besten versteht man dies an Hand eines Beispiels: Es gibt den Wochentag des heutigen Tages aus. Das Programm funktioniert im Terminalmdous:
STATIC PUBLIC SUB Main() PRINT WeekDay(Now) PRINT "Heute ist "; IF WeekDay(Now) = 1 THEN PRINT "Montag" IF WeekDay(Now) = 2 THEN PRINT "Dienstag" IF WeekDay(Now) = 3 THEN PRINT "Mittwoch" IF WeekDay(Now) = 4 THEN PRINT "Donnerstag" IF WeekDay(Now) = 5 THEN PRINT "Freitag" IF WeekDay(Now) = 6 THEN PRINT "Samstag" IF WeekDay(Now) = 7 THEN PRINT "Sonntag" END
Das Programm nutzt den Befehl Weekday und den Befehl Now von Gambas
Zwischen If und Then kann man auch mehrere Bedingungen auflisten und auch bei den Anweisungen nach dem Then Befehl kann mehrere Anweisungen aufreihen, die man dann mit Endif abschließt.
If Bedingung1 Bedingung2 Then Anweisung1 Anweisung2 Endif
if then else
[Bearbeiten]Der If then Else erlaubt die Programmierung einer Alternative zur If Bedingung. Das wird am besten an einem Beispiel klar
dim name as string if name = männlich then Print "An Herrn " & name else Print "An Frau " & name endif
Hier muß allerdings noch die Funktion männlich definiert werden.
Ein weiteres Beispiel: Sie brauchen eine leere Form , um das Programm in Gang zu bringen. Es erzeugt 100 Zufallszahlen zwischen 1 und 99 und überprüft ihre Teilbarkeit durch 2.
PUBLIC SUB Form_Open() a AS Integer x AS Integer Randomize() FOR x = 1 TO 100 a = Int(Rnd(1,100)) 'Zufallszahl zwischen 1 und 99 erzeugen IF a MOD 2 = 0 THEN 'teilbar durch 2 ?? PRINT a & " ist teilbar durch 2" ELSE PRINT a & " ist nicht teilbar durch 2" ENDIF NEXT END
GOTO Sprungadresse
[Bearbeiten]Auch das alte GOTO gibt es noch in Gambas. Man kann es allerdings nur in einem Unterprogramm verwenden. Wie das geht zeigt folgendes Beispiel:
Man braucht eine Textarea und einen Befehlsbutton um das Programm in Gang zu bringen.
PUBLIC SUB Form_Open() ME.Width = 400 ME.Height = 300 ME.Text = "GOTO Befehl mit Labels als Sprungadresse" Button1.Text = "Zufallszahl einordnen" Button1.Width = 200 Textarea1.Text = "" Textarea1.Width = 300 Textarea1.Height = 160 END PUBLIC SUB Button1_Click() z AS Integer Randomize() z = Int(Rnd(1,100)) IF z < 10 THEN GOTO zehn IF z < 20 THEN GOTO z2 IF z < 50 THEN GOTO z5 'PRINT " z > 49 , da z = ";z textarea1.Text = textarea1.Text & " z > 49 , da z = " & z & Chr(10) RETURN zehn: textarea1.Text = textarea1.Text & " z < 10 , da z = " & z & Chr(10) RETURN z2: textarea1.Text = textarea1.Text & " z < 20 , da z = " & z & Chr(10) RETURN z5: textarea1.Text = textarea1.Text & " z < 50 , da z = " & z & Chr(10) RETURN END
Select Case
[Bearbeiten]Der Select Case Befehl erlaubt die Auswahl aus mehreren Alternativen.
Wie er funktioniert zeigt folgendes Beispiel. Es überprüft die Randomfunktion eines Würfels 1000 mal und gibt die Häufigkeit, wie oft eine Zahl des Würfels erhalten wurde im Direktfenster aus. Sie brauchen nur eine leere Form um das Programm in gang zu bringen.
PUBLIC SUB Form_Open() x AS Integer w AS Integer a AS Integer b AS Integer c AS Integer d AS Integer e AS Integer f AS Integer Randomize() FOR x = 1 TO 1000 w = Int(Rnd(6) + 1) SELECT CASE TRUE CASE w = 1 a = a + 1 CASE w = 2 b = b + 1 CASE w = 3 c = c + 1 CASE w = 4 d = d + 1 CASE w = 5 e = e + 1 CASE w = 6 f = f + 1 END SELECT NEXT PRINT a,b,c,d,e,f END
Das Programm kann man etwas abkürzen:
PUBLIC SUB Form_Open() x AS Integer w AS Integer a AS Integer b AS Integer c AS Integer d AS Integer e AS Integer f AS Integer FOR x = 1 TO 1000 w = Int(Rnd(6) + 1) SELECT CASE w CASE 1 a = a + 1 CASE 2 b = b + 1 CASE 3 c = c + 1 CASE 4 d = d + 1 CASE 5 e = e + 1 CASE 6 f = f + 1 END SELECT NEXT PRINT a, b, c, d, e, f END
Schleifen
[Bearbeiten]Schleifen erlauben es, einen bestimmten Programmteil mehrfach zu wiederholen. Wenn man nicht weiß , wie oft man die Anweisung in der Schleife wiederholen muß, dann sind Do-Schleifen eine gute Wahl. Wenn man genau weiß, wie oft die Schleife wiederholt werden soll, dann sollte man den For...Next-Befehl wählen. Die For-Next Schleife verwendet eine Zähler (counter), dessen Wert während jeder Wiederholung der Schleife erhöht oder verringert wird.
For next Schleife
[Bearbeiten]Schleifen erlauben es, einen bestimmten Programmteil mehrfach mit einer sich verändernden Zahl durchlaufen zu lassen . Deswegen wird die FOR...NEXT Schleife auch als Zählerschleife bezeichnet.
Das Prinzip der Schleife schaut so aus:
FOR i = 1 to 9 STEP 1 Print i 'Programmcode NEXT
Die Variable i besitzt am Anfang den Wert 1. Jedesmal wenn das Programm das Ende der Schleife bei dem Befehl NEXT erreicht, springt das Programm an den Anfang der Schleife bei FOR zurück. Für jeden neuen Schleifendurchgang wird i um 1 (STEP 1) erhöht. Erreicht i den Endwert der Schleife , den to Wert (im Beispiel 9) so bricht die Schleife ab, der Programmablauf wird nach der Schleife fortgesetzt.
Das folgende Programm zeigt den Gebrauch einer For-Next Schleife. Sie brauchen dazu nur eine leere Form. Klicken Sie auf die Form im Entwurfsmodus und geben Sie den Programmcode weiter unten ein. Dann starten Sie das Programm mit F5 . Jedesmal wenn sie mit der Maus auf die Form kommen , wird Hallo Welt 10 mal ausgegeben.
PUBLIC SUB Form_Enter() DIM i AS Integer FOR i = 1 TO 10 PRINT "Hallo Welt" NEXT END
Probieren Sie eine Variante die noch einfacher ist:
PUBLIC SUB Form_Enter() DIM i AS Integer FOR i = 1 TO 10 PRINT i NEXT END
Probieren Sie noch folgende Variante:
PUBLIC SUB Form_Enter() DIM i AS Integer FOR i = 1 TO 10 PRINT i,i*i,i*i*i NEXT END
Sie können die 3 Beispiele auch mit dem Befehl
PUBLIC SUB Form_Open()
automatisch starten.
Um Schleifen lesbarer zu machen, rückt man den inneren Befehlsteil der Schleife ein. Er wird mehrfach durchlaufen. Im Gegensatz zu VB verzichtet Gambas auf die Nennung des Zählers am Ende der Schleife nach dem Next Befehl.
For I = 1 to 10 print I ' Next I in VB möglich ' In Gambas als überflüssig herausgeworfen. Next
Wenn Sie auf die Grafik verzichten und den Terminalmdous nutzen, dann lautet das letzte Programm folgendermaßen:
STATIC PUBLIC SUB Main() DIM i AS Integer FOR i = 1 TO 10 PRINT i,i*i,i*i*i,i^4,i^5 NEXT END
Das Ergebnis schaut so aus:
1 1 1 1 1 2 4 8 16 32 3 9 27 81 243 4 16 64 256 1024 5 25 125 625 3125 6 36 216 1296 7776 7 49 343 2401 16807 8 64 512 4096 32768 9 81 729 6561 59049 10 100 1000 10000 100000
Eine Schleife mit dem Step Befehl zeigt folgendes Beispiel: Erstaunlicherweise funktioniert hier das Komma in der Printausgabe nicht richtig . Probieren Sie einmal das Semikolon stattdessen aus.
PUBLIC SUB Form_Open() x AS Integer FOR x = 0 TO 100 STEP 5 PRINT x, NEXT END
Das Ergebnis sollte lauten:
0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100
Das tut es aber nicht ! Noch ein paar komische Beispiele:
PUBLIC SUB Form_Open() DIM i AS Integer FOR i = 1 TO 100 STEP i PRINT i NEXT END
PUBLIC SUB Form_Open() DIM i AS Integer DIM x AS Integer FOR x = 1 TO 10 FOR i = 1 TO 100 STEP x PRINT i & " "; NEXT NEXT END
Do Schleifen
[Bearbeiten]Eine DO LOOP Schleife ist im Prinzip eine Endlosschleife und muß durch irgendeine Bedingung in der Schleife unterbrochen werden.
Beispiel1: Endlosschleife
PUBLIC SUB Form_Open() x AS Integer x = 1 DO THEN PRINT "x = " & x x = x + 1 LOOP END
Beispiel 2: Endlosschleife , scheinbar zu Ende.
PUBLIC SUB Form_Open() a AS Integer x AS Integer Randomize() x = 1 DO a = Int(Rnd(1,100)) IF x < a THEN PRINT "x = " & x & " a = " & a x = x + 1 LOOP END
Warum werden nicht alle Zahlen von 1 bis 99 im Direktfenster ausgegeben ? Wann und warum hört die Schleife eigentlich auf ?
-> Die Schleife hört nicht auf. Es fehlt die Abbruchbedingung.
For Each Schleife
[Bearbeiten]Kommt bei Arrays zur Anwendung Siehe Gambas: Arrays
Schleife und Verzweigung kombiniert
[Bearbeiten]Der Programmcode schaut so aus. Sie brauchen nur einen Befehlsknopf und starten mit F5.
PUBLIC SUB Button1_Click() DIM k AS Integer FOR k = 1 TO 10000 IF k = 5000 THEN PRINT "Die Zahl 5000 wurde erreicht !" NEXT END
Sortierungen
[Bearbeiten]Siehe Gambas: Sortieren
Allgemeines
[Bearbeiten]Funktionen sind Unterprogramme, die einen Wert ( Zahl, Text etc) an das Hauptprogramm zurückgeben.
Umgekehrt wird oft ein Wert vom Hauptprogramm an die Funktion übergeben, dort wird der Wert verarbeitet und das Ergebnis wiederzurückgegeben.
Funktionen sind am Anfang gewöhnungsbedürftig. Beim effektiven Gebrauch einer Programmiersprache sind sie aber irgendwann unverzichtbar, da sie die Programmerstellung erleichtern und die Programme verkürzen, wenn ein Programmteil öfter durchlaufen werden muss. Fast alle abgeleiteten Befehle einer Programmiersprache haben sich aus Funktionen entwickelt. Prozeduren sind mit den Funktionen verwandt, nur geben Sie keinen Wert zurück.
Ein ganz einfaches Beispiel
[Bearbeiten]Sie definieren eine Funktion Add die 2 Zahlen zusammenzählt.
Die 2 Zahlen , die addiert werden sollen, werden dabei einfach in der Klammer hinter dem Funktionsnamen angegeben.
Sie brauchen für das Beispiel:
- Eine Form
- Einen Commandbutton
Der Code lautet:
'Hauptprogramm PUBLIC SUB Button1_Click() Message.Info(Add(6,10)) 'Funktionsaufruf und Rückgabe des Wertes END 'Funktion als Unterprogramm PUBLIC FUNCTION Add(a AS Integer, b AS Integer) AS Integer RETURN a + b END
Diese Funktion ist von den Werten a und b abhängig. Die Werte a und b können beliebig gewählt werden.
Beispiele von Funktionen:
[Bearbeiten]- Time ( Die Systemzeit wird zurückgegeben)
- Date ( Das Datum wird zurückgegeben)
- Quadratwurzel ( Eine Zahl wird eingegeben , die Quadratwurzel kommt zurück) a*a wird zu sqr(a)
- VGA Farbe in RGB umwandeln ( Eine der 16 VGA Farben wird eingegeben, der RGB-Wert kommt zurück)
Beispiel TIME: ( in die Funktion geht kein Parameter ein , es kommt trotzdem ein Wert zurück)
[Bearbeiten]Ein gutes Beispiel für eine einfache Funktion ist der Befehl Time ( = Zeit). Diese Funktion liefert die aktuelle Systemzeit. Sie können diese Funktion mit folgendem Befehl testen:
Print Time
Das folgende kleine Programm ohne Grafik gibt die Zeit im Direktfenster aus:
STATIC PUBLIC SUB Main() PRINT Time END
Wenn Sie die Zeit immer wieder aktualisiert haben wollen, müssen Sie eine Endlosschleife einbauen. Das Programm schaut dann so aus:
STATIC PUBLIC SUB Main() DIM i AS Integer i = 1 DO WHILE i <= 10 PRINT Time LOOP END
Ein ähnliches Beispiel für die Grafikausgabe aktualisiert die Zeitausgabe immer wieder. Dazu nutzt man den Timer, das Zeitgeber-Steuerelement. Dieser hat zunächst mit der aktuellen Zeit nichts zu tun, sondern löst ein Ereignis nach einer bestimmten Zeit aus.
Das folgende kleine Beispielprogramm kombiniert den Timer und die Timefunktion zu einer ständig aktualisierten Zeitangabe, wie sie diese auch rechts unten an ihrem PC finden.
Starten Sie ein neues Projekt. Nennen Sie es Zeitausgabe. Platzieren Sie anschließend eine Textbox auf Ihrer Form. Außerdem brauchen Sie das Zeitgebersteuerelement mit dem Uhrsymbol. Holen Sie sich beides mit F6 und einem Doppelclick auf das Symbol aus der Werkzeugkiste. Achten Sie darauf, dass der Zeitgeber mit der Enabled Eigenschaft erst angeschaltet werden muß. Dies können Sie bei den Eigenschaften des Timers zur Entwurfszeit einstellen oder Sie können es auch im Programmcode mit der Zeile
timer1.Enabled = TRUE
erreichen.
PUBLIC SUB Timer1_Timer() timer1.Enabled = TRUE textbox1.Text = Time END
Das Programm zeigt in der Textbox die aktuelle Zeit an. Diese wird jede Sekunde ( = 1000 millisekunden ) aktualisiert.
Beispiel UCASE : ( in die Funktion geht ein Parameter ein und es kommt ein umgewandelter Wert zurück)
[Bearbeiten]Die Funktion UCase ( = Großschreibung) ist eine einfache Funktion, die nur die Übergabe eines Strings benötigt. Um so etwas ( Variablen, Konstanten oder Strings ) zu übergeben, müssen diese in Klammern eingeschlossen werden und nach dem Funktionsnamen stehen.
Erstellen Sie eine Form mit einer Textbox und einem Commandbutton. Schreiben Sie für den Commandbutton folgenden Code:
PUBLIC SUB Button1_Click() Textbox1.Text = UCase(Textbox1.text) END
Starten Sie das Programm, tippen Sie beliebigen Text in das Textfeld und clicken Sie auf den Befehlsbutton. Als Ergebnis steht der Text in Großbuchstaben in der Textbox.
Folgender Code funktioniert erstaunlichwerweise nicht:
PUBLIC SUB TextBox1_KeyRelease() IF Key.return THEN UCase(Textbox1.text) END
Der Text wird in der Version 0.99 nicht groß geschrieben.
Obwohl folgender Code für die KeyReleasemethode funktioniert. Meines Erachtens liegt hier noch ein Programmfehler vor.
PUBLIC SUB TextBox1_KeyRelease() IF Key.return THEN textbox1.visible = FALSE END
Die Textbox wird unsichtbar.
Wenn Sie die Funktionen UCase und LCase ( = Kleinschreibung) noch einmal zusammen in einem einfachen Programm anschauen wollen, dann probieren Sie folgenden Code ohne Grafik:
STATIC PUBLIC SUB Main() DIM a AS String a = "Test" PRINT a PRINT LCase(a) PRINT UCase(a) END
( Siehe dazu im Abschnitt Erste Schritte , Drittes Programm: Programme im Terminalfenster ohne Grafik )
Beispiel 3: (mehrere Parameter)
[Bearbeiten]Werden mehrere Werte übergeben , dann müssen sie in der Klammer nach dem Funktionsnamen durch Kommata voneinander getrennt werden.
In Beispiel 2 gab die Funktion unterschiedlichen Text zurück, abhängig von der Zeichenkette, die ihr übergeben wurde. Andere Funktionen benötigen zusätzliche Parameter, um ihr zu sagen, wie sie diese Parameter handhaben soll. Zum Beispiel übernimmt die Funktion Mid$ ( = Text aus der Mitte herausschneiden)
- einen Parameter für den benutzen Text,
- einen Parameter um den Startpunkt zu fixieren (gemessen in Zeichenanzahl),
- und dann einen dritten und optionellen Parameter um festzulegen, wieviele Zeichen zurückgegeben werden sollen.
Im folgenden Beispiel werden alle Möglichkeiten der Stringbearbeitung = Zeichenfolgenmanipulation die Gambas kennt, zusammgefasst. Auch die Funktion Mid$ ist dabei. Sie brauchen nur eine leer Form um das Programm in Gang zu bringen.
PUBLIC SUB Form_Open() DIM Wort$ AS String Wort$ = "Kleinstaatengrenze" PRINT Len(Wort$) PRINT Left$(Wort$,7) PRINT Right$(Wort$,6) PRINT Mid$(Wort$,3,5) PRINT Mid$(Wort$,6) PRINT Instr(Wort$,"eng") PRINT Instr(Wort$,"Tomate") PRINT Instr(Wort$,"eng", 12) PRINT Instr(Wort$,"e",11) END
Ergebnis
- 18 ( Länge des Wortes )
- Kleinst ( Die 7 ersten Buchstaben )
- grenze ( Die 6 letzten Buchstaben )
- einst ( 5 mittlere Buchstaben beginnend beim 3.)
- staatengrenze ( Buchstaben beginnend ab dem 6. Buchstaben )
- 11 ( "eng" steht an der 11.Position im Wort )
- 0 ( Tomate findet sich nicht )
- 0 ( eng findet er nicht, wenn erst ab der 12.Position gesucht werden soll )
- 11 ( "e" findet er an 11.Position , wenn erst ab der 11.Position gesucht werden soll.)
ACHTUNG: In VB kann man den Befehl Mid$() nutzen um eine Buchstabenfolge aus einem Text herauszuschneiden und dafür einen anderen Text einzusetzen. Das geht in Gambas nicht.
Beispiel:
rem VB: MyString = "Der Hund springt" Mid$(MyString, 5, 4) = "Ball"
Ergebnis MyString = "The fox jumps".
In Gambas geht das nicht, Dafür kann man folgendes machen:
MyString = "Der Hund springt" MyString = Left$(MyString, 4) & "Ball" & Mid$(MyString, 9)
Ein komplettes Programm dazu ( ohne Grafik) schaut so aus:
STATIC PUBLIC SUB Main() DIM MyString AS String MyString = "Der Hund springt" PRINT MyString 'in VB moeglich: Mid$(MyString, 5, 4) = "Ball" in Gambas nicht MyString = Left$(MyString, 4) & "Ball" & Mid$(MyString, 9) PRINT MyString END
Befehle zur Stringbearbeitung = Zeichenfolgenmanipulation
[Bearbeiten]& | Zusammenkleben von Strings |
InStr() | Man bekommt die Position eines Zeichens oder Substrings zurück |
left() | Substrings von Links beginnend abtrennen |
like | Vergleich von 2 Strings oder Substrings |
LTrim() | Wegschneiden von Leerzeichen am Beginn eines Strings |
mid() | Schneidet einen Substring aus der Mitte heraus |
right() | Substrings von Rechts beginnend abtrennen |
RTrim() | Wegschneiden von Leerzeichen am Ende eines Strings |
split() | Aufteilung eines Strings in einzelne Wörter |
Trim() | Wegschneiden von Leerzeichen am Beginn und am Ende eines Strings |
CStr() | Einen Ausdruck in einen String umwandeln. |
Str() | Einen Ausdruck in einen String umwandeln. (Umkehrfunktion oder Gegenteil von val()) |
val() | Verwandelt einen String in eine Zahl, eine Fließkommazahl oder sonst etwas. |
Funktionen selber programmieren
[Bearbeiten]Richtig versteht man Funktionen erst, wenn man sie selbst programmiert hat. Dann erkennt man auch Ihre praktische Bedeutung. Man kann Sie nämlich meist völlig unverändert in andere Programme übernehmen.
Hoch3
[Bearbeiten]Im Folgenden soll eine Funktion programmiert, werden die eine Zahl hoch 3 nimmt. Dazu starten Sie ein neues grafisches Gambasprojekt: Auf der Form plazieren Sie 2 Textboxen und einen Befehlsbutton. Die Textboxen befreien Sie mittels Eigenschaftsfenster F4 von ihrem Text. Beim Commandbutton geben Sie folgenden Code ein:
PUBLIC SUB Button1_Click() DIM b AS Integer b = Val(Textbox1.text) textbox2.Text = Cstr(Hoch(b)) END '-Hier fängt die Funktion an ------------------------------------ PUBLIC FUNCTION Hoch(a AS Integer ) AS Integer a = a^3 RETURN a END
Vergessen Sie nicht den Return Befehl in Ihrer Funktion. Sonst bekommen Sie nichts zurück geliefert.
Die Programmierung von Funktionen in Gambas unterscheidet sich etwas von der Programmierung in VB. In Gambas kann man den Funktionsnamen in der Funktion nicht aufrufen, in VB ist das möglich.
Dritte Wurzel ( hoch 1/3 )
[Bearbeiten]Im Folgenden soll eine Funktion programmiert werden, die aus einer Zahl die dritte Wurzel zieht . Dazu starten Sie ein neues grafisches Gambasprojekt: Auf der Form plazieren Sie 2 Textboxen und einen Befehlsbutton. Die Textboxen befreien Sie mittels Eigenschaftsfenster F4 von ihrem Text. Beim Commandbutton geben Sie folgenden Code ein:
PUBLIC SUB Button1_Click() DIM b AS Integer b = Val(Textbox1.text) textbox2.Text = Cstr(wurzel(b)) END '-Hier fängt die Funktion an - PUBLIC FUNCTION wurzel(a AS Float ) AS Float a = a^(1/3) RETURN a END
Wenn Sie jetzt in die Textbox eine positive Zahl eingeben und auf den Befehlsbutton clicken, wird aus ihr die dritte Wurzel errechnet.
Warum wurde hier die Funktionsvariable als float-Zahl definiert. Probieren Sie dasselbe mit einer Integervariablen aus. Vergessen Sie nicht den Return Befehl in Ihrer Funktion. Sonst bekommen Sie nichts zurück geliefert.
Texte Zusammenkleben mit einer Funktion
[Bearbeiten]Das nächste Beispiel Programm zeigt Ihnen den Aufruf einer Funktion zum Kleben zwei Textteile.
Sie brauchen eine Textbox und 2 Befehlsbuttons, um das Programm in Gang zu bekommen.
' Gambas class file PUBLIC SUB Button1_Click() DIM b AS String Textbox1.Text = wort(b) & "Franz" END '------------ PUBLIC SUB Button2_Click() Textbox1.Text = wort & "Fritz" 'Dieser Aufruf der Funktion ergibt eine Fehlermeldung, da der erwartete Parameter nicht mitübergeben wurde. END '-------------------- PUBLIC FUNCTION wort ( a AS String) AS String a = "Hallo " RETURN a END
Wenn Sie auf den Button 1 Clicken wird die Funktion korrekt aufgerufen. Wenn Sie auf den Button 2 Clicken ergibt sich eine Fehlermeldung. Verstehen Sie auch warum ?. Wie könnte man den Code der Funktion umändern , so dass der Code unter dem Button 2 auch korrekt abläuft ?
Lösung:
' Gambas class file PUBLIC SUB Button1_Click() DIM b AS String Textbox1.Text = wort(b) & "Franz" END PUBLIC SUB Button2_Click() Textbox1.Text = worte() & "Fritz" END PUBLIC FUNCTION wort ( a AS String) AS String a = "Hallo " RETURN a END PUBLIC FUNCTION worte() AS String a AS String a = "Hallo " RETURN a END
Fakultaet
[Bearbeiten]Im folgenden Beispiel soll die Fakultät einer Zahl berechnet werden.
Die Fakultät zu einer Zahl (mathematische Darstellung: "n!", wird gesprochen: "n Fakultät") ist das Produkt der natürlichen, d.h. ganzzahlig, positiven Zahlen von 1 bis n.
Symbol: ! = Ausrufezeichen
Es gilt:
- 0! = 1
- 1! = 1
- 2! = 1*2 = 2
- 3! = 1*2*3 = 6
- 4! = 1*2*3*4 = 24
- 5! = 1*2*3*4*5 = 120
- 6! = 1*2*3*4*5*6 = 720
- .......
- n! = n * (n - 1)!
Die höchste Zahl, deren Fakultät sich in Gambas Basic ohne Kunstgriffe zur Emulation eines größeren Wertebereichs berechnen lässt, ist 170. Bei dem Programm unten ist 13 die Obergrenze Sie brauchen für das Programm einen Befehlsknopf = Commandbutton und zwei Textboxen.
' Gambas class file PUBLIC SUB Button1_Click() DIM a AS Integer a = Val(textbox1.text) ' textbox2.Text = Fakultaet(Val(textbox1.text)) textbox2.Text = Fakultaet(a) END '---Hier beginnt die Funktion --------------------------------------- FUNCTION Fakultaet(F AS Integer) AS Integer DIM k AS Integer DIM z AS Integer IF F = 0 THEN F = 1 z = F - 1 FOR k = 1 TO z F = F*k NEXT RETURN F END
Binominalkoeffizient
[Bearbeiten]Will man eine Summe potenzieren, dann kann man dazu gut den Binominalkoeffizienten gebrauchen .
Beispiel:
(a+b)^2 = 1*a^2 + 2*a*b + 1*b^2 (a+b)^3 = 1*a^3 + 3*a^2*b + 3*a*b^2 + 1*b^3 (a+b)^4 = 1*a^4 + 4*a^3*b + 6*a^2*b^2 + 4*a*b^3 + 1*b^4
Die Zahlen vor den verschiedenen a-und-b Gliedern werden Koeffizienten genannt und gehorchen den Regeln des Pascalschen Dreiecks. Siehe http://www.madeasy.de/2/pascal.htm
Die Regel des Dreiecks ist einfach: jede Zahl (außer der 1 am Rand) erhält man durch Addition der beiden Zahlen, die über ihr liegen (siehe Beispiel).
Man kann die Zahlen aber auch mit der Formel für den Binominalkoeffizienten ausrechnen:
Auch in der Statistik und Kombinatorik findet man immer wieder diese Formel, deswegen soll sie im folgenden programmiert werden.
Schreiben wir die Formel zunächst von der obigen grafischen Darstellung in eine Textdarstellung um:
N-ueber-k = N! / k! / (N-k)!
wobei N! = 1*2*3*4*.....*(N-1)*N = N Fakultät
Dabei muss immer gelten N > 0 und k > 0 und N > k oder N = k .
Zu Eingabe und Ausgabe der Werte brauchen Sie 3 Textboxen und zum Starten der Berechnung einen Befehlsbutton. Das ganze schaut dann so aus:
Will man die Formel programmieren, kann man das ohne Funktionsaufruf tun, dies zeigt der der folgende Programmcode:
' Gambas class file PUBLIC SUB Button1_Click() DIM N AS Integer DIM k AS Integer DIM F AS Integer DIM x AS Integer DIM nf AS Integer ' N Fakultät DIM nmk AS Integer ' n minus k Fakultät DIM kf AS Integer ' k Fakultät DIM nuk AS Integer N = Val(textbox1.text) k = Val(textbox2.text) F = 1 FOR x = 1 TO N F = F * x NEXT nf = F F = 1 FOR x = 1 TO k F = F * x NEXT kf = F F = 1 FOR x = 1 TO (n- k) F = F * x NEXT nmk = F nuk = nf / nmk / kf textbox3.Text = nuk END
Probieren Sie jetzt einmal die Werte für (a+b)^4 aus . Dabei ist N = 4 und k steigt von 0 bis 4 an . Setzen Sie diese Werte 4 und 0, 4 und 1, 4 und 2 , 4 und 3, 4 und 4 in Ihr Programm ein und Sie erhalten die Koeffizienten der Binomischen Gleichung und der entsprechenden Zeile im Pascalschen Dreieck.
Eleganter funktioniert die Programmierung , wenn man die Fakultätsberechnung einer Funktion übergibt.
Pascalsche Dreieck
[Bearbeiten]Wenn man den Binominalkoeffizienten n über k auch einer Funktion anvertraut , kann man in einer Doppelschleife alle Werte des Pascalschen Dreiecks beispielsweise von Zeile 1 bis Zeile 20 berechnen.
Da die Ausgabe in einer grafischen Form schwierig ist, kann man es im Terminalmodus programmieren:
Das Programm schaut so aus
For Zeile = 1 to Zeile = 12 Berechne N ueber K wobei N = Zeile und k von 0 bis N wächst Ausgabe als Print zeilenweise getrennt durch Kommas Next Zeile
Verfeinern wird das Programm in der inneren Schleife
For Zeile = 1 to Zeile = 20 For K = 0 To N = zeile Berechne N ueber K Print N ueber k; Next k Print ' fuegt einen Zeilenvorschub ein Next Zeile
Das komplette Programm schaut dann so aus :
' Gambas class file STATIC PUBLIC SUB Main() DIM Zeile AS Integer DIM N AS Integer DIM k AS Integer DIM F AS Integer DIM x AS Integer DIM nf AS Integer ' N Fakultät DIM nmk AS Integer ' n minus k Fakultät DIM kf AS Integer ' k Fakultät DIM nuk AS Integer FOR Zeile = 1 TO 12 N = Zeile FOR k = 0 TO N F = 1 FOR x = 1 TO N F = F * x NEXT nf = F F = 1 FOR x = 1 TO k F = F * x NEXT kf = F F = 1 FOR x = 1 TO (n- k) F = F * x NEXT nmk = F nuk = nf / nmk / kf PRINT nuk & " "; NEXT PRINT NEXT END
Das Ergebnis im Direktfenster schaut so aus.
1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1 1 9 36 84 126 126 84 36 9 1 1 10 45 120 210 252 210 120 45 10 1 1 11 55 165 330 462 462 330 165 55 11 1 1 12 66 220 495 792 924 792 495 220 66 12 1
Ein schiefes , aber doch erkennbares Pascalsches Dreieck.
Man kann das Programm deutlich vereinfachen, wenn man sich n uber k und die Fakultät als Funktion ausrechnen laesst.
Vordefinierte Konstanten
[Bearbeiten]gb.Null
|
Null value |
gb.Boolean
|
Boolean value |
gb.Byte
|
Byte integer number |
gb.Short
|
Short integer number |
gb.Integer
|
Integer number |
gb.Float
|
Floating point number |
gb.Date
|
Date and time value |
gb.String
|
Character string |
gb.Variant
|
Variant |
gb.Object
|
Object reference |
Datei Typen
[Bearbeiten]gb.File
|
Regular file |
gb.Directory
|
Directory |
gb.Device
|
Special file for a device |
gb.Pipe
|
Named pipe |
gb.Socket
|
Special file for a socket |
gb.Link
|
Symbolic link |
String Konstanten
[Bearbeiten]gb.NewLine
|
Newline character. Equivalent to Chr$(10) |
gb.Tab
|
Tab character. Equivalent to Chr$(9) |
Sortierungen
[Bearbeiten]gb.Binary
|
Binary sort |
gb.Case
|
Case insensitive sort |
gb.Lang
|
Language based sort |
Wochentage
[Bearbeiten]gb.Monday
|
Monday |
gb.Tuesday
|
Tuesday |
gb.Wednesday
|
Wednesday |
gb.Thursday
|
Thursday |
gb.Friday
|
Friday |
gb.Saturday
|
Saturday |
gb.Sunday
|
Sunday |
Vorgegebene Zahlenformate
[Bearbeiten]gb.GeneralNumber
|
Write a number with twelve decimal digits. Use scientific format if its absolute value is lower than 10-4 or greater than 107. |
gb.Fixed
|
Equivalent to "0.00" |
gb.Percent
|
Equivalent to "###%" |
gb.Scientific
|
Write a number with its exponent and eighteen decimal digits. |
Vorgegebene Datums- und Zeitformate
[Bearbeiten]gb.GeneralDate
|
Write a date only if the date and time value has a date part, and write a time only if it has a date part. |
gb.LongDate
|
Long date format. |
gb.MediumDate
|
Medium date format. |
gb.ShortDate
|
Short date format. |
gb.LongTime
|
Long time format. |
gb.MediumTime
|
Medium time format. |
gb.ShortTime
|
Short time format. |
Verschiedene Formate
[Bearbeiten]gb.Standard
|
Use gb.GeneralNumber for formatting numbers and gb.GeneralDate for formatting dates and times.
|
Sortierverfahren werden bei Datenbanken, Tabellen, Arrays und vielem mehr gebraucht. Einige einfache Sortierverfahren werden im Folgenden beschrieben.
Ripplesort
[Bearbeiten]Sie haben eine Zahlenfolge 13,12,15,11,14 . Diese Zahlen wollen Sie in aufsteigender Reihenfolge ordnen, so daß die kleinste Zahl am Anfang und die größte am Ende steht.
Wie das geht zeigt folgendes Programm. Es nutzt ein Array ( siehe Gambas: Arrays) und mehrere Hilfsvariablen . Dieses Array wird mehrfach durchsortiert, bis die Reihenfolge stimmt.
Sie brauchen eine Form und einen Commandbutton, um das Programm in Gang zu bringen.
' Gambas class file ar AS Integer[] PUBLIC SUB Form_Open() 'schon beim Öffnen der Form wird der Array mit lauter Nullen gefüllt. x AS Integer ar = NEW Integer[] ME.Text = "Sortieren" FOR x = 0 TO 4 ar.Add(Str(0)) NEXT END PUBLIC SUB Button1_Click() c AS Integer j AS Integer n AS Integer y AS Integer element AS Integer y = 0 n = ar.count ar[0] = 13 ar[1] = 12 ar[2] = 15 ar[3] = 11 ar[4] = 14 REPEAT c = 0 FOR j = 0 TO n - 2 PRINT j,y,ar[0],ar[1],ar[2],ar[3],ar[4] IF ar[j] > ar[j + 1] THEN y = ar[j] ar[j] = ar[j + 1] ar[j + 1] = y c = 1 ENDIF NEXT UNTIL c = 0 END
Die Ausgabe im Direktfenster schaut dann so aus:
PRINT j,y,ar[0],ar[1],ar[2],ar[3],ar[4]
0 0 1 2 3 4 5
0 0 13 12 15 11 14 1 13 12 13 15 11 14 2 13 12 13 15 11 14 3 15 12 13 11 15 14 0 15 12 13 11 14 15 1 15 12 13 11 14 15 2 13 12 11 13 14 15 3 13 12 11 13 14 15 0 13 12 11 13 14 15 1 12 11 12 13 14 15 2 12 11 12 13 14 15 3 12 11 12 13 14 15 0 12 11 12 13 14 15 1 12 11 12 13 14 15 2 12 11 12 13 14 15 3 12 11 12 13 14 15
Das Sortierverfahren steckt in der Repeat until Schleife . Darin steckt eine for next Schleife und darin steckt wieder eine Vertauschung mit if then . Das ist schon ein bißchen schwer zu kapieren. Mit der ausführlichen Ausgabe im Direktfenster kann man das Sortieren genau verfolgen. Man kann den Array ändern und andere Zahlen einfügen. Dann kann man wieder zuschauen, wie die Sortierung abläuft. Der Kern ist eine Vertauschung zweier benachbarter Zahlen, wenn die linke Zahl größer als die rechte ist. Der Rest der Zeile bleibt stehen. Dann erfolgt ein neuer Durchlauf der For Next Schleife , bei dem nichts passiert da in Position ar[1] des Arrays jetzt 13 steht und 13 < 15 ist. ( das Array beginnt mit der zahl 0 und hört mit n-1 auf, wenn es n Elemente hat. Beim nächsten Durchlauf der For Next Schleife wird die Position ar[2] = 15 mit ar[3] = 11 verglichen . Da 15 > 11 wird getauscht. Dann ist die For next Schleife das erste Mal zu Ende, da j = 3 = n-2 und die Repeatschleife wird ein zweites mal durchlaufen an, denn der Hilfsparameter c zeigt einen stattgefundenen Tausch an. Und so geht das immer weiter bis c = 0 , d.h. keine Vertauschung mehr nötig war.
Ripplesort mit Zufallszahlen
[Bearbeiten]Das folgende Programm ist vom obigen abgeleitet. Erst werden per Zufall 5 Zahlen zwischen 1 und 5 erzeugt. Diese werden dann sortiert. Sie brauchen eine Textarea und 2 Commandbuttons, um das Programm in Gang zu bringen.
' Gambas class file ar AS Integer[] PUBLIC SUB Form_Open() 'schon beim Öffnen der Form wird der Array mit lauter Nullen gefüllt. x AS Integer ar = NEW Integer[] ME.Text = "Sortieren" FOR x = 0 TO 4 ar.Add(Str(0)) NEXT END PUBLIC SUB Button1_Click() x AS Integer r AS Integer element AS Integer txt AS String z AS Integer txt = "" 'der Array wird komplett auf Null gestellt FOR x = 0 TO 4 ar[x] = 0 NEXT Randomize() FOR x = 0 TO 4 r = Int(Rnd(1,6)) ar[x] = r NEXT x = 0 FOR EACH element IN ar PRINT x,element txt = txt & x & " " & element & Chr(10) x = x + 1 NEXT textarea1.Text = txt END PUBLIC SUB Button2_Click() c AS Integer j AS Integer n AS Integer y AS Integer element AS Integer txt AS String y = 0 n = ar.count REPEAT c = 0 FOR j = 0 TO n - 2 PRINT j,y,ar[0],ar[1],ar[2],ar[3],ar[4] IF ar[j] > ar[j + 1] THEN y = ar[j] ar[j] = ar[j + 1] ar[j + 1] = y c = 1 ENDIF NEXT UNTIL c = 0 FOR EACH element IN ar txt = txt & element & Chr(10) NEXT textarea1.Text = textarea1.Text & txt END
Zahlenliste beliebiger Länge durchsortieren
[Bearbeiten]Im folgenden Beispiel wird der Ripplesort-Algorithmus zum Sortieren einer beliebig langen Werteliste benutzt. Sie brauchen 2 Textareas und 2 Commandbuttons, um das Programm in Gang zu bringen.
Code:
' Gambas class file PUBLIC SUB Button1_Click() c AS Integer j AS Integer n AS Integer y AS Variant DIM Liste AS String[] element AS String txt AS String text AS String text = Textarea1.Text liste = Split(text,Chr(10)) y = 0 n = liste.length REPEAT c = 0 FOR j = 0 TO n - 2 'PRINT j,y,liste[0],ar[1],ar[2],ar[3],ar[4] IF Val(liste[j]) > Val(liste[j + 1]) THEN y = Val(liste[j]) liste[j] = liste[j + 1] liste[j + 1] = Str(y) c = 1 ENDIF NEXT UNTIL c = 0 FOR EACH element IN liste txt = txt & Str(element) & Chr(10) NEXT 'PRINT txt textarea2.Text = "" textarea2.Text = txt END PUBLIC SUB Button2_Click() 'Beispielliste textarea1.Text = "114,3" textarea1.Text = textarea1.Text & Chr(10) & "135,7" textarea1.Text = textarea1.Text & Chr(10) & "104,8" textarea1.Text = textarea1.Text & Chr(10) & "118,5" textarea1.Text = textarea1.Text & Chr(10) & "125,7" textarea1.Text = textarea1.Text & Chr(10) & "121,4" textarea1.Text = textarea1.Text & Chr(10) & "122,4" textarea1.Text = textarea1.Text & Chr(10) & "96,8" textarea1.Text = textarea1.Text & Chr(10) & "118,9" textarea1.Text = textarea1.Text & Chr(10) & "120" textarea1.Text = textarea1.Text & Chr(10) & "112,2" textarea1.Text = textarea1.Text & Chr(10) & "127,9" textarea1.Text = textarea1.Text & Chr(10) & "122,8" textarea1.Text = textarea1.Text & Chr(10) & "128,9" textarea1.Text = textarea1.Text & Chr(10) & "120,3" END
Ereignisse der Steuerelemente
[Bearbeiten]Jedes Steuerelement hat verschiedene Ereignisse, die mit ihm verknüpft sind. Das häufigste Ereignis und meistens auch die Voreinstellung ist das Click Ereignis. Es wird benutzt, wenn etwas passieren soll, wenn man das Steuerelement einmal anklickt. Relativ häufig wird auch das Enter oder das Keypressereignis benutzt. Viele andere Ereignisse dagegen wird man eher selten nutzen. Was der genaue Unterschied ist zwischen den Ereignissen und den Methoden eines Steuerelementes, das ist wohl nicht so ganz klar definiert.
Typisches Beispiel mit einem Befehlsknopf auf der Form:
PUBLIC SUB Button1_Click() Message.Info("Hallo Welt") END
Das Ereignis ist der einfache Click. Die ausgelöste Folge ist die Ausgabe einer Meldung. (Ein 'Click' mit der Maus besteht aus dem Herunterdrücken UND Loslassen der Maustaste, erst mit dem Loslassen ist das Ereignis komplett, wünscht man eine Reaktion schon beim Herunterdrücken, so wähle man das Ereignis 'MouseDown'. Ein 'Click' mit der Tastatur wird ausgelöst, wenn der Knopf den Fokus hat und die Leertaste gedrückt und losgelassen wird.)
Ein weiteres 'Click'-Ereignis mit der Tastatur ist der Zugriff auf Befehlsknöpfe mit einer Tastenkombination ('Alt' und ein Zeichen des Knopfbezeichners. Dazu im Eigenschaftenfenster vor den Buchstaben, welcher mit der 'Alt'-Taste zum Auslösen des 'Click'-Ereignisses dienen soll, ein '&' stellen. Daraufhin wird bei laufendem Programm dieser Buchstabe unterstrichen. Zur Auslösung des Ereignisses muß der entsprechende Knopf nicht den Fokus haben.
Die weitere Bedienung des Befehlsknopfes mit der Tastatur:
PUBLIC SUB Button1_KeyPress() IF key.Code = key.Space OR key.Code = key.Return OR key.code=key.Enter THEN Message.Info("Hallo Welt") ENDIF END
Die Meldung wird ausgegeben, wenn der Befehlsknopf den Fokus hat, und eine der Tasten 'Leerzeichen', 'Return' oder 'Enter' gedrückt wurde ('Return' ist die Taste beim alphanumerischen Block, 'Enter' befindet sich beim Ziffernblock der Tastatur).
Wenn bei dem Knopf gleichzeitig das 'Click'-Ereignis abgefragt wird, muß das Code-Fragment 'key.Code = key.Space OR ' entfallen, da sonst 2 Subroutinen aufgerufen werden.
Alle Ereignismöglichkeiten , die mit einem Steuerelement ausgelöst werden können, finden Sie heraus, wenn Sie mit der rechten Maustaste auf das Steuerelement klicken und die Zeile Ereignis wählen.
Beim Steuerelement Button ( Befehlsknopf) finden sich beispielsweise folgende programmierbaren Ereignisse:
Click DblClick Drag DragMove Drop Enter GotFocus KeyPress KeyRelease Leave LostFocus Menu MouseDown MouseMove MouseUp MouseWheel
Probieren Sie einmal folgendes Ereignis aus:
PUBLIC SUB Button1_Enter() Message.Info("Funktioniert schon wenn die Maus auf den Button kommt") END
Oder folgende Variante:
PUBLIC SUB Button1_Leave() Message.Info("Funktioniert erst wenn die Maus den Button verläßt") END
Wenn man die Ereignisse kombiniert, kommen sich die Ereignisse manchmal in die Quere:
Probieren Sie zb folgendes Programm:
PUBLIC SUB Button1_Leave() ME.Text = "Funktioniert erst wenn die Maus den Button verlaesst." END PUBLIC SUB Button1_Click() Message.Info("Funktioniert schon wenn geklickt wird") END
Wenn man hier den Befehlsknopf anklickt und verläßt ihn nicht, wird trotzdem schon die Überschrift der Form geändert.
Ereignisse programmieren mit EVENT, STOP EVENT, RAISE
[Bearbeiten]Ereignisse selbst programmieren macht nur selten Sinn. Man kann beispielsweise die Tasteneingabe einer Textbox überprüfen, wenn man verhindern will, daß etwas anderes als Zahlen eingegeben wird. Es handelt sich hier um eine Art Fehlermanagement.
Beispiel: Sie brauchen eine Textbox auf Ihrer Form.
'Meine Textbox verarbeitet nur Ziffern. PUBLIC SUB TextBox1_KeyPress() IF Instr("0123456789", Key.Text) = 0 THEN STOP EVENT ENDIF END SUB
Wenn Sie etwas anderes eingaben als Ziffern, verweigert die Textbox die Annahme. Ziffern hingegen werden akzeptiert und in der Textbox dargestellt.
Siehe auch Gambas:_Textbearbeitung#Texteingabe
Beim folgenden Beispiel wird ein Ereignis nach dem 4.Mal Klicken auf die Taste ausgelöst.
Sie brauchen eine Form mit einem Befehlsbutton darauf. Außerdem brauchen Sie eine neue Klasse Class1. Diese erhalten Sie, wenn Sie im Projektmenü auf die Zeile Klasse mit der rechten Maustaste klicken und Neue Klasse wählen. Den vorgeschlagenen Namen Class1 sollten sie einfachheitshalber beibehalten:
Folgender Code für die Form wurde verwendet:
PUBLIC SUB Form_Open() MyClass=NEW Class1 AS "Beobachte" END PRIVATE MyClass AS Class1 PUBLIC SUB Button1_Click() MyClass.testen () END PUBLIC SUB Beobachte_ereignis(Data AS String) Message.Info (Data) END
Folgender Code für die Klasse wurde verwendet:
PRIVATE zaehler AS Integer EVENT ereignis (Data AS String) PUBLIC SUB testen() zaehler=zaehler + 1 IF zaehler>3 THEN RAISE ereignis("Taste > 3 mal gedrückt") zaehler=0 END IF END
Fehler abfangen mit Catch
[Bearbeiten]Der Befehl CATCH markiert den Beginn einer Fehlerroutine innerhalb einer Funktion oder einer Procedure.
Der Catch-Teil wird immer dann ausgeführt, wenn ein Fehler bei der Ausführung der Funktion auftritt.
Der Fehler kann innerhalb der Prozedur selber auftreten oder aber in einer anderen Funktion, die aus der Prozedur heraus aufgerufen wurde. Dies gilt allerdings nur unter der Voraussetzung, dass die aufgerufene Funktion selber keinen CATCH-Befehl enthält.
Je tiefer der Catch-Teil zu finden ist, desto größere Priorität hat er.
Wenn ein Fehler im Catch-Teil selber auftaucht, dann wird er nicht korrigiert. Der Catch-Teil schützt sich also nicht selber.
Falls ein Finally-Teil in der Funktion auftaucht, muss er dem Catch-Teil vorausgehen.
Siehe FINALLY.
Beispiel 1
[Bearbeiten]Das Programm speichert der Inhalt der Textarea als Datei. Die Fehlerroutine fängt den Abbrechen Befehl im Dateiauswahldialog ab.
Sie brauchen eine Textarea und einen Befehlsbutton auf Ihrer Form, um das Programm in Gang zu bringen.
Der Code:
[Bearbeiten]PUBLIC SUB Form_Open() Textarea1.Text = "Dies ist ein Test" END PUBLIC SUB Button1_Click() Dialog.SaveFile() File.Save(Dialog.Path, TextArea1.Text) CATCH IF Error THEN RETURN END
Siehe auch Gambas:_Dateien#Datei_speichern
Beispiel 2
[Bearbeiten]Sie haben ein Programm geschrieben, welches die Kreisfläche aus dem Radius berechnen soll. Sie wollen verhindern, dass in die Textbox mit der Radiuseingabe etwas anderes als eine Zahl eingegeben wird. Dazu ergänzen Sie Ihren Code durch eine Fehlerroutine mit CATCH.
CATCH message.Info("Bitte eine Zahl eingeben") END
Das komplette Programm schaut so aus:
Sie brauchen:
- 2 Textboxen
- 1 Befehlsbutton
- 1 Labelfeld
umd das Programm in Gang zu bringen.
Der Code
[Bearbeiten]PUBLIC SUB Form_Open() Textbox1.Text = "" Textbox2.Text = "" Button1.Text = "Kreisberechnung mit dem Radius:" Label1.Text = "Fläche:" Label1.Alignment = 66 END PUBLIC SUB Button1_Click() r AS Float F AS Float IF Textbox1.Text = "" THEN r = 0 Textbox1.Text = Str(0) ELSE r = Val(textbox1.text) ENDIF F = Pi*r^2 Textbox2.Text = Str(Round(F,-2)) CATCH message.Info("Bitte eine Zahl eingeben") END
Probieren Sie ganz bewußt eine Fehleingabe aus. Geben Sie im Feld für den Radius einen Buchstaben ein. Was passiert dann? Jetzt versuchen Sie dasselbe noch einmal und schalten die Fehlerroutine CATCH nach Markierung mit der rechten Maustaste und Block auskommentieren ab.
Beispiel 3
[Bearbeiten]Das folgende Beispiel zeigt einen etwas komplizierten Code aus der Gambashilfe.
Beispiel:
' Print a file to the screen SUB PrintFile(FileName AS STRING) DIM hFile AS File DIM sLig AS STRING OPEN FileName FOR READ AS #hFile WHILE NOT EOF(hFile) LINE INPUT #hFile, sLig PRINT sLig WEND FINALLY ' Always executed, even if a error raised CLOSE #hFile CATCH ' Executed only if there is an error PRINT "Cannot print file "; FileName END
Fehler abfangen mit TRY
[Bearbeiten]Try ist im Grunde genommen dasselbe wie Catch, nur dass hierbei nicht die gesamte Funktion nach Fehlern geprüft wird, sondern nur eine spezielle Anweisung.
Beispiel
[Bearbeiten]In diesem Beispiel wird eine Datei in dem Homeverzeichnis des aktuellen Users erstellt. Wenn der Zugriff zu dem Zielort allerdings gesperrt ist (z.b. wenn die Datei oder das Verzeichnis read-only ist), wirft die Try-Anweisung einen Error, der durch das Schlüsselwort ERROR überprüft werden kann.
PUBLIC SUB Main() TRY File.Save("/home/" & User.Name & "/file.txt", "Hallo " & User.Name) IF ERROR THEN PRINT "Folgender Fehler ist aufgetreten: " & Error.Text PRINT "Und zwar genau hier: " & Error.Where ELSE PRINT "Ich habe erfolgreich eine Datei in deinem Homeverzeichnis erstellt!" ENDIF END