summaryrefslogtreecommitdiffhomepage
path: root/de-de/ruby-de.html.markdown
blob: 4815fa403b332385dd3afb02c16505f4e64c27b9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
---
language: ruby
contributors:
  - ["David Underwood", "http://theflyingdeveloper.com"]
  - ["Joel Walden", "http://joelwalden.net"]
  - ["Luke Holder", "http://twitter.com/lukeholder"]
  - ["Tristan Hume", "http://thume.ca/"]
  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
  - ["Ariel Krakowski", "http://www.learneroo.com"]
  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
  - ["Levi Bostian", "https://github.com/levibostian"]
  - ["Rahil Momin", "https://github.com/iamrahil"]
translators:
  - ["Christian Albrecht", "https://github.com/coastalchief"]
filename: ruby-de.html.markdown
lang: de-de
---

# Dies ist ein Kommentar

=begin
Dies sind multi-line
Kommentare. Niemand benutzt
die wirklich.
=end

# Objekte - Alles ist ein Objekt

## Zahlen sind Objekte
```
3.class #=> Fixnum
3.to_s #=> "3"
```

### Simple Arithmetik
```
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
2**5 #=> 32
```

// Arithmetik ist aber eigentlich nur syntaktischer Zucker
// um eine Methode eines Objekt aufzurufen
```
1.+(3) #=> 4
10.* 5 #=> 50
```

## Special values sind Objekte
```
nil # Nothing to see here
true # truth
false # falsehood

nil.class #=> NilClass
true.class #=> TrueClass
false.class #=> FalseClass
```

## Objektvergleiche
### Gleicheit
```
1 == 1 #=> true
2 == 1 #=> false
```
### Ungleichheit
```
1 != 1 #=> false
2 != 1 #=> true
```
### Neben false selbst, nil ist ein anderer 'falsey' Wert
```
!nil   #=> true
!false #=> true
!0     #=> false
```
### Weitere Vergleiche
```
1 < 10 #=> true
1 > 10 #=> false
2 <= 2 #=> true
2 >= 2 #=> true
```
### Logische Operatoren
```
true && false #=> false
true || false #=> true
!true #=> false
```

Es gibt alternative Versionen der logischen Operatoren mit niedrigerer
Wertigkeit. Diese werden meistens bei Flow-Control eingesetzt, um
verschiedenen Ausdrücke zu verketten bis einer true oder false zurück
liefert.

#### and
##### `do_something_else` wird nur ausgewertet wenn `do_something` true ist.
do_something() and do_something_else()

#### or
#####`log_error` wird nur ausgewertet wenn `do_something` false ist.
do_something() or log_error()

## Strings sind Objekte
```
'I am a string'.class #=> String
"I am a string too".class #=> String


platzhalter = 'Ruby'
"Ich kann in #{placeholder} Platzhalter mit doppelten Anführungsstrichen füllen."
```
Einfache Anführungszeichen sollten bevorzugt werden.
Doppelte Anführungszeichen führen interne Berechnungen durch.

### Strings können verbunden werden, aber nicht mit Zahlen
```
'hello ' + 'world'  #=> "hello world"
'hello ' + 3 #=> TypeError: can't convert Fixnum into String
```
#### Zahl muss in String konvertiert werden
```
'hello ' + 3.to_s #=> "hello 3"
```
### Text ausgeben
```
puts "I'm printing!"
```
# Variablen
## Zuweisungen
### Diese Zuweisung gibt den zugeordneten Wert zurück
```
x = 25 #=> 25
x #=> 25
```
### Damit funktionieren auch mehrfache Zuweisungen
```
x = y = 10 #=> 10
x #=> 10
y #=> 10
```
## Benennung
### Konvention ist snake_case 
```
snake_case = true
```
### Benutze verständliche Variablennamen
```
path_to_project_root = '/good/name/'
path = '/bad/name/'
```
# Symbols (sind auch Objekte)
Symbols sind unveränderliche, wiederverwendbare Konstanten, welche intern  
als integer repräsentiert werden. Sie werden häufig anstelle von Strings  
verwendet, um sinnvoll Werte zu übermitteln.  
Symbols werden mit dem Doppelpunkt gekennzeichnet.

```
:pending.class #=> Symbol
status = :pending
status == :pending #=> true
status == 'pending' #=> false
status == :approved #=> false
```
# Arrays

## Ein Array anlegen
```
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
```

## Array können verschiedene Typen beinhalten
```
[1, 'hello', false] #=> [1, "hello", false]
```

## Wie bei arithmetischen Ausdrücken auch wird beim Zugriff auf
## [0] eigentlich die Methode [] des Array Objekts aufgerufen.
```
array.[] 0 #=> 1
array.[] 12 #=> nil
```

## Arrays können von vorne indiziert werden
```
array[0] #=> 1
array[12] #=> nil
```

## Arrays können von hinten indiziert werden
```
array[-1] #=> 5
```

## Arrays können mit Stard Index und Länge indiziert werden
```
array[2, 3] #=> [3, 4, 5]
```

## Arrays können mit einer Range indiziert werden
```
array[1..3] #=> [2, 3, 4]
```

## Einen Wert hinzufügen
```
array << 6 #=> [1, 2, 3, 4, 5, 6]
array.push(6) #=> [1, 2, 3, 4, 5, 6]
```

## Testen, ob ein Element schon vorhanden ist
```
array.include?(1) #=> true
```

# Hashes 
Hashes sind das Hauptfeature um Key/Values zu speichern

```

## Ein Hash anlegen
```
hash = { 'color' => 'green', 'number' => 5 }
hash.keys #=> ['color', 'number']
```

## Wert per key herausfinden
```
hash['color'] #=> 'green'
hash['number'] #=> 5
hash['nothing here'] #=> nil 
// Asking a hash for a key that doesn't exist returns nil:
```

##  Symbols können auch keys sein
```
new_hash = { defcon: 3, action: true }
new_hash.keys #=> [:defcon, :action]
```

## Testen ob ein Key oder ein Value existiert
```
new_hash.has_key?(:defcon) #=> true
new_hash.has_value?(3) #=> true
```

### Tip:  Arrays und Hashes sind Enumerable
### Und haben gemeinsame, hilfreiche Methoden wie:
### each, map, count, and more

# Kontrolstrukturen
## if
```
if true
  'if statement'
elsif false
  'else if, optional'
else
  'else, also optional'
end
```
## for - Allerdings werden for Schleifen nicht oft vewendet.
```
for counter in 1..5
  puts "iteration #{counter}"
end
```
## Stattdessen: "each" Methode und einen Bloch übergeben
Ein Block ist ein Codeteil, den man einer Methode übergeben kann  
Ähnelt stark lambdas, anonymen Funktionen oder Closures in anderen  
Programmiersprachen.

```
(1..5).each do |counter|
  puts "iteration #{counter}"
end
```

Die each Methode einer Range führt den Block für jedes Element der Range aus.

Dem Block wird ein "counter" parameter übergeben.

### Den Block kann man auch in geschweiften Klammern schreiben
```
(1..5).each { |counter| puts "iteration #{counter}" }
```

### Each kann auch über den Inhalt von Datenstrukturen iterieren
```
array.each do |element|
  puts "#{element} is part of the array"
end
hash.each do |key, value|
  puts "#{key} is #{value}"
end

counter = 1
while counter <= 5 do
  puts "iteration #{counter}"
  counter += 1
end
```

## case
```
grade = 'B'

case grade
when 'A'
  puts 'Way to go kiddo'
when 'B'
  puts 'Better luck next time'
when 'C'
  puts 'You can do better'
when 'D'
  puts 'Scraping through'
when 'F'
  puts 'You failed!'
else
  puts 'Alternative grading system, eh?'
end
=> "Better luck next time"
```

### Case können auch ranges
```
grade = 82
case grade
when 90..100
  puts 'Hooray!'
when 80...90
  puts 'OK job'
else
  puts 'You failed!'
end
=> "OK job"
```

# exception handling:
```
begin
  # code here that might raise an exception
  raise NoMemoryError, 'You ran out of memory.'
rescue NoMemoryError => exception_variable
  puts 'NoMemoryError was raised', exception_variable
rescue RuntimeError => other_exception_variable
  puts 'RuntimeError was raised now'
else
  puts 'This runs if no exceptions were thrown at all'
ensure
  puts 'This code always runs no matter what'
end
```
# Funktionen
```
def double(x)
  x * 2
end
```
## Funktionen (und Blocks) 
## geben implizit den Wert des letzten Statements zurück
```
double(2) #=> 4
```

### Klammern sind optional wenn das Ergebnis nicht mehdeutig ist
```
double 3 #=> 6
double double 3 #=> 12
def sum(x, y)
  x + y
end
```

### Methoden Parameter werden per Komma getrennt
```
sum 3, 4 #=> 7
sum sum(3, 4), 5 #=> 12
```

## yield
### Alle Methoden haben einen impliziten, optionalen block Parameter
### Dieser wird mit dem Schlüsselword "yield" aufgerufen
```
def surround
  puts '{'
  yield
  puts '}'
end
surround { puts 'hello world' }
```

## Einen Block kann man auch einer Methoden übergeben
### "&" kennzeichnet die Referenz zum übergebenen Block
```
def guests(&block)
  block.call 'some_argument'
end
```

### Eine Liste von Parametern kann man auch übergeben,
### Diese wird in ein Array konvertiert
### "*" kennzeichnet dies.
```
def guests(*array)
  array.each { |guest| puts guest }
end
```
# Klassen
## Werden mit dem class Schlüsselwort definiert
```
class Human
```

### Konstruktor bzw. Initializer
```
  def initialize(name, age = 0)
    # Assign the argument to the "name" instance variable for the instance
    @name = name
    # If no age given, we will fall back to the default in the arguments list.
    @age = age
  end
```

### setter Methode
```
  def name=(name)
    @name = name
  end
```
### getter Methode
```
  def name
    @name
  end
```

#### getter können mit der attr_accessor Methode vereinfacht definiert werden
```
  attr_accessor :name
  # Getter/setter methods can also be created individually like this
  attr_reader :name
  attr_writer :name
  # A class method uses self to distinguish from instance methods.
  # It can only be called on the class, not an instance.
  def self.say(msg)
    puts msg
  end
  def species
    @@species
  end
end
```

## Eine Klasse instanziieren
```
jim = Human.new('Jim Halpert')
dwight = Human.new('Dwight K. Schrute')
```

## Methodenaufrufe
```
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"
```

## Eine Klassenmethode aufrufen
```
Human.say('Hi') #=> "Hi"
```

## Variable Gültigkeit
### Variablen die mit "$" starten, gelten global
```
$var = "I'm a global var"
defined? $var #=> "global-variable"
```

### Variablen die mit "@" starten, gelten für die Instanz
```
@var = "I'm an instance var"
defined? @var #=> "instance-variable"
```

### Variablen die mit "@@" starten, gelten für die Klasse
```
@@var = "I'm a class var"
defined? @@var #=> "class variable"
```

### Variablen die mit einem Großbuchstaben anfangen, sind Konstanten
```
Var = "I'm a constant"
defined? Var #=> "constant"
```

## Class ist auch ein Objekt
### Hat also auch Instanzvariablen
### Eine Klassenvariable wird innerhalb der Klasse und Ableitungen geteilt.

### Basis Klasse
```
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 # 2
```

### Eine Klasseninstanzvariable wird nicht geteilt
```
class Human
  @bar = 0
  def self.bar
    @bar
  end
  def self.bar=(value)
    @bar = value
  end
end
```
```
class Doctor < Human
end
```
```
Human.bar # 0
Doctor.bar # nil
```
```
module ModuleExample
  def foo
    'foo'
  end
end
```
### Module einbinden, heisst ihre Methoden an die Instanzen der Klasse zu binden
### Module erweitern, heisst ihre Mothden an die Klasse selbst zu binden
```
class Person
  include ModuleExample
end
```
```
class Book
  extend ModuleExample
end
```
```
Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
Person.new.foo # => 'foo'
Book.foo       # => 'foo'
Book.new.foo   # => NoMethodError: undefined method `foo'
```
### Callbacks werden ausgeführt, wenn ein Modul eingebunden oder erweitert wird
```
  module ConcernExample
    def self.included(base)
      base.extend(ClassMethods)
      base.send(:include, InstanceMethods)
    end
    module ClassMethods
      def bar
        'bar'
      end
    end
    module InstanceMethods
      def qux
        'qux'
      end
    end
  end
  class Something
    include ConcernExample
  end
```
```
Something.bar     # => 'bar'
Something.qux     # => NoMethodError: undefined method `qux'
Something.new.bar # => NoMethodError: undefined method `bar'
Something.new.qux # => 'qux'
```

## Additional resources

- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.