DEV Community

Alexandre
Alexandre

Posted on

Usando os métodos da classe Array no Ruby

Bem, vamos aprender a usar os métodos do Array.

E aperte o cinto que a viagem vai ser longa.

Índice


Criando um objeto Array

Antes de nós começar a usar os métodos, vamos primeiro saber algumas maneiras de criar o objeto Array, que isso talvez possa ajudar você em alguma coisa.

Vamos começar com clássico, os colchetes.

nomes = []
# ou
nomes = ["Alexandre", "Luiza", "Alisson"]
Enter fullscreen mode Exit fullscreen mode

Não tem mistério, porém existe uma outra maneira de criar um Array. Ele é limitado, porém poderoso.

Mas supor uma situação em que você quer um Array bidimensional de 3x3 com valores nulos.

Você, talvez, faria desta forma.

matriz = [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
# ou

matriz = []
3.times do
  matriz.append [nil, nil, nil]
end
matriz
#=> [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
Enter fullscreen mode Exit fullscreen mode

Não tem problema em criar uma matriz desse jeito, é que existe uma forma mais reduzida.

matriz = Array.new(3) { Array.new(3) }
#=> [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
Enter fullscreen mode Exit fullscreen mode

Viu, muito mais reduzido.

É melhor eu explicar sobre o método new.

O new aceita dois argumentos, o primeiro é o tamanho do array, o segundo é o valor padrão.

Vamos ver alguns exemplos:

array = Array.new(3)
#=> [nil,nil,nil]

zeros = Array.new(3, 0)
#=> [0,0,0]
Enter fullscreen mode Exit fullscreen mode

Eu não sei se você percebeu que eu usei o bloco no exemplo de matriz, pode ser que você esteja se perguntando, por que ele não colocou o Array.new no segundo argumentos?

Vamos ver um exemplo que discutirei o problema a seguir.

matriz = Array.new(3, Array.new(3))
#=> [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
Enter fullscreen mode Exit fullscreen mode

Olha, funcionou.

Só que não. Existe um problema grave ai.

Bem, eu não sou bom em explicar esse tipo de coisa, então eu colocarei um exemplo e deixarei você descobrir o problema sozinho.

matriz = Array.new(3, Array.new(3))

matriz[0][0] = 0
#=> [[0,nil, nil],[0,nil, nil],[0,nil, nil]]
Enter fullscreen mode Exit fullscreen mode

Viu o problema, vou deixar você descobrir isso sozinho. Mas para não deixar você sem pista, eu lhe darei uma dica, Memória.

Boa sorte com a busca da resposta.

Bem, vamos voltar pro nosso exemplo da matriz.

matriz = Array.new(3) { Array.new(3) }
#=> [[nil,nil, nil],[nil,nil, nil],[nil,nil, nil]]
Enter fullscreen mode Exit fullscreen mode

Se você olhar isso, você percebe que eu não coloquei o Array.new no segundo argumento e sim em um bloco.

Caso você não saiba o que é um bloco, de forma resumida, é um agrupamento de código que está dentro de um do end ou {}.

Bem, novamente, não sei como explicar isso, mas se você quer saber mais sobre isso, pesquise sobre yield, talvez no futuro, eu escrevo sobre isso.

Acho que nós enrolamos demais na criação, então vamos aprender a inserir item no array.

Modificando o Array

Vamos começar inserindo o item no final do array.

Inserindo no final do array

Nós temos três formas de inserir elemento no final e cada um dele faz a mesma coisa, então escolha a qual mais adequado em uma situação ou escolha o que você mais gostou.

nomes = []

nomes.push "Alexandre"
#=> ["Alexandre"]

nomes.append "Fulano"
#=> ["Alexandre", "Fulano"]

nomes << "Thiago"
#=> ["Alexandre", "Fulano", "Thiago"]
Enter fullscreen mode Exit fullscreen mode

Inserindo no começo do array

Temos dois métodos para isso, e novamente, escolha da sua preferencia.

nomes = []

nomes.unshift "Alexandre"
#=> ["Alexandre"]

nomes.prepend "Fulano"
#=> ["Fulano", "Alexandre"]
Enter fullscreen mode Exit fullscreen mode

Concatenando dois array

Talvez você queira juntar dois array para fazer algo com ele.

Tem duas formas de fazer isso, porém com uma diferença.

Por exemplo:

nomes = ["Alexandre"]

# usando concat
nomes.concat ["Fulano"]
#=> ["Alexandre", "Fulano"]

# usando o +
nomes = nomes + ["Luiza"]
#=> ["Alexandre", "Fulano", "Luiza"]
Enter fullscreen mode Exit fullscreen mode

Pode ser que você notou a diferença, se não notou, não tem problema, eu vou mostrar a diferença.

No método concat, pode notar que eu não uso atribuição, ou seja, isso significa que esse concat modifica o próprio array.

Enquanto o + não modifica o array, e para obter esse array concatenado, tem que usar a atribuição.

Também tem outro detalhe, o concat não cria um novo array e o + cria um novo array. Vamos ver uma demostração sobre isso.

# usando concat
numeros = [1,2,3]

numeros.object_id
#=> 1037700

numeros.concat [4,5,6]
#=> [1, 2, 3, 4, 5, 6]

numeros.object_id
#=> 1037700

# usando o +
numeros = [1,2,3]

numeros.object_id
#=> 1078540

numeros = numeros + [4,5,6]
#=> [1, 2, 3, 4, 5, 6]

numeros.object_id
#=> 1112080
Enter fullscreen mode Exit fullscreen mode

Viu a diferença?

Antes de explicar a diferença, talvez você não saiba o que é o object_id, considere ele como um número onde a variável está localizado na memória.

Bem, continuando.

Podemos perceber que no concat o object_id não muda após a concatenação, enquanto no + ele muda.

O que isso significa?

Isso significa que em questão de performance e eficiência, o concat pode ser considerado melhor.

Inserindo item em determinado posição

Temos dois formas de inserir em determinado posição.

A primeira vai ser inserir naquela posição, porém removendo o item que estava nessa posição.

A segunda vai ser inserir naquela posição, porém sem remover o item que estava nessa posição.

Substituindo o item

Aposto que você já usou ele, então não muito o que explicar sobre ele.

Exemplo:

comida = ["Pizza", "Pastel", "Hamburger"]
comida[1] = "Coxinha"
#=> "Coxinha"

comida
#=> ["Pizza", "Coxinha", "Hamburger"]
Enter fullscreen mode Exit fullscreen mode

Inserindo sem remover o item

Não tem mistério neste método, então tome um exemplo:

numeros = [1,3,4,5]

numeros.insert(1, 2)
#=> [1, 2, 3, 4, 5]
Enter fullscreen mode Exit fullscreen mode

Você também pode colocar mais de um elemento.

numeros = [1,4,5]

numeros.insert(1, 2, 3)
#=> [1, 2, 3, 4, 5]
Enter fullscreen mode Exit fullscreen mode

Embaralhar o array

Se você quer embaralhar os itens do array, basta usar o shuffle.

n = [1,2,3,4,5,6]

n.shuffle!
#=> [5, 6, 1, 4, 3, 2]
Enter fullscreen mode Exit fullscreen mode

Inverter o array

Para inverter, basta usar o reverse!.

n = [1,2,3,4,5,6]
n.reverse!
#=> [6, 5, 4, 3, 2, 1]
Enter fullscreen mode Exit fullscreen mode

Ordenando o array

Eu não vou me aprofundar em ordenar o array, Só vou mostrar como que usar e o resto você descobre.

Ordenando os números:

n = [1,2,3,4,5,6]
n.shuffle!
#=> [4, 2, 5, 1, 6, 3]
n.sort!
#=> [1,2,3,4,5,6]
Enter fullscreen mode Exit fullscreen mode

Ordenando pelo tamanho da string:

nomes = ["Didi", "Zacarias", "Dede", "Mussum"]
nomes.sort_by! { |nome| nome.size }
#=> ["Didi", "Dede", "Mussum", "Zacarias"]
Enter fullscreen mode Exit fullscreen mode

Acabamos de aprender alguns métodos que modifica o array, porém ainda restam alguns métodos que não citei, mas eu vou colocar uma lista aqui.

Lista de métodos não citado de modificação

  • fill
  • replace
  • rotate

Com isso, acabamos com os métodos de modificação, agora vamos para consulta no array.

Consultando o array

Vou abordar todos os métodos de consulta, menos o hash.

Consultando o tamanho do array

n = [1,2,3,4,5]
n.size
#=> 5
# ou
n.length
#=> 5
Enter fullscreen mode Exit fullscreen mode

Ambos métodos não tem diferença, então escolha por sua preferencia.

Consultando se está incluso no array

n = [100,32,21,7,2]
n.include? 100
#=> true

n.include? 5
#=> false
Enter fullscreen mode Exit fullscreen mode

Consultando se está vazio o array

n = [100,32,21,7,2]
n.empty?
#=> false

n = []
n.empty?
#=> true
Enter fullscreen mode Exit fullscreen mode

Consultando se todos os elementos cumpre a condição

O método que vou demostrar serve para verificar se os elementos do array está seguindo uma condição posta.

Caso você não colocar uma condição, ele vai verificar pelo elemento que são verdadeiro, ou seja, se tiver um elemento false ou nil, vai ser falso, senão vai ser verdadeiro.

Vamos para um exemplo.

[0, 1, "eu"].all?
# => true

[0, 1, false].all?
# => false

[0, 1, nil].all?
# => false
Enter fullscreen mode Exit fullscreen mode

Para colocar uma condição, você pode usar um argumento ou pelo bloco, vamos primeiro com argumento.

[0, 0, 0].all? 0
#=> true

[0, 1, 2].all? 0
#=> false

["Alex", "Alvin", "Annie"].all? /^A/
#=> true

["Alex", "Bia", "Carlos"].all? /^A/
#=> false
Enter fullscreen mode Exit fullscreen mode

Agora vamos para o bloco

[0, 1, 2].all? { |elemento| elemento < 3}
#=> true

[0, 1, 2].all? { |elemento| elemento > 2}
#=> false
Enter fullscreen mode Exit fullscreen mode

Consultando se existe pelo menos um elemento que cumpre a condição

É mesma coisa com all?, porém aqui é se existe pelo menos um.

Se você não dar um condição, ele vai considera o elemento verdadeiro, como eu citei no método all?.

[nil, 1, false].any?
# => true

[nil, false].any?
# => false

[].any?
# => false
Enter fullscreen mode Exit fullscreen mode

Como no método all?, ele aceita condição pelo argumento ou pelo bloco.

Vamos primeiro pelo argumento.

[0, 0, 0, 0, 1, 0, 0, 0].any? 1
# => true

[0, 0, 0, 0, 2, 0, 0, 0].any? 1
# => false

["Alex", "Alvin", "Annie"].any? /x$/
#=> true

["Alex", "Bia", "Carlos"].any? /^D/
#=> false
Enter fullscreen mode Exit fullscreen mode

Agora para o bloco.

[0, 0, 11, 0, 0, 0].any? { |elemento| elemento > 10}
# => true

[0, 0, 11, 0, 0, 0].any? { |elemento| elemento > 100}
# => false
Enter fullscreen mode Exit fullscreen mode

Consultando se existe somente um elemento que cumpre a condição

É mesma coisa com all? e any?, então não vou repetir.

A diferença é que tem que ser somente um elemento.

[nil, 1, false].one?
# => true

[nil, false].one?
# => false

[].one?
# => false
Enter fullscreen mode Exit fullscreen mode

Usando o argumento.

[0, 0, 0, 0, 1, 0, 0, 0].one? 1
# => true

[0, 0, 0, 0, 2, 0, 0, 0].one? 1
# => false

["Alex", "Alvin", "Annie"].one? /x$/
#=> true

["Alex", "Alvin", "Annie"].one? /^A/
#=> false
Enter fullscreen mode Exit fullscreen mode

Agora para o bloco.

[0, 0, 11, 0, 0, 0].one? { |elemento| elemento > 10}
# => true

[0, 0, 11, 0, 0, 0].one? { |elemento| elemento < 10}
# => false
Enter fullscreen mode Exit fullscreen mode

Consultando se existe nenhum elemento que cumpre a condição

Como sempre, este método é quase equivalente a all?, any? e one?.

Então vamos copiar e colar do exemplo acima.

[nil, false].none?
# => true

[nil, false, 1].none?
# => false

[].none?
# => true
Enter fullscreen mode Exit fullscreen mode

Usando o argumento.

[0, 0, 0, 0, 1, 0, 0, 0].none? 1
# => false

[0, 0, 0, 0, 2, 0, 0, 0].none? 1
# => true

["Alex", "Alvin", "Annie"].none? /x$/
#=> false

["Alex", "Alvin", "Annie"].none? /^B/
#=> true
Enter fullscreen mode Exit fullscreen mode

Agora para o bloco.

[0, 0, 10, 0, 0, 0].none? { |elemento| elemento > 10}
# => true

[0, 0, 11, 0, 0, 0].none? { |elemento| elemento < 10}
# => false
Enter fullscreen mode Exit fullscreen mode

Contando os elementos

Agora você quer saber quantos elementos tem no array.

Se você não passar nenhum argumento, ele vai funcionar como o método length.

[0,0,0,0,0,0,1].count
#=> 7

[0,0,0,0,0,0,1].count 0
#=> 6
Enter fullscreen mode Exit fullscreen mode

Você pode usar bloco.

[0,0,0,0,0,0,1].count { |elemento| elemento < 1}
#=> 6

[0,0,0,0,0,0,1].count { |elemento| elemento > 1}
#=> 0
Enter fullscreen mode Exit fullscreen mode

Descobrindo a posição de um determinado elemento

Talvez a sua aplicação precisa descobrir o índice de um elemento.

Nós temos dois métodos, uma que busca a partir de direita para esquerda e a outra busca de esquerda para direita.

Vamos começar com esquerda para direita.

[10,15,20,25,30,35,25].index 25
#=> 3

[10,15,20,25,30,35,25].index 50
#=> nil
Enter fullscreen mode Exit fullscreen mode

Agora de direita para esquerda

[10,15,20,25,30,35,25].rindex 25
#=> 6

[10,15,20,25,30,35,25].rindex 50
#=> nil
Enter fullscreen mode Exit fullscreen mode

Lista de métodos não citado de consulta

  • hash

Com isso, acabamos com os métodos de consulta, agora vamos para métodos de busca.

Busca no array

Existem muitos métodos de busca, mas muito mesmo, então eu só vou focar o que mais uso.

Busca com índice

A maneira clássica de busca é o colchete.

#          0   1  2  3  4  5
numeros = [7, 12, 6, 8, 9, 2]
numeros[3]
#=> 8

numeros[100]
#=> nil
Enter fullscreen mode Exit fullscreen mode

Tem o método at, que faz o mesmo trabalho que os colchetes.

#          0   1  2  3  4  5
numeros = [7, 12, 6, 8, 9, 2]
numeros.at 3
#=> 8

numeros.at 100
#=> nil
Enter fullscreen mode Exit fullscreen mode

Também pode usar o método fetch, porém existe uma diferença, observa no exemplo.

#          0   1  2  3  4  5
numeros = [7, 12, 6, 8, 9, 2]
numeros.fetch 3
#=> 8

numeros.fetch 100
#=> index 100 outside of array bounds: -6...6 (IndexError)
Enter fullscreen mode Exit fullscreen mode

Olha, ele deu erro ao tentar buscar um elemento fora do limite do array.

Existe uma maneira de evitar, que é dando um valor padrão para caso onde der erro.

#          0   1  2  3  4  5
numeros = [7, 12, 6, 8, 9, 2]
numeros.fetch(100, "não tem")
#=> "não tem"

# Também pode usar o bloco
numeros.fetch(100) { |indice| "não tem o elemento no índice #{indice}" }
#=> "não tem o elemento no índice 100"
Enter fullscreen mode Exit fullscreen mode

Pegando o primeiro elemento

Obviamente que você usaria o colchete para pegar o primeiro elemento, mas saiba que existe um método, que é o first, por exemplo.

n = [8,5,24,1,9,1,0]
n.first
#=> 8

# também pode pegar mais de um elemento
n.first 3
#=> [8, 5, 24]
Enter fullscreen mode Exit fullscreen mode

Pegando o ultimo elemento

Faz a mesma que o método first, porém pegando o último elemento usando last.

n = [8,5,24,1,9,1,0]
n.last
#=> 0

# também pode pegar mais de um elemento
n.last 3
#=> [9, 1, 0]
Enter fullscreen mode Exit fullscreen mode

Pegando o maior número

Basta usar o max, que ele vai pegar o maior número.

n = [8,5,24,1,9,1,0]
n.max
#=> 24

# também pode pegar um conjunto de números maiores
n.max 3
#=> [24, 9, 8]
Enter fullscreen mode Exit fullscreen mode

Caso você queira busca o maior string, ele não vai funcionar, você tem passar um bloco, por exemplo:

n = ["Alex", "Xande", "Sandra", "Alexandre"]
n.max { |a, b| a.size <=> b.size }
#=> "Alexandre"
Enter fullscreen mode Exit fullscreen mode

Pegando o menor número

Basta usar o min, que ele vai pegar o menor número.

n = [8,5,24,1,9,1,0]
n.min
#=> 0

# também pode pegar um conjunto de números menores
n.min 3
#=> [0, 1, 1]
Enter fullscreen mode Exit fullscreen mode

Caso você queira busca o menor string.

n = ["Alex", "Xande", "Sandra", "Alexandre"]
n.min { |a, b| a.size <=> b.size }
#=> "Alex"
Enter fullscreen mode Exit fullscreen mode

Pegando o menor e maior número

Ele é basicamente igual aos métodos min e max, porém pegando o menor e maior número ao mesmo tempo.

n = [8,5,24,1,9,1,0]
n.minmax
#=> [0, 24]
Enter fullscreen mode Exit fullscreen mode

Também é possível usar para buscar os string menor e maior.

n = ["Alex", "Xande", "Sandra", "Alexandre"]
n.minmax { |a, b| a.size <=> b.size }
#=> ["Alex", "Alexandre"]
Enter fullscreen mode Exit fullscreen mode

Buscando um elemento aleatório

Talvez você queira fazer um sorteio para pegar um valor aleatório, basta usar o método sample.

sorteio = ["Fulano", "Você", "Eu", "Nós"]
sorteio.sample
#=> "Você"

# também pode pegar um conjunto de valores
sorteio.sample 2
#=> ["Você", "Fulano"]
Enter fullscreen mode Exit fullscreen mode

Selecionando elementos

E se você quer busca valores que começa com letra 'D'.

Vamos ver um exemplo disso.

musicas = ["Cada instante", "Pacto", "Canção de carrasco", "Deusa da lua", "Dose de respeito", "Dragão"]

musicas.select {|musica| musica.start_with? "D" }
#=> ["Deusa da lua", "Dose de respeito", "Dragão"]
Enter fullscreen mode Exit fullscreen mode

Lista de métodos não citado de busca

  • assoc
  • rassoc
  • values_at
  • values_at
  • dig
  • drop
  • take
  • drop_while
  • take_while
  • compact
  • uniq
  • bsearch
  • bsearch_index

Bem, acabamos com os métodos de busca, agora vamos para métodos de remover elemento.

Removendo elemento do array

Agora vamos remover elementos do array com alguns métodos.

Removendo o primeiro elemento

frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.shift
#=> "Maçã"
frutas
#=> ["Pera", "Uva", "Melão"]
Enter fullscreen mode Exit fullscreen mode

Removendo o último elemento

frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.pop
#=> "Melão"
frutas
#=> ["Maçã", "Pera", "Uva"]
Enter fullscreen mode Exit fullscreen mode

Removendo todos os nil do array

Tem situação em que você vai receber um array com valores nil, e então para remover, use o compact!.

frutas = ["Maçã", nil, "Pera", nil, "Uva", nil, "Melão"]
frutas.compact!
#=> ["Maçã", "Pera", "Uva", "Melão"]
Enter fullscreen mode Exit fullscreen mode

Removendo determinado elemento

frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete "Pera"
#=> "Pera"
frutas
#=> ["Maçã", "Uva", "Melão"]
Enter fullscreen mode Exit fullscreen mode

Removendo elemento usando índice

frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete_at 3
#=> "Melão"
frutas
#=> ["Maçã", "Pera", "Uva"]
Enter fullscreen mode Exit fullscreen mode

Removendo elemento com condição

frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete_if { |fruta| fruta.end_with? "a" }
#=> ["Maçã", "Melão"]
Enter fullscreen mode Exit fullscreen mode

Mantendo elemento com condição

Esse método é o oposto do método anterior, pois ao invés de remover os elementos, ele mantém os elementos e remove aqueles que não cumpre a condição.

frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.keep_if { |fruta| fruta.end_with? "a" }
#=> ["Pera", "Uva"]
Enter fullscreen mode Exit fullscreen mode

Removendo duplicata

numeros = [0, 1, 1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 9, 9, 0]
numeros.uniq!
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Enter fullscreen mode Exit fullscreen mode

Lista de métodos não citado de remoção

  • reject!
  • slice!
  • select!, filter!

Bem, acabamos com os métodos de remoção, agora vamos para métodos de iteração.

Iteração

Eu só vou abordar dois métodos, que são each e each_with_index.

Talvez você já usou um dele para iterar um array, veja um exemplo:

nomes = ["Bruno", "Rafinha", "Neymar", "Fred"]

nomes.each do |nome|
  puts nome
end
# Bruno
# Rafinha
# Neymar
# Fred
Enter fullscreen mode Exit fullscreen mode

Tem vezes que você quer a posição do elemento na iteração, então basta usar o each_with_index.

nomes = ["Bruno", "Rafinha", "Neymar", "Fred"]

nomes.each_with_index do |nome, indice|
  puts "#{indice}: #{nome}"
end
# 0: Bruno
# 1: Rafinha
# 2: Neymar
# 3: Fred
Enter fullscreen mode Exit fullscreen mode

Com isso, nós acabamos de ver quase todos os métodos da classe Array.

Conclusão

Com isso, agora você vai construir a sua aplicação com mais eficiente.

Bem, é isso, Tchau!

Top comments (0)