Cara memeriksa apakah ada nilai dalam array di Ruby

Saya memiliki nilai 'Dog'dan array ['Cat', 'Dog', 'Bird'].

Bagaimana cara memeriksa apakah ada dalam array tanpa mengulanginya? Apakah ada cara sederhana untuk memeriksa apakah nilainya ada, tidak lebih?

Anda sedang mencari include?:

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

Ada in?metode di ActiveSupport(bagian dari Rails) sejak v3.1, seperti yang ditunjukkan oleh @campaterson. Jadi di dalam Rails, atau jika Anda require 'active_support', Anda dapat menulis:

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

OTOH, tidak ada inoperator atau #in?metode dalam Ruby itu sendiri, meskipun telah diusulkan sebelumnya, khususnya oleh Yusuke Endoh seorang anggota terkemuka ruby-core.

Seperti yang ditunjukkan oleh orang lain, metode terbalik include?ada, untuk semua Enumerables termasuk Array, Hash, Set, Range:

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

Perhatikan bahwa jika Anda memiliki banyak nilai dalam array Anda, mereka semua akan diperiksa satu demi satu (yaitu O(n)), sedangkan pencarian untuk hash akan menjadi waktu yang konstan (yaitu O(1)). Jadi, jika array Anda konstan, misalnya, lebih baik menggunakan Set sebagai gantinya. Misalnya:

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

Sebuah tes cepat menunjukkan bahwa menelepon include?pada elemen 10 Setadalah sekitar 3.5x lebih cepat daripada menelepon pada setara Array(jika unsur ini tidak ditemukan).

Catatan penutup terakhir: berhati-hatilah saat menggunakan include?pada Range, ada kehalusan, jadi rujuk ke dokumen dan bandingkan dengan cover?...

Mencoba

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

Gunakan Enumerable#include:

a = %w/Cat Dog Bird/

a.include? 'Dog'

Atau, jika sejumlah tes dilakukan, ¹ Anda dapat menyingkirkan loop (yang bahkan include?telah) dan beralih dari O (n) ke O (1) dengan:

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

Jika Anda ingin memeriksa dengan blok, Anda dapat mencoba any?atau 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  

Lihat Enumerable untuk informasi lebih lanjut.

Inspirasi saya berasal dari " mengevaluasi apakah array memiliki item dalam ruby "

Ruby memiliki sebelas metode untuk menemukan elemen dalam array.

Yang disukai adalah include?atau, untuk akses berulang, membuat Set dan kemudian memanggil include?atau member?.

Inilah semuanya:

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

Mereka semua mengembalikan truenilai ish jika elemen ada.

include?adalah metode yang disukai. Ini menggunakan forloop bahasa-C secara internal yang rusak ketika elemen cocok dengan rb_equal_opt/rb_equalfungsi internal . Itu tidak bisa menjadi jauh lebih efisien kecuali Anda membuat Set untuk cek keanggotaan berulang.

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?tidak didefinisikan ulang di Arraykelas dan menggunakan implementasi yang tidak dioptimalkan dari Enumerablemodul yang secara harfiah menyebutkan semua elemen:

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

Diterjemahkan ke kode Ruby hal ini tentang hal berikut:

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

Keduanya include?dan member?memiliki kompleksitas waktu O (n) karena keduanya mencari array untuk kemunculan pertama dari nilai yang diharapkan.

Kita dapat menggunakan Set untuk mendapatkan O (1) waktu akses dengan biaya harus membuat representasi Hash dari array terlebih dahulu. Jika Anda berulang kali memeriksa keanggotaan pada larik yang sama, investasi awal ini dapat melunasi dengan cepat. Settidak diimplementasikan dalam C tetapi sebagai kelas Ruby biasa, masih waktu akses O (1) yang mendasarinya @hashmembuat ini berharga.

Berikut ini adalah implementasi dari kelas 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

Seperti yang Anda lihat kelas Set hanya membuat @hashinstance internal , memetakan semua objek ke truedan kemudian memeriksa keanggotaan menggunakan Hash#include?yang diimplementasikan dengan O (1) waktu akses di kelas Hash.

Saya tidak akan membahas tujuh metode lainnya karena semuanya kurang efisien.

Sebenarnya ada lebih banyak metode dengan kompleksitas O (n) di luar 11 yang tercantum di atas, tetapi saya memutuskan untuk tidak mencantumkannya karena mereka memindai seluruh array daripada merusak pada pertandingan pertama.

Jangan gunakan ini:

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

Beberapa jawaban menyarankan Array#include?, tetapi ada satu peringatan penting: Melihat sumbernya, bahkan Array#include?melakukan perulangan:

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

Cara untuk menguji keberadaan kata tanpa perulangan adalah dengan membuat trie untuk array Anda. Ada banyak implementasi trie di luar sana (google "ruby trie"). Saya akan gunakan rambling-triedalam contoh ini:

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 }

Dan sekarang kami siap untuk menguji keberadaan berbagai kata dalam array Anda tanpa mengulanginya, pada O(log n)waktunya, dengan kesederhanaan sintaksis yang sama seperti Array#include?, menggunakan sublinear Trie#include?:

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

Jika Anda tidak ingin mengulang, tidak ada cara untuk melakukannya dengan Array. Anda harus menggunakan Set sebagai gantinya.

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

Set berfungsi secara internal seperti Hash, sehingga Ruby tidak perlu mengulang-ulang koleksi untuk menemukan item, karena seperti namanya, ia menghasilkan hash tombol dan membuat peta memori sehingga setiap hash menunjuk ke titik tertentu dalam memori. Contoh sebelumnya dilakukan dengan Hash:

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

Kelemahannya adalah set dan kunci hash hanya dapat menyertakan item unik dan jika Anda menambahkan banyak item, Ruby harus mengulang semuanya setelah sejumlah item tertentu untuk membangun peta baru yang sesuai dengan ruang tombol yang lebih besar. Untuk lebih lanjut tentang ini, saya sarankan Anda menonton " MountainWest RubyConf 2014 - Big O in a Homemade Hash oleh Nathan Long ".

Inilah patokan:

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

Dan hasilnya:

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

Ini adalah cara lain untuk melakukan ini: gunakan Array#indexmetode ini.

Ini mengembalikan indeks kemunculan pertama elemen dalam array.

Sebagai contoh:

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

index() juga dapat mengambil blok:

Sebagai contoh:

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

Ini mengembalikan indeks kata pertama dalam array yang berisi huruf 'o'.

Fakta yang menyenangkan,

Anda dapat menggunakan *untuk memeriksa keanggotaan array dalam caseekspresi.

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

Perhatikan sedikit *dalam klausa when, ini memeriksa keanggotaan dalam array.

Semua perilaku sulap biasa dari operator percikan berlaku, jadi misalnya jika arraysebenarnya bukan array tetapi satu elemen akan cocok dengan elemen itu.

Ada banyak cara untuk mencapai ini. Beberapa di antaranya adalah sebagai berikut:

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

2.in? a  #=> true

8.in? a #=> false

a.member? 1 #=> true

a.member? 8 #=> false

Jika Anda perlu memeriksa beberapa kali untuk kunci apa saja, konversikan arrke hash, dan sekarang periksa di 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

Kinerja Hash # has_key? versus Array # include?

Parameter Hash # has_key? Array # termasuk

Kompleksitas Waktu O (1) operasi O (n) operasi 

Jenis Akses Mengakses Hash [kunci] jika iterasi melalui setiap elemen
                        mengembalikan nilai apa pun dari array hingga itu
                        true dikembalikan ke menemukan nilai dalam Array
                        Hash # has_key? panggilan
                        panggilan    

Untuk sekali pakai cek include?baik-baik saja

Ini akan memberi tahu Anda tidak hanya bahwa itu ada tetapi juga berapa kali muncul:

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

Untuk apa nilainya, The Ruby docs adalah sumber yang luar biasa untuk pertanyaan-pertanyaan semacam ini.

Saya juga akan mencatat panjang array yang Anda cari. The include?Metode akan menjalankan pencarian linear dengan O (n) kompleksitas yang bisa mendapatkan cukup jelek tergantung pada ukuran array.

Jika Anda bekerja dengan array besar (diurutkan), saya akan mempertimbangkan untuk menulis algoritma pencarian biner yang seharusnya tidak terlalu sulit dan memiliki kasus terburuk O (log n).

Atau jika Anda menggunakan Ruby 2.0, Anda dapat memanfaatkan bsearch.

Anda dapat mencoba:

Contoh: jika Kucing dan Anjing ada dalam array:

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

Dari pada:

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

Catatan: member?dan include?sama.

Ini dapat melakukan pekerjaan dalam satu baris!

Jika kita ingin tidak menggunakan include?ini juga berfungsi:

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

Bagaimana dengan ini?

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

Jika Anda mencoba melakukan ini dalam tes unit MiniTest , Anda dapat menggunakannya assert_includes. Contoh:

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

Ada cara lain untuk ini.

Misalkan susunannya adalah [ :edit, :update, :create, :show ], yah mungkin keseluruhan tujuh dosa yang mematikan / tenang .

Dan mainan lebih lanjut dengan ide menarik tindakan yang valid dari beberapa string:

"my brother would like me to update his profile"

Kemudian:

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

Jika Anda ingin mengembalikan nilai bukan hanya benar atau salah, gunakan

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

Ini akan mengembalikan 'Anjing' jika ada dalam daftar, jika tidak nihil.

Berikut ini satu cara lagi untuk melakukan ini:

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

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

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

ia memiliki banyak cara untuk menemukan elemen dalam array apa pun tetapi cara paling sederhana adalah 'di?' metode.

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

jika Anda tidak ingin menggunakan, include?Anda pertama-tama dapat membungkus elemen dalam array dan kemudian memeriksa apakah elemen yang dibungkus sama dengan persimpangan array dan elemen yang dibungkus. Ini akan mengembalikan nilai boolean berdasarkan kesetaraan.

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

Saya selalu merasa tertarik untuk menjalankan beberapa tolok ukur untuk melihat kecepatan relatif dari berbagai cara melakukan sesuatu.

Menemukan elemen array di awal, tengah atau akhir akan memengaruhi pencarian linear apa pun, tetapi hampir tidak memengaruhi pencarian terhadap Set.

Mengkonversi Array ke Set akan menyebabkan hit dalam waktu pemrosesan, jadi buat Set dari Array sekali, atau mulai dengan Set dari awal.

Inilah kode patokan:

# 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

Yang mana, ketika dijalankan di laptop Mac OS saya, menghasilkan:

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

Pada dasarnya hasilnya memberitahu saya untuk menggunakan Set untuk semuanya jika saya akan mencari inklusi kecuali saya dapat menjamin bahwa elemen pertama adalah yang saya inginkan, yang sangat tidak mungkin. Ada beberapa overhead ketika memasukkan elemen ke dalam hash, tetapi waktu pencarian jauh lebih cepat, saya tidak berpikir itu harus menjadi pertimbangan. Sekali lagi, jika Anda perlu mencarinya, jangan gunakan Array, gunakan Set. (Atau Hash.)

Semakin kecil Array, semakin cepat metode Array akan berjalan, tetapi mereka masih tidak akan mengikuti, meskipun dalam array kecil perbedaannya mungkin kecil.

"Pertama", "Tengah" dan "Terakhir" mencerminkan penggunaan first, size / 2dan lastuntuk ARRAYuntuk elemen yang dicari. Elemen itu akan digunakan saat mencari ARRAYdan SETvariabel.

Perubahan kecil dibuat untuk metode yang membandingkan > 0karena tes harus >= 0untuk indextes tipe.

Informasi lebih lanjut tentang Fruity dan metodologinya tersedia di README -nya .