Ruby'nin bir dizideki öğeleri bulmak için on bir yöntemi vardır.
Tercih edilen include?veya tekrarlanan erişim için bir Set oluşturup ardından include?veya öğesini çağırır member?.
İşte hepsi:
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
trueÖğe varsa, hepsi bir ish değeri döndürür .
include?tercih edilen yöntemdir. forBir öğe dahili rb_equal_opt/rb_equalişlevlerle eşleştiğinde kırılan dahili olarak bir C dili döngüsü kullanır . Tekrarlanan üyelik kontrolleri için bir Set oluşturmazsanız çok daha verimli olamaz.
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?Arraysınıfta yeniden tanımlanmaz ve Enumerablemodülden tam anlamıyla tüm öğeler arasında numaralandırılan optimize edilmemiş bir uygulama kullanır :
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;
}
Ruby koduna çevrildiğinde bu aşağıdakilerle ilgilidir:
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
Hem include?ve member?yana O (n) zaman karmaşıklığı sahip hem beklenen değerin ilk oluşum için bir dizi arama.
İlk önce dizinin Hash temsilini oluşturmak zorunda kalmadan O (1) erişim süresini elde etmek için bir Set kullanabiliriz. Aynı dizideki üyeliği tekrar tekrar kontrol ederseniz, bu ilk yatırım hızlı bir şekilde ödenebilir. SetC dilinde değil, temel Ruby sınıfı olarak uygulanmış, yine de altta yatan O (1) erişim süresi@hash buna değer.
Set sınıfının uygulanması:
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
Set sınıfının yalnızca dahili bir @hashörnek oluşturduğunu görebileceğiniz gibi, tüm nesneleri eşler ve Hash sınıfında O (1) erişim süresi ile uygulanan trueüyeliği denetler Hash#include?.
Diğer yedi yöntemi daha az verimli oldukları için tartışmayacağım.
Aslında yukarıda listelenen 11'in ötesinde O (n) karmaşıklığına sahip daha fazla yöntem var, ancak ilk maçta kırmak yerine tüm diziyi taradıkları için bunları listelememeye karar verdim.
Bunları kullanmayın:
# bad examples
array.grep(element).any?
array.select { |each| each == element }.size > 0
...