Un altro metodo per inserire elementi in un array è rappresentato dai metodi << e push che inseriscono i nuovi valori in fondo all'array che si comporta in questo caso come una pila (stack):
> arr = [1, 2, 3] => [1, 2, 3] > arr << 5 << 6 => [1, 2, 3, 5, 6] > arr.push(7,8) => [1, 2, 3, 5, 6, 7, 8]
All'opposto il metodo pop invece elimina l'ultimo elemento di un array:
> arr.pop => 8 > arr => [1, 2, 3, 5, 6, 7]
Un altro metodo per inserire valori in un array già esistente è insert che prende come argomenti un indice ed uno o più oggetti da inserire nell'array:
> arr = [10, 30, 40] => [10, 30, 40] > arr.insert(1, 20) => [10, 20, 30, 40]
è possibile anche indicare due o più oggetti, in questo modo il primo verrà inserito nella posizione indicata dall'indice e gli altri di seguito:
> arr.insert(4, 50, 60, 70) => [10, 20, 30, 40, 50, 60, 70]
Agli array è possibile anche applicare le operazioni +, -, *, &. Il metodo concatenazione (+) restituisce un nuovo array ottenuto dalla concatenazione di due array:
> a = ["a", "e", "i"] => ["a", "e", "i"] > b = ["o", "u"] => ["o", "u"] > c = a + b => ["a", "e", "i", "o", "u"]
Analogamente il metodo differenza restituisce un nuovo array ottenuto dalla differenza di due array:
> a = ["a", "e", "i"] => ["a", "e", "i"] > b = ["a", "u"] => ["a", "u"] > c = a - b => ["e", "i"]
Il metodo (*) invece si comporta in modo diverso a seconda dell'argomento; se gli viene passato un intero n restituisce un array costituito da n copie dell'array originario:
> a = ["a", "e", "i"] => ["a", "e", "i"] > a * 2 => ["a", "e", "i", "a", "e", "i"]
Se invece all'argomento può essere applicato il metodo to_str, e non è un intero, avremo come risultato una stringa costituita dagli elementi dell'array intervallati dalla stringa argomento:
> a = ["a", "e", "i"] => ["a", "e", "i"] > a * "..." => "a...e...i"
Infine c'è il metodo intersezione (&) che restituisce un nuovo array costituito dagli elementi comuni dei due array:
> a = ["a", "e", "i"] => ["a", "e", "i"] > b = ["i", "e", "i"] => ["i", "e", "i"] > a & b => ["e", "i"]
Altri metodi di grande utilità pratica sono:
- clear che rimuove tutti gli elementi
- compact rimuove solo gli elementi nil
- delete rimuove gli elementi passati come argomento
- empty? che restituisce true se l'array è vuoto, false in caso contrario
- include? restituisce true se l'elemento passato come argomento è presente nell'array
- index restituisce l'indice della prima occorrenza dell'oggetto passato come argomento
- join restituisce una stringa ottenuta dalla concatenazione degli elementi dell'array, è possibile anche fornire come argomento il separatore
- [1, 2, 3].join -> "123"
- [1, 2, 3].join("...") -> "1...2...3"
- length, size e nitems restituiscono il numero di elementi con la differenza che l'ultimo metodo non tiene conto degli elementi nil
- reverse crea un nuovo array con l'ordine degli elementi invertito
- sort restituisce un nuovo array con gli elementi ordinati
- [1, 44, 6, 2 ,4].sort -> [1, 2, 4, 6, 44]
Per la lista completa dei metodi rimando al comado ri Array.
Concludiamo con i principali iteratori applicabili alle istanze della classe Array.
Il metodo each esegue il blocco per ogni elemento dell'array passandolo come parametro. Analogo è il comportamento di reverse_each con la differenza che gli elementi dell'array vengono passati al blocco in ordine inverso:
> arr = ["rosso", "bianco", "nero"]
=> ["rosso", "bianco", "nero"]
> arr.each {|colore| puts colore}
rosso
bianco
nero
=> ["rosso", "bianco", "nero"]
> arr.reverse_each {|colore| puts colore}
nero
bianco
rosso
=> ["rosso", "bianco", "nero"]
each_index invece di passare gli elementi come parametri passa gli indici di tali elementi:
> arr.each_index {|indice| puts indice}
0
1
2
=> ["rosso", "bianco", "nero"]
Il metodo collect e il suo sinonimo map
> arr = [1, 2, 3]
=> [1, 2, 3]
> arr.collect{|n| n*3}
=> [3, 6, 9]
delete_if elimina dall'array tutti quegli elementi per il quale la valutazione nel blocco restituisce valore true. Similmente si comportano select e reject.