Ruby in 10 Minuten lernen

8 October 2025 — Programmiersprache

Ruby ist eine dynamische, objektorientierte Programmiersprache, die für ihre elegante Syntax und entwicklerfreundlichen Funktionen bekannt ist. Dieses Tutorial behandelt die Kernkonzepte von Ruby, um dir zu helfen, die Sprache schnell zu erlernen.

1. Dein erstes Ruby-Programm schreiben

Beginnen wir mit einem einfachen Programm. Erstelle eine Datei namens hello.rb und gib folgenden Code ein:

puts "Hello, World!"

Speichere die Datei und führe folgenden Befehl im Terminal aus:

ruby hello.rb

Die Ausgabe wird sein:

Hello, World!

Dieses einfache Programm demonstriert Rubys grundlegende Ausgabefunktionalität. Die puts-Methode wird verwendet, um Textinformationen in der Konsole anzuzeigen.

2. Grundlegende Syntax

Rubys Syntax ist sauber und lesbar, entworfen um natürlich und intuitiv zu sein.

# Dies ist ein Kommentar
puts "Hello, World!"

Grundlegende Syntaxregeln in Ruby:

Kommentare: Einzeilige Kommentare beginnen mit #, während mehrzeilige Kommentare =begin und =end verwenden.
Anweisungen: Typischerweise eine Anweisung pro Zeile, kein Semikolon ; am Ende erforderlich.
Code-Blöcke: Definiert durch do...end oder geschweifte Klammern {}.
Methodenaufrufe: Klammern sind optional für Methodenaufrufe ohne Argumente.

Beispiel mit mehrzeiligen Kommentaren:

=begin
Dies ist ein mehrzeiliger Kommentar,
der sich über mehrere Zeilen erstreckt.
=end

3. Variablen und Datentypen

In Ruby sind Variablen dynamisch typisiert und erfordern keine expliziten Typdeklarationen.

Grundlegende Regeln für Variablennamen:

Variablennamen dürfen nur Buchstaben, Zahlen und Unterstriche enthalten.
Variablennamen dürfen nicht mit einer Zahl beginnen.
Variablennamen sind case-sensitive.
Ruby-Schlüsselwörter können nicht als Variablennamen verwendet werden.

Rubys wichtigste grundlegende Datentypen sind:

Integer (Ganzzahl): z.B. 42 oder -10.
Float (Gleitkommazahl): z.B. 3.14 oder 2.5e3.
String (Zeichenkette): z.B. "hallo" oder 'welt', mit einfachen oder doppelten Anführungszeichen.
Boolean (Wahrheitswert): true oder false.
Nil (Nullwert): Dargestellt durch nil, zeigt null oder keinen Wert an.
Symbol (Symbol): z.B. :name, unveränderliche Identifikatoren.

3.1 Numerische Typen

Ruby unterstützt Ganzzahlen und Gleitkommazahlen.

# Integer
alter = 25
bevölkerung = 1_000_000  # Unterstriche für bessere Lesbarkeit

# Float
temperatur = 36.5
pi = 3.14159

# Operationen
puts 10 + 5   # 15
puts 10 / 3   # 3 (Ganzzahldivision)
puts 10.0 / 3 # 3.333... (Gleitkommadivision)

3.2 String

Strings sind Zeichenfolgen, eingeschlossen in einfache oder doppelte Anführungszeichen.

single_quote = 'String mit einfachen Anführungszeichen'
double_quote = "String mit doppelten Anführungszeichen"
multiline = "Dies ist ein
mehrzeiliger String"

# String-Interpolation (nur in doppelten Anführungszeichen)
name = "Alice"
gruß = "Hallo, #{name}!"
puts gruß  # "Hallo, Alice!"

String-Operationen:

text = "Ruby Programmierung"
puts text.length        # String-Länge
puts text.upcase        # In Großbuchstaben umwandeln
puts text.downcase      # In Kleinbuchstaben umwandeln
puts text[0]            # Auf erstes Zeichen zugreifen
puts text[0..3]         # String-Slicing
puts text.include?("Ruby")  # Auf Inklusion prüfen

3.3 Boolean-Typ

Der Boolean-Typ hat zwei Werte: true und false.

is_active = true
is_complete = false

# Boolean-Operationen
result1 = true && false  # false
result2 = true || false  # true
result3 = !true          # false

3.4 Nil-Typ

nil repräsentiert einen Null- oder keinen-Wert-Zustand.

wert = nil

if wert.nil?
  puts "Wert ist null"
end

3.5 Symbol

Symbole sind unveränderliche Identifikatoren, die oft als Schlüssel in Hashes verwendet werden.

:name
:email
:created_at

# Symbole vs. Strings
puts :name.object_id == :name.object_id  # true (gleiches Objekt)
puts "name".object_id == "name".object_id  # false (verschiedene Objekte)

4. Datenstrukturen

Ruby bietet mehrere eingebaute Datenstrukturen zum Speichern und Manipulieren von Daten.

4.1 Array

Ein Array ist eine geordnete Sammlung, die mehrere Werte enthalten kann.

zahlen = [1, 2, 3, 4, 5]
zahlen.push(6)        # Element hinzufügen
zahlen.unshift(0)     # Am Anfang einfügen
zahlen.delete(3)      # Bestimmten Wert entfernen
zahlen[0] = 10        # Element modifizieren
puts zahlen.inspect   # [10, 2, 4, 5, 6]

Array-Operationen:

zahlen = [10, 20, 30, 40, 50]
puts zahlen[1..3]     # [20, 30, 40]
puts zahlen.first     # 10
puts zahlen.last      # 50
puts zahlen.include?(30)  # true

4.2 Hash

Ein Hash ist eine Sammlung von Schlüssel-Wert-Paaren, ähnlich wie Wörterbücher in anderen Sprachen.

student = {
  name: "John",
  age: 20,
  major: "Computer Science"
}

# Auf Hash zugreifen und modifizieren
puts student[:name]
student[:age] = 21
student[:gpa] = 3.8

# Über Hash iterieren
student.each do |key, value|
  puts "#{key}: #{value}"
end

5. Kontrollstrukturen

Ruby bietet mehrere Kontrollstrukturanweisungen, um die Programmausführung zu steuern.

5.1 if-Anweisungen

Die if-Anweisung wertet eine Bedingung aus und führt ihren Block aus, wenn die Bedingung wahr ist.

alter = 20
if alter >= 18
  puts "Erwachsener"
elsif alter >= 13
  puts "Teenager"
else
  puts "Kind"
end

# Einzeiliges if
puts "Erwachsener" if alter >= 18

5.2 unless-Anweisungen

unless ist das Gegenteil von if - wird ausgeführt, wenn die Bedingung falsch ist.

alter = 15
unless alter >= 18
  puts "Kein Erwachsener"
end

# Einzeiliges unless
puts "Kein Erwachsener" unless alter >= 18

5.3 case-Anweisungen

case-Anweisungen bieten eine saubere Möglichkeit, mehrere Bedingungen zu behandeln.

note = "B"

case note
when "A"
  puts "Ausgezeichnet"
when "B"
  puts "Gut"
when "C"
  puts "Durchschnittlich"
else
  puts "Verbesserungsbedarf"
end

5.4 Schleifen

Ruby unterstützt verschiedene Schleifenkonstrukte.

while-Schleife:

zähler = 0
while zähler < 5
  puts zähler
  zähler += 1
end

until-Schleife:

zähler = 0
until zähler >= 5
  puts zähler
  zähler += 1
end

for-Schleife:

for i in 0..4
  puts i
end

each-Iterator:

(0..4).each do |i|
  puts i
end

# Mit Arrays
früchte = ["Apfel", "Banane", "Kirsche"]
früchte.each do |frucht|
  puts frucht
end

break und next:

(0..9).each do |i|
  break if i == 5     # Schleife verlassen
  next if i % 2 == 0  # Gerade Zahlen überspringen
  puts i              # Ausgabe: 1, 3
end

6. Methoden

Methoden in Ruby werden mit dem def-Schlüsselwort definiert.

Grundlegende Methodendefinition:

def grüße(name)
  "Hallo, #{name}!"
end

# Methode aufrufen
nachricht = grüße("John")
puts nachricht

Standardparameter:

def grüße(name, gruß = "Hallo")
  "#{gruß}, #{name}!"
end

puts grüße("Alice")          # "Hallo, Alice!"
puts grüße("Bob", "Hi")      # "Hi, Bob!"

Variable Argumente:

def summiere_zahlen(*zahlen)
  zahlen.sum
end

puts summiere_zahlen(1, 2, 3, 4)  # 10

Schlüsselwortargumente:

def erstelle_person(name:, alter:, stadt: "Unbekannt")
  { name: name, alter: alter, stadt: stadt }
end

person = erstelle_person(name: "Alice", alter: 25)
puts person.inspect

7. Blöcke und Procs

Blöcke sind Code-Abschnitte, die an Methoden übergeben werden können.

Blöcke verwenden:

# do...end verwenden
3.times do
  puts "Hallo!"
end

# Geschweifte Klammern verwenden
3.times { puts "Hallo!" }

# Blöcke mit Parametern
(1..3).each do |zahl|
  puts "Zahl: #{zahl}"
end

Yield-Schlüsselwort:

def block_ausführen
  puts "Vor Block"
  yield
  puts "Nach Block"
end

block_ausführen { puts "Innerhalb des Blocks" }

Procs:

Procs sind Objekte, die Blöcke kapseln.

quadrat = Proc.new { |x| x * x }
puts quadrat.call(5)  # 25

# Procs an Methoden übergeben
def wende_operation_an(zahlen, operation)
  zahlen.map { |n| operation.call(n) }
end

zahlen = [1, 2, 3, 4]
quadrate = wende_operation_an(zahlen, quadrat)
puts quadrate.inspect  # [1, 4, 9, 16]

8. Klassen und Objekte

Ruby ist eine rein objektorientierte Sprache, in der alles ein Objekt ist.

Grundlegende Klassendefinition:

class Person
  def initialize(name, alter)
    @name = name
    @alter = alter
  end

  def stelle_vor
    "Ich bin #{@name}, #{@alter} Jahre alt"
  end

  def habe_geburtstag
    @alter += 1
    "#{@name} hatte Geburtstag, jetzt #{@alter} Jahre alt"
  end
end

# Objekte erstellen
person1 = Person.new("John", 25)
person2 = Person.new("Jane", 30)

puts person1.stelle_vor
puts person2. habe_geburtstag

Accessor-Methoden:

class Person
  attr_reader :name    # Lesezugriff
  attr_writer :alter   # Schreibzugriff
  attr_accessor :stadt # Lese- und Schreibzugriff

  def initialize(name, alter, stadt)
    @name = name
    @alter = alter
    @stadt = stadt
  end
end

person = Person.new("Alice", 25, "New York")
puts person.name      # "Alice"
person.alter = 26       # Alter setzen
person.stadt = "Boston" # Stadt setzen
puts person.stadt      # "Boston"

Klassenmethoden und -variablen:

class Student
  @@studenten_zähler = 0  # Klassenvariable

  def initialize(name)
    @name = name
    @@studenten_zähler += 1
  end

  def self.studenten_zähler  # Klassenmethode
    @@studenten_zähler
  end
end

student1 = Student.new("John")
student2 = Student.new("Jane")
puts Student.studenten_zähler  # 2

Vererbung:

class Tier
  def initialize(name)
    @name = name
  end

  def sprechen
    "#{@name} macht ein Geräusch"
  end
end

class Hund < Tier
  def sprechen
    "#{@name} bellt"
  end
end

class Katze < Tier
  def sprechen
    "#{@name} miaut"
  end
end

hund = Hund.new("Buddy")
katze = Katze.new("Mimi")

puts hund.sprechen  # "Buddy bellt"
puts katze.sprechen  # "Mimi miaut"

9. Module und Mixins

Module werden verwendet, um verwandte Methoden und Konstanten zu gruppieren und können in Klassen gemischt werden.

Moduldefinition:

module Sprechbar
  def sprechen
    "#{@name} sagt etwas"
  end
end

class Person
  include Sprechbar

  def initialize(name)
    @name = name
  end
end

person = Person.new("Alice")
puts person.sprechen  # "Alice sagt etwas"

Namespacing mit Modulen:

module Math
  PI = 3.14159

  def self.quadrat(x)
    x * x
  end
end

puts Math::PI        # 3.14159
puts Math.quadrat(5)  # 25

10. Ausnahmebehandlung

Ruby bietet robuste Ausnahmebehandlung mit begin, rescue, ensure und raise.

Grundlegende Ausnahmebehandlung:

begin
  ergebnis = 10 / 0
rescue ZeroDivisionError => e
  puts "Kann nicht durch Null teilen: #{e.message}"
else
  puts "Division erfolgreich"
ensure
  puts "Dies wird immer ausgeführt"
end

Ausnahmen auslösen:

def teile(a, b)
  raise "Kann nicht durch Null teilen" if b == 0
  a / b
end

begin
  ergebnis = teile(10, 0)
rescue => e
  puts "Fehler: #{e.message}"
end

11. Dateioperationen

Ruby bietet einfache Methoden zum Lesen und Schreiben von Dateien.

Dateien lesen:

# Ganze Datei lesen
inhalt = File.read("beispiel.txt")
puts inhalt

# Zeile für Zeile lesen
File.foreach("beispiel.txt") do |zeile|
  puts zeile.chomp
end

Dateien schreiben:

# In Datei schreiben
File.write("ausgabe.txt", "Hallo, Ruby!\n")

# An Datei anhängen
File.open("ausgabe.txt", "a") do |datei|
  datei.puts "Neuen Inhalt anhängen."
end

12. Nützliche eingebaute Methoden

Ruby kommt mit vielen nützlichen eingebauten Methoden.

String-Methoden:

text = "  Ruby Programmierung  "
puts text.strip        # Leerzeichen entfernen
puts text.split(" ")   # In Array aufteilen
puts text.gsub("Ruby", "Python")  # Ersetzen

Array-Methoden:

zahlen = [3, 1, 4, 1, 5, 9, 2]
puts zahlen.sort.inspect      # [1, 1, 2, 3, 4, 5, 9]
puts zahlen.uniq.inspect      # [3, 1, 4, 5, 9, 2]
puts zahlen.select { |n| n > 3 }.inspect  # [4, 5, 9]

Hash-Methoden:

person = { name: "Alice", alter: 25, stadt: "New York" }
puts person.keys.inspect    # [:name, :alter, :stadt]
puts person.values.inspect  # ["Alice", 25, "New York"]
puts person.has_key?(:alter)  # true

13. Ruby Gems

RubyGems ist Rubys Paketmanager zum Installieren und Verwalten von Bibliotheken.

Gems installieren:

gem install rails

Gems im Code verwenden:

require 'json'

# JSON parsen
json_string = '{"name": "Alice", "age": 25}'
person = JSON.parse(json_string)
puts person["name"]  # "Alice"

# JSON generieren
person_hash = { name: "Bob", age: 30 }
json_ausgabe = JSON.generate(person_hash)
puts json_ausgabe  # {"name":"Bob","age":30}

14. Ruby Style Guide

Ruby hat einen starken Community-Style-Guide, der sauberen, lesbaren Code fördert.

Einrückung: Verwende 2 Leerzeichen für die Einrückung.

Namenskonventionen:

Variablen und Methoden: snake_case
Klassen und Module: CamelCase
Konstanten: SCREAMING_SNAKE_CASE

Klammern: Verwende Klammern für Methodenaufrufe mit Argumenten, lasse sie für Methodenaufrufe ohne Argumente weg.

Blöcke: Verwende do...end für mehrzeilige Blöcke, {} für einzeilige Blöcke.

Rubys elegante Syntax und leistungsstarke Funktionen machen es zu einer Freude, damit zu arbeiten. Der Fokus auf Entwicklerzufriedenheit und Produktivität hat es für Webentwicklung, Skripting und Automatisierungsaufgaben beliebt gemacht.