A montanha-russa colossal de Chaitana

Arrays são uma estrutura de dados comum de se trabalhar. Por isso, existe uma coleção de métodos que podem ser usados para lidar com arrays. Isso inclui ordenar, inverter, inserir e muito mais.

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

Veja alguns dos métodos mais comuns que podem ser usados ao lidar com arrays:

insert

Ao inserir um elemento em um array, você pode usar o método insert, que recebe um índice e um elemento como argumentos. O elemento será inserido no índice especificado, e o restante do array será deslocado para a direita. Se o índice estiver fora dos limites, um IndexError será gerado.

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 você quer excluir um elemento específico de um array, pode usar o método delete, que recebe um elemento como argumento. O método retorna o elemento que foi removido. Se o elemento não existir no array, nil será retornado.

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

first & last

Quando você quer obter o primeiro ou o último elemento de um array, pode usar os métodos first e last. Esses métodos recebem um argumento opcional que especifica quantos elementos retornar. Eles podem melhorar a legibilidade em comparação com o uso do índice 0 ou -1, ou de um intervalo. Se o array estiver vazio, um Enumerable::EmptyError será gerado.

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 você quer inverter um array, pode usar o método reverse, que retorna um novo array com os elementos em ordem inversa. É importante observar que reverse retorna um novo array e não modifica o array original. Se você quiser modificar o array original, adicione um ! ao final 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 append (<<) é útil quando você quer adicionar objetos a um array. No entanto, ao combinar dois arrays, você pode usar o operador +, que retorna um novo array com os elementos de ambos os arrays.

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

Se você adicionar um array a outro array, o array será adicionado como um único elemento.

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

empty?

Ao verificar se um array está vazio, você pode usar o método empty?, que retorna true se o array estiver vazio e false caso contrário. Isso melhora a legibilidade em comparação com verificar o comprimento do array em relação a 0.

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

index

Quando você quer obter o índice de um elemento em um array, pode usar o método index, que recebe um elemento como argumento. Se o elemento não existir no array, nil será retornado.

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

size

Quando você quer saber o número de elementos de um array, pode usar o método size.

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

count

Quando você quer contar quantas vezes um elemento aparece em um array, pode usar o método count.

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

sort

Quando você quer ordenar um array, pode usar o método sort, que retorna um novo array com os elementos ordenados. Assim como reverse, esse método retorna 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]