Como verificar se existe um valor em uma matriz no Ruby

Eu tenho um valor 'Dog'e uma matriz ['Cat', 'Dog', 'Bird'].

Como verifico se ele existe na matriz sem passar por ela? Existe uma maneira simples de verificar se o valor existe, nada mais?

Você está procurando include?:

>> ['Cat', 'Dog', 'Bird'].include? 'Dog'
=> true

Existe um in?método em ActiveSupport(parte do Rails) desde a v3.1, como apontado por @campaterson. Portanto, no Rails, ou se você require 'active_support', você pode escrever:

'Unicorn'.in?(['Cat', 'Dog', 'Bird']) # => false

OTOH, não há inoperador ou #in?método no próprio Ruby, mesmo que já tenha sido proposto anteriormente, em particular por Yusuke Endoh, um membro de alto nível do núcleo do rubi.

Como foi assinalado por outros, o método inverso include?existe, para todos os Enumerables incluindo Array, Hash, Set, Range:

['Cat', 'Dog', 'Bird'].include?('Unicorn') # => false

Observe que, se você tiver muitos valores em sua matriz, todos eles serão verificados um após o outro (ou seja O(n)), enquanto a pesquisa de um hash será um tempo constante (ou seja O(1)). Portanto, se sua matriz é constante, por exemplo, é uma boa ideia usar um conjunto . Por exemplo:

require 'set'
ALLOWED_METHODS = Set[:to_s, :to_i, :upcase, :downcase
                       # etc
                     ]

def foo(what)
  raise "Not allowed" unless ALLOWED_METHODS.include?(what.to_sym)
  bar.send(what)
end

Um teste rápido revela que chamar include?um elemento 10 Seté cerca de 3,5x mais rápido do que chamá-lo no equivalente Array(se o elemento não for encontrado).

Uma nota final: seja cauteloso ao usar include?a Range, existem sutilezas; consulte o documento e compare com cover?...

Tentar

['Cat', 'Dog', 'Bird'].include?('Dog')

Use Enumerable#include:

a = %w/Cat Dog Bird/

a.include? 'Dog'

Ou, se vários testes forem realizados, ¹ você poderá se livrar do loop (que ainda include?possui) e passar de O (n) para O (1) com:

h = Hash[[a, a].transpose]
h['Dog']

Se você quiser verificar por um bloco, você pode tentar any?ou all?.

%w{ant bear cat}.any? {|word| word.length >= 3}   #=> true  
%w{ant bear cat}.any? {|word| word.length >= 4}   #=> true  
[ nil, true, 99 ].any?                            #=> true  

Consulte Enumerável para obter mais informações.

Minha inspiração veio de " avaliar se o array tem algum item em ruby "

Ruby tem onze métodos para encontrar elementos em uma matriz.

O preferido é include?ou, para acesso repetido, crie um conjunto e depois chame include?ou member?.

Aqui estão todos eles:

array.include?(element) # preferred method
array.member?(element)
array.to_set.include?(element)
array.to_set.member?(element)
array.index(element) > 0
array.find_index(element) > 0
array.index { |each| each == element } > 0
array.find_index { |each| each == element } > 0
array.any? { |each| each == element }
array.find { |each| each == element } != nil
array.detect { |each| each == element } != nil

Todos eles retornam um truevalor ish se o elemento estiver presente.

include?é o método preferido. Ele usa um forloop de linguagem C internamente que interrompe quando um elemento corresponde às rb_equal_opt/rb_equalfunções internas . Não pode ser muito mais eficiente, a menos que você crie um conjunto para verificações de associação repetidas.

VALUE
rb_ary_includes(VALUE ary, VALUE item)
{
  long i;
  VALUE e;

  for (i=0; i<RARRAY_LEN(ary); i++) {
    e = RARRAY_AREF(ary, i);
    switch (rb_equal_opt(e, item)) {
      case Qundef:
        if (rb_equal(e, item)) return Qtrue;
        break;
      case Qtrue:
        return Qtrue;
    }
  }
  return Qfalse;
}

member?não é redefinido na Arrayclasse e usa uma implementação não otimizada do Enumerablemódulo que literalmente enumera todos os elementos:

static VALUE
member_i(RB_BLOCK_CALL_FUNC_ARGLIST(iter, args))
{
  struct MEMO *memo = MEMO_CAST(args);

  if (rb_equal(rb_enum_values_pack(argc, argv), memo->v1)) {
    MEMO_V2_SET(memo, Qtrue);
    rb_iter_break();
  }
  return Qnil;
}

static VALUE
enum_member(VALUE obj, VALUE val)
{
  struct MEMO *memo = MEMO_NEW(val, Qfalse, 0);

  rb_block_call(obj, id_each, 0, 0, member_i, (VALUE)memo);
  return memo->v2;
}

Traduzido para o código Ruby, isso ocorre sobre o seguinte:

def member?(value)
  memo = [value, false, 0]
  each_with_object(memo) do |each, memo|
    if each == memo[0]
      memo[1] = true 
      break
    end
  memo[1]
end

Ambos include?e member?possuem complexidade de tempo O (n), pois os dois pesquisam na matriz a primeira ocorrência do valor esperado.

Podemos usar um conjunto para obter o tempo de acesso O (1) com o custo de ter que criar uma representação Hash da matriz primeiro. Se você verificar repetidamente a associação na mesma matriz, esse investimento inicial poderá render rapidamente. Setnão é implementado em C, mas como classe Ruby simples, ainda assim o tempo de acesso O (1) do subjacente @hashvale a pena.

Aqui está a implementação da classe Set:

module Enumerable
  def to_set(klass = Set, *args, &block)
    klass.new(self, *args, &block)
  end
end

class Set
  def initialize(enum = nil, &block) # :yields: o
    @hash ||= Hash.new
    enum.nil? and return
    if block
      do_with_enum(enum) { |o| add(block[o]) }
    else
      merge(enum)
    end
  end

  def merge(enum)
    if enum.instance_of?(self.class)
      @hash.update(enum.instance_variable_get(:@hash))
    else
      do_with_enum(enum) { |o| add(o) }
    end
    self
  end

  def add(o)
    @hash[o] = true
    self
  end

  def include?(o)
    @hash.include?(o)
  end
  alias member? include?

  ...
end

Como você pode ver, a classe Set cria apenas uma @hashinstância interna , mapeia todos os objetos truee verifica a associação usando o Hash#include?que é implementado com o tempo de acesso O (1) na classe Hash.

Não discutirei os outros sete métodos, pois todos são menos eficientes.

Na verdade, existem ainda mais métodos com complexidade O (n) além dos 11 listados acima, mas decidi não listá-los, pois eles examinam toda a matriz em vez de interromperem na primeira correspondência.

Não use estes:

# bad examples
array.grep(element).any? 
array.select { |each| each == element }.size > 0
...

Várias respostas sugerem Array#include?, mas há uma ressalva importante: Olhando para a fonte, até Array#include?realiza loop:

rb_ary_includes(VALUE ary, VALUE item)
{
    long i;

    for (i=0; i<RARRAY_LEN(ary); i++) {
        if (rb_equal(RARRAY_AREF(ary, i), item)) {
            return Qtrue;
        }
    }
    return Qfalse;
}

A maneira de testar a presença palavra sem looping é através da construção de um trie para sua matriz. Existem muitas implementações disponíveis no mercado (google "ruby trie"). Vou usar rambling-trieneste exemplo:

a = %w/cat dog bird/

require 'rambling-trie' # if necessary, gem install rambling-trie
trie = Rambling::Trie.create { |trie| a.each do |e| trie << e end }

E agora estamos prontos para testar a presença de várias palavras em sua matriz sem repetir, com o O(log n)tempo, a mesma simplicidade sintática que Array#include?usando sublinear Trie#include?:

trie.include? 'bird' #=> true
trie.include? 'duck' #=> false

Se você não deseja fazer um loop, não há como fazê-lo com matrizes. Você deve usar um conjunto.

require 'set'
s = Set.new
100.times{|i| s << "foo#{i}"}
s.include?("foo99")
 => true
[1,2,3,4,5,6,7,8].to_set.include?(4) 
  => true

Os conjuntos funcionam internamente como Hashes, portanto, o Ruby não precisa percorrer a coleção para encontrar itens, pois, como o nome indica, gera hashes das chaves e cria um mapa de memória para que cada hash aponte para um determinado ponto da memória. O exemplo anterior feito com um Hash:

fake_array = {}
100.times{|i| fake_array["foo#{i}"] = 1}
fake_array.has_key?("foo99")
  => true

A desvantagem é que as chaves Sets e Hash podem incluir apenas itens exclusivos e, se você adicionar muitos itens, Ruby terá que refazer a coisa toda após certo número de itens para criar um novo mapa que se adapte a um espaço de teclas maior. Para saber mais sobre isso, recomendo que você assista " MountainWest RubyConf 2014 - Big O em um Hash Caseiro de Nathan Long ".

Aqui está uma referência:

require 'benchmark'
require 'set'

array = []
set   = Set.new

10_000.times do |i|
  array << "foo#{i}"
  set   << "foo#{i}"
end

Benchmark.bm do |x|
  x.report("array") { 10_000.times { array.include?("foo9999") } }
  x.report("set  ") { 10_000.times { set.include?("foo9999")   } }
end

E os resultados:

      user     system      total        real
array  7.020000   0.000000   7.020000 (  7.031525)
set    0.010000   0.000000   0.010000 (  0.004816)

Esta é outra maneira de fazer isso: use o Array#indexmétodo

Retorna o índice da primeira ocorrência do elemento na matriz.

Por exemplo:

a = ['cat','dog','horse']
if a.index('dog')
    puts "dog exists in the array"
end

index() também pode pegar um bloco:

Por exemplo:

a = ['cat','dog','horse']
puts a.index {|x| x.match /o/}

Isso retorna o índice da primeira palavra na matriz que contém a letra 'o'.

Fato engraçado,

Você pode usar *para verificar a associação da matriz em uma caseexpressão.

case element
when *array 
  ...
else
  ...
end

Observe o pouco *na cláusula when, isso verifica a associação na matriz.

Todo o comportamento mágico usual do operador splat se aplica; por exemplo, se arraynão for realmente uma matriz, mas um único elemento, ele corresponderá a esse elemento.

Existem várias maneiras de conseguir isso. Alguns deles são os seguintes:

a = [1,2,3,4,5]

2.in? a  #=> true

8.in? a #=> false

a.member? 1 #=> true

a.member? 8 #=> false

Se você precisar verificar múltiplos tempos para qualquer tecla, converta arrpara hashe, agora, verifique O (1)

arr = ['Cat', 'Dog', 'Bird']
hash = arr.map {|x| [x,true]}.to_h
 => {"Cat"=>true, "Dog"=>true, "Bird"=>true}
hash["Dog"]
 => true
hash["Insect"]
 => false

Desempenho do hash # has_key? versus Array # include?

Parâmetro Hash # has_key? A matriz # inclui

Complexidade de tempo O (1) operação O (n) operação 

Tipo de acesso Acessa Hash [chave] se iterar através de cada elemento
                        retorna qualquer valor então da matriz até
                        true é retornado para localiza o valor na matriz
                        Hash # has_key? ligar
                        ligar    

Para verificação única, include?é bom usar

Isso informará não apenas a existência, mas também quantas vezes ela será exibida:

 a = ['Cat', 'Dog', 'Bird']
 a.count("Dog")
 #=> 1

Pelo que vale, os documentos do Ruby são um recurso incrível para esse tipo de pergunta.

Eu também anotaria o comprimento da matriz que você está pesquisando. O include?método executará uma pesquisa linear com complexidade O (n) que pode ficar muito feia dependendo do tamanho da matriz.

Se você estiver trabalhando com uma matriz grande (classificada), consideraria escrever um algoritmo de pesquisa binária que não deve ser muito difícil e tem o pior caso de O (log n).

Ou, se você estiver usando Ruby 2.0, poderá aproveitar bsearch.

Podes tentar:

Exemplo: se Gato e Cachorro existem na matriz:

(['Cat','Dog','Bird'] & ['Cat','Dog'] ).size == 2   #or replace 2 with ['Cat','Dog].size

Ao invés de:

['Cat','Dog','Bird'].member?('Cat') and ['Cat','Dog','Bird'].include?('Dog')

Nota: member?e include?são os mesmos.

Isso pode fazer o trabalho em uma linha!

Se queremos não usar include?isso também funciona:

['cat','dog','horse'].select{ |x| x == 'dog' }.any?

['Cat', 'Dog', 'Bird'].detect { |x| x == 'Dog'}
=> "Dog"
!['Cat', 'Dog', 'Bird'].detect { |x| x == 'Dog'}.nil?
=> true

Que tal esse caminho?

['Cat', 'Dog', 'Bird'].index('Dog')

Se você estiver tentando fazer isso em um teste de unidade MiniTest , poderá usar assert_includes. Exemplo:

pets = ['Cat', 'Dog', 'Bird']
assert_includes(pets, 'Dog')      # -> passes
assert_includes(pets, 'Zebra')    # -> fails 

Existe o contrário.

Suponha que a matriz seja [ :edit, :update, :create, :show ], bem, talvez os sete pecados mortais / repousantes .

E brinque com a idéia de puxar uma ação válida de alguma string:

"my brother would like me to update his profile"

Então:

[ :edit, :update, :create, :show ].select{|v| v if "my brother would like me to update his profile".downcase =~ /[,|.| |]#{v.to_s}[,|.| |]/}

Se você deseja retornar o valor não apenas verdadeiro ou falso, use

array.find{|x| x == 'Dog'}

Isso retornará 'Dog' se existir na lista, caso contrário, nulo.

Aqui está mais uma maneira de fazer isso:

arr = ['Cat', 'Dog', 'Bird']
e = 'Dog'

present = arr.size != (arr - [e]).size

array = [ 'Cat', 'Dog', 'Bird' ]
array.include?("Dog")

ele tem muitas maneiras de encontrar um elemento em qualquer matriz, mas a maneira mais simples é 'in?' método.

example:
arr = [1,2,3,4]
number = 1
puts "yes #{number} is present in arr" if number.in? arr

se você não quiser usar, include?pode agrupar o elemento em uma matriz e depois verificar se o elemento agrupado é igual à interseção da matriz e o elemento agrupado. Isso retornará um valor booleano com base na igualdade.

def in_array?(array, item)
    item = [item] unless item.is_a?(Array)
    item == array & item
end

Eu sempre acho interessante executar alguns benchmarks para ver a velocidade relativa das várias maneiras de fazer alguma coisa.

A localização de um elemento da matriz no início, no meio ou no final afetará todas as pesquisas lineares, mas apenas afetará uma pesquisa em um conjunto.

A conversão de uma matriz em um conjunto causará um impacto no tempo de processamento; portanto, crie o conjunto a partir de uma matriz uma vez ou comece com um conjunto desde o início.

Aqui está o código de referência:

# frozen_string_literal: true

require 'fruity'
require 'set'

ARRAY = (1..20_000).to_a
SET = ARRAY.to_set

DIVIDER = '-' * 20

def array_include?(elem)
  ARRAY.include?(elem)
end

def array_member?(elem)
  ARRAY.member?(elem)
end

def array_index(elem)
  ARRAY.index(elem) >= 0
end

def array_find_index(elem)
  ARRAY.find_index(elem) >= 0
end

def array_index_each(elem)
  ARRAY.index { |each| each == elem } >= 0
end

def array_find_index_each(elem)
  ARRAY.find_index { |each| each == elem } >= 0
end

def array_any_each(elem)
  ARRAY.any? { |each| each == elem }
end

def array_find_each(elem)
  ARRAY.find { |each| each == elem } != nil
end

def array_detect_each(elem)
  ARRAY.detect { |each| each == elem } != nil
end

def set_include?(elem)
  SET.include?(elem)
end

def set_member?(elem)
  SET.member?(elem)
end

puts format('Ruby v.%s', RUBY_VERSION)

{
  'First' => ARRAY.first,
  'Middle' => (ARRAY.size / 2).to_i,
  'Last' => ARRAY.last
}.each do |k, element|
  puts DIVIDER, k, DIVIDER

  compare do
    _array_include?        { array_include?(element)        }
    _array_member?         { array_member?(element)         }
    _array_index           { array_index(element)           }
    _array_find_index      { array_find_index(element)      }
    _array_index_each      { array_index_each(element)      }
    _array_find_index_each { array_find_index_each(element) }
    _array_any_each        { array_any_each(element)        }
    _array_find_each       { array_find_each(element)       }
    _array_detect_each     { array_detect_each(element)     }
  end
end

puts '', DIVIDER, 'Sets vs. Array.include?', DIVIDER
{
  'First' => ARRAY.first,
  'Middle' => (ARRAY.size / 2).to_i,
  'Last' => ARRAY.last
}.each do |k, element|
  puts DIVIDER, k, DIVIDER

  compare do
    _array_include? { array_include?(element) }
    _set_include?   { set_include?(element)   }
    _set_member?    { set_member?(element)    }
  end
end

Que, quando executado no meu laptop Mac OS, resulta em:

Ruby v.2.7.0
--------------------
First
--------------------
Running each test 65536 times. Test will take about 5 seconds.
_array_include? is similar to _array_index
_array_index is similar to _array_find_index
_array_find_index is faster than _array_any_each by 2x ± 1.0
_array_any_each is similar to _array_index_each
_array_index_each is similar to _array_find_index_each
_array_find_index_each is faster than _array_member? by 4x ± 1.0
_array_member? is faster than _array_detect_each by 2x ± 1.0
_array_detect_each is similar to _array_find_each
--------------------
Middle
--------------------
Running each test 32 times. Test will take about 2 seconds.
_array_include? is similar to _array_find_index
_array_find_index is similar to _array_index
_array_index is faster than _array_member? by 2x ± 0.1
_array_member? is faster than _array_index_each by 2x ± 0.1
_array_index_each is similar to _array_find_index_each
_array_find_index_each is similar to _array_any_each
_array_any_each is faster than _array_detect_each by 30.000000000000004% ± 10.0%
_array_detect_each is similar to _array_find_each
--------------------
Last
--------------------
Running each test 16 times. Test will take about 2 seconds.
_array_include? is faster than _array_find_index by 10.000000000000009% ± 10.0%
_array_find_index is similar to _array_index
_array_index is faster than _array_member? by 3x ± 0.1
_array_member? is faster than _array_find_index_each by 2x ± 0.1
_array_find_index_each is similar to _array_index_each
_array_index_each is similar to _array_any_each
_array_any_each is faster than _array_detect_each by 30.000000000000004% ± 10.0%
_array_detect_each is similar to _array_find_each

--------------------
Sets vs. Array.include?
--------------------
--------------------
First
--------------------
Running each test 65536 times. Test will take about 1 second.
_array_include? is similar to _set_include?
_set_include? is similar to _set_member?
--------------------
Middle
--------------------
Running each test 65536 times. Test will take about 2 minutes.
_set_member? is similar to _set_include?
_set_include? is faster than _array_include? by 1400x ± 1000.0
--------------------
Last
--------------------
Running each test 65536 times. Test will take about 4 minutes.
_set_member? is similar to _set_include?
_set_include? is faster than _array_include? by 3000x ± 1000.0

Basicamente, os resultados me dizem para usar um conjunto para tudo, se vou procurar inclusão, a menos que eu possa garantir que o primeiro elemento seja o que eu quero, o que não é muito provável. Há alguma sobrecarga ao inserir elementos em um hash, mas os tempos de pesquisa são muito mais rápidos que acho que isso nunca deve ser considerado. Novamente, se você precisar procurá-lo, não use uma matriz, use um conjunto. (Ou um Hash.)

Quanto menor o Array, mais rápido os métodos Array serão executados, mas eles ainda não acompanharão, embora em pequenos arrays a diferença possa ser pequena.

"Primeiro", "Middle" e "Last" refletem o uso de first, size / 2e lastpara ARRAYpara o elemento que está sendo procurado. Esse elemento será usado ao pesquisar o ARRAYe SETvariáveis.

Pequenas alterações foram feitas nos métodos comparados > 0porque o teste deveria ser >= 0para indextestes de tipo.

Mais informações sobre o Fruity e sua metodologia estão disponíveis no README .