mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
[crystal/de-de] Translated crystal to German. (#3911)
* Started translation of crystal-lang * continued with translation * finished translation * Replaced 'ss' with 'ß' * Fixed some small typos
This commit is contained in:
parent
548117c36b
commit
cbbce7f185
561
de-de/crystal-de.html.markdown
Normal file
561
de-de/crystal-de.html.markdown
Normal file
@ -0,0 +1,561 @@
|
||||
---
|
||||
language: crystal
|
||||
contributors:
|
||||
- ["Vitalii Elenhaupt", "http://veelenga.com"]
|
||||
- ["Arnaud Fernandés", "https://github.com/TechMagister/"]
|
||||
translators:
|
||||
- ["caminsha", "https://github.com/caminsha"]
|
||||
filename: learncrystal-de.cr
|
||||
lang: de-de
|
||||
---
|
||||
|
||||
```crystal
|
||||
|
||||
# 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
|
||||
|
||||
- [offizielle Dokumentation, englisch](https://crystal-lang.org/)
|
Loading…
Reference in New Issue
Block a user