Die Programmiersprache Ruby

Blog| Forum| Wiki  

Das Kernel-Modul definiert eine Reihe von (größtenteils private) Methoden, die überall in einem Programm verfügbar sind, da bereits die Klasse Object das Kernel-Modul einmixt. Um eine Klasse zu erhalten, die selbst von den Methoden des Kernel-Moduls frei ist, sollte man als Superklasse BasicObject nehmen, das Kernel nicht einmixt.

Inhaltsverzeichnis

Modulmethoden

__callee__

Alias für __method__.

__method__

Anwendung __method__ ==> einSymbol
Argumente

Keine.

Beschreibung Gibt den Namen der momentan ausgeführten Methode zurück. Wird es außerhalb einer Methode aufgerufen, nil.
Rückgabewert Ein Symbol oder nil.
Beispiel
1
2
3
4
5
6
def a
  __method__
end

p __method__ #=> nil
p a #=> :a



`

Anwendung `cmd` ==> einString
Argumente
  • cmd: Der auszuführende Befehl.
Beschreibung Führt einenen Systembefehl aus und gibt dessen Output zurück. Die eingebaute %x{..}-Syntax benutzt diese Methode. $? wird auf den Beendigungsstatus gesetzt.
Rückgabewert Ein String.
Beispiel
1
2
`echo hello` #=> "hello\n"
$?.exitstatus #=> 0



Array

Anwendung Array( arg ) ==> einArray
Argumente
  • arg: Das zu konvertierende Objekt.
Beschreibung Konvertiert arg zu einem Array, indem es zunächst versucht, die Methode to_ary auf arg anzuwenden, dann to_a.
Rückgabewert Ein Array.
Beispiel
Array(1..5) #=> [1, 2, 3, 4, 5]



Complex

Anwendung Complex( r , i ) ==> einComplex
Argumente
  • r: Der Realteil der komplexen Zahl.
  • i: Der Imaginärpart der komplexen Zahl.
Beschreibung Erstellt eine komplexe Zahl.
Rückgabewert Die komplexe Zahl.
Beispiel
Complex(3, 9) #=> (3+9i)


Float

Anwendung Float( arg ) ==> einFloat
Argumente
  • arg: Das zu konvertierende Objekt.
Beschreibung Konvertiert arg in ein Float.

Numerische Objekte werden direkt konvertiert, alles andere über die Methode to_f.

Rückgabewert Ein Float.
Beispiel
1
2
3
Float(1) #=> 1.0
Float("123.456") #=> 123.456
Float(nil) #=> TypeError



Integer

Anwendung Integer (arg ) ==> einInteger
Argumente
  • arg: Das zu konvertierende Objekt.
Beschreibung Konvertiert ein Objekt in einen Integer, je nach Größe Fixnum oder Bignum. Kommazahlen werden abgeschnitten, nicht gerundet. Wenn arg ein Präfix wie 0x enthält, wird es von der Methode berücksichtigt, alle anderen Objekte werden per to_int und to_i konvertiert. Das Verhalten dieser Methode unterscheidet sich allerdings von dem von String#to_i.
Rückgabewert Ein Fixnum oder Bignum.
Beispiel
1
2
3
4
5
Integer(123.999) #=> 123
Integer("0x1A") #=> 26
Integer(Time.new) #=> 1204973019
"A".to_i #=> 0
Integer("A") #=> ArgumentError


Rational

Anwendung Rational( z, n ) ==> einRational
Argumente
  • z: Der Zähler des Bruchs.
  • n: Der Nenner des Bruchs.
Beschreibung Erstellt einen Bruch, der eine Zahl sehr viel präziser beschreiben kann als zum Beispiel ein Float.
Rückgabewert Ein Bruch in Form eines Rational-Objekts.
Beispiel
1
2
3
Rational(3, 2) #=> (3/2)
Rational(4, 7) #=> (4/7)
Rational(50, 100) #=> (1/2)


String

Anwendung String( arg ) ==> einString
Argumente
  • arg: Das zu konvertierende Objekt.
Beschreibung Konvertiert ein Objekt zu einem String, indem dessen to_s-Methode aufgerufen wird.
Rückgabewert Ein String.
Beispiel
1
2
3
String(self) #=> "main"
String(self.class) #=> "Object"
String(123456) #=> "123456"



abort

Anwendung abort( [msg = nil ] )
Argumente
  • msg (nil): Der hier angegebene Text wird vor Beenden auf STDERR geschrieben.
Beschreibung Beendet einen Prozess über den Aufruf Kernel.exit(1).
Rückgabewert Undefiniert.
Beispiel
1
2
3
4
#Encoding: Windows-1252
puts "A"
abort("Ende im Gel��nde")
puts "B"

Output:

1
2
A
Ende im Gel��nde


at_exit

Anwendung at_exit{...} ==> einProc
Argumente

Keine.

Beschreibung Konvertiert den mitgegebenen Block in ein Proc-Objekt und registriert es zur Ausführung kurz vor Programmende. Wenn mehrere Blöcke registriert wurden, werden sie in umgekehrter Reihenfolge ausgeführt.
Rückgabewert Das registrierte Proc-Objekt.
Beispiel
1
2
3
4
5
6
7
def do_at_exit(str1)
  at_exit { print str1 }
end

at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit


Output:

goodbye cruel world



autoload

Anwendung autoload( mod , filename ) ==> nil
Argumente
  • mod: Das/Die zu registrierende Modul/Klasse. Kann ein String oder ein Symbol sein.
  • filename: Die Datei, die zu laden ist.
Beschreibung Registriert ein Modul oder eine Klasse, um bei Bedarf - d.h. beim ersten Auftreten des registrierten Namens - per Kernel#require geladen zu werden. Kernel#autoload ist eine oft verkannte Möglichkeit, Dateien einzubinden. Es ermöglicht ein kontextabhängiges Laden von Dateien, sodass nicht immer alle Bibliotheken, die zur vollständigen Funktion eines Programms notwendig sind, geladen werden müssen.
Rückgabewert Stets nil.
Beispiel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
autoload(:EinModul, "ein_modul")
class A

  def initialize
    p defined? EinModul
  end

  def load_module
    EinModul
    p defined? EinModul
  end

end

x = A.new
x.load_module


Output:

1
2
3
Test.rb:9: warning: useless use of a constant in void context
nil
"constant"



autoload?

Anwendung autoload?( mod ) ==> einString oder nil
Argumente
  • mod: Das/Die zu prüfende Modul/Klasse, ein Symbol oder String.
Beschreibung Prüft, ob ein Modul oder eine Klasse zur automatischen Einbindung per Kernel#require registriert ist.
Rückgabewert Wenn das/die Modul/Klasse registriert ist, wird der Dateipfad angegeben, der geladen werden würde, wenn nein, nil.
Beispiel
1
2
3
p autoload? :EinModul #=> nil
autoload(:EinModul, "ein_modul")
p autoload? :EinModul #=> "ein_modul"



binding

Anwendung binding ==> einBinding
Argumente

Keine.

Beschreibung Bildet den Status des Ruby-Interpreters zum Zeitpunkt des Methodenaufrufs auf ein Binding-Objekt ab, das z.B. in Kernel#eval gegeben werden kann und so z.B. lokale Variablen verfügbar macht.
Rückgabewert Ein Binding.
Beispiel
1
2
3
4
5
6
def get_binding(x)
  binding
end

b = get_binding("Hello!")
eval("x", b) #=> Hello!


block_given?

Anwendung block_given? ==> true oder false
Argumente

Keine.

Beschreibung Prüft, ob yield an dieser Stelle einen Block ausführen würde. Wird benutzt, um Iteratormethoden zu schreiben.
Rückgabewert true oder false, je nach Ergebnis der Analyse.
Beispiel
1
2
3
4
5
6
7
8
9
10
11
12
13
def execute_block
  if block_given?
    yield
  else
    puts "No block given!"
  end
end

execute_block #=> No block given!
execute_block{puts "Hello world!"} #=> Hello world!
execute_block do
  puts "Hello world!"
end #=> Hello world!


caller

Anwendung caller( [start = 1 ] ) ==> einArray
Argumente
  • start(1): Gibt an, wie viele Angaben vom Aufrufpunkt aus gesehen weggelassen werden sollen.
Beschreibung Ermittelt die Position der Codezeile, in der Kernel#caller aufgerufen wird.
Rückgabewert Ein Array, das Strings in der Form "file:line" oder "file:line: in `method'" enthält.
Beispiel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def a(skip)
  caller(skip)
end

def b(skip)
  a(skip)
end

def c(skip)
  b(skip)
end

c(0)   #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10"]
c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11"]
c(2)   #=> ["prog:8:in `c'", "prog:12"]
c(3)   #=> ["prog:13"]


catch

Anwendung catch( obj ) {...} ==> einObject
Argumente
  • obj: Das zu fangende Objekt. Klassischerweise ein Symbol.
Beschreibung Vorweg: Diese Methode hat nichts mit Exceptions zu tun, siehe dazu Kernel#raise.

catch fängt ein von Kernel#throw geworfenes Objekt. Wird throw innerhalb des Blockes von catch aufgerufen (und gibt das catch angegebene Objekt zurück), terminiert catch die Ausführung des Blockes unverzüglich. catch/throw-Aufrufe können verschachtelt werden, und ein throw muss sich nicht im Gültigkeitsbereich eines catchs befinden.

Rückgabewert Das Objekt, das throw mitgegeben wurde, oder, falls throw nicht aufgerufen wird, der Wert des letzten Ausdrucks des Blocks. Wird throw aufgerufen, ohne, dass ihm ein Wert mitgegeben wird, ist der Rückgabewert nil.
Beispiel
1
2
3
4
5
6
7
def routine(n)
  puts n
  throw :done if n <= 0
  routine(n-1)
end

catch(:done) { routine(3) }


Output:

1
2
3
4
3
2
1
0


eval

Anwendung eval( string [, bind [, name [, lineno ] ] ] ) ==> einObject
Argumente
  • string: Der zu evaluierende String.
  • bind (binding()): Der Evaluierungskontext. Siehe dazu Binding und Kernel#binding.
  • name ("(eval)"): Name des evals in Fehlermeldungen.
  • lineno (1): Die Zeilennummer der ersten Codezeile. Wird bei Fehlern als Angabe benutzt.
Beschreibung Evaluiert Ruby-Ausdrücke, dass heißt, führt sie aus, als wären sie eine Skript-Datei. Wird der Parameter bind mit angegeben, erhält der Code im eval diesen als Kontext, kann also z.B. auf lokale Variablen, die in einer Methode definiert wurden, zugreifen. Der dritte Parameter name wird benutzt, um bei Fehlermeldungen während des Evaluierens angezeigt zu werden.

eval ist gefährlich! Wenn der Input von eval zum Beispiel von außen kommt und nicht geprüft wird, ermöglicht das dem Benutzer sämtlichen Ruby-Code ausführen lassen zu können. Siehe dazu unbedingt den Artikel Evil eval.

Rückgabewert Der Wert des letzten ausgewerteten Ausdrucks in string.
Beispiel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
code = 'puts "Hello!"'
eval(code) #=> Hello!

def scope
  x = 1
  return binding
end

code = "puts x"
eval(code) #=> NameError
eval(code, scope) #=> 1

invalid_code = "puts(1"
eval(invalid_code)
#=> Test.rb:3:in `eval': (eval):1: syntax error, unexpected $end, expecting ')' (SyntaxError)
eval(invalid_code, binding, "Absichtlich falscher Code")
#=> Test.rb:3:in `eval': Absichtlich falscher Code:1: syntax error, unexpected $end, expecting ')' (SyntaxError)
#binding musste ��bergeben werden, damit der letzte Parameter auch ��bergeben werden konnte. 
eval(invalid_code, binding, "Absichtlich falscher Code", 10)
#=> Test.rb:3:in `eval': Absichtlich falscher Code:10: syntax error, unexpected $end, expecting ')' (SyntaxError)


exec

Anwendung exec( [env, ] command [, options ] )
Argumente
  • env (nil): Die Umgebung, in der der Befehl ausgeführt werden soll. Standardmäßig die des jetzigen Prozesses.
  • command: Der auszuführende Befehl.
  • options (nil): An den Befehl zu übergebende Argumente.
Beschreibung Ersetzt den aktuellen Prozess mit einem anderen.
Rückgabewert Undefiniert.
Beispiel
1
2
exec("echo *") #Listet alle Dateien im aktuellen Verzeichnis
puts("Das hier wird nicht ausgef��hrt.")


1
2
exec("echo", "*") #Gibt ein Sternchen aus
puts("Das hier wird nicht ausgef��hrt.")



exit

Anwendung exit( [ret = 0] )

Process.exit( [ret = 0] )

Argumente
  • ret (0): Der an das Betriebssystem zurückzugebende Exitcode.
Beschreibung Beendet ein Ruby-Programm, indem es die SystemExit-Exception wirft. Diese kann allerdings aufgefangen werden.
Rückgabewert Undefiniert.
Beispiel
1
2
3
puts "Vor exit"
exit
puts "Nach exit"

Output:

Vor exit


1
2
3
4
5
6
7
begin
  exit
  puts "Das wird nicht ausgef��hrt."
rescue SystemExit
  puts "SystemExit abgefangen. "
end
puts "Nach dem begin/rescue-Block. "

Output:

1
2
SystemExit abgefangen. 
Nach dem begin/rescue-Block.



exit!

Anwendung exit!( [ret = -1] )

Process.exit!( [ret = -1] )

Argumente
  • ret (-1): Der an das Betriebssystem zurückzugebende Exitcode
Beschreibung Terminiert ein Ruby-Programm sofort. Es werden keine END- und at_exit-Blöcke ausgeführt.
Rückgabewert Undefiniert.
Beispiel
1
2
3
END{puts "END"}
at_exit{puts "at_exit"}
exit!

Kein Output.


fail

Alias für Kernel#raise.

fork

Anwendung fork{...} ==> einInteger oder nil

Process.fork{...} ==> einInteger oder nil

Argumente

Keine.

Beschreibung Erstellt einen Kindprozess, in dem der angegebene Block ausgeführt wird. Die Methode ist nur auf unixoiden Systemen implementiert.
Rückgabewert Die PID des Kindprozesses oder nil.
Beispiel
fork{sleep(20)}


format

Alias für Kernel#sprintf.

gem

Anwendung gem( name [, *versions ] ) ==> true oder false
Argumente
  • name: Der Name des Gems.
  • *versions(neueste): Die vorzubereitende Version. Es kann sich auch um mehrere begrenzende Angaben handeln.
Beschreibung Fügt die angegebene Version eines Gems $: hinzu, sodass in jedem Fall die angegebene Version des Gems geladen wird, auch wenn eine neuere installiert ist.
Rückgabewert Undefiniert.
Beispiel
1
2
gem("rubylexer", "<0.7")
require "rubylexer"


gets

Anwendung gets( [sep = $/ ] ) ==> einString oder nil
Argumente
  • sep($/): Der Eingabe-Separator. Standardmäßig Newline.
Beschreibung Gibt die nächste Zeile der auf ARGV angegebenen Dateien zurück (und setzt $_ auf den Wert). Ist sep nil, wird eine ganze Datei auf einmal ausgegeben, und wenn es ein Leerstring ist, ein Absatz (Absätze werden durch zwei aufeinanderfolgende Newlines getrennt). Sind keine Dateien angegeben, wird von der Standardeingabe gelesen.
Rückgabewert Ein String. Wurde das Ende der letzten auf ARGV angegebenen Dateien erreicht, nil.
Beispiel
1
2
3
print "Geben Sie Ihren Namen ein: "
name = gets.chomp
puts "Ihr Name ist #{name.length} Zeichen lang. "


1
2
ARGV << "testfile"
print while gets

Output:

1
2
3
4
This is line one
This is line two
This is line three
And so on...



global_variables

Anwendung global_variables ==> einArray
Argumente

Keine.

Beschreibung Gibt eine Liste aller globalen Variablen zurück. Siehe dazu auch Vordefinierte Variablen.
Rückgabewert Ein Array, das die Namen der globalen Variablen als Symbole enthält.
Beispiel
puts global_variables.collect{|sym| sym.to_s}.sort

Output:

1
2
3
4
5
$!
$"
$$
$&
...



iterator?

Alias für block_given?.

lambda

Anwendung lambda{...} ==> einProc
Argumente

Keine.

Beschreibung Erstellt ein Proc-Objekt, das Zugriff auf den aktuellen Ausführungskontext hat. Im Gegensatz zu Proc.new und proc überprüft der Block die Anzahl der Argumente, die an ihn übergeben wurden.
Rückgabewert Ein Proc.
Beispiel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
hello = lambda{puts "Hello world"}
hello.call #=> Hello word

def foo(pr)
  pr.call
end
x = 10
pr = lambda{puts x}
foo(pr) #=> 10

x = lambda{|val| puts val}
y = proc{|val| puts val}
x.call #=> ArgumentError
y.call #=>


load

Anwendung load( file [, wrap = false] ) ==> true oder false
Argumente
  • file: Die zu ladende Datei.
  • wrap(false): Wenn true, wird der Code in Namespace eines anonymen Moduls ausgeführt, sodass der globale Namespace nicht angefasst wird.
Beschreibung Führt ein Ruby-Programm aus. Lokale Variablen werden unter keinen Umständen in den Namespace des aufrufenden Programms übernommen. Im Gegensatz zu require kann eine Datei auch mehrfach geladen werden.
Rückgabewert Undefiniert.
Beispiel
1
2
3
#Load.rb
XY = 8
puts "Hello"


1
2
3
4
5
#Main.rb
load("Load.rb", true) #=> Hello!
puts XY #=> NameError
load("Load.rb") #=> Hello!
puts XY #=> 8


local_variables

Anwendung local_variables ==> einArray
Argumente

Keine.

Beschreibung Gibt die momentan definierten lokalen Variablen zurück.
Rückgabewert Ein Array, das die Symbole der aktuell definierten lokalen Variablen enthält.
Beispiel
1
2
3
4
5
6
7
def lvars(var)
  x = 1
  p local_variables
end
y = :ruby
p local_variables
lvars(Math::PI)

Output:

1
2
[:y]
[:var, :x]



loop

Anwendung loop{...} ==> nil
Argumente

Keine.

Beschreibung Die Endlosschleife implementiert als Iterator. Diese Methode führt unendlich oft den ihr mitgegebenen Codeblock aus.
Rückgabewert nil.
Beispiel
1
2
3
4
loop do
  print "Eingabe>"
  break if gets =~ /^q/i
end


method_missing

Anwendung method_missing( name [, *args [&block ] ] ) ==> einObject
Argumente
  • name: Das Symbol der fehlenden Methode.
  • *args: Die an die Methode übergebenen Argumente.
  • &block: Ein an die Methode übergebener Block.
Beschreibung Eine Hook-Methode, die immer dann aufgerufen wird, wenn eine Methode nicht bei einem Objekt gefunden wurde. Die standardmäßige Implementierung sieht das Werfen eines NoMethodErrors vor, aber dieses Verhalten kann überschrieben werden.
Rückgabewert Der letzte Ausdruck in der Methode.
Beispiel
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Roman

  def roman_to_int
    #Code...
  end
  
  def method_missing(name, *args, &block)
    super if !args.empty? or block
    roman_to_int(name.to_s)
  end
  
end

r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000


1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MyDelegator
  
  def initialize(an_object)
    @object = an_object
  end
  
  def method_missing(name, *args, &block)
    @object.send(name, *args, &block)
  end
  
end

d = MyDelegator.new(10)
puts(d / 2) #=> 5



open

Anwendung open( path [, mode = "r" ] ) ==> einIO
open( path [, mode = "r"] ){|io|...} ==> einObject
Argumente
  • path: Der Pfad zur zu öffnenden Datei oder ein Befehl.
  • mode("r"): Der Modus, in dem eine Datei zu öffnen ist. Standardmäßig Lesemodus.
  • io(Blockargument): Das IO-Objekt, das bei der Nicht-Blockform zurückgegeben würde.
Beschreibung Öffnet eine Datei oder einen Kindprozess. Ein Kindprozess wird dann erstellt, wenn path mit einem Balken | beginnt, ansonsten wird eine Datei mit dem entsprechenden Namen geöffnet. Im Falle der Blockform wird die Datei nach Beenden des Blocks (auch bei Fehler) geschlossen.
Rückgabewert Bei der Nicht-Blockform ein IO-Objekt, das den Kindprozess oder ein Filehandle darstellt.
Bei der Blockform der letzte Ausdruck innerhalb des Blocks.
Beispiel
1
2
3
4
5
6
7
8
file = open("Test.txt", "w")
file.write("Test")
file.close
open("Test.txt"){|f| puts f.read} #=> Test

cmd = open("|date")
puts cmd.gets #=> Do 2. Jul 10:47:52 CEST 2009
cmd.close



p

Anwendung p( *obj) ==> *obj
Argumente
  • *obj: Auszugebende Objekte.
Beschreibung Gibt lesbare Beschreibungen der ihm mitgegebenen Objekte aus, indem es die inspect-Methoden der Objekte aufruft.
Rückgabewert Ein Array, das die p mitgegebenen Objekte enthält.
Beispiel
1
2
3
4
5
p "a" #=> "a"
p Hash[1, 2, 3, 4] #=> {1=>2, 3=>4}
#Um den Unterschied zu puts zu verdeutlichen: 
puts nil #=>
p nil #=> nil



print

Anwendung print( *obj) ==> nil
Argumente
  • *obj: Die zu schreibenden Objekte.
Beschreibung Gibt wie puts die Objekte auf $stdout aus, der Output-Separator ist allerdings nicht zwangsläufig Newline, sondern der Wert von $\, der ungesetzt nil ist. $, wird zwischen die einzelnen Elemente geschrieben.
Rückgabewert nil.
Beispiel
1
2
3
4
5
print "Eingabe >"
gets
$\ = "--"
$, = "|"
print 1, 2 #=> 1|2--



printf

Anwendung printf( format_string [, *obj ] ) ==> nil
Argumente
  • format_string: Ein String mit Formatierungsanweisungen.
  • *obj: Die Objekte, mit denen die Formatierungsanweisungen in format_string gefüllt werden.
Beschreibung Das gleiche wie
$stdout.write(sprintf(format_string, *obj))
Rückgabewert nil.
Beispiel
printf("Eine Zahl: %i", 5) #=> Eine Zahl: 5


proc

Anwendung proc{...} ==> einProc
Argumente

Keine.

Beschreibung Erstellt ein Proc-Objekt. Diese Methode gilt seit 1.9 als deprecated, zugunsten von lambda. Der Grund dafür ist, dass proc seine Argumente nicht überprüft.
Rückgabewert Ein Proc.
Beispiel
1
2
proc{|a| p a}.call #=> nil
lambda{|a| p a}.call #=> ArgumentError



putc

Anwendung putc( obj ) ==> obj
Argumente
  • obj: Das auszugebende Objekt.
Beschreibung Gibt ein Zeichen aus. Ist obj ein String ist es das erste Byte dieses Strings; handelt es sich um ein anderes Objekt, wird versucht es in ein Integer zu konvertieren und aus diesem wiederum das dazugehörige ASCII-Zeichen auszugeben.
Rückgabewert Der mitgegebene Parameter.
Beispiel
1
2
3
putc("ABC") #=> A
putc(65) #=> A
putc(131.0/2.0) #=> A


puts

Anwendung puts(*args) ==> nil
Argumente
  • *args: Die auszugebenden Objekte.
Beschreibung Gibt die angegebenen Objekte auf $stdout aus.
Rückgabewert Stets nil.
Beispiel
1
2
3
puts "a"
puts 7
puts("A", "B")

Output:

1
2
3
4
a
7
A
B


raise

Anwendung raise ==> nil
raise( string ) ==> nil
raise( exception [, string [, caller ] ] ) ==> nil
Argumente
  • string: Für Variante 2 der anzuzeigende Text eines RuntimeErrors. Für Variante 3 der anzuzeigende Text.
  • exception: Für Variante 3 der zu werfende Fehler. Kann eine beliebige Exception-Klasse sein.
  • caller (nil): Für Variante 3: Gibt das zusätzlich zum Error anzugebende Backtrace an. Ein Array, das von Kernel#caller zurückgegeben wird.
Beschreibung Wirft einen Error. Ohne Argumente wird die letzte geworfene (und vermutlich aufgefangene) Exception (das Objekt in $!) noch einmal geworfen. Ist $! nil, wird ein RuntimeError geworfen. Mit einem Argument wird ein RuntimeError mit dem in string angegebenen Text geworfen, bei der dritten Variante kann man zusätzlich noch die Exception-Klasse und den Backtrace definieren. Exceptions können mit dem begin/rescue-Block aufgefangen werden.
Rückgabewert nil.
Beispiel
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
raise "A" #=> RuntimeError: A
raise(ArgumentError, "B") #=> ArgumentError: B

def a
  raise("Error in A")
end

def b
  a
end

def c
  b
end

c #=> Test.rb:5:in `a': Error in A (RuntimeError)
#        from Test.rb:9:in `b'
#        from Test.rb:13:in `c'
#        from Test.rb:16:in `<main>'

def a
  raise(RuntimeError, "Error in a!", caller)
end

c #=> Test.rb:9:in `b': Error in a! (RuntimeError)
#        from Test.rb:13:in `c'
#        from Test.rb:25:in `<main>'


rand

Anwendung rand( max = 0 ) ==> einInteger
Argumente
  • max: Die ausschließliche Obergrenze der Zufallszahlen.
Beschreibung Erzeugt Pseudozufallszahlen < max. Ist max 0, wird ein Float > 0.0 und < 1.0 zurückgegeben, ansonsten ein Integer > 0 und < max. Siehe auch Kernel#srand.
Rückgabewert Ein Float oder ein Integer.
Beispiel
1
2
3
rand #=> 0.663831935617695
rand #=> 0.665359685021351
rand(10) #=> 7



readline

Anwendung readline (sep = $/ ) ==> einString
Argumente
  • sep($/): Input-Separator. Standardmäßig Newline.
Beschreibung Arbeitet prinzipiell wie gets, aber wirft einen EOFError, wenn das Ende aller Dateien erreicht ist.
Rückgabewert Eine String, der eine Zeile enthält.
Beispiel
1
2
3
4
5
#Eingabe: ABC
puts readline #=> ABC
#Eingabe: ^d
puts readline #=> EOFError
puts gets #=> nil



readlines

Anwendung readlines( sep = $/ ) ==> einArray
Argumente
  • sep: Eingabeseparator, standardmäßig Newline.
Beschreibung Gibt ein Array aller Zeilen aus $stdin zurück, indem es gets solange aufruft, bis das Ende aller Dateien erreicht ist.
Rückgabewert Ein Array.
Beispiel
1
2
#Eingabe ist die Datei Test.txt
puts readlines #=> ["ABC\n", "DEF\n"]



require

Anwendung require( lib ) ==> true oder false
Argumente
  • lib: Die zu ladende Programmbibliothek. Die Dateiendung kann weggelassen werden.
Beschreibung Lädt eine Programmbibliothek. Ruby kann normale Ruby-Skripte laden (.rb) oder auch C-Extensions (.o, .so, .dll, usw.). Eine geladene Programmbibliothek wird $" hinzugefügt, was dafür sorgt, dass nichts mehrfach geladen wird. Wirft einen LoadError, falls es die Programmbibliothek nicht finden kann; durchsucht werden alle in $: angegebenen Pfade. Siehe auch load.
Rückgabewert Bei erfolgreichem Laden true, sonst false. false bedeutet aber nicht, dass die Datei nicht erfolgreich geladen wurde, sondern dass die Datei schon an anderer Stelle geladen und beim jetzigen Aufruf nicht noch einmal geladen wurde.
Beispiel
1
2
require "timeout" #Impliziert .rb
require "win32/api" #Impliziert .so (auf MinGW)


require_relative

Anwendung require_relative( lib ) ==> true oder false
Argumente
  • lib: Die zu ladende Library. Die Dateiendung kann ausgelassen werden.
Beschreibung Erlaubt das Einbinden von Libraries relativ zum Speicherort des Skripts. So sind Pfade wie "../lib/backend.rb" nun nicht mehr anstößig wie in 1.8. Jede Datei wird nur einmal geladen und ihr Pfad anschließend in $" verewigt.
Rückgabewert Bei erfolgreichem Laden true, sonst false. false bedeutet aber nicht, dass die Datei nicht erfolgreich geladen wurde, sondern dass die Datei schon an anderer Stelle geladen und beim jetzigen Aufruf nicht noch einmal geladen wurde.
Beispiel
require_relative "../lib/my_module/backend"


select

Anwendung select( read_ios [, write_ios [, error_ios [, timeout ] ] ] ) ==> einArray oder nil
Argumente
  • read_ios: Ein Array von zu prüfenden IO-Objekten.
  • write_ios (nil): Ein Array von auf leere Buffer zu prüfenen IOs.
  • error_ios (nil): Ein Array von IOs, die auf eine Exception hin geprüft werden sollen.
  • timeout (nil): Timeout in Sekunden.
Beschreibung Wartet solange, bis eine der folgenen Bedingungen erfüllt ist:
  • Jedes der IOs in read_ios hat Daten bekommen
  • Jedes der IOs in write_ios kann beschrieben werden
  • Ein Fehler taucht in jedem der IOs in error_ios auf
  • timeout wird erreicht.
Rückgabewert Ein dreielementiges Array, das die IOs angibt, die die Bedingungen erfüllt haben, oder nil, wenn timeout erreicht wurde.
Beispiel
#Beispiel folgt!



set_trace_func

Anwendung set_trace_func( &proc ){|event, filename, lineno, object_id, bind, classname| ... } ==> proc oder nil
Argumente
  • &proc: Ein Proc oder nil. Das Argument muss als Proc übergeben werden, ein Block ist nicht möglich.
  • event (Blockargument): Der Name des Events.
  • filename (Blockargument): Der Name der Datei.
  • lineno (Blockargument): Die Zeile, in der das Event aufgetaucht ist.
  • object_id (Blockargument): Die ID des Objektes, dass das Event ausgelöst hat.
  • bind (Blockargument): Ein Bindung mit dem Ausführungskontext beim Auslösen des Events.
  • classname (Blockargument): Die Klasse des Objektes, das das Event ausgelöst hat.
Beschreibung Registriert proc, um jedes Mal ausgeführt zu werden, wenn ein Ereignis stattfindet. Ist proc nil, wird der bisher registrierte Proc entfernt. Mögliche Events sind:
  • c-call: Aufruf einer in C geschriebenen Funktion
  • c-return: Ende einer in C geschriebenen Funktion
  • call: Aufruf einer Ruby-Funktion
  • return: Ende einer Ruby-Funktion
  • class: Beginn einer Klassen- oder Moduldefinition
  • end: Ende einer Klassen- oder Moduldefinition
  • line: Beginn einer neuen Codezeile
  • raise: Exception

In proc selbst gibt es keine Überwachung.

Rückgabewert Der registrierte Proc oder nil.
Beispiel
1
2
3
4
set_trace_func lambda{|event, filename, lineno, object_id, bind, classname| p object_id}
x = 0
x += 1
puts x

Output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
:set_trace_func
nil
nil
nil
:puts
:puts
:to_s
:to_s
:write
1:write
:write

:write
:puts
:puts



sleep

Anwendung sleep( [ time = 0 ] ) ==> einInteger
Argumente
  • time: Die Zeit zu warten, in Sekunden. Es muss sich nicht um eine ganze Zahl handeln.
Beschreibung Hält die Ausführung des Progamms für die dauer von time an. Ist time 0, wacht der aufrufende Thread nicht mehr auf.
Rückgabewert Die tatsächliche Zahl von Sekunden, die gewartet wurde, gerundet. Es muss sich hierbei nicht um die angegebene Anzahl an Sekunden handeln, die angegeben wurde; gerade im Zusammenhang mit Threads kann es zu Differenzen kommen.
Beispiel
sleep(3)


1
2
3
4
5
ts = []
puts Time.now
10.times{ts.push(Thread.new{puts(sleep(1.9))})}
ts.each{|thread| thread.join}
puts Time.now

Output:

1
2
3
4
5
6
7
8
9
10
11
12
2009-07-21 12:50:06 +0200
1
1
1
1
1
1
1
1
1
1
2009-07-21 12:50:07 +0200


spawn

Anwendung spawn( [env , ] command [, *args [, options ] ] ) ==> anInteger
Argumente
  • env ({}): Ändert Umgebungsvariablen für den Kindprozess. Die Hash-Keys müssen Strings sein.
  • command: Der auszuführende Befehl.
  • *args ([]): Dem Befehl zu übergebende Argumente.
  • options (nil): Änderungen am Setup der Subshell.
Beschreibung Führt wie system einen Systembefehl aus, aber gibt den Programmfluss im Gegensatz zu diesem sofort zurück. Über den Parameter env können Werte zu Umgebungsvariablen hinzugefügt oder aber entfernt werden (mittels auf-nil-setzen).
Rückgabewert Die PID des gestarteten Prozesses.
Beispiel
1
2
3
spawn({"MEINE_VAR" => "Toll!"}, "sleep 5;echo $MEINE_VAR")
puts "Hauptprogramm"
sleep 6

Output:

1
2
Hauptprogramm
Toll!


sprintf

Anwendung sprintf(format_string [, *args] ) ==> einString

format_string % *args ==> einString

Argumente
  • format_string: Mit Formatdirektiven versehener String.
  • args: Beliebig viele Argumente, die dazu benutzt werden, die im format_string angegebenen Direktiven zu füllen.
Beschreibung Bitte dokumentieren!
Rückgabewert Undefiniert.
Beispiel
#Beispiel folgt!


srand

Anwendung srand( [ seed = 0 ] ) ==> anInteger
Argumente
  • seed (0): Ausgangswert des Zufallszahlengenerators.
Beschreibung Initialisiert den Zufallszahlengenerator neu. Durch das Benutzen von srand kann der Wert eines rand über mehrere Programmdurchläufe hinweg vorhersehbar gemacht werden. Ist seed 0, wird der Ausgangswert des Betriebssystems benutzt (was auch der Fall ist, wenn srand gar nicht benutzt wird).
Rückgabewert Der vorherige Ausgangswert.
Beispiel
1
2
3
4
5
6
srand(1020304050)
puts rand #=> 0.639737924661234
puts rand(10) #=> 7
srand(1020304050)
puts rand #=> 0.639737924661234
puts rand(10) #=> 7



syscall

Anwendung syscall( num_id [, *args ] ) ==> anInteger
Argumente
  • num_id: Der numerische Identifier der Funktion.
  • *args: Die zu übergebenden Argumente. Höchstens 9, sie müssen auf jedenfall in einem plattform-nativen long gespeichert werden können.
Beschreibung Ruft die Systemfunktion Nummer num_id auf (diese sind betriebssystembedingt). Auf unixoiden Systemen können diese Nummern in der Datei syscall.h nachgeschlagen werden.
Rückgabewert Undefiniert.
Beispiel
syscall(4, 1, "hello\n", 6) #=> hello #=> 6



system

Anwendung system( [ env , ] command [, *args ] [, options ] ) ==> true or false or nil
Argumente
  • env ({}): Manipuliert die Umgebungsvariablen für den Subprozess (Keys müssen Strings sein.)
  • command: Das auszuführende Kommando.
  • *args([]): Die dem Befehl zu übergebenden Argumente.
  • options (nil): Ändert das Setup der Subshell.
Beschreibung Führt ein Kommando als Kindprozess aus und wartet auf das Ende. Gibt den Erfolgsstatus zurück oder nil, falls der Befehl nicht gefunden wurde. Setzt $? auf den Exitstatus des Prozesses.
Rückgabewert true oder false, je nach Erfolg.
Beispiel
1
2
3
4
system("echo *") #=> true
system("uname -unknownoption") #=> false
system("kuddelmuddel") #=> nil
system({"MEINE_VAR" => "Test"}, "echo $MEINE_VAR") #=> Test #=> true


test

Anwendung test( cmd , file1 [, file2 ] ) ==> einObject
Argumente
  • cmd: Der Befehl zum Testen
  • file1: Die erste Datei zum Testen
  • file2 (nil): Die zweite Datei zum Testen
Beschreibung Wendet einen Testbefehl auf die angegebenen Dateien an. Die möglichen Testbefehle sind:
BefehlTest
ALetzte Aufrufzeit von file1
btrue, wenn file1 ein Block device ist
ctrue, wenn file1 ein Character device ist
CLetzte Änderungszeit von file1
dtrue, wenn file1 ein Verzeichnis ist
etrue, wenn file1 existiert
ftrue, wenn file1 eine normale Datei ist
gtrue, wenn file1 das setguid-Bit gesetzt hat (false in Windows)
Gtrue, wenn file1 der Gruppe gehört, in der der Aufrufer ist
ltrue, wenn file1 ein Symlink ist
MLetzte Änderungszeit von file1
otrue, wenn file1 der UID des Aufrufers gehört
Otrue, wenn file1 dem Aufrufer gehört
ptrue, wenn file1 ein Fifo ist
rtrue, wenn file1 vom Aufrufer gelesen werden kann
strue, wenn file1 Daten enthält
Strue, wenn file1 ein Socket ist
utrue, wenn file1 das setuid-Bit gesetzt hat
wtrue, wenn file1 von der UID oder GUID des Aufrufers geschrieben werden kann
Wtrue, wenn file1 vom Aufrufer oder seiner Gruppe schreibbar ist
xtrue, wenn file1 von der UID oder GUID des Aufrufers ausgeführt werden kann
Xtrue, wenn file1 vom Aufrufer oder seiner Gruppe ausgeführt werden kann
ztrue, wenn file1 leer ist
-true, wenn file1 ein Symlink auf file2 ist
=true, wenn die Änderungszeiten von file1 und file2 gleich sind
<true, wenn die Änderungszeit von file1 vor der von file2 liegt
>true, wenn die Änderungszeit von file1 hinter der von file2 liegt
In früheren Versionen von Ruby wurde mithilfe des Literals ?x der ASCII-Wert des Befehls übergeben. Die Verwendung des Literals ist zwar nach wie vor möglich, aber da es nur den Buchstaben selbst zurückangibt, kann das Zeichen auch direkt übergeben werden.
Rückgabewert Das Ergebnis des Tests, siehe die Tabelle oben.
Beispiel
1
2
test("A", "Test.txt") #=> 2009-08-02 18:42:33 +0200
test("-", "test1.txt", "test2.txt") #=> false



throw

Anwendung throw( obj [, ret = nil ] )
Argumente
  • obj: Das zu werfende Objekt. Klassischerweise ein Symbol.
  • ret (nil): Das von catch zurückzugebende Objekt.
Beschreibung Wirft ein Objekt, das von einem catch irgendwo aufgegangen werden muss. Wird es das nicht, folgt ein LocalJumpError.
Rückgabewert ret.
Beispiel
1
2
3
4
5
6
7
8
9
10
catch(:a) do
  throw(:a)
  puts "Das wird nicht ausgef��hrt"
end
#Kein Output. 

p catch(:a) do
  throw(:a, "ABC")
end
#=> "ABC"



trace_var

Anwendung trace_var( sym, cmd ) ==> nil

trace_var( sym ){|val| ...} ==> nil

Argumente
  • sym: Das Symbol der zu beobachtenden Variablen.
  • cmd: Der aufzurufende Proc. Alternativ zur Blockvariante.
  • val (Blockargument): Der neue Wert der Variablen.
Beschreibung Observiert eine globale Variable. cmd oder der Block der Methode wird jedesmal aufgerufen, wenn sich der Wert der Variablen verändert. Es können auch mehrere Blöcke zum Beobachten ein und derselben Variablen definiert werden (druch mehrfachen Aufruf von trace_var).
Rückgabewert nil.
Beispiel
1
2
3
trace_var(:$abc){|val| puts "$abc ist jetzt '#{val}'. "}
$abc = 1 #=> $abc ist jetzt '1'. 
$abc = /regexp/ #=> $abc ist jetzt '(?-mix:regexp)'.



trap

Anwendung trap( sig , cmd ) ==> einObject

trap( sig ){|signo| ... } ==> einObject
Signal.trap( sig , cmd ) ==> einObject
Signal.trap( sig ){|signo| ...} ==> einObject

Argumente
  • sig: Das zu fangende Signal. Ein String oder Symbol, Leerstring oder "SIG_IGN" führen zur Ignorierung des Signals.
  • cmd: Das auszuführende Kommando, wenn sig aufgefangen wird, als Proc. Ist es ein Leerstring, wird das Signal ignoriert. Ist es "DEFAULT" oder "SIG_DFL", wird das Signal an ads Betriebssystem weitergeleitet. Ist es "EXIT", wird das Skript beendet.
  • signo (Blockargument): Die Nummer des Signals, das gesendet wurde.
Beschreibung Fängt ein Prozess-Signal auf und führt einen assoziierten Codeblock dazu aus.
Rückgabewert Der bisherige Handler des Signals.
Beispiel
1
2
3
4
5
6
7
8
9
10
puts "Erstelle Kindprozess"
pid = fork do
  Signal.trap("TERM"){puts "SIGTERM"; exit}
  loop{sleep 1}
end
puts "Warten"
sleep 5
puts "Sende SIGTERM zum Kindprozess #{pid}"
Process.kill("SIGTERM", pid)
puts "Ende des Programms"

Output:

1
2
3
4
5
Erstelle Kindprozess
Warten
Sende SIGTERM zum Kindprozess 5565
Ende des Programms
SIGTERM



untrace_var

Anwendung untrace_var( sym [, cmd ] ) ==> einArray
Argumente
  • sym: Das Symbol der Variablen, von der das Tracing entfernt werden soll.
  • cmd (nil): Der zu entfernende Tracer. Wenn nil, werden alle entfernt.
Beschreibung Entfernt das Tracing von einer globalen Variablen.
Rückgabewert Ein Array aller entfernten Tracing-Procs.
Beispiel
1
2
3
4
5
6
7
8
trace_var(:$abc){|val| puts val}
x = lambda{|val| p val}
trace_var(:$abc, x)
$abc = "Z"
untrace_var(:$abc, x)
$abc = "Y"
untrace_var(:$abc)
$abc = "X"

Output:

1
2
3
"Z"
Z
Y



warn

Anwendung warn( str ) ==> nil
Argumente
  • str: Der auszugebende String.
Beschreibung Schreibt str auf $stderr. Wird benutzt, um Warnungen auszugeben (daher der Name).
Rückgabewert Immer nil.
Beispiel
1
2
3
4
def dangerous
  warn("Warning: Using this method could result in data loss")
  #Code...
end