Variablen und deren Basistypen (Literals)

Variablen sind dazu da, Informationen zu speichern.

In Variablen kann man in einfachsten Fall Zahlen oder Text speichern.

Deklaration, Definition, Initialisierung und Zuweisung

Bei der Deklaration wird der Variablenname und dessen Typ festgelegt. Bei Crystal muss dern Typ allerdings nicht zwingend angegeben werden. Der Compiler versucht beim compilieren, den "richtigen" Typ herauszufinden. Gelingt das nicht oder gibt es widersprüchliche Zuweisungen, kommt es zum Fehler. Der Typ gibt Auskunft, wie die Daten im Speicher zu interpretieren sind.

Die Definition reserviert den erforderlichen Speicherplatz für die Variable.

Bei der Initialisierung wird der Variablen ein Anfangsert zugewiesen.

Eine Zuweisung kann während Laufzeit durchgeführt werden und ändert den Wert einer Variablen.

In Crystal wird es dem Programmierer weitgehend frei überlassen, wie wie strikt er bereits bei der Deklaration an einen Datentypen halten will. So mancher C-Experte wird jetzt die Hände über den Kopf zusammenschlagen. Crystal geht nach der Devise, dass man kann aber nicht muss. Allerdings kann nicht jeder diese Freiheit aushalten!

Beispiel:

# Die Variable 'zahl': 
# - wird als positive Ganzzahl deklariert, 
# - es werden 2 Byte Speicherplatz reseriert
# - wird mit 37 belegt
zahl = 37_u16

# schriebe man
zahl = 37
# wird die 37 als Int32 interpretiert

Vorabbeispiele

Hallo MASCHINFO

text = "Hallo MASCHINFO"	# der Variable 'text' wird mit '=' der String 'Hallo MASCHINFO' zugewiesen

puts text					# gibt die Variable 'text' aus
p! text						# gibt zusätzliche Informationen zur Variable mit aus


Ausgabe:
Hallo MASCHINFO
text # => "Hallo MASCHINFO"

Kommentare werden mit dem Nummerzeichen, Lattenzaun oder neuderings aus Hashtag '#' eingeleitet. Alles was dahinter steht wird vom Compiler ignoriert.

Der Variablenname muß mit einem Kleinbuchstaben oder Unterstrich (_) beginnen und sollte in snake_case geschrieben werden. Ansonsten können beliebige alphanumerische Ausrücke verwendet werden.

Ausgabe mit Variablen

text = "Hallo MASCHINFO"
zahl = 7

p! text
p! zahl

puts "Variable ist: #{zahl}"	# In den Ausgabestring wird eine Variable mit eingebunden


Ausgabe:
text # => "Hallo MASCHINFO"
zahl # => 7
Variable ist: 7

Rechnen mit Variablen

preis = 7
anzahl = 3

ergebnis = preis * anzahl

p! ergebnis

Ausgabe:
ergebnis # => 21

Typen

Nil

'nil' bedeutet, dass eine Wert nicht gesetzt ist. In anderen Programmiersprachen gerne als 'null' bezeichnet.

# Array mit Index 0, 1, 2
arr = [7, 12, 3]

# Wenn es den Index 2 nicht gibt
if arr[2]? == nil 
	puts "Index 2 ist nicht vorhanden."
end

# Wenn es den Index 3 nicht gibt
if arr[3]? == nil 
	puts "Index 3 ist nicht vorhanden."
end


Ausgabe:
Index 3 ist nicht vorhanden.

Bool

'bool' kann nur 'true' oder 'false' annehmen.

# behauptung darf nur wahr (true) oder falsch (false) seind
behauptung : Bool
 
# wir vergleichen zwei Zahlen miteinander
behauptung = (1 == 2)
 
# das Ergebnis vom Vergleich wird ausgegeben
if behauptung == true 
	puts "behauptung ist richtig"
else
	puts "behauptung ist falsch"
end


Ausgabe:
behauptung ist falsch

Integers

Als Interger werden werden ganze Zahlen bezeichnet. Genauere Infos sind unter Zahlen zu finden.
43_int32, 11_u8

Floats

Floats benutzt man für krumme Zahlen.
3.14_f64, 27.8834_f32

Char

Als Char werden einzelen Zeichen bezeichnet.
'a'

String

Strings sind Zeichen ketten. Weiter Infos gibts unter Strings.
"Servus"

Symbol

:symbol

Array

Eine indexbasierte Variable. Ausführliche Infos gibts unter Arrays.
[1, 2, 7, 9]

Array-like

{1, 3, 9,10}

Hash

Auslistung im Key=>Value Stil.

# Hash deklarieren
lieferanten = Hash(String, Float64)

# Hash erstellen
lieferanten = {"dpd" => 5.5, "dhl" => 4.9, "post" => 3.7}

# Der Werte eines Elements kann geändert werden
lieferanten["dhl"] = 8.0

# Zugriff auf einzelne Elemente
p! lieferanten["dpd"]
p! lieferanten["dhl"]

Ausgabe:
lieferanten["dpd"] # => 5.5
lieferanten["dhl"] # => 8.0

Hash-like

{"rot" => 12, "gruen" = 10}

Range

Gibt einen Zahlenbereich zwischen zwei Werten an.
'..' zwei Punkte schliessen die beiden angegeben Wert ein.
'...' drei Punkte schliessen nur den ersten Wert ein.

# Anlegen von Range Variablen
reihe_eins = 1..3
reihe_zwei = 1...3

# Schleife mit allen Zahlen
reihe_eins.each do |zahl|
  p! zahl
end
puts "---"

# Schleife mit allen Zahlen
reihe_zwei.each do |zahl|
  p! zahl
end


Ausgabe:
zahl # => 1
zahl # => 2
zahl # => 3
---
zahl # => 1
zahl # => 2

Regex

Reguläre Ausdrücke. Dazu wird es eine separate Seite geben.

Tuple

Eine indexbasierte Variable.

NamedTuple

Auflistung nach dem Key=>Value Stil. Die Daten werden auf dem Stack gespeichert und sind nicht änderbar.

# Named Tuple erstellen mit {} Klammern
lieferanten = {dpd: 5.5, dhl: 4.9, gls: 7.4, "post": 3.7}

# Der Zugriff auf einzelen Elemente erfolgt so
p! lieferanten[:dhl]
p! lieferanten["post"]
p! lieferanten[:post]
p! lieferanten["gls"]


Ausgabe:
lieferanten[:dhl] # => 4.9
lieferanten["post"] # => 3.7
lieferanten[:post] # => 3.7
lieferanten["gls"] # => 7.4

Wer sich die geschweiften Klammer sparen will, kann das Tuple auch mit NamedTuple.new erstellen:

# Named Tuple erstellen mit NamedTuple.new
lieferanten = NamedTuple.new(dpd: 5.5, dhl: 4.9, gls: 7.4, "post": 3.7)

# Der Zugriff auf einzelen Elemente erfolgt so
p! lieferanten[:dhl]


Ausgabe:
lieferanten[:dhl] # => 4.9

Proc

Funktionspointer

Command

Ausführung von Shell Kommandos

Typ von Variablen feststellen mit typeof

Den Type einer Variablen kann mit typeof feststellen:

# NamedTuple
var1 = {dpd: 5.5, dhl: 4.9, gls: 7.4, "post": 3.7}

# gibt den Typ von var1 aus
p! typeof(var1)


Ausgabe:
typeof(var1) # => NamedTuple(dpd: Float64, dhl: Float64, gls: Float64, post: Float64)