Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial
  • Lezione 15 di 45
  • livello principiante
Indice lezioni

Array - II

Array in Ruby: altri metodi e i principali iteratori applicabili alle sue istanze
Array in Ruby: altri metodi e i principali iteratori applicabili alle sue istanze
Link copiato negli appunti

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, ereditati da Enumerable, invocano il blocco per ogni elemento dell'array e restituiscono un array costituito dagli elementi modificati dal blocco:

> 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.


Ti consigliamo anche