Programmierung in Ruby

Der Leitfaden der Pragmatischen Programmierer
class Array
Parent: Object
Version: 1.6

Index:

[ ] new & * + -- << <=> == === [ ] [ ]= | assoc at clear collect collect! compact compact! concat delete delete_at delete_if each each_index empty? eql? fill first flatten flatten! include? index indexes indices join last length map! nitems pack pop push rassoc reject! replace reverse reverse! reverse_each rindex shift size slice slice! sort sort! to_a to_ary to_s uniq uniq! unshift

Arrays sind geordnete, ganz-zahlig-indizierte Sammlungen von beliebigen Objekten. Die Indizierung eines Arrays beginnt bei 0, genau wie in C oder Java. Ein negativer Index wird vom Ende des Arrays heruntergezählt---das bedeutet, dass ein Index von -1 das letzte Element des Arrays anzeigt, -2 das vorletzte Element, und so weiter.
mixins
Enumerable: collect, detect, each_with_index, entries, find, find_all, grep, include?, map, max, member?, min, reject, select, sort, to_a

class methods
[ ] Array[ [einObjekt]* ] -> einArray

Gibt ein neues Array, das mit den angegebene Objekten gefüllt ist, zurück. Die Methode ist equivalent zur Operator-Form Array.[](...).

Array.[]( 1, 'a', /^A/ ) » [1, "a", /^A/]
Array[ 1, 'a', /^A/ ] » [1, "a", /^A/]
[ 1, 'a', /^A/ ] » [1, "a", /^A/]

new Array.new( einInteger=0, einObjekt=nil ) -> einArray

Gibt ein neues Array zurück. Eine Größe und ein Startwert können optional übergeben werden (d.h., einInteger referenziert dasselbe einObjekt).

Array.new » []
Array.new(2) » [nil, nil]
Array.new(5, "A") » ["A", "A", "A", "A", "A"]
Array.new(2, Hash.new) » [{}, {}]

instance methods
& arr & einAnderesArray-> einArray

Schnittmenge---Gibt ein neues Array, das alle gemeinsamen Elemente beider Arrays ohne Duplikate enthält, zurück.

[ 1, 1, 3, 5 ] & [ 1, 2, 3 ] » [1, 3]

* arr * einInteger-> einArray
arr * einString-> einAndererString

Wiederholung---Mit einem String-Argument ist die Methode equivalent mit arr.join(einString). Mit anderen Argumenten wird ein neues Array zurückgegeben, in dem einInteger Kopien von arr enthalten sind.

[ 1, 2, 3 ] * 3 » [1, 2, 3, 1, 2, 3, 1, 2, 3]

+ arr + einAnderesArray-> einArray

Zusammensetzung---Gibt ein neues Array, das durch Zusammensetzung der beiden Arrays zu einem Dritten erhalten wird, zurück.

[ 1, 2, 3 ] + [ 4, 5 ] » [1, 2, 3, 4, 5]

-- arr - einAnderesArray-> einArray

Differenz---Gibt ein Array zurück, das aus einer Kopie des Originals abzüglich aller Elemente aus anOtherArray sowie abzüglich aller doppelten Elemente erhalten wird.

[ 1, 1, 2, 2, 3, 3, 3, 4, 5 ] - [ 1, 2, 4 ] » [3, 5]

<< arr << einObjekt-> arr

Anhängen---Verschiebt das gegebene Objekt an das Ende dieses Arrays. Dieser Ausdruck gibt das Array selbst zurück, so dass mehrere Aufrufe aneinander gehängt werden können. Siehe auch Array#push.

[ 1, 2 ] << "c" << "d" << [ 3, 4 ] » [1, 2, "c", "d", [3, 4]]

<=> arr <=> einAnderesArray-> -1, 0, +1

Vergleich---Gibt einen Ganzzahlwert von -1, 0, oder +1 zurück, je nachdem, ob das Array kleiner, gleich oder größer als einAnderesArray ist. Jedes Objekt in den Arrays wird verglichen (mit <=>). Sollte kein Wert gleich sein, wird die Ungleichheit zurückgegeben. Werden alle Werte identisch gefunden, so wird der Rückgabewert aus einem Vergleich der Array-Längen bestimmt. Somit sind zwei Arrays in Bezug auf Array#<=> "gleich", dann und nur dann, wenn sie dieselbe Länge haben und jedes Element einem Element des anderen Arrays entspricht.

[ "a", "a", "c" ]    <=> [ "a", "b", "c" ] » -1
[ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ] » 1

== arr == einAnderesArray-> true oder false

Gleichheit---Zwei Arrays sind gleich, wenn sie dieselbe Anzahl von Elementen enthalten und wenn jedes Element (in Bezug auf Object#==) einem korrespondierenden Element aus dem anderen Array gleicht.

[ "a", "c" ]    == [ "a", "c", 7 ] » false
[ "a", "c", 7 ] == [ "a", "c", 7 ] » true
[ "a", "c", 7 ] == [ "a", "d", "f" ] » false

=== arr === einAnderesArray-> true oder false

Case-Gleichheit---Dieser Vergleichsoperator wird von case-Ausdrücken verwendet. Im Falle von Arrays ist er identisch mit Array#==.

[ ] arr[einInteger] -> einObject oder nil
arr[start, länge] -> einSubArray oder nil
arr[einBereich] -> einSubArray oder nil

Element Referenz---Gibt das Element am Index einInteger bzw. ein Teil-Array beginnend bei start mit länge Elementen bzw. den Teil-Array, der dem Bereich einBereich entspricht, zurück. Negative Indizes werden dabei vom Ende des Arrays an rückwärts gezählt (-1 ist das letzte Element). Die Methode gibt nil zurück, wenn ein Index ungültig ist.

a = [ "a", "b", "c", "d", "e" ]
a[2] +  a[0] + a[1] » "cab"
a[6] » nil
a[1, 2] » ["b", "c"]
a[1..3] » ["b", "c", "d"]
a[4..7] » ["e"]
a[6..10] » nil
a[-3, 3] » ["c", "d", "e"]

[ ]= arr[einInteger] = einObjekt-> einObjekt
arr[start, länge] = einSubArray-> einSubArray
arr[einBereich] = einSubArray-> einSubArray

Element-Zuweisung---Setzt ein Element am Index einInteger bzw. ersetzt ein Teil-Array beginnend bei start mit der Länge länge bzw. ersetzt ein TeilArray, das mit einBereich bestimmt ist. Für den Fall, dass einInteger größer ist, als die aktuelle Kapazität des Arrays, wird das Array automatisch erweitert. Ein negativer Wert von einInteger zählt vom Ende des Arrays ab herunter. Die Methode fügt Elemente ein, wenn länge 0 ist. Löscht Elemente aus arr, wenn subArray gleich nilist. Ein IndexError wird geworfen, wenn ein negativer Index weiter als bis zum Array-Beginn hinabzeigt. Siehe auch Array#push, Array#unshift.

a = Array.new » []
a[4] = "4";                  a » [nil, nil, nil, nil, "4"]
a[0, 3] = [ 'a', 'b', 'c' ]; a » ["a", "b", "c", nil, "4"]
a[1..2] = [ 1, 2 ];          a » ["a", 1, 2, nil, "4"]
a[0, 2] = "?";               a » ["?", 2, nil, "4"]
a[0..2] = "A";               a » ["A", "4"]
a[-1]   = "Z";               a » ["A", "Z"]
a[1..-1] = nil;              a » ["A"]

| arr | einAnderesArray-> einArray

Vereinigungsmenge---Gibt ein neues Array, das alle Elemente beider Arrays ohne Duplikate enthält, zurück.

[ "a", "b", "c" ] | [ "c", "d", "a" ] » ["a", "b", "c", "d"]

assoc arr.assoc( einObjekt ) -> einArray oder nil

Durchsucht ein Array, dessen Elemente ebenfalls Arrays sind, auf die Übereinstimmung von einObjekt mit dem jeweils ersten Element der Arrays mit Hilfe von einObjekt.==. Die Methode gibt das erste übereinstimmende Array, d.h. das erste "associated array" zurück, bzw. nil, wenn keine Treffer gefunden wird. Siehe auch Array#rassoc.

s1 = [ "colors", "red", "blue", "green" ]
s2 = [ "letters", "a", "b", "c" ]
s3 = "foo"
a  = [ s1, s2, s3 ]
a.assoc("letters") » ["letters", "a", "b", "c"]
a.assoc("foo") » nil

at arr.at( einInteger ) -> einObjekt oder nil

Gibt das Element am Index einInteger zurück. Ein negativer Index zählt vom Ende von arr zurück. Die Methode gibt nil zurück, wenn der Index ausserhalb des Gültigkeitsbereichs liegt.Siehe auch Array#[]. (Array#at is etwas schneller als Array#[], da hier keine Index-bereiche etc. akzeptiert werden.)

a = [ "a", "b", "c", "d", "e" ]
a.at(0) » "a"
a.at(-1) » "e"

clear arr.clear -> arr

Entfernt alle Elemente aus arr.

a = [ "a", "b", "c", "d", "e" ]
a.clear » []

collect arr.collect {| obj | block }

-> einArray

Gibt ein neues Array zurück, indem block für jedes Element einmal aufgerufen wird. Dabei wird jedes Element als Parameter an block übergeben. Das Ergbnis von block wird als Element in das neue Element eingefügt. Siehe auch Array#collect!.

a = [ "a", "b", "c", "d" ]
a.collect {|x| x + "!" } » ["a!", "b!", "c!", "d!"]
a » ["a", "b", "c", "d"]

collect! arr.collect! {| obj | block }

-> arr

Ruft block einmal für jedes Element von arr auf, wobei jedes Element durch das Ergebnis von block ersetzt wird. Siehe auch Array#collect.

a = [ "a", "b", "c", "d" ]
a.collect! {|x| x + "!" } » ["a!", "b!", "c!", "d!"]
a » ["a!", "b!", "c!", "d!"]

compact arr.compact -> einArray

Gibt ein neues Array auf der Basis von arr zurück, in dem alle nil-Elemente entfernt sind.

[ "a", nil, "b", nil, "c", nil ].compact » ["a", "b", "c"]

compact! arr.compact! -> arr oder nil

Dieselbe Funktion wie Array#compact, jedoch wird das Array selbst modifiziert statt einer Kopie. Gibt nil zurück, wenn keine Änderungen gemacht wurden.

[ "a", nil, "b", nil, "c" ].compact! » ["a", "b", "c"]
[ "a", "b", "c" ].compact! » nil

concat arr.concat( einAnderesArray ) -> arr

Erweitert arr um die Elemente aus einAnderesArray.

[ "a", "b" ].concat( ["c", "d"] ) » ["a", "b", "c", "d"]

delete arr.delete( einObjekt ) -> einObjekt oder nil
arr.delete( einObjekt ) {| | block }

-> einObjekt oder nil

Entfernt Elemente aus self, die mit einObjekt übereinstimmen. Wenn das Element nicht gefunden wird, gibt die Methode nil zurück. Falls der optionale Codeblock angegeben ist, wird das Ergebnis von block zurückgegeben, wenn das Element nicht existiert.

a = [ "a", "b", "b", "b", "c" ]
a.delete("b") » "b"
a » ["a", "c"]
a.delete("z") » nil
a.delete("z") { "not found" } » "not found"

delete_at arr.delete_at( einIndex ) -> einObjekt oder nil

Entfernt ein Element am angegebenen Index und gibt dieses Element zurück bzw. nil wenn der Index ausserhalb des Gültigkeitsbereichs liegt. Siehe auch Array#slice!.

a = %w( ant bat cat dog )
a.delete_at(2) » "cat"
a » ["ant", "bat", "dog"]
a.delete_at(99) » nil

delete_if arr.delete_if {| | block }

-> arr

Löscht jedes Element aus arr für das der Ausdruck in block den Wert true ergibt.

a = [ "a", "b", "c" ]
a.delete_if {|x| x >= "b" } » ["a"]

each arr.each {| item | block }-> arr

Ruft block einmal für jedes Element in arr auf und übergibt dieses Element als Parameter. 

a = [ "a", "b", "c" ]
a.each {|x| print x, " -- " }
ergibt:
a -- b -- c --

each_index arr.each_index {| einIndex | block }-> arr

Die Funktion ist dieselbe wie bei Array#each. Jedoch wird statt des Elements dessen Index an block übergeben. 

a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }
produces:
0 -- 1 -- 2 --

empty? arr.empty? -> true oder false

Gibt true zurück, wenn arr keine Elemente enthält.

[].empty? » true

eql? arr.eql?( einAnderesArray ) -> true oder false

Ein Array gleicht einem anderen, wenn die Längen beider Arrays gleich sind und die jeweiligen Elemente bezüglich Object#eql? gleich sind. Siehe auch Array#<=>. eql? wird für den Vergleich von Hashes verwendet.

[ "a", "b", "c" ].eql?(["a", "b", "c"]) » true
[ "a", "b", "c" ].eql?(["a", "b"]) » false
[ "a", "b", "c" ].eql?(["b", "c", "d"]) » false

fill arr.fill( einObjekt ) -> arr
arr.fill( einObjekt, start[, laenge] ) -> arr
arr.fill( einObjekt, einBereich ) -> arr

Setzt alle Elemente von arr (die das ganze Array darstellen können) auf den Wert von einObjekt. Ein start mit nil ist equivalent mit Null. Eine laenge von nil ist equivalent mit arr.laenge.

a = [ "a", "b", "c", "d" ]
a.fill("x") » ["x", "x", "x", "x"]
a.fill("z", 2, 2) » ["x", "x", "z", "z"]
a.fill("y", 0..1) » ["y", "y", "z", "z"]

first arr.first -> einObjekt oder nil

Gibt das erste Element des Arrays zurück. Wenn das Array leer ist, wird nil zurückgegeben.

a = [ "q", "r", "s", "t" ]
a.first » "q"

flatten arr.flatten -> einArray

Gibt ein neues Array, das eine (rekursiv) ein-dimensional geglättete Version dieses Arrays ist, zurück. D.h. aus jedem enthaltenen Element, das selbst ein Array ist, werden alle Elemente in das neue Array extrahiert.

s = [ 1, 2, 3 ] » [1, 2, 3]
t = [ 4, 5, 6, [7, 8] ] » [4, 5, 6, [7, 8]]
a = [ s, t, 9, 10 ] » [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
a.flatten » [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

flatten! arr.flatten! -> arr oder nil

Dieselbe Funktion wie Array#flatten mit dem Unterschied, dass hier das Array selbst geglättet wird. Wenn keine Veränderungen gemacht werden (d.h. arr enthält keine Unter-Arrays) wird nil zurückgegeben.

a = [ 1, 2, [3, [4, 5] ] ]
a.flatten! » [1, 2, 3, 4, 5]
a.flatten! » nil
a » [1, 2, 3, 4, 5]

include? arr.include?( einObjekt ) -> true oder false

Gibt true zurück, wenn das angegebene Objekt in arr enthalten ist (d.h. wenn irgendein Objekt in arr==einObjekt). Anderenfalls wird false zurückgegeben.

a = [ "a", "b", "c" ]
a.include?("b") » true
a.include?("z") » false

Kurzzeichen für Array#pack
Anweisung Bedeutung
@ Springt zur absoluten Position
A ASCII string (getrennt mit Leerzeichen, Zahlwert ist Zeichenbreite)
a ASCII string (getrennt mit Nullen, Zahlwert ist Zeichenbreite)
B Bit string (absteigende Bit-Reihenfolge)
b Bit string (aufsteigende Bit-Reihenfolge)
C Unsigned char
c Char
d Double-precision float, natürliches Format
E Double-precision float, little-endian Byteanordnung
e Single-precision float, little-endian Byteanordnung
f Single-precision float, natürliches Format
G Double-precision float, Netzwerk (big-endian) Byteanordnung
g Single-precision float, Netzwerk (big-endian) Byteanordnung
H Hex string (high nibble first)
h Hex string (low nibble first)
I Unsigned integer
i Integer
L Unsigned long
l Long
M Quoted printable, MIME encoding (see RFC2045)
m Base64 encoded string
N Long, Netzwerk (big-endian) Byteanordnung
n Short, Netzwerk (big-endian) Byteanordnung
P Zeiger auf eine Struktur (String mit fixierter Länge)
p Zeiger auf einen Null-terminierten String
S Unsigned short
s Short
U UTF-8
u UU-encoded string
V Long, little-endian Byteanordnung
v Short, little-endian Byteanordnung
X Back up a byte
x Null byte
Z Dasselbe wie ``A''

index arr.index( einObjekt ) -> einInteger oder nil

Gibt den Index des ersten Objekts in arr zurück, wobei das betreffende Objekt ==einObjekt. Die Methode gibt nil zurück, wenn kein übereinstimmendes Objekt gefunden wird.

a = [ "a", "b", "c" ]
a.index("b") » 1
a.index("z") » nil

indexes arr.indexes( i1, i2, ... iN ) -> einArray

Gibt ein neues Array zurück, das aus den Elementen an den gegebenen Indizes besteht. Die Methode fügt nil für Indizes ausserhalb des Gültigkeitsbereichs ein.

a = [ "a", "b", "c", "d", "e", "f", "g" ]
a.indexes(0, 2, 4) » ["a", "c", "e"]
a.indexes(0, 2, 4, 12) » ["a", "c", "e", nil]

indices arr.indices( i1, i2, ... iN ) -> einArray

Synonym für Array#indexes.

join arr.join( TrennerString=$, ) -> einString

Gibt einen String zurück, der aus der Konversion jedes Elements in einen String entsteht. Die einzelnen Elemente werden dabei mit TrennerString getrennt.

[ "a", "b", "c" ].join » "abc"
[ "a", "b", "c" ].join("-") » "a-b-c"

last arr.last -> einObjekt oder nil

Gibt das letzte Element von arr zurück. Wenn das Array leer ist, wird nil zurückgegeben.

[ "w", "x", "y", "z" ].last » "z"

length arr.length -> einInteger

Gibt die Anzahl der Elemente in arr zurück. Kann den Wert Null annehmen.

[ 1, 2, 3, 4, 5 ].length » 5

map! arr.map! {| obj | block }

-> arr

Synonym für Array#collect!.

nitems arr.nitems -> einInteger

Gibt die Anzahl der nicht-nil Elemente in arr zurück. Kann den Wert Null annehmen.

[ 1, nil, 3, nil, 5 ].nitems » 3

pack arr.pack ( einTemplateString ) -> einBinaerString
Packt den Inhalt von arr in eine binär-Sequenz nach den Vorgaben in einTemplateString (vgl. Tabelle 22.1). Die Anweisungen ``A,'' ``a,'' und ``Z'' können von einem Zähler gefolgt werden, der die Breite des entsprechenden Feldes vorgibt. Die übrigen Anweisungen können ebenfalls von einem Zähler gefolgt werden, der dann jedoch die Anzahl der Elemente angibt, die Konvertiert werden sollen. Wenn der Zähler ein Stern ist (``*'') werden alle verbleibenden Array-Elemente konvertiert. Die Anweisungen ``sSiIlL'' können von einem Unterstrich (``_'') gefolgt sein, um die der zugrunde liegenden Plattform Größe des jeweiligen Datentyps zu verwenden. Anderenfalls werden Plattform- unabhängige Datenlängen verwendet. Leerzeichen im Template-String werden ignoriert. Siehe auch String#unpack.

a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
a.pack("A3A3A3") » "a[visible space][visible space]b[visible space][visible space]c[visible space][visible space]"
a.pack("a3a3a3") » "a\000\000b\000\000c\000\000"
n.pack("ccc") » "ABC"

pop arr.pop -> einObjekt oder nil

Entfernt das letzte Element aus arr und gibt es zurück (wie bei einem Stack nach dem LIFO-Prinzip). Die Methode gibt entweder das letzte Element oder -- bei einem leeren Array -- nil zurück.

a = [ "a", "m", "z" ]
a.pop » "z"
a » ["a", "m"]

push arr.push( [einObjekt]+ ) -> arr

Hängt das übergebene Argument (bzw. mehrere Argumente) an das Ende von arr an (wie bei einem Stack).

a = [ "a", "b", "c" ]
a.push("d", "e", "f") » ["a", "b", "c", "d", "e", "f"]

rassoc arr.rassoc( key ) -> einArray oder nil

Durchsucht das Array nach Elementen, die ebenfalls Arrays sind. Die Methode vergleicht key mit dem zweiten Element jedes enthaltenen Arrays. Sie gibt das erste auf == passende Array zurück. Siehe auch assoc.

a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
a.rassoc("two") » [2, "two"]
a.rassoc("four") » nil

reject! arr.reject! {| | block }

-> arr oder nil

Equivalent mit Array#delete_if, but returns nil wenn keine Änderungen gemacht wurden.

replace arr.replace( anOtherArray ) -> arr

Ersetzt den Inhalt von arr mit dem Inhalt von anOtherArray je nach Notwendigkeit unter Abschneidung überzähliger oder Ergänzung unterzähliger Elemente.

a = [ "a", "b", "c", "d", "e" ]
a.replace( [ "x", "y", "z" ] ) » ["x", "y", "z"]
a » ["x", "y", "z"]

reverse arr.reverse -> einArray

Gibt ein neues Array zurück, das arrs Element in umgekehrter Reihenfolge enthält.

[ "a", "b", "c" ].reverse » ["c", "b", "a"]
[ 1 ].reverse » [1]

reverse! arr.reverse! -> arr oder nil

Dieselbe Funktion wie reverse. Jedoch wird nil zurückgegeben, wenn arr unverändert bleibt (weil arr.length null bzw. eins ist).

a = [ "a", "b", "c" ]
a.reverse! » ["c", "b", "a"]
a » ["c", "b", "a"]
[ 1 ].reverse! » nil

reverse_each arr.reverse_each {| | block }

Dieselbe Funktion wie Array#each. Jedoch wird arr in umgekehrter Reihenfolge zurückgegeben. 

a = [ "a", "b", "c" ]
a.reverse_each {|x| print x, " " }
produces:
c b a

rindex arr.rindex( einObjekt ) -> einInteger oder nil

Gibt den Index des letzten Objekts in arr für das ==einObjekt. Die Methode gibt nil zurück, wenn kein Treffer gefunden wird.

a = [ "a", "b", "b", "b", "c" ]
a.rindex("b") » 3
a.rindex("z") » nil

shift arr.shift -> einObjekt oder nil

Gibt das erste Element aus arr zurück und entfernt dieses (wobei die verbleibenden Elemente um je eine Position nach unten verschoben werden. Die Methode gibt nil zurück, wenn das Array leer ist.

args = [ "-m", "-q", "filename" ]
args.shift » "-m"
args » ["-q", "filename"]

size arr.size -> einInteger

Synonym für Array#length.

slice arr.slice( einInteger ) -> einObjekt
arr.slice( start, length ) -> aSubArray
arr.slice( aRange ) -> aSubArray

Synonym für Array#[ ].

a = [ "a", "b", "c", "d", "e" ]
a.slice(2) + a.slice(0) + a.slice(1) » "cab"
a.slice(6) » nil
a.slice(1, 2) » ["b", "c"]
a.slice(1..3) » ["b", "c", "d"]
a.slice(4..7) » ["e"]
a.slice(6..10) » nil
a.slice(-3, 3) » ["c", "d", "e"]

slice! arr.slice!( einInteger ) -> einObjekt oder nil
arr.slice!( start, length ) -> einSubArray oder nil
arr.slice!( einBereich ) -> einSubArray oder nil

Entfernt das Element / die Elemente, die durch den Index (optional mit einer Längenangabe) oder den Bereich beschrieben sind. Die Methode gibt das entfernte Objekt oder Array bzw. nil (wenn der Index ausserhalb der Gültigkeitsgrenzen liegt) zurück. Equivalent mit: 

def slice!(*args)
  result = self[*args]
  self[*args] = nil
  result
end

a = [ "a", "b", "c" ]
a.slice!(1) » "b"
a » ["a", "c"]
a.slice!(-1) » "c"
a » ["a"]
a.slice!(100) » nil
a » ["a"]

sort arr.sort -> einArray
arr.sort {| a,b | block }

-> einArray

Gibt ein neues Array zurück, das nach der Sortierung von arr entsteht. Vergleiche für die Sortierung geschehen mot Hilfe des <=> Operators oder des Code-Blocks. Der Block implementiert dabei einen Vergleich zwischen a und b und ergibt -1, 0, oder +1.

a = [ "d", "a", "e", "c", "b" ]
a.sort » ["a", "b", "c", "d", "e"]
a.sort {|x,y| y <=> x } » ["e", "d", "c", "b", "a"]

sort! arr.sort! -> arr
arr.sort! {| a,b | block }

-> arr

Dieselbe Funktion wie Array#sort, jedoch wird das Array selbst verändert. arr wird während der Operation vollständig eingefroren.

a = [ "d", "a", "e", "c", "b" ]
a.sort! » ["a", "b", "c", "d", "e"]
a » ["a", "b", "c", "d", "e"]

to_a arr.to_a -> arr

Gibt arr zurück.

to_ary arr.to_ary -> arr

Synonym für Array#to_a.

to_s arr.to_s -> aString

Gibt arr.join zurück.

[ "a", "e", "i", "o" ].to_s » "aeio"

uniq arr.uniq -> einArray

Gibt ein neues Array zurück, aus dem die doppelten Elemente in arr entfernt wurden.

a = [ "a", "a", "b", "b", "c" ]
a.uniq » ["a", "b", "c"]

uniq! arr.uniq! -> arr oder nil

Dieselbe Funktion wie Array#uniq, jedoch wird das Array selbst modifiziert. Die Methode gibt nil zurück, wenn keine Veränderungen gemacht wurden (d.h. es wurden keine Duplikate gefunden).

a = [ "a", "a", "b", "b", "c" ]
a.uniq! » ["a", "b", "c"]
b = [ "a", "b", "c" ]
b.uniq! » nil

unshift arr.unshift( einObjekt ) -> arr

Verschiebt einObjekt an den Anfang von arr, und verschiebt die übrigen Elemente um eins nach oben.

a = [ "b", "c", "d" ]
a.unshift("a") » ["a", "b", "c", "d"]

Extracted from the book "Programming Ruby - The Pragmatic Programmer's Guide"
Übersetzung: Carsten Schinzer
Für das englische Original:
© 2000 Addison Wesley Longman, Inc. Released under the terms of the Open Publication License V1.0. That reference is available for download.
Diese Lizenz sowie das Original vom Herbst 2001 bilden die Grundlage der Übersetzung
Es wird darauf hingewiesen, dass sich die Lizenz des englischen Originals inzwischen geändert hat.
Für die deutsche Übersetzung:
© 2002 Jürgen Katins
Der Copyright-Eigner stellt folgende Lizenzen zur Verfügung:
Nicht-freie Lizenz:
This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/). Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder. Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.
Freie Lizenz:
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".