Як перевірити, чи існує значення в масиві в Ruby

У мене є значення 'Dog'і масив ['Cat', 'Dog', 'Bird'].

Як перевірити, чи існує він у масиві, не перебираючи його? Чи існує простий спосіб перевірити, чи існує значення, нічого більше?

Ви шукаєте include?:

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

Існує in?метод у ActiveSupport(частина Rails) починаючи з v3.1, як вказував @campaterson. Тож у Rails, або якщо ви можете require 'active_support', ви можете написати:

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

OTOH, у самому Ruby немає жодного inоператора чи #in?методу, навіть якщо це було запропоновано раніше, зокрема Юсуке Ендох, найвищий член рубінового ядра.

Як вказувалося іншими, зворотний метод include?існує, то для всіх Enumerableх в тому числі Array, Hash, Set, Range:

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

Зауважте, що якщо у вас у масиві багато значень, всі вони перевірятимуться один за одним (тобто O(n)), тоді як пошук цього хешу буде постійним часом (тобто O(1)). Отже, якщо масив є постійним, наприклад, добре використовувати замість цього набір . Наприклад:

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

Швидкий тест показує , що виклик include?на 10 елемента Setстановить близько 3.5x швидше , ніж виклик його еквівалент Array(якщо елемент не знайдене).

Заключна примітка: будьте обережні при використанні include?на a Range, є тонкощі, тому зверніться до документа і порівняйте з cover?...

Спробуйте

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

Використання Enumerable#include:

a = %w/Cat Dog Bird/

a.include? 'Dog'

Або, якщо зроблено ряд тестів, ¹ ви можете позбутися циклу (який навіть include?є) і перейти від O (n) до O (1) за допомогою:

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

Якщо ви хочете перевірити за допомогою блоку, ви можете спробувати any?або 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  

Див перечислимого для отримання додаткової інформації.

Моє натхнення прийшло від " оцінити, чи є в масиві якісь елементи в рубіні "

У Ruby є одинадцять методів пошуку елементів у масиві.

Кращим є include?або, для повторного доступу, створити набір, а потім зателефонувати include?або member?.

Ось усі вони:

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значення ish, якщо елемент присутній.

include?є кращим способом. Він використовує forвнутрішньо цикл мови С, який розривається, коли елемент відповідає внутрішнім rb_equal_opt/rb_equalфункціям. Він не може бути набагато ефективнішим, якщо не створити набір для повторних перевірок членства.

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?не переосмислюється в Arrayкласі та використовує неоптимізовану реалізацію з Enumerableмодуля, яка буквально перераховується через усі елементи:

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 це стосується наступного:

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

Обидва include?і member?мають O (n) часову складність, оскільки обидва шукають масив для першого появи очікуваного значення.

Ми можемо використовувати набір, щоб отримати час доступу O (1) ціною, щоб спочатку створити Hash-представлення масиву. Якщо ви неодноразово перевіряєте членство в одному масиві, ця початкова інвестиція може швидко окупитися. Setне реалізовано в C, але як звичайний клас Ruby, все-таки час доступу O (1) базового @hashробить це вартим.

Ось реалізація класу 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

Як ви бачите, клас Set просто створює внутрішній @hashекземпляр, відображає всі об'єкти trueі потім перевіряє членство, використовуючи, Hash#include?який реалізується з часом доступу O (1) в класі Hash.

Я не буду обговорювати інші сім методів, оскільки всі вони менш ефективні.

Насправді є ще більше методів із складністю O (n) поза 11 перелічених вище, але я вирішив їх не перераховувати, оскільки вони сканують весь масив, а не розбивають у першому матчі.

Не використовуйте такі:

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

Кілька відповідей підказують Array#include?, але є один важливий застереження: дивлячись на джерело, навіть Array#include?виконуються циклічні роботи:

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

Спосіб перевірити наявність слова без циклу - побудувати трійку для свого масиву. Існує багато реалізацій трійки (google "ruby trie"). Я буду використовувати rambling-trieв цьому прикладі:

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 }

І тепер ми готові перевірити наявність різних слів у вашому масиві, не перебираючи його на O(log n)час, з такою ж синтаксичною простотою Array#include?, що і за допомогою підлінійного Trie#include?:

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

Якщо ви не хочете робити цикл, немає ніякого способу зробити це з масивами. Натомість слід використовувати набір.

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

Набори працюють як внутрішні хеші, тому Рубі не потрібно перебирати колекцію для пошуку елементів, оскільки, як випливає з назви, вона генерує хеші ключів і створює карту пам'яті, щоб кожен хеш вказував на певну точку пам'яті. Попередній приклад, зроблений за допомогою хеша:

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

Мінус полягає в тому, що клавіші Sets і Hash можуть включати лише унікальні елементи, і якщо ви додасте багато предметів, Ruby доведеться повторно переробити все після певної кількості елементів, щоб створити нову карту, що відповідає більшому простору клавіш. Детальніше про це я рекомендую переглянути " MountainWest RubyConf 2014 - Big O у домашньому хеші Натана Лонга ".

Ось орієнтир:

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

І результати:

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

Це ще один спосіб зробити це: використовувати Array#indexметод.

Він повертає індекс першого появи елемента в масиві.

Наприклад:

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

index() також може взяти блок:

Наприклад:

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

Це повертає індекс першого слова в масиві, який містить літеру 'o'.

Смішний факт,

Ви можете використовувати *для перевірки належності масиву у caseвиразах.

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

Зауважте, що *в пункті "коли" це не перевіряється на наявність членства в масиві.

Застосовується вся звичайна магічна поведінка оператора splat, тому, наприклад, якщо arrayце насправді не масив, а окремий елемент, він відповідатиме цьому елементу.

Існує кілька способів цього досягти. Кілька з них такі:

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

2.in? a  #=> true

8.in? a #=> false

a.member? 1 #=> true

a.member? 8 #=> false

Якщо вам потрібно перевірити кратні рази на наявність будь-якого ключа, перетворіть arrйого hash, а тепер перевірте 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

Продуктивність Hash # has_key? проти масиву # включати?

Параметр Hash # has_key? Масив # включати

Складність часу O (1) операція O (n) операція 

Тип доступу Доступ до хеш [клавіші], якщо він взаємодіє через кожен елемент
                        повертає будь-яке значення тоді масиву до нього
                        true повертається знаходкам значення в масиві
                        Хеш # has_key? дзвінок
                        дзвінок    

Для одноразової перевірки використання include?нормально

Це скаже вам не тільки про те, що воно існує, але і скільки разів воно з'являється:

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

Для чого це варто, документи Ruby - це дивовижний ресурс для таких питань.

Я б також взяв до уваги довжину масиву, який ви шукаєте. include?Метод буде працювати лінійний пошук з O (N) складності , які можуть отримати досить потворні в залежності від розміру масиву.

Якщо ви працюєте з великим (відсортованим) масивом, я б розглядав можливість написання бінарного алгоритму пошуку, який не повинен бути надто складним і має найгірший випадок O (log n).

Або якщо ви використовуєте Ruby 2.0, ви можете скористатися цим bsearch.

Ви можете спробувати:

Приклад: якщо у масиві існують Cat and Dog:

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

Замість:

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

Примітка: member?і include?однакові.

Це може зробити роботу в один рядок!

Якщо ми хочемо не використовувати include?це, також працює:

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

Як щодо цього?

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

Якщо ви намагаєтеся зробити це в тесті MiniTest , ви можете використовувати assert_includes. Приклад:

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

Є навпаки.

Припустимо, масив - це [ :edit, :update, :create, :show ], можливо, цілих сім смертельних / спокійних гріхів .

І далі іграшка з ідеєю витягнути дійсну дію з якоїсь струни:

"my brother would like me to update his profile"

Тоді:

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

Якщо ви хочете повернути значення не просто істинним чи хибним, використовуйте

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

Це поверне 'Собака', якщо воно є в списку, інакше буде нульовим.

Ось ще один спосіб зробити це:

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

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

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

у нього є багато способів знайти елемент у будь-якому масиві, але найпростіший спосіб - "in?" метод.

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

якщо ви не хочете використовувати, include?ви можете спочатку обернути елемент у масив, а потім перевірити, чи дорівнює обернутий елемент перетину масиву та загорнутого елемента. Це поверне булеве значення, засноване на рівності.

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

Мені завжди цікаво запустити деякі орієнтири, щоб побачити відносну швидкість різних способів щось робити.

Пошук елемента масиву на початку, середині чи в кінці вплине на будь-який лінійний пошук, але ледь вплине на пошук набору.

Перетворення масиву в набір призведе до звернення в процесі обробки, тому створіть набір з масиву один раз або почніть з набору з самого початку.

Ось базовий код:

# 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

Що при запуску на моєму ноутбуці Mac OS призводить до:

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

В основному результати підказують мені використовувати набір для всього, якщо я збираюся шукати включення, якщо я не можу гарантувати, що першим елементом є той, який я хочу, що не дуже ймовірно. Під час вставки елементів у хеш є деякі накладні витрати, але часи пошуку настільки швидкі, що я не думаю, що це колись слід враховувати. Знову ж таки, якщо вам потрібно здійснити пошук, не використовуйте масив, використовуйте набір. (Або хеш.)

Чим менше масив, тим швидше будуть працювати методи масиву, але вони все ще не збираються йти в ногу, хоча в невеликих масивах різниця може бути невеликою.

«Перший», «Середній» і «Last» відображають використання first, size / 2і lastдля ARRAYдля елемента розшукується. Цей елемент буде використовуватися при пошуку змінних ARRAYта SETзмінних.

Незначні зміни були внесені в порівнянні з методами, > 0оскільки тест повинен бути >= 0для indexтипових тестів.

Більше інформації про Фруктовість та її методологію можна знайти в її читанні .