| language |
contributors |
translators |
filename |
lang |
| crystal |
|
|
learncrystal-de.cr |
de-de |
# Das ist ein Kommentar
# Alles ist ein Objekt
nil.class # => Nil
100.class # => Int32
true.class # => Bool
# Falschwerte sind: nil, false und Nullpointer
!nil # => true : Bool
!false # => true : Bool
!0 # => false : Bool
# Integer
1.class # => Int32
# Fünf vorzeichenbehaftete Ganzzahlen
1_i8.class # => Int8
1_i16.class # => Int16
1_i32.class # => Int32
1_i64.class # => Int64
1_i128.class # => Int128
# Fünf vorzeichenlose Ganzzahlen
1_u8.class # => UInt8
1_u16.class # => UInt16
1_u32.class # => UInt32
1_u64.class # => UInt64
1_u128.class # => UInt128
2147483648.class # => Int64
9223372036854775808.class # => UInt64
# Binäre Zahlen
0b1101 # => 13 : Int32
# Oktalzahlen
0o123 # => 83 : Int32
# Hexadezimalzahlen
0xFE012D # => 16646445 : Int32
0xfe012d # => 16646445 : Int32
# Gleitkommazahlen (floats)
1.0.class # => Float64
# Es gibt zwei Typen von Gleitkommazahlen
1.0_f32.class # => Float32
1_f32.class # => Float32
1e10.class # => Float64
1.5e10.class # => Float64
1.5e-7.class # => Float64
# Chars (einzelne Zeichen)
'a'.class # => Char
# Oktale Schreibweise
'\101' # => 'A' : Char
# Unicode Schreibweise
'\u0041' # => 'A' : Char
# Strings (Zeichenketten)
"s".class # => String
# Strings sind unveränderlich
s = "hello, " # => "hello, " : String
s.object_id # => 1234667712 : UInt64
s += "Crystal" # => "hello, Crystal" : String
s.object_id # => 142528472 : UInt64
# Interpolation wird unterstützt
"sum = #{1 + 2}" # => "sum = 3" : String
# Mehrzeilige Strings
" Dies ist ein
mehrzeiliger String."
# String mit doppeltem Anführungszeichen
%(hello "world") # => "hello \"world\""
# Symbole
# Unveränderbare, wiederverwendbare Konstanten, welche intern als Int32 Integer
# Werte repräsentiert werden.
# Symbole werden oft anstelle von Strings verwendet, um bestimmte Werte zu bestimmen.
:symbol.class # => Symbol
sentence = :question? # :"question?" : Symbol
sentence = :question? # => true : Bool
sentence = :exclamation! # => false : Bool
sentence = "question?" # => false : Bool
# Arrays
[1, 2, 3].class # => Array(Int32)
[1, "hello", 'x'].class # => Array(Int32 | String | Char)
# Leere Arrays sollten einen Typen definieren
[] # => Syntaxfehler: für leere Arrays,
# verwende `[] of ElementType`
[] of Int32 # => [] : Array(Int32)
Array(Int32).new # => [] : Array(Int32)
# Arrays können indiziert werden
array = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5] : Array(Int32)
array[0] # => 1 : Int32
array[10] # führt zu einem IndexError
array[-6] # führt zu einem IndexError
array[10]? # => nil : (Int32 | Nil)
array[-6]? # => nil : (Int32 | Nil)
# Starte am Ende des Arrays
array[-1] # => 5
# Mit einem Startindex und einer Länge
array[2, 4] # => [3, 4, 5]
# oder mit einem Bereich
array[1..3] # => [2, 3, 4]
# Füge etwas zu einem Array hinzu
array << 6 # => [1, 2, 3, 4, 5, 6]
# Entferne Einträge am Ende des Arrays
array.pop # => 6
array # => [1, 2, 3, 4, 5]
# Entferne ersten Eintrag im Array
array.shift # => 1
array # => [2, 3, 4, 5]
# Überprüfe, ob ein Element in einem Array existiert
array.includes? 3 # => true
# Spezielle Syntax für String-Arrays und Symbol-Arrays
%w(one two three) # => ["one", "two", "three"] : Array(String)
%i(one two three) # 0> [:one, :two, :three] : Array(Symbol)
# Es gibt auch für andere Arrays eine spezielle Syntax, wenn die Methoden
# `.new` und `#<<` definiert werden.
set = Set{1, 2, 3} # => [1, 2, 3]
set.class # => Set(Int32)
# Das obere ist äquivalent zu:
set = Set(typeof(1, 2, 3)).new
set << 1
set << 2
set << 3
# Hashes
{1 => 2, 3 => 4}.class # => Hash(Int32, Int32)
{1 => 2, 'a' => 3}.class # => Hash (Int32 | Char, Int32)
# Leere Hashes sollten einen Typen spezifieren
{} # Syntaxfehler
{} of Int32 => Int32 # {}
Hash(Int32, Int32).new # {}
# Hashes können schnell mit dem Key nachgeschaut werden
hash = {"color" => "green", "number" => 5}
hash["color"] # => "green"
hash["no_such_key"] # => Fehlender hash key: "no_such_key" (KeyError)
hash["no_such_key"]? # => nil
# Überprüfe die Existenz eines Hashkeys
hash.has_key? "color" # => true
# Spezielle Schreibweise für Symbol- und Stringkeys
{key1: 'a', key2: 'b'} # {:key1 => 'a', :key2 => 'b'}
{"key1": 'a', "key2": 'b'} # {"key1" => 'a', "key2" => 'b'}
# Die spezielle Syntax für Hash-Literale gibt es auch für andere Typen, sofern
# diese die Methoden `.new` und `#[]=` Methoden definieren.
class MyType
def []=(key, value)
puts "do stuff"
end
end
MyType{"foo" => "bar"}
# Das obere ist äquivalent zu:
tmp = MyType.new
tmp["foo"] = "bar"
tmp
# Ranges (Bereiche)
1..10 # => Range(Int32, Int32)
Range.new(1,10).class # => Range(Int32, Int32)
# Ranges können inklusiv oder exklusiv sein.
(3..5).to_a # => [3, 4, 5]
(3...5).to_a # => [3, 4]
# Überprüfe, ob ein Range einen Wert enthält oder nicht.
(1..8).includes? 2 # => true
# Tupel sind unveränderliche, Stack-zugewiese Folgen von Werten mit fester
# Größe und möglicherweise unterschiedlichen Typen
{1, "hello", 'x'}.class # => Tuple(Int32, String, Char)
# Erhalte den Wert eines Tupels über den Index
tuple = {:key1, :key2}
tuple[1] # => :key2
tuple[2] # syntax error: Index out of bound
# Können auf mehrere Variablen erweitert werden
a, b, c = {:a, 'b', "c"}
a # => :a
b # => 'b'
c # => "c"
# Procs repräsentieren ein Funktionspointer mit einem optionalen Kontext.
# Normalerweise wird ein Proc mit einem proc-Literal erstellt.
proc = ->(x : Int32) { x.to_s }
proc.class # => Print(Int32, String)
# Außerdem kann man auch mit der Methode `new` ein Proc erstellen.
Proc(Int32, String).new { |x| x.to_s }
# Rufe ein Proc auf mit der Methode `call`
proc.call 10 # => "10"
# Kontrollstatements
if true
"if statement"
elsif false
"else-f, optional"
else
"else, auch optional"
end
puts "if as a suffix" if true # => if as a suffix
# If als Ausdruck
a = if 2 > 1
3
else
4
end
a # => 3
# Bedingter ternärer Ausdruck
a = 1 > 2 ? 3 : 4 # => 4
# Case-Statement
cmd = "move"
action = case cmd
when "create"
"Creating..."
when "copy"
"Copying..."
when "move"
"Moving..."
when "delete"
"Deleting..."
end
action # => "Moving..."
# Schleifen
index = 0
while index <= 3
puts "Index: #{index}"
index += 1
end
# Index: 0
# Index: 1
# Index: 2
# Index: 3
index = 0
until index > 3
puts "Index: #{index}"
index += 1
end
# Index: 0
# Index: 1
# Index: 2
# Index: 3
# Der bevorzugte Weg, ist `each` zu verwenden.
(1..3).each do |index|
puts "Index: #{index}"
end
# Index: 1
# Index: 2
# Index: 3
# Der Typ der Variablen hängt vom Typen innerhalb der Kontrollanweisung ab
if a < 3
a = "hello"
else
a = true
end
typeof a # => (Bool | String)
if a && b
# Hier wird garantiert, dass weder a noch b vom Typ Nil sind
end
if a.is_a? String
a.class # => String
end
# Funktionen
def double(x)
x * 2
end
# Funktionen geben implizit den Wert der letzten Anweisung zurück
# Dies ist auch bei anderen Blöcken der Fall.
double(2) # => 4
# Klammern müssen nicht gesetzt werden, wenn der Aufruf eindeutig ist
double 3 # => 6
double double 3 # => 12
def sum(x, y)
x + y
end
# Funktionsargumente werden mit einem Komma separiert.
sum 3, 4 # => 7
sum sum(3, 4), 5 # => 12
# yield
# Alle Methoden haben einen impliziten, optionalen Blockparameter.
# Dieser kann mit dem Schlüsselwort `yield` aufgerufen werden.
def surround
puts '{'
yield
puts '}'
end
surround { puts "Hallo Welt" }
# {
# Hallo Welt
# }
# Du kannst ein Block einer Funktion übergeben.
# "&" kennzeichnet eine Referenz zu einem übergebenen Block
def guests(&block)
block.call "some_argument"
end
# Du kannst eine Liste von Argumenten mitgeben, welche zu einem Array
# umgewandelt werden.
# Hierfür ist der Splat-Operator ("*")
def guests(*array)
array.each { |guest| puts guest }
end
# Wenn eine Methode ein Array zurückgibt, kann destrukturiende Zuordnung
# verwendet werden.
def foods
["pancake", "sandwich", "quesadilla"]
end
breakfast, lunch, dinner = foods
breakfast # => "pancake"
dinner # => "quesadilla"
# Gemäß der Konvention enden alle Methoden, welchen einen Boolean zurückgeben
# mit einem Fragezeichen.
5.even? # false
5.odd? # true
# Und wenn eine Methode mit einem Ausrufezeichen endet, macht sie etwas
# destruktives. Zum Beispiel wird der Aufrufer verändert. Einige Methoden haben
# eine !-Version, um eine Änderung zu machen und eine Nicht-!-Version, welche
# lediglich eine neue veränderte Version zurückgibt.
company_name = "Dunder Mifflin"
company_name.gsub "Dunder", "Donald" # => "Donald Mifflin"
company_name # => "Dunder Mifflin"
company_name.gsub! "Dunder", "Donald"
company_name # => "Donald Mifflin"
# definiere eine Klasse mit dem Schlüsselwort `class`.
class Human
# eine Klassenvariable. Diese wird mit allen Instanzen dieser Klasse geteilt.
@@species = "H. sapiens"
# type of name is String
@name: String
# Grundlegender Intialisierer
# Weise das Argument der Instanz-Variable "name" zu
# Wenn kein Alter angegeben wird, wird der Default (hier 0) genommen.
def initialize(@name, @age = 0)
end
# Einfache Setter-Methode
def name=(name)
@name = name
end
# einfache Getter-Methode
def name
@name
end
# Die obere Funktionalität kann mit der property-Methode gekapselt werden:
property :name
# Getter/Setter-Methoden können auch individuell erstellt werden:
getter :name
setter :name
# eine Klassenmethode verwendet `self` um sich von Instanzmethoden zu
# unterscheiden. Diese kann lediglich von einer Klasse aufgerufen werden,
# nicht von einer Instanz.
def self.say(msg)
puts msg
end
def species
@@species
end
end
# Eine Klasse instanzieren
jim = Human.new("Jim Halpert")
dwight = Human.new("Dwight K. Schrute")
# Lass uns ein paar Methoden aufrufen
jim.species # => "H. sapiens"
jim.name # => "Jim Halpert"
jim.name = "Jim Halpert II" # => "Jim Halpert II"
jim.name # => "Jim Halpert II"
dwight.species # => "H. sapiens"
dwight.name # => "Dwight K. Schrute"
# Rufe die Klassenmethode auf
Human.say("Hi") # => gibt Hi aus und gibt `nil` zurück
# Variablen, welche mit @ starten, sind im Scope der Instanz
class TestClass
@var = "Ich bin eine Instanzvariable"
end
# Variablen, welche mit @@ starten, sind im Scope der Klasse
class TestClass
@@var = "Ich bin eine Klassenvariable"
end
# Variablen, welche mit einem Großbuchstaben starten, sind Konstanten.
Var = "Ich bin eine Konstante"
Var = "Ich kann nicht aktualisiert werden." # Die Konstante Var wurde bereits
# initialisiert.
# In Crystal ist Class auch ein Objekt. Dadurch können Klassen Instanzvariablen
# haben. Klassenvariablen werden mit der Klasse und allen Subklassen geteilt.
# Basisklasse
class Human
@@foo = 0
def self.foo
@@foo
end
def self.foo=(value)
@@foo = value
end
end
# abgeleitete Klasse
class Worker < Human
end
Human.foo # => 0
Worker.foo # => 0
Human.foo = 2 # => 2
Worker.foo # => 0
Worker.foo = 3 # => 3
Human.foo # => 2
Worker.foo # => 3
module ModuleExample
def foo
"foo"
end
end
# Wenn ein Modul mit include eingeschlossen wird, so werden die Methoden an die
# Instanzen gebunden.
# Wenn eine Klasse mit einem Modul erweitert wird, so werden die Methoden an die
# Klasse selbst gebunden.
class Person
include ModuleExample
end
class Book
extend ModuleExample
end
Person.foo # => undefinierte Methode 'foo' für Person:Class
Person.new.foo # => 'foo'
Book.foo # => 'foo'
Book.new.foo # => undefinierte Methode für Book
# Ausnahmebehandlung
# Definiere eine neue Ausnahme
class MyException < Exception
end
# Definiere eine weitere Ausnahme
class MyAnotherException < Exception; end
ex = begin
raise MyException.new
rescue ex1 : IndexError
"ex1"
rescue ex2 : MyException | MyAnotherException
"ex2"
rescue ex3 : Exception
"ex3"
rescue ex4 # fange alle Ausnahmen ab
"ex4"
end
ex # => "ex2"
Weitere Unterlagen
