|
class methods
|
|
Array
|
Array( arg ) -> anArray |
|
Liefert arg.to_a.
Array(1..5) |
» |
[1, 2, 3, 4, 5] |
|
|
Float
|
Float( arg ) -> aFloat |
|
Liefert arg, in ein Float konvertiert. Numerische Typen werden direkt
konvertiert, nil wird zu 0.0 konvertiert und der Rest wrid mit
arg.to_f konvertiert.
Float(1) |
» |
1.0 |
Float(nil) |
» |
0.0 |
Float("123.456") |
» |
123.456 |
|
|
Integer
|
Integer( arg ) -> anInteger |
|
Konvertiert arg in ein Fixnum oder Bignum.
Numerische Typen werden direkt konvertert (wobei Kommazahlen abgeschnitten werden).
Falls arg ein String ist, werden führende
Basis-Indikatioren (0, 0b und 0x) beachtet. Dieses Verhalten ist
anders als das von
String#to_i.
Integer(123.999) |
» |
123 |
Integer("0x1a") |
» |
26 |
Integer(Time.new) |
» |
983770240 |
|
|
String
|
String( arg ) -> aString |
|
Konvertiert arg in einen String durch Aufruf seiner
to_s-Methode.
String(self) |
» |
"main" |
String(self.type) |
» |
"Object" |
String(123456) |
» |
"123456" |
|
|
` (backquote)
|
`cmd` -> aString |
|
Liefert den Standard-Output vom in einer Subshell ausgeführten cmd.
Die auf Seite 75 beschriebene Syntax %x{...} benutzt diese Methode.
`date` |
» |
"Sun Mar 4 23:30:40 CST 2001\n" |
`ls testdir`.split[1] |
» |
"main.rb" |
|
|
abort
|
abort
|
|
Beendet die Ausführung sofort, tatsächlich wird
Kernel.exit(1) aufgerufen.
|
|
at_exit
|
at_exit { block }-> aProc |
|
Konvertiert einen block in ein Proc-Objekt (und
verbindet ihn deshalb mit dem Aufruf-Punkt). Registriert es zur Ausführung bei
Programmende. Falls mehrere solche Objekte registriert sind, werden sie in der
umgedrehten Reihenfolge ihrer Registrierung abgearbeitet.
def do_at_exit(str1)
at_exit { print str1 }
end
at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit
|
erzeugt:
|
|
autoload
|
autoload( aModule, aFile )
-> nil |
|
Registriert aFile zum Laden (mit
Kernel::require)
bei ersten Mal, wenn auf aModule (welches ein String
oder ein Symbol sein darf) zugegriffen wird.
autoload :MyModule, "/usr/local/lib/modules/my_module.rb"
|
|
|
binding
|
binding -> aBinding |
|
Liefert ein Binding-Objekt, das die Variablen- und
Methoden-Bindungen zum Zeitpunkt des Aufrufs beschreibt. Dieses Objekt kann benutzt
werden, wenn man eval aufruft, um den ausgewerteten Ausdruck in
dieser Umgebung auszuführen. Siehe auch die Beschreibung von
Binding ab Seite 295.
def getBinding(param) |
return binding |
end |
b = getBinding("hello") |
eval "param", b |
» |
"hello" |
|
|
block_given?
|
block_given? -> true or false |
|
Liefert true falls yield im aktuellen Kontext einen
Block ausführen würde.
def try |
if block_given? |
yield |
else |
"no block" |
end |
end |
try |
» |
"no block" |
try { "hello" } |
» |
"hello" |
try do |
» |
"no block" |
"hello" |
end |
|
|
callcc
|
callcc {| cont | block }-> anObject |
|
Erzeugt ein Continuation-Objekt, das an den zugehörigen Block
weitergereicht wird. Die Ausführung eines cont.call lässt
callcc zurückkehren (genauso wie das Erreichen des Blockendes).
Der Rückgabewert von callcc ist der Wert des Blocks, oder der an
cont.call übergebene Wert. Mehr zu Continuation
auf Seite 298. Siehe auch
Kernel::throw,
dort gibts einen alternativen Mechanismus zum Abwickeln des Aufruf-Stacks.
|
|
caller
|
caller( [anInteger] )
-> anArray |
|
Liefert den aktuellen Ausführungs-Stack --- ein Array mit Strings in
der Form
``file:line'' oder ``file:line: in `method'''. Der
Parameter anInteger bestimmt die Anzahl der führenden Stack-Einträge,
die beim Ergebnis weggelassen werden sollen.
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
|
catch( symbol ) {| | block }-> anObject |
|
catch führt seinen Block aus. Wenn ein throw ausgeführt wird,
sucht Ruby seinen Stack ab nach einem catch-Block mit dem zum
symbol von throw passenden Block. Falls es ihn findet, wird der Block
normal beendet und catch gibt den an throw übergebenen Wert
zurück. Falls kein throw aufgerufen wird, wird der Block normal durchlaufen
und der Wert von catch ist der Wert des letzten ausgewerteten Asudrucks.
catch-Ausdrücke dürfen verschachtelt sein und der throwAufruf
muss nicht im Lexical Scope sein (das ist mir nicht klar, der Übersetzer).
def routine(n)
puts n
throw :done if n <= 0
routine(n-1)
end
catch(:done) { routine(3) }
|
erzeugt:
|
|
chomp
|
chomp( [aString] )
-> $_ or aString |
|
Äquivalent zu
$_ = $_.chomp(aString).
Siehe String#chomp auf Seite 372.
$_ = "now\n" |
chomp |
» |
"now" |
$_ |
» |
"now" |
chomp "ow" |
» |
"n" |
$_ |
» |
"n" |
chomp "xxx" |
» |
"n" |
$_ |
» |
"n" |
|
|
chomp!
|
chomp!( [aString] )
-> $_ or nil |
|
Äquivalent zu $_.chomp!(aString).
Siehe String#chomp!
$_ = "now\n" |
chomp! |
» |
"now" |
$_ |
» |
"now" |
chomp! "x" |
» |
nil |
$_ |
» |
"now" |
|
|
chop
|
chop -> aString |
|
Äquivalent zu
($_.dup).chop!, außer dass nil niemals zurückgegeben wird.
Siehe String#chop! auf Seite 372.
a = "now\r\n" |
$_ = a |
chop |
» |
"now" |
$_ |
» |
"now" |
chop |
» |
"no" |
chop |
» |
"n" |
chop |
» |
"" |
chop |
» |
"" |
a |
» |
"now\r\n" |
|
|
chop!
|
chop! -> $_ or nil |
|
Äquivalent zu $_.chop!.
a = "now\r\n" |
$_ = a |
chop! |
» |
"now" |
chop! |
» |
"no" |
chop! |
» |
"n" |
chop! |
» |
"" |
chop! |
» |
nil |
$_ |
» |
"" |
a |
» |
"" |
|
|
eval
|
eval( aString[, aBinding[file[line]]])
-> anObject |
|
Wertet den/die Ruby-Ausdruck/Ausdrücke in aString aus. Falls
aBinding angegeben ist, wird die Auswertung in diesem Kontext
durchgeführt.
Diese Bindung darf ein Binding-Objekt oder ein
Proc-Objekt sein. Wenn die optinalen file-
und line-Parameter vorhanden sind, werden sie für die Meldung von
Syntax-Fehlern benutzt.
def getBinding(str) |
return binding |
end |
str = "hello" |
eval "str + ' Fred'" |
» |
"hello Fred" |
eval "str + ' Fred'", getBinding("bye") |
» |
"bye Fred" |
|
|
exec
|
exec( command[, args])
|
|
Ersetzt den laufenden Prozess durch den des gebenen externen Kommandos.
Falls exec ein einzelnes Argument mitbekommt, wird dieses als Zeile
angesehen, die noch der Shell-Expansion unterliegt. Wenn mehrere Argumente übergeben
werden, werden das zweite und alle weiteren Argumente als Parameter für command
angesehen und es wird keine Shell-Expansion durchgeführt. Falls das erste Argument ein
zwei-elementiges Array ist, ist das erste Element das auszuführende Kommando und das
zweite wird als argv[0]-Wert angesehen, der in Prozess-Listen auftauchen kann.
In MSDOS-Umgebungen wird das Kommando in einer Unter-Shell ausgeführt; ansonsten wird einer
der exec(2)-System-Aufrufe benutzt, so dass das ausgeführte Kommando etwas
von der Umgebung des Original-Programms erben kann (inklusive die Bezeichner von
offenen Dateien).
exec "echo *" # echoes list of files in current directory
# never get here
exec "echo", "*" # echoes an asterisk
# never get here
|
|
|
exit
|
exit( anInteger=0 )
|
|
Initiiert das Beenden des Ruby-Scripts durch Auslösen der
SystemExit-Exception. Diese Exception kann abgefangen
werden. Der optionale Parameter wird als Rückgabe-Wert für die übergeordnete Umgebung
benutzt.
begin
exit
puts "never get here"
rescue SystemExit
puts "rescued a SystemExit exception"
end
puts "after begin block"
|
erzeugt:
rescued a SystemExit exception
after begin block
|
Direkt vor Programmende führt Ruby alle at_exit-Funktionen
aus und lässt die Finalizers der Objekte laufen (siehe
ObjectSpace ab Seite 434).
at_exit { puts "at_exit function" }
ObjectSpace.define_finalizer(self, proc { puts "in finalizer" })
exit
|
erzeugt:
at_exit function
0x4019ac90
n finals=>0
|
|
|
exit!
|
exit!( anInteger=-1 )
|
|
Ähnlich wie
Kernel::exit,
aber Exception-Handling,
at_exit-Funktionen und Finalizers werden übergangen.
|
|
fail
|
fail
fail( aString )
fail( anException[, aString[anArray]] )
|
|
Synonym für Kernel::raise.
|
|
fork
|
fork [{ block }]-> aFixnum
or nil |
|
Erzeugt eine Unter-Shell. Wenn ein Block angegeben wurde, wird dieser
in der Unter-Shell laufen gelassen und die Unter-Shell wird mit Status Null
beendet.
Andernfalls gibt der forkAufruf zweimal Werte zurück, einmal im
Elternteil die Prozess-Id des Kindes, und einmal im Kind einfach nur nil.
Der Kind-Prozess kann mit
Kernel::exit!
beendet werden, um irgendwelche
at_exit-Funktionen zu vermeiden. Der Eltern-Prozess sollte
Process::wait
benutzen, um den Abschluss-Status seiner Kinder einzusammeln; ansonsten könnte das
Betriebssystem Zombie-Prozesse anhäufen.
fork do
3.times {|i| puts "Child: #{i}" }
end
3.times {|i| puts "Parent: #{i}" }
Process.wait
|
erzeugt:
Parent: 0
Child: 0
Child: 1
Parent: 1
Parent: 2
Child: 2
|
|
|
format
|
format( aString[,
anObject]* ) -> aString |
|
Synonym für Kernel::sprintf.
|
|
gets
|
gets( aString=$/ )
-> aString or nil |
|
Liefert (und schreibt in $_) die nächste Zeile aus der
Liste der Dateien in ARGV (oder $*), oder
vom Standard-Input, falls in der Kommandozeile keine Dateien angegeben sind.
Liefert nil am Ende der Datei.
Das optionale Argument gibt den Record-Seperator an. Dieser Seperator ist im
Inhalt jedes Records enthalten. Der Seperator nil liest den
gesamten Inhalt und ein Seperator der Länge Null liest den Input Absatz für
Absatz, wobei die Absätze durch zwei auf einander folgende Newlines getrennt
sind. Falls mehrere Dateien in ARGV stehen, so liest
gets(nil) immer nur eine Datei.
ARGV << "testfile"
print while gets
|
erzeugt:
This is line one
This is line two
This is line three
And so on...
|
|
|
global_variables
|
global_variables
-> anArray |
|
Liefert ein Array mit den Namen der globalen Variablen.
global_variables.grep /std/ |
» |
["$stderr", "$stdout", "$stdin"] |
|
|
gsub
|
gsub( pattern, replacement )
-> aString
gsub( pattern ) {| | block }-> aString |
|
Äquivalent zu $_.gsub..., außer dass $_
das modifizierte Ergebenis erhält.
$_ = "quick brown fox" |
gsub /[aeiou]/, '*' |
» |
"q**ck br*wn f*x" |
$_ |
» |
"q**ck br*wn f*x" |
|
|
gsub!
|
gsub!( pattern, replacement )
-> aString or nil
gsub!( pattern ) {| | block }-> aString or nil |
|
Äquivalent zu Kernel::gsub,
außer dass nil zurückgegeben wird, falls
$_ nicht verändert wird.
$_ = "quick brown fox" |
gsub! /cat/, '*' |
» |
nil |
$_ |
» |
"quick brown fox" |
|
|
iterator?
|
iterator? -> true or false |
|
Synonym für Kernel::block_given?.
Diesen iterator? wird es in Ruby 1.8 nicht mehr geben.
|
|
lambda
|
lambda {| | block }-> aProc |
|
Synonym für Kernel::proc.
|
|
load
|
load( aFileName,
wrap=false ) -> true |
|
Lädt das Ruby-Programm aus der Datei aFileName und
führt es aus.
Falls der Dateiname keinen absoluten Pfad ergibt, wird die
Datei gesucht in den Bibliotheks-Verzeichnissen aus
$:. Falls der optionele wrap-Parameter
true ist, wird das geladene Script innerhalb eines
anonymen Moduls ausgeführt, um den globalen Namensraum des aufrufenden
Programms zu schützen. Die ladende Umgebung erhält keine lokalen Variablen
von der geladenen Datei.
|
|
local_variables
|
local_variables
-> anArray |
|
Liefert die Namen der aktuellen lokalen Variablen.
fred = 1 |
for i in 1..10 |
# ... |
end |
local_variables |
» |
["fred", "i"] |
|
|
loop
|
loop {| | block }
|
|
Führt den Block mehrfach aus.
loop {
print "Input: "
break if !gets or $_ =~ /^qQ/
# ...
}
|
|
|
open
|
open( aString[, aMode[perm]] )
-> anIO or nil
open( aString[, aMode[perm]] ) {| anIO | block }-> nil |
|
Erzeugt ein IO-Objekt, das mit dem angegebenen Stream,
der angegebenen Datei oder dem angegebenen Unterprozess verbunden ist.
Falls aString nicht mit dem Pipe-Zeichen
(``|'') anfängt, wird er als Name der zu öffnenden Datei interpretiert,
wobei der Modus defaultmäßig auf ``r'' gesetzt ist (siehe die
Tabelle für die zulässigen Modi auf Seite 331). Falls dabei eine Datei erzeugt
wird, kann man ihre Berechtigungen als ganze Zahl mit dem optionalen
dritten Parameter setzen.
Falls ein Block angegeben ist, wird er mit dem File-Objekt
als Parameter aufgerufen, und die Datei wird beim Ende des Blocks
automatisch geschlossen. In diesem Fall gibt der Aufruf immer
nil zurück.
Falls aString mit dem Pipe-Zeichen anfängt, wird ein Unterprozess
erzeugt, der mit dem Aufrufer durch ein Pipe-Paar verbunden ist. Mit dem
zurückgegebenen IO-Objekt kann man auf den Standard-Input
der Unterprozesses schreiben und von seinem Standard-Output lesen. Falls das Kommando
nach dem ``|'' ein einzelnes Minuszeichen ist, spaltet sich Ruby auf
(fork), und dieser Unterprozess ist mit dem Elternprozess verbunden.
Im Unterprozess liefert der open-aufruf nil zurück.
Falls das Kommando nicht ``-'' ist, bearbeitet der Unterprozess das
Kommando. Wenn mit einem open("|-")-Aufruf ein Block verbunden ist, so
wird dieser zweimal ausgeführt --- einmal im Elternteil und einmal im Kind. Der
Parameter des Blocks ist ein IO-Objekt im Elternteil
und nil im Kind. Das IO-Objekt ist
verbunden mit den $stdin und $stdout des Kindes. Der
Unterprozess wird am Ende des Blocks beendet.
open("testfile") do |f|
print f.gets
end
|
erzeugt:
Öffne einen Unterprozess und lies seinen Output:
cmd = open("|date")
print cmd.gets
cmd.close
|
erzeugt:
Sun Mar 4 23:30:41 CST 2001
|
Öffne einen Unterprozess im selben Ruby-Programm:
f = open("|-", "w+")
if f == nil
puts "in Child"
exit
else
puts "Got: #{f.gets}"
end
|
erzeugt:
Öffne einen Unterprozess mit einem Block, um das I/O-Objekt zu erhalten:
open("|-") do |f|
if f == nil
puts "in Child"
else
puts "Got: #{f.gets}"
end
end
|
erzeugt:
|
|
p
|
p( [anObject]+ )
-> nil |
|
Schreibt direkt auf den Standard-Output des Programms
anObject.inspect gefolgt vom aktuellen Output-Record-Seperator.
p umgeht die Ruby-I/O-Bibliotheken.
erzeugt:
|
|
print
|
print( [anObject]* )
-> nil |
|
Schreibt jedes Objekt nach $defout. Wenn der Output-Field-Seperator
nicht nil ist, wird sein Inhalt zwischen jedem Feld ausgegeben.
Wenn der Output-Record-Seperator ($\) nicht nil ist, wird
er an den Output angehängt. Falls keine Argumente angegeben sind, wird
$_ beschrieben. Objekte, die keine Strings sind, werden mit der
to_s-Methode ausgegeben.
print "cat", [1,2,3], 99, "\n"
$, = ", "
$\ = "\n"
print "cat", [1,2,3], 99
|
erzeugt:
cat12399
cat, 1, 2, 3, 99
|
|
|
printf
|
printf( anIO, aString[, anObject]* )
-> nil
printf( aString[, anObject]* )
-> nil |
|
Äquivalent zu:
anIO.write sprintf(aString, anObject ...)
oder
$defout.write sprintf(aString, anObject ...)
|
|
proc
|
proc { block }-> aProc |
|
Erzeugt ein neues Procedure-Objekt aus dem Block. Äquivalent
zu Proc.new.
aProc = proc { "hello" } |
aProc.call |
» |
"hello" |
|
|
putc
|
putc( anInteger ) -> anInteger |
|
Äquivalent zu $defout.putc(anInteger).
|
|
puts
|
puts( [args]* ) -> nil |
|
Äquivalent zu $defout.puts(args).
|
|
raise
|
raise
raise( aString )
raise( anException[, aString[anArray]] )
|
|
Ohne Argumente wird die Exception aus $! ausgelöst, oder ein
RuntimeError falls $! nil ist.
Mit einen einzelnen String-Argument wird ein
RuntimeError mit dem String als Nachricht ausgelöst.
Andernfalls sollte der erste Parameter der Name einer
Exception-Klasse sein (oder ein Objekt, das auf die Nachricht
exception eine Exception zurückliefert).
Der optionale zweite Parameter bestimmt die Nachricht, die mit der Exception
verbunden ist, und der dritte ist ein Array mit Callback-Informationen. Exceptions
werden mit der rescue-Klausel eines begin...end-Blocks abgefangen.
raise "Failed to create socket"
raise ArgumentError, "No parameters", caller
|
|
|
rand
|
rand( max=0 )
-> aNumber |
|
Konvertiert max in ein Integer mit max1 =
max.to_i.abs. Falls das Ergebnis Null ist, wird eine
Pseudo-Zufallszahl als Fließkommazahl zwischen (inklusive) 0.0 und
(exklusive) 1.0 zurück geliefert. Andernfalls eine Pseudo-Zufallszahl als
Integer zwischen (inklusive) 0 und (exklusive) max1.
Mit Kernel::srand
kann man in diesem Zusammenhang wiederholbare Folgen von
Zufallszahlen erzeugen.
srand 1234 |
» |
0 |
[ rand, rand ] |
» |
[0.7408769294, 0.2145348572] |
[ rand(10), rand(1000) ] |
» |
[3, 323] |
srand 1234 |
» |
1234 |
[ rand, rand ] |
» |
[0.7408769294, 0.2145348572] |
|
|
readline
|
readline( [aString=$/] )
-> aString |
|
Äquivalent zu Kernel::gets,
außer dass readline einen
EOFError am Ende der Datei auslöst.
|
|
readlines
|
readlines( [aString=$/] )
-> anArray |
|
Liefert ein Array mit den durch Kernel.gets(aString)
bis zum Ende der Datei erhaltenen Zeilen.
|
|
require
|
require( aString )
-> true or false |
|
Ruby versucht die Bibliothek namens aString zu laden und liefert
im Erfolgsfall true zurück. Falls der Dateiname keinen absoluten
Pfad ergibt, wird in den Verzeichnissen aus $: gesucht. Falls die
Datei die Endung ``.rb'' hat, wird sie als Quelldatei geladen; ist die Endung
``.so'', ``.o'', oder ``.dll'', [Oder was immer die defaultmäßige Endung
für die Shared-Library auf der aktuellen Plattform ist.] so lädt Ruby
diese Datei als eine Ruby-Erweiterung. Andernfalls versucht Ruby,
``.rb'', ``.so'' und so weiter an den Namen anzuhängen. Der Name der geladenen
Datei wird zu dem Array in $" hinzugefügt. Die Datei wird nicht geladen,
falls sie schon in $" auftaucht.
require liefert true, falls die Datei erfolgreich geladen
wurde.
require "my-library.rb"
require "db-driver"
|
|
|
scan
|
scan( pattern ) -> anArray
scan( pattern ) {| | block }-> $_ |
|
Äquivalent zum Aufruf von $_.scan. Siehe String#scan
auf Seite 378.
|
|
select
|
select( readArray[,
writeArray[errorArray[timeout]]] )
-> anArray or nil |
|
Führt einen low-level select-Aufruf aus, der darauf wartet, dass Daten von einem Input/Output-Gerät verfügbar werden. Die ersten drei Parameter sind Arrays aus IO-Objekten oder nil. Der letzte ist ein Timeout in Sekunden, der ein Integer oder ein Float sein sollte. Der Aufruf wartet darauf, dass Daten verfügbar werden von irgendeinem der IO-Objekte in readArray, dass Puffer erstmal genügend geleert werden, um schreiben zu können in ein Gerät aus writeArray, oder dass ein Fehler auftritt bei einem der Geräte aus errorArray. Wenn eine oder mehrere dieser Bedingungen zutreffen, gibt der Afuruf ein drei-elementiges Array mit den Arrays der auslösenden IO-Objekte zurück. Falls anderenfalls nach timeout Sekunden keine Änderung eingetreten ist, gibt der Aufruf nil zurück. Falls alle Parameter nil sind , so wird der aktuelle Thread ewig schlafen bleiben.
select( [$stdin], nil, nil, 1.5 ) |
» |
[[#<IO:0x4019202c>], [], []] |
|
|
set_trace_func
|
set_trace_func( aProc ) -> aProc
set_trace_func( nil ) -> nil |
|
Etabliert aProc als den Handler für das Tracing, oder schaltet das Tracing aus falls der Parameter nil ist. aProc nimmt bis zu sechs Parameter entgegen: Den Namen eines Ereignisses, den Namen einer Datei, eine Zeilennummer, eine Objekt-Id, eine Bindung und den Namen einer Klasse. aProc wird immer ausgeführt, wenn ein Ereignis eintritt. Ereignisse sind:
c-call (Aufruf einer Routine der Sprache C),
c-return (Rückkehr aus einer Routine der Sprache C),
call (Aufruf einer Ruby-Methode),
class (Start einer Klassen- oder Modul-Definition),
end (Ende einer Klassen- oder Modul-Definition),
line (Ausführen von Code auf einer neuen Zeile),
raise (Auslösung einer Exception) und
return (Rückkehr von einer Ruby-Methode).
Innerhalb des Kontexts von aProc ist das Tracing abgeschaltet.
Siehe das Beispiel ab Seite 271 für mehr Informationen.
|
|
singleton_method_added
|
singleton_method_added( aFixnum ) -> nil |
|
Wird immer dann mit einer Symbol-Id aufgerufen, wenn eine Singleton-Methode zu einem Modul oder einer Klasse hinzugefügt wird. Die defautlmäßige Implementation von Kernel nutzt das zwar nicht, aber Unterklassen könnten das ja überschreiben, um spezielle Funktionalität einzufügen.
class Test
def Test.singleton_method_added(id)
puts "Added #{id.id2name} to Test"
end
def a() end
def Test.b() end
end
def Test.c() end
|
erzeugt:
Added singleton_method_added to Test
Added b to Test
Added c to Test
|
|
|
sleep
|
sleep( [aNumeric] )
-> aFixnum |
|
Unterbricht den aktuellen Thread für aNumber Sekunden (was auch ein Float mit Sekunden-Bruchteilen sein kann). Gibt die tatsächliche Anzahl von verschlafenen Sekunden zurück (gerundet). Das kann weniger sein, falls der Thread mit
SIGALRM unterbrochen wurde, oder falls ein anderer Thread Thread#run aufruft. Null als Argument lässt den Thread ewig schlafen.
Time.new |
» |
Sun Mar 04 23:30:41 CST 2001 |
sleep 1.2 |
» |
2 |
Time.new |
» |
Sun Mar 04 23:30:43 CST 2001 |
sleep 1.9 |
» |
2 |
Time.new |
» |
Sun Mar 04 23:30:45 CST 2001 |
|
|
split
|
split( [pattern[limit]] ) -> anArray |
|
Äquivalent zu
$_.split(pattern, limit). Siehe String#split
auf Seite 379.
|
|
sprintf
|
sprintf( aFormatString[, arguments]* ) -> aString |
|
Liefert den String, den man erhält durch Anwendung von aFormatString auf die weiteren Argumente. Alle Zeichen aus dem Format-String, die keine Format-Sequenzen sind, werden ins Ergebnis kopiert.
Eine Format-Sequenz besteht aus einem Prozent-Zeichen, gefolgt von optionalen Flags, Breite- und Genauigkeits-Indikatoren, dann abgeschlossen von einem Feld-Typ-Zeichen. Der Feld-Typ bestimmt, wie das dazugehörende sprintf-Argument interpretiert werden soll, während die Flags diese Interpretation steuern. Die Flag-Zeichen werden in Tabelle 23.1 auf Seite 428 gezeigt und die Feld-Typen in Tabelle 23.2.
Die Feld-Breite ist ein optionaler Integer, optional gefolgt von einem Punkt und einer Genauigkeit. Die Breite gibt die minimale Anzahl an Zeichen für dieses Feld an. Bei numerischen Feldern gibt die Genauigkeit die Anzahl der Dezimalstellen an. Bei Strings gibt die Genauigkeit die maximale Anzahl von Zeichen an. (Damit schiebt die Format-Sequenz %10.10s immer genau zehn Zeichen in das Ergebnis.)
sprintf Flag-Zeichen
| Flag |
greift bei |
Bedeutung |
![[visible space]](visible_space.gif) |
bdeEfgGioxXu |
Erhält ein Leerzeichen am Anfang einer positiven Zahl. |
# |
beEfgGoxX |
Benutze ein anderes Format. Bei der Konversion von `o', `x', `X' und `b' hänge vorne ein
``0'', ``0x'', ``0X'' bzw. ``0b'' an. Bei `e',
`E', `f', `g' und 'G' erzwinge einen Dezimalpunkt, auch wenn keine Ziffern mehr folgen. Bei `g' und 'G' entferne keine abschließenden Nullen. |
+ |
bdeEfgGioxXu |
Füge ein führendes Plus-Zeichen bei positiven Zahlen hinzu. |
- |
all |
Das Ergebnis dieser Konversion soll linksbündig sein. |
0 (Null) |
all |
Fülle mit Nullen statt mit Leerzeichen auf. |
* |
all |
Benutze das nächste Argument als Feld-Breite. Falls negativ soll das Ergebnis linksbündig sein. Falls auf das Sternchen eine Zahl und ein Dollarzeichen folgen, benutze das dadurch indizierte Argument als Breite. |
 |
|
sprintf-Feld-Typen
| Feld |
Konversion |
| b |
Konvertiere das Argument als binäre Zahl. |
| c |
Das Argument ist der numerische Code für ein einzelnes Zeichen. |
| d |
Konvertiere das Argument als dezimale Zahl. |
| E |
Äquivalent zu `e', aber mit großem E um den Exponenten anzuzeigen. |
| e |
Konvertiere das Fließkomma-Argument in die exponentielle Schreibweise mit einer Stelle vor dem Dezimalpunkt. Die Genauigkeit gibt die Anzahl der Nahkommastallen an (default sechs). |
| f |
Konvertiere das Fließkomma-Argument als [-]ddd.ddd, wobei die Genauigkeit die Nachkommastellen angibt. |
| G |
Äquivalent zu `g', aber benutzt das große `E' in der Exponential-Form. |
| g |
Konvertiere eine Fließkomma-Zahl und benutze die Exponential-Schreibweise, falls der Exponent kleiner als -4 ist oder größer/gleich der Genauigkeit, sonst die Form d.dddd. |
| i |
Identisch mit `d'. |
| o |
Konvertiere das Argument als oktale Zahl. |
| s |
Das Argument ist ein String, der eingesetzt werden soll. Wenn in der Format-Sequenz eine Genauigkeit angegeben ist, ist das die Maximal-Zahl an einzufügenden Zeichen. |
| u |
Behandle das Argument als vorzeichenlose Dezimal-Zahl. |
| X |
Konvertiere das Argument als Hexadzimal-Zahl mit Großbuchstaben als Ziffern. |
| x |
Konvertiere das Argument als Hexadezimal-Zahl. |
|
|
sprintf("%d %04x", 123, 123) |
» |
"123007b" |
sprintf("%08b '%4s'", 123, 123) |
» |
"01111011'123'" |
sprintf("%*2$s %d", "hello", 10) |
» |
"hello10" |
sprintf("%*2$s %d", "hello", -10) |
» |
"hello-10" |
sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) |
» |
"+1.23:1.23:1.23" |
|
|
srand
|
srand( [aNumber] )
-> oldSeed |
|
Initialisiert den Pseudozufallszahlen-Generator mit dem Wert von aNumber.to_i.abs. Falls aNumber fehlt oder Null ist, wird dazu eine Kombination aus der Zeit, der Prozess-Id und einer laufenden Nummer benutzt. (Genau das selbe passiert, wenn man Kernel::rand ohne vorheriges
srand aufruft, dabei aber ohne laufende Nummer.)
Durch diese Initialisierung auf einen bekannten Wert kann man Skripte beim Testen deterministisch machen. Der vorherige Initialisierungswert wird zurückgegeben. Siehe auch Kernel::rand auf Seite 425.
|
|
sub
|
sub( pattern, replacement )
-> $_
sub( pattern ) { block }
-> $_ |
|
Äquivalent zu $_.sub(args), außer dass $_
erneuert wird, falls eine Substitution erfolgt.
|
|
sub!
|
sub!( pattern, replacement )
-> $_ or nil
sub!( pattern ) { block }
-> $_ or nil |
|
Äquivalent zu $_.sub!(args).
|
|
syscall
|
syscall( aFixnum[, args]* )
-> anInteger |
|
Ruft die Betriebs-System-Funktion mit der Nummer aFixnum auf und übergibt ihr die Argumente, die entweder String-Objekte oder Integer-Objekte sein müssen, die genau in ein long (unterschiedlich groß, je nach Maschine) passen müssen. Bis zu neun Parameter (14 auf dem Atari-ST) können nötig sein. Welche Funktion zur Nummer Fixnum gehört, hängt vom Betriebssystem ab. Bei manchen Unix-Systemen kann man die Nummern über eine Header-Datei namens
syscall.h erhalten.
syscall 4, 1, "hello\n", 6 # '4' is write(2) on our box
|
erzeugt:
|
|
system
|
system( aCmd[, args]* )
-> true or false |
|
Führt aCmd in einer Unter-Shell aus und liefert true, falls das Kommando gefunden und erfolgreich ausgeführt wurde, ansonsten false. Einen detailierten Fehler-Code erhält man in $?. Die Argumente werden in der selben Weise behandelt wie bei Kernel::exec
auf Seite 419.
system("echo *")
system("echo", "*")
|
erzeugt:
|
|
test
|
test(aCmd, file1[, file2] )
-> anObject |
|
Benutzt den Integer aCmd, um verschieden Tests mit
file1 (Tabelle 23.3 auf Seite 430) oder mit file1 und
file2 (Tabelle 23.4) auszuführen.
Datei-Tests mit einem Argument
| Integer |
Beschreibung |
Liefert |
| ?A |
Letzte Zugriffszeit für file1 |
Time |
| ?b |
True falls file1 ein Block-Device ist |
true oder false |
| ?c |
True falls file1 ein Zeichen.Device ist |
true oder false |
| ?C |
Zeit der letzten Änderung an file1 |
Time |
| ?d |
True falls file1 existiert und ein Verzeichnis ist |
true oder false |
| ?e |
True falls file1 existiert |
true oder false |
| ?f |
True falls file1 existiert und eine reguläre Datei ist |
true oder false |
| ?g |
True falls bei file1 das setgid-Bit gesetzt ist (bei NT immer falsch) |
true oder false |
| ?G |
True falls file1 existiert und der selben Gruppe angehört wie der Aufrufer |
true oder false |
| ?k |
True falls file1 existiert und das Sticky-Bit gesetzt hat |
true oder false |
| ?l |
True falls file1 existiert und ein symbolischer Link ist |
true oder false |
| ?M |
Zeit der letzten Modifikation an file1 |
Time |
| ?o |
True falls file1 existiert und die effektive UID des Aufrufers daran die Besitzrechte hat |
true oder false |
| ?O |
True falls file1 existiert und die reale UID des Aufrufers daran die Besitzrechte hat |
true oder false |
| ?p |
True falls file1 existiert und ein Fifo ist |
true oder false |
| ?r |
True falls die Datei mit der effektiven UID/GID des Aufrufers lesbar ist |
true oder false |
| ?R |
True falls die Datei mit der realen UID/GDI des Aufrufers lesbar ist |
true oder false |
| ?s |
liefert die Größe von file1 falls nicht Null, sonst nil |
Integer oder nil |
| ?S |
True falls file1 existiert und ein Socket ist |
true oder false |
| ?u |
True falls bei file1 das Setuid-Bit gesetzt ist |
true oder false |
| ?w |
True falls file1 existiert und mit der effektiven UID/GID schreibbar ist |
true oder false |
| ?W |
True falls file1 existiert und mit der realen UID/GID schreibbar ist |
true oder false |
| ?x |
True falls file1 existiert und mit der effektiven UID/GID ausführbar ist |
true oder false |
| ?X |
True falls file1 existiert und mit der effektiven UID/GID ausführbar ist |
true oder false |
| ?z |
True falls file1 existiert und die Länge Null hat |
true oder false |
|
|
Datei-Tests mit zwei Argumenten
| Integer |
Beschreibung |
| ?- |
True falls file1 ein Hard-Link auf file2 ist |
| ?= |
True falls die Zeiten der Modifikationen von file1 und file2 gleich sind |
| ?< |
True falls die Zeit der Modifikation von file1 früher als die von file2 ist |
| ?> |
True falls die Zeit der Modifikation von file1 später als die von file2 ist |
|
|
|
|
throw
|
throw( aSymbol[, anObject] )
|
|
Übergibt die Kontrolle an das Ende des aktuellen catch-Blocks und wartet auf aSymbol. Löst eine NameError aus, falls es für dieses Symbol keinen solchen catch-Block gibt. Der optionale zweite Parameter stellt einen Rückgabe-Wert für den catch-Block zur Verfügung, ansonsten ist dieser nil. Beispiele gibt's bei Kernel::catch auf Seite 417.
|
|
trace_var
|
trace_var( aSymbol, aCmd ) -> nil
trace_var( aSymbol ) {| val | block }-> nil |
|
Kontrolliert das Tracing von Zuweisungen an globale Variablen. Der Parameter aSymbol bestimmt die Variable (entweder als String-Name oder als Symbol). Jedesmal, wenn die Variable etwas zugewiesen bekommt, wird
cmd (das kann ein String sein oder ein Proc-Objekt) oder der Block ausgeführt. Der Block oder das Proc-Objekt erhalten den Wert der neuen Variablen als Parameter. Siehe auch Kernel::untrace_var.
trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
$_ = "hello"
$_ = ' there'
|
erzeugt:
$_ is now 'hello'
$_ is now ' there'
|
|
|
trap
|
trap( signal, cmd ) -> anObject
trap( signal ) {| | block }-> anObject |
|
Bestimmt das Verhalten bei Signalen. Der erste Parameter ist ein Signal-Name (ein String wie ``SIGALRM'', ``SIGUSR1'' und so weiter) oder eine Signal-Nummer. Die Zeichen ``SIG'' können beim Signal-Namen auch weggelassen werden. Das Kommando oder der Block geben den Code an, der ausgeführt werden soll, wenn das Signal ausgelöst wurde. Falls das Kommando der String ``IGNORE'' oder ``SIG_IGN'' ist, wird das Signal ignoriert. Falls das Kommando ``DEFAULT'' oder ``SIG_DFL'' ist, wird die defaultmäßige Behandlung des Betriebssystems aufgerufen. Falls das Kommando ``EXIT'' ist, so wird das Skript von dem Signal beendet. Andernfalls wird das angegebene Kommando oder der angegebene Block ausgeführt.
Der spezielle Signal-Name ``EXIT'' oder die Signal-Nummer Null wird direkt vor Programmende ausgelöst.
trap gibt den vorherigen Handler für das angegebene Signal zurück.
trap 0, proc { puts "Terminating: #{$$}" }
trap("CLD") { puts "Child died" }
fork && Process.wait
|
erzeugt:
Terminating: 16422
Child died
Terminating: 16421
|
|
|
untrace_var
|
untrace_var( aSymbol[,
aCmd] ) -> anArray or nil |
|
Entfernt das Tracing für das angegebenen Kommando und die gegebene globale Variable und gibt nil zurück. Falls kein Kommando angegeben wird, wird sämtliches Tracing für dieses Variable abgeschaltet und ein Array mit den gerade entfernten Kommandos zurück gegeben.
|