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
- Modificando o Array
-
Consultando o array
- Consultando o tamanho do array
- Consultando se está incluso no array
- Consultando se está vazio o array
- Consultando se todos os elementos cumpre a condição
- Consultando se existe pelo menos um elemento que cumpre a condição
- Consultando se existe somente um elemento que cumpre a condição
- Consultando se existe nenhum elemento que cumpre a condição
- Contando os elementos
- Descobrindo a posição de um determinado elemento
- Lista de métodos não citado de consulta
- Busca no array
- Removendo elemento do array
- Iteração
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"]
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]]
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]]
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]
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]]
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]]
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]]
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"]
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"]
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"]
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
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"]
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]
Você também pode colocar mais de um elemento.
numeros = [1,4,5]
numeros.insert(1, 2, 3)
#=> [1, 2, 3, 4, 5]
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]
Inverter o array
Para inverter, basta usar o reverse!.
n = [1,2,3,4,5,6]
n.reverse!
#=> [6, 5, 4, 3, 2, 1]
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]
Ordenando pelo tamanho da string:
nomes = ["Didi", "Zacarias", "Dede", "Mussum"]
nomes.sort_by! { |nome| nome.size }
#=> ["Didi", "Dede", "Mussum", "Zacarias"]
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
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
Consultando se está vazio o array
n = [100,32,21,7,2]
n.empty?
#=> false
n = []
n.empty?
#=> true
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
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
Agora vamos para o bloco
[0, 1, 2].all? { |elemento| elemento < 3}
#=> true
[0, 1, 2].all? { |elemento| elemento > 2}
#=> false
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
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"
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]
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]
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]
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"
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]
Caso você queira busca o menor string.
n = ["Alex", "Xande", "Sandra", "Alexandre"]
n.min { |a, b| a.size <=> b.size }
#=> "Alex"
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]
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"]
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"]
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"]
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"]
Removendo o último elemento
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.pop
#=> "Melão"
frutas
#=> ["Maçã", "Pera", "Uva"]
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"]
Removendo determinado elemento
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete "Pera"
#=> "Pera"
frutas
#=> ["Maçã", "Uva", "Melão"]
Removendo elemento usando índice
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete_at 3
#=> "Melão"
frutas
#=> ["Maçã", "Pera", "Uva"]
Removendo elemento com condição
frutas = ["Maçã", "Pera", "Uva", "Melão"]
frutas.delete_if { |fruta| fruta.end_with? "a" }
#=> ["Maçã", "Melão"]
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"]
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]
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
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
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)