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

Du suchst ?:

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

InformationsquelleAutor der Antwort Brian Campbell

Versuchen

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

InformationsquelleAutor der Antwort schmitzelburger

Wenn Sie prüfen wollen, durch einen block, könnten Sie versuchen, jede? oder alle?.

%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  

Details sind hier: http://ruby-doc.org/core-1.9.3/Enumerable.html

Meine inspiration kommt von hier: https://stackoverflow.com/a/10342734/576497

InformationsquelleAutor der Antwort Van

Ruby hat 11 Methoden zum finden von Elementen in einem array.

Bevorzugt ist include?

Oder für den wiederholten Zugriff, das erstellen einer Reihe und rufen dann include? oder member?

Hier sind Sie 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

Alle von Ihnen kehren ein trueish Wert, wenn das element vorhanden ist.

include? ist die bevorzugte Methode. Es verwendet eine C-Sprache for loop intern, die bricht, wenn ein element entspricht der internen rb_equal_opt/rb_equal Funktionen. Ist es nicht viel effizienter, es sei denn, Sie erstellen Sie eine Gruppe für die wiederholte Mitgliedschaft überprüft.

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 nicht neu definiert, in Array Klasse und verwendet eine nicht optimierte Umsetzung von Enumerable Modul, das buchstäblich Durchlaufen aller Elemente.

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, um Ruby-code, dieser sieht über die folgenden

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? und member? haben O(n) Zeit, Komplexität, da die beiden Suche im array nach dem ersten auftreten des erwarteten Wertes.

Können wir ein set zu bekommen O(1) Zugriffszeit auf die Kosten haben, erstellen Sie eine hash-Repräsentation des Arrays zuerst. Wenn Sie wiederholt zu prüfen, die Mitgliedschaft auf den gleichen array, diese anfängliche Investitionen zahlen sich schnell aus. Set ist nicht implementiert in C, aber als nur-Ruby-Klasse, noch die O(1) Zugriffszeit der zugrunde liegenden @hash macht diese lohnt.

Hier ist die Umsetzung 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 können die Set Klasse erzeugt nur eine interne @hash Instanz, Karten, alle Objekte true und prüft dann die Mitgliedschaft mit Hash#include? umgesetzt wird mit O(1) Zugriffszeit in Hash Klasse.

Werde ich nicht diskutieren, die anderen 7 Methoden, wie Sie sind weniger effizient.

Gibt es eigentlich noch mehr Methoden mit O(n) Komplexität über die 11 oben aufgeführten, aber ich beschloss, nicht die Liste, da Sie Scannen das gesamte array anstatt zu brechen bei dem ersten Spiel.

Nicht, verwenden Sie diese,

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

InformationsquelleAutor der Antwort akuhn

Dies ist ein weiterer Weg, dies zu tun: verwenden Sie die Array#index-Methode.

Es gibt den index des ersten Auftretens des Elements in dem array.

Beispiel:

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

index() kann auch ein block

beispielsweise

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

hier, gib den index des ersten Wortes in dem array, das mit den Buchstaben 'o'.

InformationsquelleAutor der Antwort Zack Xu

Spaß Tatsache,

Können Sie * zu überprüfen, array-Mitgliedschaft in einem case Ausdrücken.

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

Beachten Sie die etwas * in der when-Klausel, diese Prüfungen für die Mitgliedschaft in der array.

Alle üblichen magic Verhalten der splat-operator gilt, so zum Beispiel, wenn array ist nicht wirklich ein array, aber ein einzelnes element es entspricht dem element.

InformationsquelleAutor der Antwort akuhn

Für was es Wert ist, Die Ruby-docs sind eine erstaunliche Ressource, die für diese Art von Fragen.

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

Wenn Sie arbeiten mit einer großen (sortierte) array, ich würde schreiben ein binäre Suche Algorithmus das sollte nicht allzu schwierig sein, und hat eine worst-case von O(log n).

Oder wenn Sie mit Ruby 2.0 ist, können Sie die Vorteile bsearch.

InformationsquelleAutor der Antwort davissp14

Gibt es das auch Umgekehrt!

Angenommen, der array [ :edit, :update, :create, :show ] - gut, vielleicht die gesamte seven deadly/restful Sünden 🙂

Sowie weitere Spielzeug mit der Idee der ziehen eine gültige Aktion von einigen string - sagen

mein Bruder möchte mir zu aktualisieren sein Profil

Lösung

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

InformationsquelleAutor der Antwort walt_die

Konvertieren arr zu hashüberprüfen Sie nun in O(1) - multiples mal für jede Taste : hash = arr.map {|x| [x,true]}.to_h

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 Hash#has_key? versus Array#include?

Parameter Hash#has_key? Array#include 

Zeit Komplexität O(1) - operation O(n) operation 

Access Zugreift, Hash[key] wenn es Durchläuft jedes element 
gibt jeden Wert des Arrays, bis es 
true wird zurückgegeben, der feststellt, dass der Wert im Array 
Hash#has_key? rufen 
rufen 

InformationsquelleAutor der Antwort aqfaridi

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

InformationsquelleAutor der Antwort Rahul Patel

wenn Sie nicht möchten, zu verwenden sind? Sie können zuerst wickeln Sie das element in ein array und überprüfen Sie, ob das umwickelte element ist gleich dem Schnittpunkt von array und element gewickelt. Dies wird geben einen booleschen Wert zurück, basierend auf Gleichheit.

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

InformationsquelleAutor der Antwort mgidea

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

InformationsquelleAutor der Antwort Matthew Maurice