Beginnt eine eingegebene Zeile mit einer Zahl, wird sie nicht ausgeführt, sondern als Programmzeile gespeichert. Die Zahl wird als Zeilennummer betrachtet und alle eingegebenen Zeilen nach ihren Zeilennummern aufsteigend sortiert. Um eine Zeile zu löschen, gibt man Ihre Nummer ein und drückt die Eingabetaste. Um eine Zeile zu ändern, tippt man sie einfach nochmals korrekt ein.
Das eingegebene Programm kann man sich mit dem Befehl
list
anzeigen lassen. Dabei kann man auch angeben, welche Zeilennummer oder welchen Zeilennummernbereich man sehen möchte.
list 200 (zeigt Zeile 200)
list 200-300 (zeigt Zeilen 200 bis 300)
list -1000 (zeigt Programm von Anfang bis Zeile 1000)
Die Zeilennummern müssen nicht fortlaufend vergeben werden. Im Gegenteil: Da man die Zeilennummern nachträglich nicht mehr ändern kann, sollte man die Zeilen in größeren Schritten durchnummerieren. Nur so kann man noch nachträglich Zeilen einfügen.
Das fertige Programm kann man mit „RUN“ starten.
Ein einfaches Basicprogramm sieht beispielsweise so aus:
100 print „Quaderberechnungen“
110 input „Breite:“; b
120 input „Tiefe:“; t
130 input „Höhe:“; h
140 print „Der Quader hat eine Grundfläche von “; b*t
150 print „und ein Volumen von “; b*t*h
160 end
Das Programm kommt mit nur drei Befehlen aus:
„print“ schreibt Texte oder Zahlen auf den Bildschirm. Dabei werden Terme gleich ausgerechnet. Soll mit einer Programmzeile ein Text und eine Zahl ausgegeben werden, trennt man beides durch ein Semikolon.
„input“ schreibt einen Text auf den Bildschirm und wartet dann auf eine Eingabe. Diese wird dann in die angegebene Variable übergeben.
„end“ steht am Programmende. Der Befehl kann meist auch weggelassen werden, da ein Programm ohnehin beendet wird, wenn es die letzte Zeile erreicht.
Wir dieses Programm gestartet, passiert folgendes (Ausgaben des Computer fett geschrieben, Eingaben des Anwenders kursiv:
run
Quaderberechnungen
Breite:? 50
Tiefe:? 20
Höhe:? 15
Der Quader hat eine Grundfläche von 1000
und ein Volumen von 15000
ready.
In diesem einfachen Fall läuft das Programm einfach von der ersten bis zur letzten Programmzeile durch. Das muss aber nicht so sein. Basic kennt sogenannte Strukturbefehle, mit denen der Programmfluss verändert werden kann. Die wichtigsten sind:
if Bedingung then Zeilennummer
if Bedingung then Befehl
for Variable=Startwert to Endwert [...] next Variable
gosub Zeilennummer
goto Zeilennummer
Mit „if“ wird eine bedingte Verzweigung durchgeführt, d.h. wenn die Bedingung zutrifft wird entweder das Programm an der angegebenen Zeilennummer fortgesetzt oder der angegebene Befehl ausgeführt. Da Basic keine Blockbildung kennt, wird ein Programm rasch unübersichtlich.
Was in einer modernen Programmiersprache wie Java, PHP, Perl oder C so aussieht:
if( a>b ) {
[Befehle, die ausgeführt werden, wenn die Bedingung zutrifft ...]
} else {
[Befehle, die andernfalls ausgeführt werden...]
}
[hier geht das Programm weiter...]
wird in Basic zu einem ziemlichen Verhau:
1000 if a>b then 1100
1010 [Befehle, die ausgeführt werden, wenn die Bedingung nicht zutrifft ...]
1090 goto 1200
1100 [Befehle, die ausgeführt werden, wenn die Bedingung zutrifft ...]
1200 [hier geht das Programm weiter...]
Mit der Anweisung for [...] next wird eine sogenannte Schleife programmiert. Das heißt, dass der Programmcode zwischen „for“ und „next“ mehrfach ausgeführt wird.
Beispiel:
100 for x=1 to 10
110 for y=1 to 10
120 print x*y;
130 next y
140 print
150 next x
160 end
Dieses Programm enthält gleich zwei Schleifen. Die erste beginnt in Zeile 100 und endet in Zeile 150. Die Variable x erhält beim ersten Durchlauf der Zeilen 110 bis 140 den Wert 1, danach den Wert 2 und so weiter bis zum Wert 10. In jedem Durchlauf wird auch die Schleife ausgeführt, die in Zeile 110 beginnt und in Zeile 130 endet. In diesem Fall wird die Zeile 120 zehn mal ausgeführt. Zuerst mit dem Wert 1 in der Variable y, dann mit 2 und so weiter bis zum Wert 10.
Das Programm berechnet das kleine Einmaleins und zeigt es am Bildschirm an.
Mit dem Befehl gosub kann man ein Unterprogramm aufrufen. Das bedeutet, dass das Programm zunächst in der hinter gosub angegebenen Zeile fortgesetzt wird. Kommt nun der Befehl „return“, wird das Programm in der auf den gosub-Befehl folgenden Zeile fortgesetzt. Unterprogramme sind die Basic-Entsprechung der aus moderneren Sprachen bekannten Funktionen, allerdings ohne Parameterübergabe.
Der Befehl goto gilt als größte Sünde von Basic. Er sorgt dafür, dass das Programm an der angegebenen Zeilennummer fortgesetzt wird. Das ist in vielen Fällen notwendig, da Basic einige wichtige Strukturbefehle fehlen. Man kann mit goto aber auch völlig unstrukturierte Konstruktionen bauen, z.B. aus Schleifen oder Unterprogrammen herausspringen oder völlig wirren Programmcode fabrizieren. Was insbesondere ungeübte Programmierer mit Basic zustande brachten wurde früher häufig als „Spaghetticode“ bezeichnet.
Beispiel:
Was in einer modernen Sprache so aussieht:
while( a>b ) {
[Programmzeilen, die ausgeführt werden, solange die Bedingung zutrifft]
}
[hier geht das Programm weiter...]
ist in Basic nur mit einem „goto“ zu lösen:
1000 if a<=b then 1100
1010 [Programmzeilen, die ausgeführt werden, solange die Bedingung zutrifft]
1090 goto 1000
1100 [hier geht das Programm weiter...]
Variablen, Operatoren und Funktionen
Im Gegensatz zu den meisten höheren Programmiersprachen muss man in Basic Variablen nicht deklarieren. Das heißt, dass man Variablen einfach verwenden kann. Beim ersten Auftauchen im Programm wird eine Variable automatisch mit dem Wert 0 vorbelegt. Einzige Ausnahme von dieser Regel sind Feldvariablen. Diese müssen vor der ersten Verwendung dimensioniert werden, d.h. es muss festgelegt werden, wie viele Elemente das Feld bekommen soll. Der Befehl zur Dimensionierung heißt „dim“. Um ein Feld für 50 Zahlenwerte in der Feldvariablen a zu dimensionieren muss folgender Befehl verwendet werden:
dim a(50)
Auf die Variablenwerte greift man durch Angabe des Feldindex in runden Klammern zu. Auf das sechste Element der Feldvariablen a wird also mit a(5) zugegriffen (die Indizes beginnen bei 0).
Es gibt drei Variablentypen, die sich durch ein Anhängsel am Variablennamen unterscheiden. Endet ein Variablenname mit „%“ kann die Variable nur ganzzahlige Werte zwischen -32768 und +32767 annehmen. Ist die Endung ein „$“, handelt es sich um eine Variable für Zeichenketten, sogenannte Strings. Ganz ohne Endung ist eine Variable für Gleitkommazahlen vorgesehen. Variablen können zwar lange Namen haben, es werden aber nur die ersten beiden Zeichen beachtet. Die Variablen „paris“ und „paderborn“ sind aus Sicht von Basic identisch!
Für Berechnungen beherrscht Basic die üblichen Rechenoperatoren +, -, * und /. Darüber hinaus sind auch Klammerungen möglich und mit ^ kann man einen Exponenten berechnen. Für Zeichenketten existiert nur der Operator „+“, mit dem zwei Zeichenketten aneinandergehängt werden.
Basic kennt zahlreiche mathematische Funktionen. Die wichtigsten sind:
sin(x) Sinus
cos(x) Cosinus
tan(x) Tangens
atn(x) Arcustangens
sqr(x) Wurzel
exp(x) Exponentialfunktion
abs(x) Betrag
int(x) Ganzzahliger Anteil
Wichtig sind auch Funktionen für Zeichenketten:
left$(a$,x) liefert die x ersten Zeichen von a$
right$(a$,x) liefert die x letzten Zeichen von a$
mid$(a$,x,y) liefert y Zeichen ab der x. Position von a$
asc(a$) liefert den ASCII-Code des ersten Zeichens von a$
chr$(x) liefert das Zeichen mit dem ASCII-Code x
