| |
| |
|
 | var Bezeichner [ = Wert ] [, Bezeichner [ = Wert ], ...
Deklariert Variablenbezeichner und weist ihnen ggf. Werte zu.
Es können beliebig viele Variablen erstellt werden, erlaubt für die Bezeichnernamen sind Buchstaben und Ziffern und das erste Zeichen muss ein Buchstabe sein. Auch erlaubt sind die Zeichen _ und .
Hinweis: Var als Funktion kann verwendet werden um den Variablentyp zurückzuerhalten.
Siehe auch: § 5 - Datentypen
Beispiele für die Verwendung von Variablen:
Einfache Variable:
Einfache Variable, kompaktere Schreibweise:
var a=10,b=20.5,c="Hallo Welt"
print a,b,c// gibt 10 20.5 Hallo Welt aus
Array:
Assoziative Arrays:
var a=["Magnet"=5,"Faktor"=5.5,"Farbe"="Grün"]
print a["Faktor"]// gibt 5,5
Arrays als Objekte:
Arrays als Objekte:
Typ einer Variablen beziehen:
Keywords: var,declare,gettype |
|
| |
| |
| |
|
|
| Achtung Änderung für Arraydeklaration:
aus var o=array(10,20,30) wird var o=[10,20,30] |
|
| |
| |
| |
|
|
| Neu:
Var kann auch verwendet werden um den Variablentyp zurückzuerhalten. In diesem Fall ist Var als Funktion zu verwenden: var a=1.1;print var(a) //gibt float aus. |
|
| |
| |
| |
|
|
HofK | Im Zusammenhang mit dem "Space-Operator" [...]  beim Präkompilierer wäre ein optionales Sonderzeichen zur Typermittlung für total Schreibfaule  super. Bei einer polymorphen Funktionsdefinition sieht man die Reduzierung des Schreibstreassfaktors deutlich.
proc poly a b c// der Präkompilierer richtet das
// Typprüfung mit optionalem Sonderzeichen (bspw °) wäre etwas für total Schreibfaule wie ...
if ((°a==long)&&(°b==long)&&(°c==null))
return "Das Ergebnis ist: " + str(a-2*b)
elseif ((°a==string)&&((°b==long)||(°b==float))&&((°c==long)||(°c==float)))
return a + " = " + str(sqrt(a*a+b*b))
elseif ((°a==string)&&(°b==null)&&(°c==null))
return "Genau eine Zeichenkette wurde übergeben."
// ... Befehle zur Verarbeitung der Zeichenkette ...
elseif ((°a==string)&&((°b==long)||(°b==float))&&(°c==null))
if (°b==long)
return "Ãœbergabe: 1. Parameter Zeichenkette, 2. Parameter ganze Zahl"
endif
if (°b==float)
return "Ãœbergabe: 1. Param. ist Zeichenkette, 2. Parameter Dezimalzahl"
endif
// ... Befehle zur Verarbeitung der Zeichenkette und/oder der Zahl ...
elseif ((°a==string)&&((°b==long)||(°b==float))&&(°c==bool))
return "Parameterübergabe: 1. Zeichenkette, 2. Zahl, 3. Wahrheitswert
// ... Befehle zur Verarbeitung der drei Parameter ...
else
return null
endif
endproc
// so ist es nach derzeitiger Referenz mit var( )
proc poly(a,b,c)
// Typprüfung mit var()
if ((var(a)==long)&&(var(b)==long)&&(var(c)==null))
return "Das Ergebnis ist: " + str(a-2*b)
elseif ((var(a)==string)&&((var(b)==long)||(var(b)==float))&&((var(c)==long)||(var(c)==float)))
return a + " = " + str(sqrt(a*a+b*b))
elseif ((var(a)==string)&&(var(b)==null)&&(var(c)==null))
return "Genau eine Zeichenkette wurde übergeben."
// ... Befehle zur Verarbeitung der Zeichenkette ...
elseif ((var(a)==string)&&((var(b)==long)||(var(b)==float))&&(var(c)==null))
if (var(b)==long)
return "Ãœbergabe: 1. Parameter Zeichenkette, 2. Parameter ganze Zahl"
endif
if (var(b)==float)
return "Ãœbergabe: 1. Param. ist Zeichenkette, 2. Parameter Dezimalzahl"
endif
// ... Befehle zur Verarbeitung der Zeichenkette und/oder der Zahl ...
elseif ((var(a)==string)&&((var(b)==long)||(var(b)==float))&&(var(c)==bool))
return "Parameterübergabe: 1. Zeichenkette, 2. Zahl, 3. Wahrheitswert
// ... Befehle zur Verarbeitung der drei Parameter ...
else
return null
endif
endproc
|
|
| |
| |
| |
|
|
| if ((°a==long)&&(°b==long)&&(°c==null))
da könnte man doch sagen, statt:
°c==null
einfach
c==null
denn Typ Null kann ja nur den Wert null liefern - hier also ein Typenzeichen
unnötig.
So weitergedacht überlege ich natürlich, ob nicht einfach
a==long oder s==string oder f==float,
schließlich werden hier long, float etc nicht als Funktion verwendet
sonden könnten als Konstante verstanden werden. Ich muss mal
herausbekommen ob sich das mit irgendwas beißt. |
|
| |
| |
| |
|
|
| Ach und übrigens Deine Zeile:
geht dank Space-Operator viel einfacher:
und eigentlich sowieso nur so notwendig:
Weil string+float = string |
|
| |
| |
| |
|
|
HofK | ... denn Typ Null kann ja nur den Wert null liefern - hier also ein Typenzeichen unnötig ... immer auch noch diese Sonderfälle 
... übrigens Deine Zeile: ...soweit war ich noch garnicht! Da ist noch ganz schön viel Potential. |
|
| |
| |
| |
|
|
HofK | Hm, wodurch wird klar, ob das letzte Pluszeichen eine Stringanfügung oder eine Addition ist? Leider ist + ja üblicherweise doppelt belegt.
return a + " = " + sqrt a*a+b*b |
|
| |
| |
| |
|
|
| Das vom Typ her höherwertige Ergebnis bestimmt den Typ weil nur so
ohne Datenverlust konvertiert werden kann. Höherwertig demzufolge
in dieser Reihenfolge:
String
Float
Long
Bool
Null
Ergo ist 1+"Test" immer "1Test" genau wie "Test"+1 immer "Test1" ist,
1.1+2 ist immer 2.2 genau wie 2+1.1 immer 2.2 ist.
Man kann auch sagen, was Du mit String verknüpfst ist immer String.
Dies hier: 2.2+1+"hallo"+5.5+1
ergibt: 3.2hallo5.51,
in diesem Fall also von Links nach Rechts ausargumentiert.
Wenn man mit den Zahlen in einer Stringkonstante rechnen will dann
per long( oder float( den String konvertieren. |
|
| |
| |
| |
|
|
HofK | Das war soweit klar, hatten wir auch schon vor einiger Zeit in der Diskussion - finde ich aber gerade nicht. Schön hier nochmal die konkrete Auflistung der Wertigkeit, würde sich da [...] gut machen.
Wenn ich jetzt nicht total schief liege, nur daher meine Anmerkung bezüglich des mitdenkenden Präkompilierers, müsste dann in der letzten Vereinfachung doch noch return a + " = " + sqrt( a*a+b*b) stehen, da ja in der Ausgangszeile der Pythagoras anvisiert war.
Es sei denn, nach sqrt wird solange numerisch "gedacht" wie es geht.
Da ist der . für die Konkatenation bei php und Konsorten dann eben eindeutiger und übersichtlicher. Aber den Punkt übersieht man auch mal schneller, er ist so lütt. |
|
| |
| |
| |
|
|
| iF (01.12.14)
Space-Operator (Freizeichen), eigentlich kein Operator sondern eine Sprach/ Syntaxeigenschaft, näheres dazu unter: [...]
Die Zeile:
return a + " = " + str(sqrt(a*a+b*b))
kann durchaus so vereinfacht werden:
return a + " = " + sqrt a*a+b*b
Der Space-Operator ist kein logischer Operator sondern ein Syntaxmittel,
das vor den logischen Operatoren aufgelöst wird und nicht wie die log.
Operatoren von Links nach Rechts sondern er kann nur von Rechts
nach Links aufgelöst werden.
Du hast es mit
> Es sei denn, nach sqrt wird solange numerisch "gedacht" wie es geht.
richtig erkannt. Der Space-Operator kann Kommas und Klammern
herbeizaubern anhand dessen ob er eine Funktion findet oder einen Wert.
So würde aus:
proc test a b c;endproc
return a + " = " + str sqrt a*a+b*b test a b c
proc test(a,b,c);endproc
return a + " = " + str(sqrt(a*a+b*b,test(a,b,c))) |
|
| |
| |
| |
|
|
HofK | "Es sei denn, nach sqrt wird solange numerisch "gedacht" wie es geht."
Ich hatte es gehofft, aber nicht unbedingt erwartet, denn derartig lästige Sonderzeichen sparendes, wirklich vereinfachendes habe ich bei den gängigen Sprachen bisher nicht gesehen. Gibt es das überhaupt schon irgendwo?
Sicher muss man es so einsetzen, dass die Übersichtlichkeit nicht zu kurz kommt. Das wird sich praktisch schnell zeigen.
Der Präkompilierer mit der Syntaxeigenschaft/Syntaxmittel Kodeergänzung durch Space Operator verdient eventuell einen eigenen Paragraphen, bei § 7 Operatoren geht der Space Operator etwas unter und ist ja dann auch kein klassischer Operator.
Das Leerzeichen, der Space Operator ist ein intelligenter Space Seperator, ein intelligenter Trenner, ein Space-Autoseparator kurz ein Autoseparator, ein polymorpher Seperator, damit noch etwas polymorphes bei InfinityProfan.
" ... das vor den logischen Operatoren aufgelöst wird ... er kann nur von Rechts nach Links aufgelöst werden." ist ganz wichtig zum Verständnis und sollte in den Paragraphen rein. Kann man den zugrundeliegenden Algorithmus kurz/vereinfacht/übersichtlich darstellen?
Freue mich schon auf's konstruieren und erklären von Beispielen zur Syntaxeigenschaft. |
|
| |
| |
| |
|
(910)
Deutsch
English
Français
Español
Italia