Cách kiểm tra nếu một giá trị tồn tại trong một mảng trong Ruby

Tôi có một giá trị 'Dog'và một mảng ['Cat', 'Dog', 'Bird'].

Làm thế nào để tôi kiểm tra nếu nó tồn tại trong mảng mà không lặp qua nó? Có một cách đơn giản để kiểm tra nếu giá trị tồn tại, không có gì hơn?

Bạn đang tìm kiếm include?:

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

Có một in?phương thức trong ActiveSupport(một phần của Rails) kể từ phiên bản 3.1, như được chỉ ra bởi @campaterson. Vì vậy, trong Rails, hoặc nếu bạn require 'active_support', bạn có thể viết:

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

OTOH, không có intoán tử hay #in?phương thức nào trong Ruby, mặc dù nó đã được đề xuất trước đó, đặc biệt là Yusuke Endoh, một thành viên xuất sắc hàng đầu của ruby-core.

Như đã chỉ ra bởi những người khác, phương pháp ngược lại include?tồn tại, cho tất cả các Enumerables bao gồm Array, Hash, Set, Range:

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

Lưu ý rằng nếu bạn có nhiều giá trị trong mảng của mình, tất cả chúng sẽ được kiểm tra lần lượt từng cái (nghĩa là O(n)), trong khi việc tìm kiếm băm sẽ là thời gian không đổi (nghĩa là O(1)). Vì vậy, nếu mảng của bạn là hằng số, chẳng hạn, nên sử dụng Set thay thế. Ví dụ:

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

Một thử nghiệm nhanh cho thấy rằng việc gọi include?một phần tử 10 Setnhanh hơn khoảng 3,5 lần so với việc gọi nó trên phần tử tương đương Array(nếu không tìm thấy phần tử này).

Lưu ý cuối cùng: hãy cảnh giác khi sử dụng include?trên a Range, có sự tinh tế, vì vậy hãy tham khảo tài liệu và so sánh với cover?...

Thử

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

Sử dụng Enumerable#include:

a = %w/Cat Dog Bird/

a.include? 'Dog'

Hoặc, nếu một số bài kiểm tra được thực hiện, ¹ bạn có thể thoát khỏi vòng lặp (thậm chí include?có) và đi từ O (n) đến O (1) với:

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

Nếu bạn muốn kiểm tra theo một khối, bạn có thể thử any?hoặc 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  

Xem Vô số để biết thêm thông tin.

Cảm hứng của tôi đến từ " đánh giá xem mảng có bất kỳ vật phẩm nào trong ruby ​​không "

Ruby có mười một phương thức để tìm các phần tử trong một mảng.

Cái ưa thích là include?hoặc, để truy cập nhiều lần, hãy tạo Set và sau đó gọi include?hoặc member?.

Đây là tất cả chúng:

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

Tất cả đều trả về truegiá trị ish nếu phần tử có mặt.

include?là phương pháp ưa thích. Nó sử dụng forvòng lặp ngôn ngữ C bên trong, ngắt khi một phần tử khớp với các rb_equal_opt/rb_equalchức năng bên trong . Nó không thể hiệu quả hơn nhiều trừ khi bạn tạo Set để kiểm tra thành viên nhiều lần.

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?không được định nghĩa lại trong Arraylớp và sử dụng một triển khai không được tối ưu hóa từ Enumerablemô đun mà liệt kê theo nghĩa đen thông qua tất cả các yếu tố:

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

Được dịch sang mã Ruby, điều này thực hiện như sau:

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

Cả hai include?và member?có độ phức tạp thời gian O (n) kể từ khi cả hai tìm kiếm mảng cho lần xuất hiện đầu tiên của giá trị mong đợi.

Chúng ta có thể sử dụng Set để lấy thời gian truy cập O (1) với chi phí phải tạo đại diện Hash của mảng trước. Nếu bạn liên tục kiểm tra tư cách thành viên trên cùng một mảng, khoản đầu tư ban đầu này có thể được thanh toán nhanh chóng. Setkhông được triển khai trong C mà là lớp Ruby đơn giản, vẫn là thời gian truy cập O (1) của cơ sở @hashlàm cho điều này đáng giá.

Dưới đây là việc triển khai lớp 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

Như bạn có thể thấy lớp Set chỉ tạo một thể hiện bên trong @hash, ánh xạ tất cả các đối tượng truevà sau đó kiểm tra tư cách thành viên bằng cách sử dụng Hash#include?thời gian truy cập O (1) trong lớp Hash.

Tôi sẽ không thảo luận về bảy phương pháp khác vì tất cả chúng đều kém hiệu quả.

Thực tế thậm chí còn có nhiều phương thức với độ phức tạp O (n) ngoài 11 được liệt kê ở trên, nhưng tôi quyết định không liệt kê chúng vì chúng quét toàn bộ mảng thay vì phá vỡ ở trận đấu đầu tiên.

Đừng sử dụng những thứ này:

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

Một số câu trả lời gợi ý Array#include?, nhưng có một cảnh báo quan trọng: Nhìn vào nguồn, thậm chí Array#include?không thực hiện lặp:

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

Cách để kiểm tra sự hiện diện từ mà không lặp là bằng cách xây dựng một Trie cho mảng của bạn. Có rất nhiều triển khai trie ngoài kia (google "ruby trie"). Tôi sẽ sử dụng rambling-trietrong ví dụ này:

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 }

Và bây giờ chúng tôi đã sẵn sàng để kiểm tra sự hiện diện của các từ khác nhau trong mảng của bạn mà không lặp lại theo O(log n)thời gian, với sự đơn giản cú pháp giống như Array#include?, sử dụng dòng con Trie#include?:

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

Nếu bạn không muốn lặp, không có cách nào để làm điều đó với Mảng. Bạn nên sử dụng Set thay thế.

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

Các bộ hoạt động bên trong như Băm, vì vậy Ruby không cần phải lặp qua bộ sưu tập để tìm các mục, vì như tên của nó, nó tạo ra các giá trị băm của các phím và tạo một bản đồ bộ nhớ để mỗi điểm băm chỉ đến một điểm nhất định trong bộ nhớ. Ví dụ trước được thực hiện với Hash:

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

Nhược điểm là các khóa Bộ và Hash chỉ có thể bao gồm các vật phẩm duy nhất và nếu bạn thêm nhiều vật phẩm, Ruby sẽ phải thử lại toàn bộ vật phẩm sau một số vật phẩm nhất định để xây dựng bản đồ mới phù hợp với không gian phím lớn hơn. Để biết thêm về điều này, tôi khuyên bạn nên xem " MountainWest RubyConf 2014 - Big O in a Homemade Hash của Nathan Long ".

Đây là một điểm chuẩn:

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

Và kết quả:

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

Đây là một cách khác để làm điều này: sử dụng Array#indexphương pháp.

Nó trả về chỉ mục của lần xuất hiện đầu tiên của phần tử trong mảng.

Ví dụ:

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

index() cũng có thể mất một khối:

Ví dụ:

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

Điều này trả về chỉ mục của từ đầu tiên trong mảng có chứa chữ 'o'.

Sự thật thú vị,

Bạn có thể sử dụng *để kiểm tra thành viên mảng trong một casebiểu thức.

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

Lưu ý một chút *trong mệnh đề khi, điều này kiểm tra tư cách thành viên trong mảng.

Tất cả các hành vi ma thuật thông thường của toán tử splat đều được áp dụng, vì vậy, ví dụ nếu arraykhông thực sự là một mảng mà là một phần tử duy nhất thì nó sẽ khớp với phần tử đó.

Có nhiều cách để thực hiện điều này. Một vài trong số đó là như sau:

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

2.in? a  #=> true

8.in? a #=> false

a.member? 1 #=> true

a.member? 8 #=> false

Nếu bạn cần kiểm tra bội số lần cho bất kỳ khóa nào, hãy chuyển đổi arrthành hashvà bây giờ kiểm tra 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

Hiệu suất của Hash # has_key? so với mảng # bao gồm?

Tham số Hash # has_key? Mảng # bao gồm

Thời gian phức tạp O (1) hoạt động O (n) hoạt động 

Kiểu truy cập Truy cập Hash [key] nếu nó lặp qua từng phần tử
                        trả về bất kỳ giá trị nào sau đó của mảng cho đến khi
                        true được trả về giá trị tìm thấy trong Array
                        Băm # has_key? gọi
                        gọi    

Đối với kiểm tra một lần sử dụng include?là tốt

Điều này sẽ cho bạn biết không chỉ nó tồn tại mà còn bao nhiêu lần nó xuất hiện:

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

Đối với những gì nó có giá trị, tài liệu Ruby là một nguồn tài nguyên tuyệt vời cho những loại câu hỏi này.

Tôi cũng sẽ lưu ý về độ dài của mảng bạn đang tìm kiếm. Các include?phương pháp sẽ chạy một tìm kiếm tuyến tính với O (n) sự phức tạp mà có thể nhận được khá xấu xí tùy thuộc vào kích thước của mảng.

Nếu bạn đang làm việc với một mảng lớn (được sắp xếp), tôi sẽ xem xét việc viết một thuật toán tìm kiếm nhị phân không quá khó và có trường hợp xấu nhất là O (log n).

Hoặc nếu bạn đang sử dụng Ruby 2.0, bạn có thể tận dụng bsearch.

Bạn co thể thử:

Ví dụ: nếu Cat và Dog tồn tại trong mảng:

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

Thay vì:

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

Lưu ý: member?và include?giống nhau.

Điều này có thể làm công việc trong một dòng!

Nếu chúng ta không muốn sử dụng include?thì nó cũng hoạt động:

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

Làm thế nào về cách này?

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

Nếu bạn đang cố gắng thực hiện việc này trong bài kiểm tra đơn vị MiniTest , bạn có thể sử dụng assert_includes. Thí dụ:

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

Có cách khác để giải quyết vấn đề này.

Giả sử mảng đó [ :edit, :update, :create, :show ], có lẽ là toàn bộ bảy tội lỗi chết người / yên tĩnh .

Và hơn nữa đồ chơi với ý tưởng kéo một hành động hợp lệ từ một số chuỗi:

"my brother would like me to update his profile"

Sau đó:

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

Nếu bạn muốn trả về giá trị không chỉ đúng hay sai, hãy sử dụng

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

Điều này sẽ trả về 'Dog' nếu nó tồn tại trong danh sách, nếu không thì không.

Đây là một cách khác để làm điều này:

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

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

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

nó có nhiều cách để tìm một phần tử trong bất kỳ mảng nào nhưng cách đơn giản nhất là 'in?' phương pháp.

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

nếu bạn không muốn sử dụng, include?trước tiên bạn có thể bọc phần tử trong một mảng và sau đó kiểm tra xem phần tử được bao bọc có bằng giao điểm của mảng và phần tử được bao bọc không. Điều này sẽ trả về một giá trị boolean dựa trên sự bình đẳng.

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

Tôi luôn thấy thú vị khi chạy một số điểm chuẩn để thấy tốc độ tương đối của các cách khác nhau để làm một cái gì đó.

Tìm một phần tử mảng ở đầu, giữa hoặc cuối sẽ ảnh hưởng đến bất kỳ tìm kiếm tuyến tính nào nhưng hầu như không ảnh hưởng đến tìm kiếm đối với Tập hợp.

Chuyển đổi một mảng thành một tập hợp sẽ gây ra một cú hích trong thời gian xử lý, vì vậy hãy tạo một tập hợp từ một mảng một lần hoặc bắt đầu với một tập hợp ngay từ đầu.

Đây là mã điểm chuẩn:

# 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

Mà, khi chạy trên máy tính xách tay Mac OS của tôi, kết quả là:

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

Về cơ bản, kết quả bảo tôi sử dụng Set cho mọi thứ nếu tôi sẽ tìm kiếm để đưa vào trừ khi tôi có thể đảm bảo rằng yếu tố đầu tiên là thứ tôi muốn, điều đó không có khả năng. Có một số chi phí khi chèn các phần tử vào hàm băm, nhưng thời gian tìm kiếm nhanh hơn rất nhiều, tôi không nghĩ đó nên là một sự cân nhắc. Một lần nữa, nếu bạn cần tìm kiếm nó, đừng sử dụng Mảng, hãy sử dụng Set. (Hoặc một Hash.)

Mảng càng nhỏ, các phương thức Array sẽ chạy càng nhanh, nhưng chúng vẫn không theo kịp, mặc dù trong các mảng nhỏ, sự khác biệt có thể rất nhỏ.

"Đầu tiên", "Trung" và "Last" phản ánh việc sử dụng first, size / 2và lastcho ARRAYcho các phần tử con người tìm kiếm. Phần tử đó sẽ được sử dụng khi tìm kiếm ARRAYvà SETcác biến.

Những thay đổi nhỏ đã được thực hiện đối với các phương pháp được so sánh với > 0vì thử nghiệm nên >= 0dành cho indexthử nghiệm loại.

Thông tin thêm về Fruity và phương pháp luận của nó có sẵn trong README của nó .