Wie in vielen anderen Programmiersprachen, so gibt es auch in Ruby Konventionen, welche den Code verständlicher, lesbarer und leichter zu debuggen machen. Ruby kennt die folgenden Konventionen:

Worttrennung

In Sprachen wie Java wird Worttrennung mittels CamelCase bei jedem weiteren Wort realisiert - das gilt in Ruby als unelegant (eine Ausnahme bilden hier nur Klassennamen). Um Wörter zu trennen, wenn man denn unbedingt mehr als ein Wort als Namen verwenden will, werden Unterstriche (_) benutzt. Klassennamen sollten, mit Großbuchstaben beginnend, nach wie vor in CamelCase geschrieben werden.

1
2
3
4
5
6
7
8
9
10

@das_ist_eine_langer_variablenname = true

$meine_variable = nil

def eine_methode
  puts "Hello!"
end

class EineKlasse #Bei Klassen findet sich sowohl die Eine_Klasse- als auch die EineKlasse-Schreibweise. 
end

Methodennamen

Methodennamen werden in Ruby generell klein geschrieben, auch wenn die Syntax der Kompatibilität wegen großgeschriebene Methodennamen erlaubt.

1
2
3
4
5
6
7

def meine_methode
  puts "Kleiner Methodenname!"
end

def UnueblicherName
  puts "Großer Methodenname"
end

Selbstmodifizierende Methoden

Alle Methoden, die das Objekt, dass sie aufrufen, modifizieren, sollten ein Ausrufezeichen (!) am Ende ihres Methodennamens tragen. Einige Methoden, wie zum Beispiel Thread#terminate tun das nicht, aber solchen Methoden sieht man für gewöhnlich bereits am Namen an, dass sie ihren Sender verändern.

1
2
3
4
5
6

string = "Hello world!"

string.sub("Hello", "Goodbye") #=> Goodbye world!
string #=> Hello world!
string.sub!("Hello", "Goodbye") #=> Goodbye world!
string #=> Goodbye world!

Boolsche Methoden

Methoden, die nur true oder false zurückgeben, sind mit einem Fragezeichen (?) gekennzeichnet:

1
2

1.nil? #=> false
[].empty? #=> true

Schreiben von Methodennamen

Wenn in der Ruby-Community über Methoden gesprochen wird oder Methoden dokumentiert werden, so muss deutlich gemacht werden, ob es sich bei der Methode nun um eine Klassen- oder Instanzmethode handelt. Es gilt folgende Konvention:

• Instanzmethoden: Klasse#instanzmethode
• Klassenmethode: Klasse::klassenmethode

In der Regel meint aber Klasse.methode Klassen- und nicht Instanzmethoden.

Konstanten

Konstanten werden in Ruby tradionell großgeschrieben.

MEINE_KONSTANTE = true

Klassen- und Modulnamen

Sowohl Klassen- als auch Modulnamen beginnen groß und gehen dann klein weiter:

1
2
3
4

module MeinModul
  class MeineKlasse
  end
end

Variablen

Alle Variablennamen sind ausschließlich klein, egal ob es sich um lokale, Instanz-, Klassen- oder globale Variablen handelt.

1
2
3
4
5
6
7
8
9
10
11

$global = "Meine globale Variable"

class Klasse

  @@klassen_variable = "Meine Klassenvariable"

  def initialize(wert = "Meine Instanzvariable")
    @instanzvariable = wert
  end

end

Klammern

Bei Methoden

Klammern sind in den meisten Fällen optional, es bleibt dem Programmierer überlassen, ob er sie verwendet oder nicht:

1
2

puts "A"
puts("A")

Decorators

Die meisten Rubyisten haben sich allerdings dafür entschieden, sogenannte Decorator-Methoden wie z.B. attr_accessor ohne Klammern zu schreiben.

1
2
3
4
5
6
7
8
9
10
11

class MeineKlasse
  attr_accessor :wert
  
  def initialize(wert)
    @wert = wert
  end

end

x = MeineKlasse.new("Ein Wert")
puts x.wert #=> Ein Wert

Methoden ohne Argumente

Wenn einer Methode keinerlei Argumente mitgegeben werden, lässt man die leeren Klammern () nach dem Methodennamen weg.

1
2
3
4

#Unüblich: 
[1, 2, 3].to_s()
#Besser: 
[1, 2, 3].to_s

Bei Konstrukten

Klammern um die Bedingungen einer if-Struktur oder einer Schleife werden weggelassen, weil unnötig:

1
2
3
4
5
6
7
8
9

a = 1
#Ungebräuchlich: 
if (a > 0)
  #Mache irgendwas...
end
#Korrekt: 
if a > 0
  #Mache irgendwas...
end

Einrückungen

Verschachtelter Ruby-Code wird eingerückt. Dies dient der Übersichtlichkeit und ermöglicht auch einfacheres Debuggen des Codes. In der Ruby-Community haben sich 2 Leerzeichen pro Verschachtelungslevel eingebürgert, Tabs werden nicht verwendet (viele Editoren lassen sich so einstellen, dass sie beim Druck der Tabulator-Taste statt Tabs Leerzeichen benutzen).

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

#Level 0
class A
  #Level 1
  attr_reader :x
  
  def initialize
    #Level 2
    @x = [1, 2, 3]
  end
  #Level 1
  def methode
    #Level 2
    @x.each do |val|
      #Level 3
      if val % 2 == 0
        #Level 4
        val += 9
      end
      #Level 3
    end
    #Level 2
  end
  #Level 1
end
#Level 0
y = A.new
y.methode
p y.x