A Montanha-Russa Colossal da Chaitana

Os arrays são uma estrutura de dados comum com que vais trabalhar. Por isso, existe um conjunto de métodos que podes usar para lidar com arrays. Entre eles, há ordenação, inversão, inserção e muitos outros.

Alguns destes métodos são destrutivos, o que significa que modificam o array original. Outros são não destrutivos, ou seja, devolvem um novo array e não modificam o original.

Aqui ficam alguns dos métodos mais comuns que podes usar quando trabalhas com arrays:

insert

Quando inseres um elemento num array, podes usar o método insert, que recebe um índice e um elemento como argumentos. O elemento é inserido no índice especificado e o resto do array é deslocado para a direita. Se o índice estiver fora dos limites, é lançado um 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 queres eliminar um elemento específico de um array, podes usar o método delete, que recebe um elemento como argumento. O método devolve o elemento que foi removido. Se o elemento não existir no array, é devolvido nil.

numbers = [1, 2, 3]
numbers.delete(2) # => 2
numbers           # => [1, 3]

first & last

Quando queres obter o primeiro ou o último elemento de um array, podes usar os métodos first e last. Estes métodos recebem um argumento opcional que especifica quantos elementos devolver. Isto pode melhorar a legibilidade em comparação com o uso do índice 0 ou -1, ou de um intervalo. Se o array estiver vazio, é lançado um 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 queres inverter um array, podes usar o método reverse, que devolve um novo array com os elementos pela ordem inversa. É importante notar que reverse devolve um novo array e não modifica o array original. Se quiseres modificar o array original, acrescenta um ! ao fim do nome do método.

numbers = [1, 2, 3]
numbers.reverse # => [3, 2, 1]
numbers         # => [1, 2, 3]

numbers.reverse! # => [3, 2, 1]
numbers          # => [3, 2, 1]

Concat(+)

O método de acrescentar (<<) é útil quando queres adicionar objetos a um array. No entanto, quando combinas dois arrays, podes usar o operador +, que devolve um novo array com os elementos de ambos os arrays.

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

Se acrescentares um array a outro array, o array é adicionado como um único elemento.

[1, 2] << [3, 4] # => [1, 2, [3, 4]]

empty?

Quando queres verificar se um array está vazio, podes usar o método empty?, que devolve true se o array estiver vazio e false caso contrário. Isto melhora a legibilidade em comparação com verificar se o comprimento do array é igual a 0.

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

index

Quando queres obter o índice de um elemento num array, podes usar o método index, que recebe um elemento como argumento. Se o elemento não existir no array, é devolvido nil.

numbers = [1, 2, 3]
numbers.index(2) # => 1

size

Quando queres saber o número de elementos de um array, podes usar o método size.

numbers = [1, 2, 3]
numbers.size # => 3

count

Quando queres contar o número de vezes que um elemento aparece num array, podes usar o método count.

fruits = ["apple", "banana", "apple"]
fruits.count("apple")      # => 2
fruits.count("banana")     # => 1
fruits.count("watermelon") # => 0

sort

Quando queres ordenar um array, podes usar o método sort, que devolve um novo array com os elementos ordenados. Tal como acontece com reverse, este método devolve um novo array e não modifica o array original.

numbers = [3, 2, 1]
numbers.sort # => [1, 2, 3]
numbers      # => [3, 2, 1]

numbers.sort! # => [1, 2, 3]
numbers       # => [1, 2, 3]