Gli array sono una struttura dati comune con cui si lavora spesso.
Per questo motivo esiste una raccolta di metodi che si possono usare per gestirli.
Tra questi ci sono l'ordinamento, l'inversione, l'inserimento e molti altri.
Alcuni di questi metodi sono distruttivi, il che significa che modificano l'array originale.
Altri sono non distruttivi, cioè restituiscono un nuovo array e non modificano quello originale.
Ecco alcuni dei metodi più comuni che si possono usare quando si lavora con gli array:
insert
Quando inserisci un elemento in un array, puoi usare il metodo insert, che accetta un indice e un elemento come argomenti.
L'elemento viene inserito all'indice specificato e il resto dell'array viene spostato a destra.
Se l'indice è fuori dai limiti, viene sollevato un IndexError.
numbers = [1, 2, 3]
numbers.insert(1, 4)
numbers # => [1, 4, 2, 3]
numbers.insert(5, 5) # => Error: Index out of bounds (IndexError)
delete
Quando vuoi eliminare un elemento specifico da un array, puoi usare il metodo delete, che accetta un elemento come argomento.
Il metodo restituisce l'elemento rimosso.
Se l'elemento non esiste nell'array, viene restituito nil.
numbers = [1, 2, 3]
numbers.delete(2) # => 2
numbers # => [1, 3]
first & last
Quando vuoi ottenere il primo o l'ultimo elemento di un array, puoi usare i metodi first e last.
Questi metodi accettano un argomento opzionale che specifica quanti elementi restituire.
Possono migliorare la leggibilità rispetto all'uso dell'indice 0 o -1, oppure di un intervallo.
Se l'array è vuoto, viene sollevato un Enumerable::EmptyError.
numbers = [1, 2, 3]
numbers.first # => 1
numbers.last # => 3
numbers.first(2) # => [1, 2]
numbers.last(2) # => [2, 3]
empty_array = [] of Int32
empty_array.last # => Error: Empty enumerable (Enumerable::EmptyError)
reverse
Quando vuoi invertire un array, puoi usare il metodo reverse, che restituisce un nuovo array con gli elementi in ordine inverso.
È importante notare che reverse restituisce un nuovo array e non modifica l'array originale.
Se vuoi modificare l'array originale, aggiungi un ! alla fine del nome del metodo.
numbers = [1, 2, 3]
numbers.reverse # => [3, 2, 1]
numbers # => [1, 2, 3]
numbers.reverse! # => [3, 2, 1]
numbers # => [3, 2, 1]
Concat(+)
Il metodo di aggiunta (<<) è utile quando vuoi aggiungere oggetti a un array.
Tuttavia, quando combini due array, puoi usare l'operatore +, che restituisce un nuovo array con gli elementi di entrambi.
[1, 2] + [3, 4] # => [1, 2, 3, 4]
Se aggiungi un array a un altro array, l'array viene aggiunto come singolo elemento.
[1, 2] << [3, 4] # => [1, 2, [3, 4]]
empty?
Per verificare se un array è vuoto, puoi usare il metodo empty?, che restituisce true se l'array è vuoto e false altrimenti.
Questo migliora la leggibilità rispetto a confrontare la lunghezza dell'array con 0.
[].empty? # => true
[1, 2, 3].empty? # => false
index
Quando vuoi ottenere l'indice di un elemento in un array, puoi usare il metodo index, che accetta un elemento come argomento.
Se l'elemento non esiste nell'array, viene restituito nil.
numbers = [1, 2, 3]
numbers.index(2) # => 1
size
Quando vuoi sapere il numero di elementi in un array, puoi usare il metodo size.
numbers = [1, 2, 3]
numbers.size # => 3
count
Quando vuoi contare quante volte un elemento è presente in un array, puoi usare il metodo count.
fruits = ["apple", "banana", "apple"]
fruits.count("apple") # => 2
fruits.count("banana") # => 1
fruits.count("watermelon") # => 0
sort
Quando vuoi ordinare un array, puoi usare il metodo sort, che restituisce un nuovo array con gli elementi ordinati.
Come con reverse, questo metodo restituisce un nuovo array e non modifica l'array originale.
numbers = [3, 2, 1]
numbers.sort # => [1, 2, 3]
numbers # => [3, 2, 1]
numbers.sort! # => [1, 2, 3]
numbers # => [1, 2, 3]
Esercizio di apprendimento
