Die Programmiersprache Ruby

Blog| Forum| Wiki  

Die Klasse Array stellt eine geordnete Kollektion von Elementen da, welche anhand ihres Indexes abgerufen werden können.

Siehe auch

Inhaltsverzeichnis

Klassenmethoden

[]

Anwendung Array[ *objs ] ==> einArray
Argumente
  • *objs: Die Elemente des Arrays.
Beschreibung Erstellt ein Array mit den angebenen Elementen.
Rückgabewert Das erstellte Array.
Beispiel 
1
2
3

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



new

Anwendung Array.new( size = 0 , obj = nil ) ==> einArray

Array.new(ary) ==> einArray
Array.new( size ){|index| ... } ==> einArray

Argumente
  • size: Die Größe des zu erstellenden Arrays.
  • obj: Das Objekt, mit dem das Array zunächst gefüllt werden soll.
  • ary: Das zu duplizierende Array.
Beschreibung Erstellt ein Array. Die erste Variante erstellt ein Array der Größe size, welches mit obj-Objekten gefüllt ist. Die zweite kopiert einfach nur ein bestehendes Array. Die dritte schließlich erstellt ein Array mit der angebenen Größe und nutzt für jedes Element den Rückgabewert des Codeblocks, welcher für jeden Index einmal aufgerufen wird.
Rückgabewert Das neue Array.
Beispiel 
1
2
3
4

Array.new #=> []
Array.new(2, "B") #=> ["B", "B"]
Array.new([1, 2]) #=> [1, 2]
Array.new(4){|i| i * i} #=> [0, 1, 4, 9]



try_convert

Anwendung Array.try_convert( obj ) ==> einArray oder nil
Argumente
  • obj: Das zu konvertierende Objekt.
Beschreibung Versucht, obj in ein Array zu konvertieren, indem versucht wird, to_ary auf obj anzuwenden.
Rückgabewert Das konvertierte Array oder bei Fehlschlag nil.
Beispiel 
1
2

Array.try_convert("1") #=> nil
Array.try_convert([1]) #=> [1]


Instanzmethoden

&

Anwendung einArray & einAnderesArray ==> einDrittesArray
Argumente
  • einAnderesArray: Operator der Operation.
Beschreibung Bildet die Schnittmenge aus self und einAnderesArray. Für mathematische Operationen ist jedoch die Klasse Set gedacht.
Rückgabewert Die geschnittene Menge als Array.
Beispiel 


[1, 1, 3, 5] & [1, 2, 3] #=> [1, 3]



|

Anwendung einArray | einAnderesArray ==> einDrittesArray
Argumente
  • einAnderesArray: Operator der Operation.
Beschreibung Bildet die Vereinigungsmenge aus self und einAnderesArray. Für mathematische Operationen ist jedoch die Klasse Set gedacht.
Rückgabewert Das Ergebnis als Array.
Beispiel 


%w[a b c] | %w[c d a] #=> ["a", "b", "c", "d"]


*

Anwendung array * einInteger ==> einArray

array * einString ==> einString

Argumente
  • einInteger: Gibt an, wie oft das Array vermehrt wird.
  • einString: Wird als Zwischenelement beim Rückgabewert benutzt.
Beschreibung Hängt self einInteger-mal hintereinander oder wandelt self in einen String um, indem zwischen jedes Element einString geschrieben wird.
Rückgabewert Ein Array oder ein String.
Beispiel 
1
2

["Ruby"] * 4 #=> ["Ruby", "Ruby", "Ruby", "Ruby"]
%w[Ruby Ruby Ruby] * "!" #=> "Ruby!Ruby!Ruby"



+

Anwendung einArray + einAnderesArray ==> einDrittesArray
Argumente
  • einAnderesArray: Anzuhängendes Array.
Beschreibung Fügt die beiden Arrays zu einem Neuen zusammen.
Rückgabewert Das Resultat der Operation.
Beispiel 


[1, 2, 3] + [4, 5, 6] #=> [1, 2, 3, 4, 5, 6]


-

Anwendung einArray - einAnderesArray ==> einDrittesArray
Argumente
  • einAnderesArray: Abzuziehende Elemente.
Beschreibung Entfernt alle Elemente aus self, die in einAnderesArray vorkommen und gibt das Ergebnis als neues Array zurück. Für mathematische Operationen ist jedoch die Klasse Set gedacht.
Rückgabewert Das Ergebnis der »Subtraktion«.
Beispiel 


[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]


<<

Anwendung einArray << einAnderesArray ==> einArray
Argumente
  • obj: Das anzufügende Objekt.
Beschreibung Fügt obj an das Array an und gibt self zurück, sodass ein Kettenaufruf möglich wird (siehe Beispiel).
Rückgabewert Das Array mit dem angehangenen Element.
Beispiel 
1
2
3

ary = []
ary << 1 << 2 << /t/ << "p" << [7, {}]
p ary #=> [1, 2, /t/, "p", [7, {}]]



<=>

Anwendung einArray <=> einAnderesArray ==> einInteger
Argumente
  • einAnderesArray: Das Objekt, mit dem verglichen werden soll.
Beschreibung Vergleicht zwei Arrays.
Rückgabewert nil, wenn die beiden Arrays nicht vergleichbar sind, sonst anhand der Längen der Arrays:
  • -1: self ist kleiner.
  • 0: Die Arrays sind gleich groß.
  • -1: self ist größer.
Beispiel 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

ary = [1, 2]
ary2 = %w[p q]
ary <=> ary2 #=> nil

ary = %w[a a c]
ary2 = %w[a b c]
ary <=> ary2 #=> -1

ary = [1, 2, 3, 4, 5, 6]
ary2 = [1, 2]
ary <=> ary2 #=> 1

ary = [1, 2]
ary2 = [3, 4]
ary <=> ary2 #=> -1

ary = [1, 2]
ary2 = [1, 2]
ary <=> ary2 #=> 0



==

Anwendung einArray == einAnderesArray ==> true oder false
Argumente
  • einAnderesArray: Das Objekt, mit dem zu vergleichen ist.
Beschreibung Prüft, ob zwei Arrays gleich sind. Zwei Arrays sind dann gleich, wenn sie die gleiche Länge haben und jedes Objekt in self im Sinne von Object#== gleich dem entsprechenden Element in einAnderesArray ist.
Rückgabewert Das Ergebnis des Vergleichs.
Beispiel 
1
2
3

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



[]

Anwendung einArray[ index ] ==> einObject

einArray[ start , ende ] ==> einObject
einArray [ einRange ] ==> einObject

Argumente
  • index: Der Index des abzufragenden Elements.
  • start: Der Anfang des abzufragenden Elemente.
  • ende: Das Ende der abzufragenden Elemente
  • einRange: Der Bereich der abzufragenden Elemente.
Beschreibung Die erste Form gibt das Element am Index index zurück, wobei das erste Element des Arrays den Index 0 hat. Die zweite Form gibt alle Elemente zwischen start und ende zurück, wobei ende ausschließtlich ist. Die dritte Form verhält sich ähnlich, verlangt aber ein Range-Objekt. Negative Indices zählen von hinten.
Rückgabewert Das oder die gefundenen Elemente, oder nil, falls der Index nicht im Array lag.
Beispiel 
1
2
3
4
5
6
7
8

ary = %w[a b c d e f g]
ary[0] #=> "a"
ary[-1] #=> "g"
ary[1000] #=> nil
ary[0, 1] #=> ["a"]
ary[0, 2] #=> ["a", "b"]
ary[0..1] #=> ["a", "b"]
ary[0...1] #=> ["a"]



[]=

Anwendung einArray[index] = einObject ==> einObject

einArray[start , ende] = einObject ==> einObject
einArray[range] = einObject ==> einObject

Argumente
  • index: Der zu setzende Index.
  • einObject: Das zu setzende Objekt oder nil, falls in der zweiten oder dritten Form gelöscht werden soll.
  • start: Der Anfangsindex.
  • end: Der Endindex (ausschließlich)
  • range: Die zu setzenden Elemente.
Beschreibung Weist einem Element in einem Array einen Wert zu. Liegt der Index bei der ersten Form außerhalb der Arraygröße, wird mit nil aufgefüllt. Alternativ kann man eine der beiden anderen Formen verwenden, um mehrere Elemente auf einmal zu setzen. Negative Indices zählen vom Ende rückwärts.

Wirft einen IndexError, wenn ein negativer Index außerhalb des Arrays liegt.

Rückgabewert Das oder die gesezten Objekte.
Beispiel 
1
2
3
4
5
6
7
8
9

a = []
a[4] = "4" #=> [nil, nil, nil, nil, "4"]
a[0, 3] = %w[a b c] #=> ["a", "b", "c", nil, "4"]
a[1..2] = [1, 2] #=> ["a", 1, 2, nil, 4]
a[0, 2] = "?" #=> ["?", 2, nil, "4"]
a[0..2] = "A" #=> ["A", "4"]
a[-1] = "Z" #=> ["A", "Z"]
a[1..-1] = nil #=> ["A", nil]
a[1..-1] = [] #=> ["A"]



assoc

Anwendung Array#assoc( obj ) ==> einArray oder nil
Argumente
  • obj: Das zu suchende Objekt.
Beschreibung Nimmt an, das self ein zweidimensionales Array ist und durchsucht es, bis das erste Element eines Subarrays nach Object#== gleich obj ist.

Siehe auch Array#rassoc.

Rückgabewert Das gefundene Array oder nil, wenn nichts gefunden wurde.
Beispiel 
1
2
3
4

ary = [ [0, 0], [1, 1], [2, 2], [0, "P"] ]
ary.assoc(0) #=> [0, 0]
ary.assoc(2) #=> [2, 2]
ary.assoc("gibtsnich") #=> nil



at

Anwendung Array#at( index ) ==> einObject
Argumente
  • index: Der abzurufende Index.
Beschreibung Gibt wie Array#[] das Element an der angebenen Stelle zurück, nummt aber keine Bereiche an. Gibt nil für Elemente außerhalb des Arrays zurück.
Rückgabewert Das gefundene Objekt oder nil.
Beispiel 
1
2
3

ary = %w[a b c]
ary.at(0) #=> "a"
ary.at(-1) #=> "c"



clear

Anwendung Array#clear ==> self
Argumente

Keine.

Beschreibung Leert self. Diese Methode ist destruktiv, auch wenn sie kein ! trägt.
Rückgabewert Das geleerte Array.
Beispiel 
1
2
3

ary = [1, 2, 3, 4, 5]
ary.clear
p ary #=> []



collect

Anwendung Array#collect{|item| ... } ==> einArray

Array#map{|item| ... } ==> einArray

Argumente
  • item: Blockargument.
Beschreibung Ruft den Block für jedes Element in self auf und erstellt im Gegensatz zu each ein neues Array, in dem die gemachten Änderungen umgesetzt wurden.
Rückgabewert Das neue Array.
Beispiel 
1
2
3

ary = %w[a b c d]
ary.collect{|str| str + "!"} #=> ["a!", "b!", "c!", "d!"]
ary #=> ["a", "b", "c", "d"]



collect!

Anwendung Array#collect!{|item| ... } ==> self

Array#map!{|item| ... } ==> self

Argumente
  • item: Blockargument.
Beschreibung Destruktive Variante von collect. Anstatt ein neues Array zurückzugeben, wird das Original modifiziert.
Rückgabewert self.
Beispiel 
1
2
3

ary = %w[a b c]
ary.collect!{|str| str + "!"}
a #=> ["a!", "b!", "c!"]



combination

Anwendung Array#combination( länge ){|comb| ... } ==> self

Array#combination( länge ) ==> einEnumerator

Argumente
  • länge: Die Länge der Kombinationen.
  • comb: Blockargument.
Beschreibung Sucht alle Kombinationen der Länge länge, die mit den Elementen dieses Arrays möglich sind. Die Blockform ruft den Block für jede gefundene Kombination auf, die andere gibt stattdessen ein Enumerator-Objekt zurück.
Rückgabewert Die Blockform gibt self zurück, die andere einen Enumerator.
Beispiel 
1
2
3
4
5
6

ary = %w[a b c d]
ary.combination(2).to_a #=> [["a", "b"], ["a", "c"], ["a", "d"], ["b", "c"], ["b", "d"], ["c", "d"]]

ary.combination(3) do |comb|
  p comb
end

Output: 

1
2
3
4

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



compact

Anwendung Array#compact ==> einArray
Argumente

Keine.

Beschreibung Gibt eine Kopie von self zurück, die keine nil-Elemente mehr enthält.
Rückgabewert Ein Array ohne nils.
Beispiel 
1
2

ary = [1, nil, "b", "c", nil, nil]
ary.compact #=> [1, "b", "c"]



compact!

Anwendung Array#compact! ==> self oder nil
Argumente

Keine.

Beschreibung Entfernt alle nil-Elemente aus self. Destruktive Form von compact.
Rückgabewert nil, wenn nichts entfernt wurde, ansonsten self.
Beispiel 
1
2
3

ary = [1, nil, "b", "c", nil, nil]
ary.compact!
ary #=> [1, "b", "c"]



concat

Anwendung Array#concat( einArray ) ==> self
Argumente
  • einArray: Das anzufügende Array.
Beschreibung Fügt den Inhalt von einArray an self an. Diese Methode modifiziert self im Gegensatz zum normalen Anhängen mit +.
Rückgabewert self.
Beispiel 
1
2
3
4

ary = [1, 2]
ary2 = [3, 4]
ary.concat(ary2)
ary #=> [1, 2, 3, 4]



count

Anwendung Array#count( [ obj ] ) ==> einInteger

Array#count{|item| ... } ==> einInteger

Argumente
  • obj: Das zu zählende Objekt.
  • item: Blockargument. Iteriertes Arrayelement.
Beschreibung Die erste Form zählt, wie oft obj im Array auftaucht, oder gibt, wenn kein Objekt übergeben wird, die Länge des Arrays zurück. Die zweite Form zählt, wie oft der Block true zurückgibt.
Rückgabewert Die gezählte Anzahl.
Beispiel 
1
2
3
4

ary = [1, 2, 4, 2]
ary.count #=> 4
ary.count(2) #=> 2
ary.count{|item| item % 2 == 0} #=> 3



cycle

Anwendung Array#cycle( [anzahl] ){|item| ... } ==> nil
Argumente
  • anzahl: Gibt an, wie oft gecyclet werden soll. Unendlich, wenn ausgelassen.
Beschreibung Geht self anzahl Mal durch (oder unendlich oft, wenn weggelassen). Gibt ohne Block einen Enumerator zurück.
Rückgabewert nil.
Beispiel 
1
2
3
4

ary = [1, 2, 3]
ary.cycle(3){|z| p z} #Gibt 3-mal 1, 2 und 3 aus. 
inf_enum = ary.cycle
100.times{p enum.next} #...



delete

Anwendung Array#delete( obj ) ==> obj oder nil

Array#delete( obj ){...} ==> einObject

Argumente
  • obj: Das zu löschende Objekt.
Beschreibung Entfernt alle Objekte aus self die gleich obj sind. Wird ein Codeblock übergeben, so wird dieser ausgeführt, wenn obj nicht gefunden wurde und das Ergebnis zurückgegeben. Gibt ansonsten bei Fund das Objekt, sonst nil zurück.
Rückgabewert Gefunden in jedem Fall: obj.

Nicht gefunden ohne Block: nil.
Nicht gefunden mit Block: Blockergebnis.

Beispiel 
1
2
3
4
5

a = %w[a b b b c]
a.delete("b") #=> "b"
a #=> ["a", "c"]
a.delete("z") #=> nil
a.delete("z"){"Gibts nich!"} #=> "Gibts nich!"



delete_at

Anwendung Array#delete_at( index ) ==> einObject
Argumente
  • index: Die Position des zu löschenden Elements.
Beschreibung Löscht das Element an der Position index und gibt es zurück. Gibt nil zurück, wenn der Index nicht im Array liegt.

Siehe auch slice!.

Rückgabewert Das gelöschte Element oder nil.
Beispiel 
1
2
3
4
5

ary = %w[a b c d]
ary.delete_at(2) #=> "c"
ary #=> ["a", "b", "d"]
ary.delete_at(99) #=> nil
ary #=> ["a", "b", "d"]



delete_if

Anwendung Array#delete_if{|item| ...} ==> self
Argumente
  • item: Blockargument. Das iterierte Element.
Beschreibung Entfernt alle Elemente aus self, für die der Block true ergiebt. Die Methode ist destruktiv.
Rückgabewert Das Array selbst.
Beispiel 
1
2
3

ary = (0..10).to_a
ary.delete_if{|i| i % 3 == 0}
ary #=> [1, 2, 4, 5, 7, 8, 10]



drop

Anwendung Array#drop( n ) ==> EinArray
Argumente
  • n: Die zu verwerfende Anzahl Elemente.
Beschreibung Löscht die ersten n Elemente aus self.
Rückgabewert Ein Array, in dem die Werte gelöscht sind.
Beispiel 
1
2
3

a = [1, 2, 3, 4, 5, 0]
a.drop(3) #=> [4, 5, 0]
a #=> [1, 2, 3, 4, 5, 0]



drop_while

Anwendung Array#drop_while{|item| ... } ==> einArray
Argumente
  • item: Blockargument. Das iterierte Element.
Beschreibung Entfernt solange Elemente aus self, bis der Block true ergibt. Dieses Element wird nicht entfernt.
Rückgabewert Das Array, in dem die Elemente entfernt wurden.
Beispiel 
1
2

ary = [1, 2, 3, 4, 5, 0]
ary.drop_while{|i| i < 3} #=> [3, 4, 5, 0]



each

Anwendung Array#each{|item| ... } ==> self
Argumente
  • item: Blockargument. Das aktuell iterierte Element.
Beschreibung Geht das Array Element für Element durch und übergibt das gerade aktuelle an den Block. Gibt ohne Block einen Enumerator zurück.
Rückgabewert self.
Beispiel 
1
2

ary = [1, 2, 3, 4, 5]
ary.each{|item| puts item}

Output: 

1
2
3
4
5

1
2
3
4
5



each_index

Anwendung Array#each_index{
Argumente

index: Blockargument. Der aktuell iterierte Index.

Beschreibung Iteriert über alle Indices dieses Arrays.
Rückgabewert Das Array selbst.
Beispiel 
1
2

a = %w[a b c]
a.each_index{|i| puts i}

Output: 

1
2
3

0
1
2



empty?

Anwendung Array#empty? ==> true oder false
Argumente

Keine.

Beschreibung Gibt true zurück, wenn das Array leer ist.
Rückgabewert true oder false.
Beispiel 
1
2

[].empty? #=> true
[1, 2].empty? #=> false



eql?

Anwendung Array#eql?(obj) ==> true oder false
Argumente

obj: Das zu prüfende Objekt.

Beschreibung Prüft, ob obj ein Array gleichen Inhalts ist.
Rückgabewert true oder false, je nachdem.
Beispiel 
1
2
3
4

ary1 = [1, 2]
ary2 = [1, 2]
ary1.eql?(ary2) #=> true
ary1.equal?(ary2) #=> false #Test gegen Object-ID



fetch

Anwendung Array#fetch( index ) ==> einObject

Array#fetch( index , default ) ==> einObject
Array#fetch( index ){|index| ... } ==> einObject

Argumente
  • index: Das auszulesende Argument.
  • default: Das Objekt, das zurückgegeben werden soll, wenn index nicht im Array liegt.
  • index: Blockargument. Gleich index.
Beschreibung Gibt das Element an der Position index zurück. Liegt der Index außerhalb des Arrays, wirft die erste Form einen IndexError, die zweite gibt default zurück, und die dritte ruft den Block mit index als Parameter auf.
Rückgabewert Siehe Beschreibung.
Beispiel 
1
2
3
4
5
6

a = [11, 22, 33, 44]
a.fetch(1) #=> 22
a.fetch(-1) #=> 44
a.fetch(4) #=> IndexError
a.fetch(4, "Gibtsnich") #=> "Gibtsnich"
a.fetch(4){|index| index + 100} #=> 104


fill

Anwendung Array#fill( obj) ==> self

Array#fill( obj , start [, ende ] ) ==> self
Array#fill( obj , range ) ==> self
Array#fill{|index| ... } ==> self
Array#fill( start [, ende ] ){|index| ... } ==> self
Array#fill( range ){|index| ... } ==> self

Argumente
  • obj: Das Objekt, mit dem gefüllt werden soll.
  • start: Anfang des Füllens.
  • length (self.length): Ende des Füllens.
  • range: Ein Bereich, der zu füllen ist.
  • index: Blockargument. Der aktuell iterierte Index.
Beschreibung Füllt das Array im angegebenen Bereich mit dem Objekt obj. Alle Blockformen füllen mit dem Ergebnis des Blocks. Diese Methde ist desktruktiv.
Rückgabewert self.
Beispiel 
1
2
3
4
5
6

ary = %w[a b c d]
ary.fill("x") #=> ["x", "x", "x", "x"]
ary.fill("z", 2, 2) #=> ["x", "x", "z", "z"]
ary.fill("y", 0..1) #=> ["y", "y", "z", "z"]
ary.fill{|i| i  * i} #=> [0, 1, 4, 9]
ary.fill(-2){|i| i ** 3} #=> [0, 1, 8, 27]


find_index

Anwendung Array#find_index( obj ) ==> einInteger oder nil

Array#find_index{|item|..} ==> einInteger oder nil

Argumente
  • obj: Das zu suchende Objekt.
  • item: Blockargument. Das aktuell iterierte Objekt.
Beschreibung Sucht das erste Objekt, das == obj ist oder für das der Block true ergibt.
Rückgabewert Der Index des Objekts oder nil, wenn es nicht gefunden wurde.
Beispiel 
1
2
3
4

ary = [1, "b", /q/, {r: 9}]
ary.find_index("b") #=> 1
ary = (rand(1000)..rand(5000)).to_a
ary.find_index{|num| num % 37 == 0} #=> 28


flatten

Anwendung Array#flatten( tiefe = -1 ) ==> einArray
Argumente
  • tiefe (-1): Die Tiefe, bis zu der gearbeitet werden soll.
Beschreibung »Plättet« das Array, d.h., entfernt alle inneren Arrays und fügt sie zu einem einzigen Array zusammen. tiefe gibt an, bis zu welcher Tiefe dies stattfinden soll; Werte < 0 plätten alles, 0 plättet nichts und alles darüber spezifiziert wie tief.
Rückgabewert Das geplättete Array.
Beispiel 
1
2
3
4

ary = [1, 2, [3, 4, [5, 6]]]
ary.flatten #=> [1, 2, 3, 4, 5, 6]
ary.flatten(1) #=> [1, 2, 3, 4, [5, 6]]
ary.flatten(0) #=> [1, 2, [3, 4, [5, 6]]]


flatten!

Anwendung Array#flatten!( tiefe = -1) ==> self oder nil
Argumente
  • tiefe: Gibt an, bis zu welcher Tiefe gearbeitet werden soll.
Beschreibung Selbstmodifizierende Version von #flatten.
Rückgabewert Wenn Modifizierungen gemacht wurden: self. Sonst: nil.
Beispiel 
1
2
3
4
5
6
7

ary = [1, 2, [3, 4, [5, 6]]]
ary2 = ary.flatten!
p ary #=> [1, 2, 3, 4, 5, 6]
p ary2 #=> [1, 2, 3, 4, 5, 6]
p(ary.equal?(ary2)) #=> true #Test gegen Object-ID
ary2 = ary.flatten!
p ary2 #=> nil


frozen?

Anwendung Array#frozen? ==> true oder false
Argumente

Keine.

Beschreibung Prüft, ob self ein eingefrorenes Objekt ist oder gerade sortiert wird.
Rückgabewert true, wenn die Prüfung zutraf, sonst false.
Beispiel 
1
2
3
4

ary = [1, 2, 3]
ary.frozen? #=> false
ary.freeze
ary.frozen? #=> true


index

Alias für find_index.

insert

Anwendung Array#insert( index [, *objs] ) ==> einArray
Argumente
  • index: Der Index, vor (positiv) oder nach (negativ) Objekte eingeschoben werden sollen.
  • *objs: Die einzuschiebenden Objekte.
Beschreibung Fügt ein oder mehrere Objekte in ein existierendes Array ein. Diese Methode ist selbst-modifizierend.
Rückgabewert Das modifizierte Array.
Beispiel 
1
2
3
4
5

ary = [1, 2, 3]
ary.insert(0, 100) #=> [100, 1, 2, 3]
ary.insert(2, "x") #=> [100, 1, "x", 2, 3]
ary.insert(-2, :r, "t") #=> [100, 1, "x", 2, :r, "t", 3]
p ary #=> [100, 1, "x", 2, :r, "t", 3]


join

Anwendung Array#join( separator = $, ) ==> einString
Argumente
  • separator ($,): Ein zwischen die Elemente zu schreibender String; $, ist für gewöhnlich nil.
Beschreibung Fügt alle Elemente des Arrays zu einem String zusammen.
Rückgabewert Der zusammengesetzte String.
Beispiel 
1
2
3
4

[1, 2, 3].join #=> "123"
[1, 2, 3].join("|") #=> "1|2|3"
$, = ", "
[1, 2, 3].join #=> "1, 2, 3"


last

Anwendung Array#last ==> einObject

Array#last( anzahl ) ==> einArray

Argumente
  • anzahl: Die Anzahl der zurückzugebenden Elemente.
Beschreibung Die erste Form gibt das letzte Element des Arrays zurück, die zweite die letzten anzahl Elemente als eigenständiges Array.
Rückgabewert Das oder die letzten Elemente. nil, wenn das Array leer ist und die erste Form benutzt wurde.
Beispiel 
1
2
3
4

[1, 2, 3].last #=> 3
[1, 2, 3].last(2) #=> [2, 3]
[].last #=> nil
[].last(2) #=> []


length

Anwendung Array#length ==> einInteger
Argumente

Keine.

Beschreibung Gibt die Größe des Arrays zurück.
Rückgabewert Die Anzahl der Elemente in self.
Beispiel 
1
2
3

[1, 2].length #=> 2
[1].length #=> 1
[].length #=> 0


map!

Alias für #collect!.

pack

Anwendung Array#pack( str ) ==> einString
Argumente
  • str: Packdirektiven (siehe Beschreibung).
Beschreibung Packt ein Array nach vorgegebenen Direktiven in einen Binärstring (siehe die folgende Tabelle). Die Direktiven »A«, »a« und »Z« können von einer Angabe gefolgt werden, die die Länge des resultierenden Feldes angibt. Auch den restlichen Direktiven kann eine Angabe folgen; diese gibt dann an, wie viele Elemente aus self konvertiert werden sollen. Handelt es sich bei der Angabe um ein Sternchen »*«, so werden alle verbleibenden Elemente konvertiert.

Jede der Direktiven sSiIlL kann zudem von einem Unterstrich _ gefolgt werden, um die auf dieser Platform native Größe des angegebenen Typs zu benutzen. Fehlt er, so wird eine platformunabhängige Größe verwendet.

Leerzeichen werden im Packstring ignoriert.

String Effekt
@ Absolute Positionsangabe.
A Beliebiger binärer String (aufgefüllt mit Leerzeichen, Angabe ist die Länge).
a Beliebiger binärer String (aufgeüllt mit NUL-Zeichen, Angabe ist die Länge).
B Bit-String, absteigende Bitfolge.
b Bit-String, aufsteigende Bitfolge.
C Vorzeichenloses Byte (wie in C unsigned char).
c Byte (wie in C char).
D, d Double-Precision-Float, natives Format.
E Double-Precision-Float, Little-Endian-Byteanordnung.
e Single-Precision-Float, Little-Endian-Byteanordnung.
F, f Single-Precision-Float, natives Format.
G Double-Precision-Float, Netzwerk-Byteanordnung (Big Endian).
g Single-Precision-Float, Netzwerk-Byteanordnung (Big Endian).
H Hex-String (Absteigend).
h Hex-String (Aufsteigend).
I Vorzeichenloses Integer.
i Integer.
L Vorzeichenloses Long.
l Long.
M Quoted-Printable, MIME-Encoding (siehe RFC2045).
m Base64-kodierter String (siehe RFC2045, Angabe ist die Länge).
N Long, Netzwerk-Byteanordnung (Big Endian).
n Short, Netzwerk-Byteanordnung (Big Endian).
P Pointer auf eine Struktur, String von fester Länge.
p Pointer auf einen NUL-terminierten String.
Q, q 64-Bit-Zahl.
S Vorzeichenloses Short.
s Short.
U UTF-8.
u UU-kodierter String.
V Long, Little-Endian-Byteanordnung.
v Short, Little-Endian-Byteanordnung.
w BER-komprimiertes Integer.
X Ein Byte zurück.
x NUL-Byte.
Z Das gleiche wie »a«, Die NULlen werden allerdings mithilfe von »*« angehangen.

Siehe auch String#unpack.

Rückgabewert Der fertig gepackte Binärstring.
Beispiel 
1
2
3
4
5

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


permutation

Anwendung permutation( länge ) ==> ein_enumerator

permutation( länge ){|ein_array| ... } ==> ein_enumerator

Argumente
  • länge: Größe der Permutationen
  • ein_array: Blockargument. Einzelteile einer Permutation.
Beschreibung Findet alle Permutationen des Arrays, d.h. alle möglichen Zusammensetzungen der Elemente.
Rückgabewert Ein Enumerator.
Beispiel 
1
2
3
4

ary = %w[L A G E R]
ary.permutation do |parts|
  puts parts.join
end

Ausgabe: 

1
2
3
4
5
6
7
8
9
10
11
12

LAGER
LAGRE
LAEGR
LAERG
LARGE
LAREG
LGAER
LGARE
.
.
.
REGAL


pop

Anwendung pop ==> ein_object

pop( n ) ==> ein_array

Argumente
  • n: Anzahl der zu lesenden Elemente.
Beschreibung Behandelt das Array als Stack und führt eine POP-Operation auf ihm durch, d.h. entfernt destruktiv das letzte Element aus dem Array und gibt es zurück. Wird n übergeben, gibt es an, wie viele Elemente entfernt werden sollen (diese werden jedoch nicht rückwärts entfernt, wie man vielleicht erwarten würde). Sind keine Elemente mehr im Array, wird nil oder ein leeres Array zurückgegeben.
Rückgabewert Das oder die entfernten Elemente.
Beispiel 
1
2
3
4
5
6

ary = %w[a b c d e f g]
ary.pop    #| "g"
ary.pop(2) #| ["e", "f"]
ary.pop(1) #| ["d"]
[].pop     #| nil
[].pop(2)  #| []


product

Anwendung product( *arrays ) ==> an_array
Argumente
  • *arrays: Die durchzurechnenden Arrays.
Beschreibung Führt eine Operation ähnlich dem mathematischen "Ausklammern" durch. Durch das Array wird iteriert und das aktuell iterierte Element wird mit jedem Element aus *arrays kombiniert (aber nicht tatsächlich "multipliziert", daher nur ähnlich dem Ausklammern) und im Ergebnisarray platziert.
Rückgabewert Das oder die entfernten Elemente.
Beispiel 
1
2
3
4
5
6

ary = [2, 3]
ary2 = [3, 4]
ary3 = [6]

ary.product(ary2)       #| [[2, 3], [2, 4], [3, 3], [3, 4]]
ary.product(ary2, ary3) #| [2, 3, 6], [2, 4, 6], [3, 3, 6], [3, 4, 6]]


push

Anwendung pop( *objs ) ==> self
Argumente
  • *objs: Die anzuhängenden Objekte.
Beschreibung Behandelt das Array als Stack und führt eine PUSH-Operation auf ihm durch, d.h. hängt *objs an das Array an.
Rückgabewert Das Array selbst.
Beispiel 
1
2
3
4

ary = [2, 45, 7]
ary.push(3)    #| [2, 45, 7, 3]
ary.push(1, 2) #| [2, 45, 7, 3, 1, 2]
ary.push       #| [2, 45, 7, 3, 1, 2]


rassoc

Anwendung rassoc( schlüssel ) ==> ein_array oder nil
Argumente
  • schlüssel: Das zu suchende Element.
Beschreibung Nimmt an, dass das Array 2-dimensional ist und iteriert durch alle enthaltenen Arrays, wobei das jeweils zweite Element der inneren Arrays mit dem schlüssel verglichen wird. Gibt das erste innere Array zurück, auf das der Schlüssel zutrifft.

Siehe auch assoc.

Rückgabewert Das gefundene Array oder nil, wenn keines gefunden wird.
Beispiel 
1
2
3
4
5
6

ary = [[1, :a], [2, :b], [3, :a]]
ary.rassoc(:a) #| [1, :a]
ary.rassoc(:b) #| [2, :b]
ary.rassoc(:c) #| nil

[1, 2, 3].rassoc("q") #| nil


Von „http://wiki.ruby-portal.de/Referenz:Array“