So überprüfen Sie, ob in einem Array in Ruby ein Wert vorhanden ist

Ich habe einen Wert 'Dog'und ein Array ['Cat', 'Dog', 'Bird'].

Wie überprüfe ich, ob es im Array vorhanden ist, ohne es zu durchlaufen? Gibt es eine einfache Möglichkeit zu überprüfen, ob der Wert vorhanden ist, nicht mehr?

Sie suchen include?:

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

In (Teil von Rails) gibt es seit Version 3.1 eine in?MethodeActiveSupport , auf die @campaterson hingewiesen hat. Also innerhalb von Rails, oder wenn Sie require 'active_support', können Sie schreiben:

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

OTOH, es gibt keinen inOperator oder keine #in?Methode in Ruby selbst, obwohl dies bereits zuvor vorgeschlagen wurde, insbesondere von Yusuke Endoh, einem erstklassigen Mitglied von Ruby-Core.

Wie von anderen darauf hingewiesen wird, die umgekehrte Methode include?existiert, für alle Enumerables einschließlich Array, Hash, Set, Range:

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

Beachten Sie, dass wenn Sie viele Werte in Ihrem Array haben, diese alle nacheinander überprüft werden (dh O(n)), während die Suche nach einem Hash eine konstante Zeit ist (dh O(1)). Wenn Ihr Array beispielsweise konstant ist, ist es eine gute Idee, stattdessen ein Set zu verwenden. Z.B:

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

Ein schneller Test zeigt, dass das Aufrufen include?eines 10-Elements Setetwa 3,5-mal schneller ist als das Aufrufen des entsprechenden ArrayElements (wenn das Element nicht gefunden wird).

Ein letzter abschließender Hinweis: Seien Sie vorsichtig, wenn Sie include?ein verwenden Range. Es gibt Feinheiten. Lesen Sie daher das Dokument und vergleichen Sie es mit cover?...

Versuchen

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

Verwendung Enumerable#include:

a = %w/Cat Dog Bird/

a.include? 'Dog'

Oder wenn eine Reihe von Tests durchgeführt werden, ^{1 können} Sie die Schleife (die es sogar include?hat) loswerden und von O (n) nach O (1) gehen mit:

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

Wenn Sie durch einen Block überprüfen möchten, können Sie versuchen any?oder 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  

Weitere Informationen finden Sie unter Aufzählbar .

Meine Inspiration kam von " bewerten, ob Array irgendwelche Elemente in Rubin hat "

Ruby verfügt über elf Methoden, um Elemente in einem Array zu finden.

Das bevorzugte ist include?oder für wiederholten Zugriff ein Set erstellen und dann include?oder aufrufen member?.

Hier sind alle:

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

Sie alle geben einen trueish-Wert zurück, wenn das Element vorhanden ist.

include?ist die bevorzugte Methode. Es wird forintern eine C-Sprachschleife verwendet , die unterbrochen wird, wenn ein Element mit den internen rb_equal_opt/rb_equalFunktionen übereinstimmt . Es kann nicht viel effizienter werden, wenn Sie kein Set für wiederholte Mitgliedschaftsprüfungen erstellen.

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?wird in der ArrayKlasse nicht neu definiert und verwendet eine nicht optimierte Implementierung aus dem EnumerableModul, die buchstäblich alle Elemente auflistet :

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

Übersetzt in Ruby-Code bewirkt dies Folgendes:

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

Beide include?undmember? haben eine zeitliche Komplexität von O (n), da beide das Array nach dem ersten Auftreten des erwarteten Werts durchsuchen.

Wir können ein Set verwenden, um die O (1) -Zugriffszeit zu erhalten, wenn zuerst eine Hash-Darstellung des Arrays erstellt werden muss. Wenn Sie wiederholt die Mitgliedschaft in demselben Array überprüfen, kann sich diese anfängliche Investition schnell auszahlen. Setist nicht in C implementiert, sondern als einfache Ruby-Klasse immer noch die O (1) -Zugriffszeit des Basiswerts@hash lohnt sich .

Hier ist die Implementierung der Set-Klasse:

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

Wie Sie sehen, erstellt die Set-Klasse nur eine interne @hashInstanz, ordnet alle Objekte zu trueund überprüft dann die Mitgliedschaft mitHash#include? der die O (1) -Zugriffszeit in der Hash-Klasse implementiert wird.

Ich werde die anderen sieben Methoden nicht diskutieren, da sie alle weniger effizient sind.

Es gibt sogar noch mehr Methoden mit O (n) -Komplexität, die über die oben aufgeführten 11 hinausgehen, aber ich habe beschlossen, sie nicht aufzulisten, da sie das gesamte Array scannen, anstatt beim ersten Match zu brechen.

Verwenden Sie diese nicht:

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

Mehrere Antworten deuten darauf hin Array#include?, aber es gibt eine wichtige Einschränkung: Wenn Sie sich die Quelle ansehen, wird sogar Array#include?eine Schleife ausgeführt:

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

Sie können die Wortpräsenz ohne Schleifen testen, indem Sie einen Versuch für Ihr Array erstellen. Es gibt viele Trie-Implementierungen (Google "Ruby Trie"). Ich werde rambling-triein diesem Beispiel verwenden:

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 }

Und jetzt sind wir bereit, das Vorhandensein verschiedener Wörter in Ihrem Array zu testen, ohne es O(log n)rechtzeitig mit derselben syntaktischen Einfachheit wie Array#include?mit sublinear zu durchlaufen Trie#include?:

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

Wenn Sie keine Schleife ausführen möchten, gibt es keine Möglichkeit, dies mit Arrays zu tun. Sie sollten stattdessen ein Set verwenden.

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

Sets funktionieren intern wie Hashes, sodass Ruby die Sammlung nicht durchlaufen muss, um Elemente zu finden, da, wie der Name schon sagt, Hashes der Schlüssel generiert und eine Speicherzuordnung erstellt wird, sodass jeder Hash auf einen bestimmten Punkt im Speicher verweist. Das vorherige Beispiel mit einem Hash:

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

Der Nachteil ist, dass Sets und Hash-Schlüssel nur eindeutige Elemente enthalten können. Wenn Sie viele Elemente hinzufügen, muss Ruby das Ganze nach einer bestimmten Anzahl von Elementen erneut aufbereiten, um eine neue Karte zu erstellen, die für einen größeren Schlüsselbereich geeignet ist. Um mehr darüber zu erfahren , empfehle ich Ihnen, " MountainWest RubyConf 2014 - Big O in einem hausgemachten Hash von Nathan Long " anzusehen .

Hier ist ein Benchmark:

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

Und die Ergebnisse:

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

Dies ist eine andere Möglichkeit, dies zu tun: Verwenden Sie die Array#indexMethode.

Es gibt den Index des ersten Auftretens des Elements im Array zurück.

Zum Beispiel:

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

index() kann auch einen Block nehmen:

Zum Beispiel:

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

Dies gibt den Index des ersten Wortes im Array zurück, das den Buchstaben 'o' enthält.

Lustige Tatsache,

Sie können *damit die Array-Mitgliedschaft in caseAusdrücken überprüfen .

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

Beachten Sie das kleine Element *in der when-Klausel, das die Mitgliedschaft im Array überprüft.

Es gilt das übliche magische Verhalten des Splat-Operators. Wenn arrayes sich also nicht um ein Array, sondern um ein einzelnes Element handelt, stimmt es mit diesem Element überein.

Es gibt mehrere Möglichkeiten, dies zu erreichen. Einige davon sind wie folgt:

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

2.in? a  #=> true

8.in? a #=> false

a.member? 1 #=> true

a.member? 8 #=> false

Wenn Sie mehrmals nach einem Schlüssel suchen müssen, konvertieren Sie arrin hashund checken Sie jetzt O (1) ein.

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

Leistung von Hash # has_key? versus Array # include?

Parameter Hash # has_key? Array # include

Zeitkomplexität O (1) -Operation O (n) -Operation 

Zugriffstyp Zugriff auf Hash [Schlüssel], wenn er durch jedes Element iteriert
                        Gibt dann einen beliebigen Wert des Arrays zurück
                        true wird zurückgegeben, um den Wert in Array zu finden
                        Hash # has_key? Anruf
                        Anruf    

Für die einmalige Überprüfung ist die Verwendung include?in Ordnung

Dies zeigt Ihnen nicht nur, dass es existiert, sondern auch, wie oft es erscheint:

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

Für das, was es wert ist, sind die Ruby-Dokumente eine erstaunliche Ressource für diese Art von Fragen.

Ich würde auch die Länge des Arrays zur Kenntnis nehmen, das Sie durchsuchen. Die include?Methode führt eine lineare Suche mit O (n) -Komplexität durch, die je nach Größe des Arrays ziemlich hässlich werden kann.

Wenn Sie mit einem großen (sortierten) Array arbeiten, würde ich in Betracht ziehen, einen binären Suchalgorithmus zu schreiben, der nicht zu schwierig sein sollte und den schlimmsten Fall von O (log n) aufweist.

Oder wenn Sie Ruby 2.0 verwenden, können Sie davon profitieren bsearch.

Du kannst es versuchen:

Beispiel: Wenn Katze und Hund im Array vorhanden sind:

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

Anstatt:

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

Hinweis: member?und include?sind gleich.

Dies kann die Arbeit in einer Zeile erledigen!

Wenn wir dies nicht verwenden möchten, include?funktioniert dies auch:

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

Wie wäre es auf diese Weise?

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

Wenn Sie dies in einem MiniTest-Komponententest versuchen , können Sie verwenden assert_includes. Beispiel:

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

Es gibt den umgekehrten Weg.

Angenommen, das Array besteht aus [ :edit, :update, :create, :show ]den gesamten sieben tödlichen / erholsamen Sünden .

Und weiter mit der Idee , eine gültige Aktion aus einer Schnur zu ziehen:

"my brother would like me to update his profile"

Dann:

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

Wenn Sie den Wert nicht nur wahr oder falsch zurückgeben möchten, verwenden Sie

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

Dies gibt 'Hund' zurück, wenn es in der Liste vorhanden ist, andernfalls null.

Hier ist noch eine Möglichkeit, dies zu tun:

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

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

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

Es gibt viele Möglichkeiten, ein Element in einem Array zu finden, aber der einfachste Weg ist 'in?' Methode.

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

Wenn Sie nicht verwenden möchten, können include?Sie das Element zuerst in ein Array einschließen und dann prüfen, ob das umschlossene Element dem Schnittpunkt des Arrays und des umschlossenen Elements entspricht. Dies gibt einen booleschen Wert zurück, der auf Gleichheit basiert.

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

Ich finde es immer interessant, einige Benchmarks durchzuführen, um die relative Geschwindigkeit der verschiedenen Arten zu sehen, etwas zu tun.

Das Suchen eines Array-Elements am Anfang, in der Mitte oder am Ende wirkt sich auf alle linearen Suchvorgänge aus, wirkt sich jedoch kaum auf die Suche nach einem Set aus.

Das Konvertieren eines Arrays in ein Set führt zu einer Beeinträchtigung der Verarbeitungszeit. Erstellen Sie das Set also einmal aus einem Array oder beginnen Sie von Anfang an mit einem Set.

Hier ist der Benchmark-Code:

# 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

Wenn Sie es auf meinem Mac OS-Laptop ausführen, erhalten Sie Folgendes:

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

Grundsätzlich sagen mir die Ergebnisse, dass ich für alles ein Set verwenden soll, wenn ich nach Inklusion suchen möchte, es sei denn, ich kann garantieren, dass das erste Element das gewünschte ist, was nicht sehr wahrscheinlich ist. Das Einfügen von Elementen in einen Hash ist mit einem gewissen Aufwand verbunden, aber die Suchzeiten sind so viel schneller, dass ich nicht denke, dass dies jemals in Betracht gezogen werden sollte. Wenn Sie danach suchen müssen, verwenden Sie kein Array, sondern ein Set. (Oder ein Hash.)

Je kleiner das Array ist, desto schneller werden die Array-Methoden ausgeführt, aber sie werden immer noch nicht mithalten können, obwohl in kleinen Arrays der Unterschied möglicherweise gering ist.

„First“, „Mitte“ und „Last“ spiegeln die Verwendung von first, size / 2und lastfür ARRAYfür das Sein Element gesucht. Dieses Element wird beim Suchen der Variablen ARRAYund verwendet SET.

Für die Methoden, mit denen verglichen wurde, wurden geringfügige Änderungen vorgenommen, > 0da der Test >= 0für indexTypprüfungen durchgeführt werden sollte.

Weitere Informationen zu Fruity und seiner Methodik finden Sie in der README-Datei .