Zuweisungen |
a = "abc"
b = a
a, b = b, a
a, b = [b, a]
a, b = plusMinus(2,1)
x,y,z = 1,2,3
x,y,z = [1,2,3]
x,y,z = [1,2,3,4,5]
x,y,z = [1,2]
|
Verzweigungen |
|
if |
a = "abc"
b = "xyz"
if a < b then
a + " ist kleiner als " + b
else
a + " ist nicht kleiner als " + b
end
def max(x,y)
if x >= y then
x
else
y
end
end
max(2,3)
|
Mehrwegverzweigungen |
|
|
def token(s)
case s
when "if" : :if
when "while" : :while
when /^[a-z]+$/ : :identifier
else nil
end
end
token "if"
token "abc"
token "123"
|
|---|
| |
bedingte Ausdrücke |
a = (defined? x) ? x : 1
x = 2
a = (defined? x) ? x : 1
a = y || 1
y = 2
a = y || 1
|
Schleifen |
|
while |
r = 0
n = 42
while n != 0 do
r = r + n
n = n - 1
end
r
|
besser |
n, r = 42, 0
while n != 0 do
n, r = n - 1, r + n
end
r
|
| |
Zählschleifen |
r = 0
for i in 1..42 do
r = r + i
end
r
|
| |
Blöcke |
sind Ausdrücke (oder Anweisungen) die
parametrisiert sind.
|
Beispiel |
|
|
Dieser Block kann aufgefasst werden als eine Funktion ohne Namen, aber mit einem formalen Parameter i.
|
|
r ist in diesem Beispiel eine zu dem Block globale Variable.
|
alternative Syntax |
|
| |
upto |
Alternative zu Zählschleifen
|
|
r = 0
1.upto(42) {|i| r = r + i }
r
|
|---|
|
Ein Block kann als letzter Parameter an eine Methode übergeben werden.
|
|
upto ist eine Methode mit 2 Parametern.
Der 2.Parameter muss ein Block sein.
|
|
for Schleifen werden intern durch Methoden mit Blöcken als Parameter realisiert.
|
|
Es können eigene Kontrollstrukturen mit Hilfe von Blöcken als Parameter realisiert werden.
Die Menge der Kontrollstrukturen ist also nicht fest von der Sprache vorgegeben.
|
| |
times |
Methode mit einem Block als Parameter
|
|
r = 0
42.times {|i| r = r + i }
r
r = 0
0.upto(41) {|i| r = r + i }
r
|
|---|
|
Mit Hilfe von Blöcken können Schleifen über alle Elemente eines Containers implementiert werden.
|
|
Methoden für Strings: each, each_line, each_byte, sub, gsub, scan,
|
|
Methoden für Listen: each, each_index, map!
|
|
Methoden für assoziative Felder: each, each_key, each_value
|
each |
für Listen
|
|
l = [1,2,3,4,5]
r = []
l.each {|i| r << i * i}
r
|
|---|
| |
each |
für Strings
|
|
r = ""
s = "hello"
s.each_byte do |c|
r << c.to_s << ' '
end
r
|
|---|
|
s = <<END
ein
paar
beliebige
Woerter
END
|
|---|
|
lc,cc=0,0
s.each_line do |l|
lc = lc + 1
cc = cc + l.length
end
cc.to_s + " Zeichen in " + lc.to_s + " Zeilen"
|
|---|
| |
scan |
für Strings
|
|
def words(s)
ws = []
s.scan(/\w+/) {|w| ws << w}
ws
end
words s
|
|---|
map und select |
für Listen
|
|
l = [1,2,3,4,5]
l.map {|x| x*x}
l
l.select {|x| x % 2 == 1}
l.select {|x| x % 2 != 1}
l
|
|---|
| |
Unix & Shell-Programmierung: Kontrollstrukturen und Blöcke
