Come verificare se esiste un valore in un array in Ruby

Ho un valore 'Dog'e un array ['Cat', 'Dog', 'Bird'].

Come posso verificare se esiste nell'array senza eseguirne il loop? Esiste un modo semplice per verificare l'esistenza del valore, niente di più?

Stai cercando include?:

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

C'è un in?metodo in ActiveSupport(parte di Rails) dalla v3.1, come sottolineato da @campaterson. Quindi in Rails, o se tu require 'active_support', puoi scrivere:

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

OTOH, non c'è nessun inoperatore o #in?metodo in Ruby stesso, anche se è stato proposto in precedenza, in particolare da Yusuke Endoh un membro di prim'ordine di ruby-core.

Come sottolineato da altri, il metodo inverso include?esiste, per tutti Enumerables compresi Array, Hash, Set, Range:

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

Nota che se hai molti valori nel tuo array, saranno tutti controllati uno dopo l'altro (es. O(n)), Mentre quella ricerca di un hash sarà un tempo costante (es O(1).). Quindi, se l'array è costante, ad esempio, è una buona idea usare un set . Per esempio:

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

Un test rapido rivela che chiamare include?un elemento 10 Setè circa 3,5 volte più veloce di chiamarlo sull'equivalente Array(se l'elemento non viene trovato).

Un'ultima nota di chiusura: fai attenzione quando usi include?su a Range, ci sono delle sottigliezze, quindi fai riferimento al documento e confronta con cover?...

Provare

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

Utilizzare Enumerable#include:

a = %w/Cat Dog Bird/

a.include? 'Dog'

Oppure, se viene eseguito un numero di test, ¹ puoi sbarazzarti del loop (che include?ha anche ) e passare da O (n) a O (1) con:

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

Se si desidera verificare con un blocco, è possibile provare any?o 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  

Vedi Enumerable per ulteriori informazioni.

La mia ispirazione è venuta da " valuta se l'array ha degli elementi in rubino "

Ruby ha undici metodi per trovare elementi in un array.

Il preferito è include?o, per un accesso ripetuto, creare un set e quindi chiamare include?o member?.

Eccone tutti:

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

Restituiscono tutti un truevalore ish se l'elemento è presente.

include?è il metodo preferito. Utilizza forinternamente un ciclo in linguaggio C che si interrompe quando un elemento corrisponde alle rb_equal_opt/rb_equalfunzioni interne . Non può essere molto più efficiente se non si crea un set per controlli di iscrizione ripetuti.

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?non viene ridefinito nella Arrayclasse e utilizza un'implementazione non ottimizzata dal Enumerablemodulo che elenca letteralmente tutti gli elementi:

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;
}

Tradotto in codice Ruby, ciò comporta quanto segue:

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

Entrambi include?e member?hanno una complessità temporale O (n) poiché entrambi cercano nell'array la prima occorrenza del valore atteso.

Possiamo usare un Set per ottenere il tempo di accesso O (1) al costo di dover prima creare una rappresentazione Hash dell'array. Se controlli ripetutamente l'appartenenza sullo stesso array, questo investimento iniziale può ripagare rapidamente. Setnon è implementato in C ma come semplice classe Ruby, comunque il tempo di accesso O (1) del sottostante @hashrende questo utile.

Ecco l'implementazione della 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

Come puoi vedere, la classe Set crea solo @hashun'istanza interna , mappa tutti gli oggetti truee quindi controlla l'appartenenza utilizzando il Hash#include?quale è implementato con il tempo di accesso O (1) nella classe Hash.

Non discuterò degli altri sette metodi poiché sono tutti meno efficienti.

Esistono in realtà ancora più metodi con complessità O (n) oltre gli 11 sopra elencati, ma ho deciso di non elencarli poiché eseguono la scansione dell'intero array anziché interrompere alla prima corrispondenza.

Non usare questi:

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

Diverse risposte suggeriscono Array#include?, ma c'è un avvertimento importante: guardando la fonte, Array#include?si esegue anche il 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;
}

Il modo per testare la presenza della parola senza loop è costruendo un trie per l'array. Ci sono molte implementazioni di trie là fuori (google "ruby trie"). Userò rambling-triein questo esempio:

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 ora siamo pronti a testare la presenza di varie parole nel tuo array senza scorrere su di esso, nel O(log n)tempo, con la stessa semplicità sintattica di Array#include?, usando sublineare Trie#include?:

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

Se non vuoi eseguire il looping, non c'è modo di farlo con gli array. Invece dovresti usare un Set.

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

I set funzionano internamente come gli hash, quindi Ruby non ha bisogno di scorrere la collezione per trovare gli elementi, poiché, come suggerisce il nome, genera hash delle chiavi e crea una mappa di memoria in modo che ogni hash punti a un certo punto della memoria. L'esempio precedente fatto con un hash:

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

Il rovescio della medaglia è che i tasti Set e Hash possono includere solo oggetti unici e se aggiungi molti oggetti, Ruby dovrà ripassare il tutto dopo un certo numero di elementi per costruire una nuova mappa che si adatti a uno spazio chiave più grande. Per ulteriori informazioni, ti consiglio di guardare " MountainWest RubyConf 2014 - Big O in a Hash fatto in casa di Nathan Long ".

Ecco un punto di riferimento:

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 i risultati:

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

Questo è un altro modo per farlo: usa il Array#indexmetodo.

Restituisce l'indice della prima occorrenza dell'elemento nella matrice.

Per esempio:

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

index() può anche prendere un blocco:

Per esempio:

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

Ciò restituisce l'indice della prima parola nella matrice che contiene la lettera 'o'.

Fatto divertente,

È possibile utilizzare *per verificare l'appartenenza all'array in caseespressioni.

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

Notare il piccolo *nella clausola when, questo controlla l'appartenenza alla matrice.

Si applica tutto il solito comportamento magico dell'operatore splat, quindi ad esempio se in arrayrealtà non è un array ma un singolo elemento corrisponderà a quell'elemento.

Esistono diversi modi per ottenere questo risultato. Alcuni di questi sono i seguenti:

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

2.in? a  #=> true

8.in? a #=> false

a.member? 1 #=> true

a.member? 8 #=> false

Se devi controllare i tempi multipli per qualsiasi chiave, converti arrin hash, e ora controlla in 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

Performance di Hash # has_key? versus Array # include?

Parametro Hash # has_key? Array # includono

Complessità temporale O (1) operazione O (n) operazione 

Tipo di accesso Accede a Hash [chiave] se scorre attraverso ciascun elemento
                        restituisce qualsiasi valore quindi dell'array fino ad esso
                        true viene restituito a trova il valore in Array
                        Hash # has_key? chiamata
                        chiamata    

Per il controllo del tempo singolo, usare include?va bene

Questo ti dirà non solo che esiste ma anche quante volte appare:

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

Per quello che vale, i documenti di Ruby sono una risorsa straordinaria per questo tipo di domande.

Vorrei anche prendere nota della lunghezza dell'array che stai cercando. Il include?metodo eseguirà una ricerca lineare con complessità O (n) che può diventare piuttosto brutta a seconda delle dimensioni dell'array.

Se stai lavorando con un array di grandi dimensioni (ordinato), prenderei in considerazione la scrittura di un algoritmo di ricerca binaria che non dovrebbe essere troppo difficile e che presenta il caso peggiore di O (log n).

O se stai usando Ruby 2.0, puoi trarne vantaggio bsearch.

Puoi provare:

Esempio: se Cat e Dog esistono nell'array:

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

Invece di:

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

Nota: member?e include?sono uguali.

Questo può fare il lavoro in una riga!

Se non vogliamo usarlo, include?funziona anche:

['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

Che ne dici di questo?

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

Se stai provando a farlo in un test di unità MiniTest , puoi usarlo assert_includes. Esempio:

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

C'è il contrario.

Supponiamo che l'array sia [ :edit, :update, :create, :show ], beh, forse tutti e sette i peccati mortali / riposanti .

E poi gioca con l'idea di tirare un'azione valida da qualche stringa:

"my brother would like me to update his profile"

Poi:

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

Se si desidera restituire il valore non solo vero o falso, utilizzare

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

Questo restituirà 'Cane' se esiste nell'elenco, altrimenti zero.

Ecco un altro modo per farlo:

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

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

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

ha molti modi per trovare un elemento in qualsiasi array ma il modo più semplice è 'in?' metodo.

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

se non si desidera utilizzare, include?è possibile innanzitutto avvolgere l'elemento in una matrice e quindi verificare se l'elemento a capo è uguale all'intersezione della matrice e all'elemento a capo. Ciò restituirà un valore booleano basato sull'uguaglianza.

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

Trovo sempre interessante eseguire alcuni benchmark per vedere la velocità relativa dei vari modi di fare qualcosa.

La ricerca di un elemento array all'inizio, al centro o alla fine influirà su qualsiasi ricerca lineare ma influenzerà a malapena una ricerca rispetto a un set.

La conversione di un array in un set provocherà un colpo nel tempo di elaborazione, quindi crea il set da un array una volta o inizia con un set dall'inizio.

Ecco il codice di riferimento:

# 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

Che, quando eseguito sul mio laptop Mac OS, si traduce in:

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

Fondamentalmente i risultati mi dicono di usare un Set per tutto se cercherò l'inclusione a meno che non possa garantire che il primo elemento sia quello che voglio, il che non è molto probabile. C'è un certo sovraccarico quando si inseriscono elementi in un hash, ma i tempi di ricerca sono molto più veloci che non penso che dovrebbero mai essere presi in considerazione. Ancora una volta, se è necessario cercarlo, non utilizzare un array, utilizzare un set. (O un hash.)

Più piccola è la matrice, più veloci saranno i metodi di matrice, ma non continueranno a tenere il passo, anche se in piccoli array la differenza potrebbe essere minuscola.

"In primo luogo", "Medio" e "Ultimo" riflettono l'uso di first, size / 2e lastper ARRAYper l'essere elemento cercato. Tale elemento verrà utilizzato durante la ricerca delle variabili ARRAYe SET.

Sono state apportate piccole modifiche ai metodi a confronto > 0perché il test dovrebbe essere >= 0per i indextest di tipo.

Ulteriori informazioni su Fruttato e la sua metodologia sono disponibili nel suo README .