Dein erstes Ruby-Programm

Ruby ist minimalistisch - du brauchst keine Klasse, keine main-Funktion, kein Boilerplate. Einfach anfangen.

Hallo Welt

Die minimale hallo.rb:

puts "Hallo, Ruby!"

Ausfuehren:

ruby hallo.rb
# Hallo, Ruby!

puts vs. print vs. p

puts "Zeile"     # mit Zeilenumbruch
print "Text"     # ohne Zeilenumbruch
p "Wert"          # Debug-Ausgabe mit Anfuehrungszeichen (inspect)
pp datenstruktur  # pretty print fuer komplexe Objekte

String-Interpolation

Anfuehrungszeichen-Varianten in Ruby:

name = "Anna"

# Single-quoted - literal, keine Interpolation
s1 = 'Hallo, #{name}!'       # "Hallo, #{name}!" (woertlich)

# Double-quoted - Interpolation und Escape-Sequenzen
s2 = "Hallo, #{name}!"        # "Hallo, Anna!"
s3 = "Zeile 1\nZeile 2"       # mit Zeilenumbruch

Nutze Double-Quotes by default - die kleine Performance-Differenz ist praktisch irrelevant.

Nutzereingabe

print "Wie heisst du? "
name = gets.chomp

puts "Hallo, #{name}!"

• gets liest eine Zeile mit Zeilenumbruch
• .chomp entfernt den Zeilenumbruch

Methoden

def addieren(a, b)
  a + b
end

puts addieren(3, 4)   # 7

• def ... end statt { ... }
• Kein return noetig - der letzte Ausdruck ist das Ergebnis

Expliziter return geht natuerlich auch:

def sicher_teilen(a, b)
  return 0 if b == 0
  a / b
end

Das if b == 0 am Zeilenende ist Statement-Modifier - sehr idiomatisch.

Einfache Beispiele

Zahl raten

geheim = rand(1..10)
puts "Rate die Zahl zwischen 1 und 10!"

loop do
  print "> "
  eingabe = gets.to_i

  if eingabe == geheim
    puts "Richtig!"
    break
  elsif eingabe < geheim
    puts "Zu klein"
  else
    puts "Zu gross"
  end
end

• rand(1..10) - zufaellige Zahl in einem Range
• gets.to_i - Eingabe als Integer, Ungueltiges wird zu 0
• loop do ... end - Endlosschleife mit break

Begruessung

def gruessen(name, gruss: "Hallo")
  "#{gruss}, #{name}!"
end

puts gruessen("Anna")                    # "Hallo, Anna!"
puts gruessen("Max", gruss: "Moin")      # "Moin, Max!"

Das gruss: nach dem Methodennamen ist ein Keyword-Argument.

Collections

namen = ["Max", "Anna", "Leo"]

namen.each do |name|
  puts "Hallo, #{name}!"
end

# Kuerzer mit {}
namen.each { |name| puts "Hallo, #{name}!" }

Beides ist legitimes Ruby. Konvention: {} fuer einzeilige Blocks, do ... end fuer mehrzeilige.

Ein klein-kompletteres Programm

# fibonacci.rb - Fibonacci-Zahlen

def fib(n)
  return n if n < 2
  fib(n - 1) + fib(n - 2)
end

print "Wie viele Fibonacci-Zahlen? "
anzahl = gets.to_i

if anzahl <= 0
  puts "Bitte eine positive Zahl."
  exit 1
end

ergebnis = (0...anzahl).map { |i| fib(i) }
puts "Fibonacci: #{ergebnis.inspect}"

Was passiert hier?

• (0...anzahl) - Range von 0 bis anzahl-1 (das ... schliesst das Ende aus)
• .map { |i| fib(i) } - transformiert jedes Element
• .inspect - formatiert fuer Debug-Ausgabe
• exit 1 - beendet mit Fehler-Code

Kommentare

# Einzeiliger Kommentar

=begin
Mehrzeiliger Kommentar
(eher selten)
=end

Im Alltag sieht man fast nur #.

Nuetzliche Methoden auf Zahlen

5.times { puts "hallo" }        # 5x "hallo"
(1..5).each { |n| puts n }      # 1 2 3 4 5

5.even?                          # false
4.even?                          # true
(-3).abs                         # 3

10.zero?                         # false

Ruby hat viele ”?-Methoden” die Booleans zurueckgeben - klarer als == 0.

Nuetzliche Methoden auf Strings

"hallo".upcase         # "HALLO"
"HALLO".downcase       # "hallo"
"  text  ".strip       # "text"
"abc".reverse          # "cba"
"ruby".length          # 4
"ruby,rails".split(",") # ["ruby", "rails"]
"ruby" + " on rails"   # "ruby on rails"
"ha" * 3               # "hahaha"

Ausgabe auf STDERR

STDERR.puts "Fehler: etwas ist schiefgelaufen"
exit 1

Oder kurz:

warn "Fehler: ..."

Shebang fuer Skripte

Fuer direkt-ausfuehrbare Skripte unter Linux/macOS:

#!/usr/bin/env ruby

puts "Hallo!"

Dann ausfuehrbar machen und starten:

chmod +x skript.rb
./skript.rb

Zusammenfassung

• puts fuer Ausgabe, gets.chomp fuer Eingabe
• Double-quoted Strings mit "#{variable}"-Interpolation
• def ... end fuer Methoden, letzter Ausdruck ist die Rueckgabe
• Statement-Modifier wie return ... if bedingung sind idiomatisch
• Blocks mit {} oder do ... end an Methoden-Aufrufen
• Ruby hat viele ausdrucksstarke Methoden auf Zahlen/Strings

Im naechsten Kapitel: Variablen, Datentypen und die Ruby-Philosophie “alles ist ein Objekt”.