[code]if <bedingung>
  ..
elsif <bedingung>
  ...
else
  ...
end


def <name>(arg1, arg2=<value>, ...)
  ...
  return <value>;
end


<zahl>.times do |i|
  ....
end


<zahl>.upto(<zahl>) do |i|
  ...
end


loop do
  ...
  break [if <bedingung>];
end


while <bedingung> do
  ...
end


<name> = [obj01, obj02, ....];
<name> = (4..7).to_a();    #-> [4, 5, 6, 7]
<name = %w(h a u s);   #-> ["h", "a", "u", "s"]

<array>.length();
<array>.empty?();

ARGV[]  # das ist die Command$ oder args[]


<feld>.each do |i|
  ...
end

<feld>.each_with_index do |i|
  value = i[0];
  index = i[1];
end


<feld>.join("_");    # implode()
<string>.split("_");   # explode()


<feld>[-1]  ==  <feld>[<feld>.length() - 1]

<feld>[2, 5]   # Elemente ab [2] fünf Stueck
<feld>[2..7]   # das Gleiche wie oben

<feld>[3,1]    # ist wieder ein Feld!
<feld>[<index>] = <value>  ==   <feld>.[]=(<index>, <value>)    # beeindruckend


def <name>(*var)
  ...
end
# kann mit beliebigen Parametern aufgerufen werden, die dann in ein Array gepackt werden.
# "def <name>(var1, *var2)" packt nur alle "ueberstehenden" Parameter in das Array

<name>(*<array>) splittet das Array in Einzelparameter auf, der Letzte bekommt den Rest als Array ab.




# Klassen (beginnen mit Großbuchstabe)

class <name> < <Oberklasse>
  ...
end

<class>.superclass();

initialize()   # ist der Konstruktor

@<name>   # sind "Objekt-Variablen"

self.<methode>    # auf eigene Methoden und Variablen zugreifen (entspricht 'this')

# mit einem erneuten "class <name>" kann eine Klasse jederzeit erweitert werden


# Getter und Setter

def <name>
  @<name>
end
# oder "attr_reader("<name>");"

def <name>=(<name>)
  @<name> = <name>
end
# oder "attr_writer("<name>");"

# beide Methoden mit "attr_accessor("<name>");"



require("<dateiname_ohne_endung>");   # zusätzliche Dateien einlesen



# Sortieren

<array>.sort();

<array>.sort do
  |a, b| a <=> b 
end

<array>.sort do |a, b| 
  a.length <=> b.length 
end

# sortiert erst nach Laenge, dann nach Alphabet
<array>.sort do |a, b|
  if a.length < b.length
    return -1;
  elsif a.length == b.length
    return a <=> b;
  else
    return 1;
  end
end

# <=>: nur bei "1" wir getauscht (= linkes Element ist groesser als das Rechte)



# Strings

var = "hallo";
var[2]        #-> 97
var[2].chr()  #-> "a"
var[2, 1]     #-> "a"


# Symbols

var01 = :hallo;
puts var01    #-> hallo


# Rechnen

<zahl1> ** <zahl2>   # Potenzierunge  vgl "<zahl1> ^ <zahl2>"
1.02e3  ==  1020



# Assoziative Arrays (Hashes)

<hash> = { "key1" => "val1", "key2" => "val2", ... }
<leerer_hash> = {}

<hash>.each do |i|
  puts i[0]   # key
  puts i[1]   # value
end

<hash>.key?
<hash>.value?

<hash>.delete(<key>);   # loescht das ganze Paar

<hash>.empty?
<hash>.length();



# RegExp

muster = /<irgendwas>/
if muster.match(<string>)
  # passt  #  Rueckgabewert ist Array mit allen Matches
else
  # passt nicht  # Rueckgabewert ist nil
end

/<regexp>/.match(<string>);

d  # digit
w  # alpha-numerisch
s  # whitespace-char

D  W  S   # die Komplementäre dazu

?   +   *    # sind gierig
??  +?  *?   # sind nicht gierig


/<regexp>/i   # CaseINsensitive





# Dateien

File.open(<dateiname>, 'r') do |f|
  ....
  f.puts "kjdkfjsl";
end

bzw. "File.open(<dateiname>, 'w') ...   oder 'wb' und 'rb' fuer Binaerdateien


Alternative:
f = File.open(<dateiname>, 'r');
...
f.close();


<array> = f.readlines();    # schreibt alle Zeilen der Datei in ein Array
[/code]