Проверьте, существует ли значение в массиве в Ruby
у меня есть значение 'Dog' и массив ['Cat', 'Dog', 'Bird'].
Как проверить, существует ли он в массиве без цикла через него? Есть ли простой способ проверить, существует ли значение, не более того?
22 ответов
вы ищете include?:
>> ['Cat', 'Dog', 'Bird'].include? 'Dog'
=> true
есть in? метод на ActiveSupport (часть рельсов) с v3.1, Как указал @campaterson. Так внутри рельсов, или если вы require 'active_support', вы можете написать:
'Unicorn'.in?(['Cat', 'Dog', 'Bird']) # => false
OTOH, нет in оператора или #in? метод в самом Ruby, хотя он был предложен ранее,в частности Юсуке Эндо член высшего класса ruby-core.
как указывали другие, обратный метод include? существует для всех Enumerables включая Array, Hash, Set, Range:
['Cat', 'Dog', 'Bird'].include?('Unicorn') # => false
обратите внимание, что если у вас много значений в массиве, все они будут проверены один за другим (т. е. O(n)), в то время как этот поиск хэша будет постоянным (i.e O(1)). Поэтому, если массив является постоянным, например, рекомендуется использовать Set вместо. Например:
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
A быстрый тест показывает, что вызов include? на a 10 элемент Set примерно на 3.5 x быстрее, чем вызов его на эквиваленте Array (если элемент не найден).
заключительное Примечание: будьте осторожны при использовании include? на Range, есть тонкости, поэтому обратитесь к док и сравниваем с cover?...
использовать Enumerable#include:
a = %w/Cat Dog Bird/
a.include? 'Dog'
или, если выполняется ряд тестов,1 вы можете избавиться от петли (что даже include? имеет) и идти от O (n) to O (1) С:
h = Hash[[a, a].transpose]
h['Dog']
1. Я надеюсь, что это очевидно, но чтобы предотвратить возражения: да, всего за несколько просмотров хэш[] и транспонирование ops доминируют в профиле и являются каждым O (n) сами.
Если вы хотите проверить блок, вы можете попробовать любой? или все?.
%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
подробности здесь:http://ruby-doc.org/core-1.9.3/Enumerable.html
Мое вдохновение приходит отсюда:https://stackoverflow.com/a/10342734/576497
несколько ответов предлагают 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;
}
способ проверить присутствие слова без цикла заключается в построении бор для вашего выбора. Существует много реализаций trie (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
Ruby имеет 11 методов для поиска элементов в массиве.
предпочтительная 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
все они возвращаются trueish значение, если элемент присутствует.
include? является предпочтительным методом. Он использует C-язык 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) время доступа за счет создания хэш-массива первого. Если вы неоднократно проверяете членство в одном массиве, эта начальная инвестиция может быстро окупиться. 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 класса.
я не буду обсуждать другие 7 методов, поскольку все они менее эффективны.
на самом деле есть еще больше методов с O(n) сложности за 11 перечисленных выше, но я решил не перечислять их после сканирования весь массив, а не ломается при первом же матче.
не
# bad examples
array.grep(element).any?
array.select { |each| each == element }.size > 0
...
если вы не хотите цикл, нет никакого способа сделать это с массивами. Вы должны использовать набор вместо этого.
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
наборы работают внутри, как хэши, поэтому Ruby не нужно перебирать коллекцию, чтобы найти элементы, так как, как следует из названия, он генерирует хэши ключей и создает карту памяти, чтобы каждая хэш-точка была в определенной точке памяти. Предыдущий пример выполнен с хэшем:
fake_array = {}
100.times{|i| fake_array["foo#{i}"] = 1}
fake_array.has_key?("foo99")
=> true
недостатком является то, что наборы и хэш-ключи могут содержать только уникальные элементы, и если вы добавите много элементов, 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".
есть несколько способов сделать это. Некоторые из них таковы:--2-->
a = [1,2,3,4,5]
2.in? a #=> true
8.in? a #=> false
a.member? 1 #=> true
a.member? 8 #=> false
забавный факт,
можно использовать * чтобы проверить членство массива в case выражения.
case element
when *array
...
else
...
end
обратите внимание * в предложении when это проверяет членство в массиве.
применяется все обычное магическое поведение оператора splat, например, если array на самом деле это не массив, а один элемент, который будет соответствовать этому элементу.
Это позволит узнать не только, что он существует, но и сколько раз он появляется:
a = ['Cat', 'Dog', 'Bird']
a.count("Dog")
#=> 1
для чего это стоит,Ruby docs являются удивительным ресурсом для таких вопросов.
Я бы также принял к сведению длину массива, который вы ищете. The include? метод будет запускать линейный поиск со сложностью O(n), которая может стать довольно уродливой в зависимости от размера массива.
Если вы работаете с большими (по убыванию) массив, я хотел написать алгоритм бинарного поиска который не должен быть слишком трудно и имеет наихудший случай O (log n).
или если вы используете Ruby 2.0, вы можете воспользоваться bsearch.
Если у вас на уме больше значений... вы можете попробовать:
пример: Если кошка и собака существуют в массиве:
(['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')
Примечание: член? и включить? быть одинаковым.
это может сделать работу в одну строку!
есть и другой способ!
предположим, что массив [: edit, :update, :create,: show ] - ну, возможно, весь семь смертных / успокоительных грехов :)
и дальнейшая игрушка с идеей потянуть допустимое действие из некоторой строки-скажем
мой брат хотел бы, чтобы я обновил его профиль
решение
[ :edit, :update, :create, :show ].select{|v| v if "my brother would like me to update his profile".downcase =~ /[,|.| |]#{v.to_s}[,|.| |]/}
Если мы не хотим использовать include? это также работает:
['cat','dog','horse'].select{ |x| x == 'dog' }.any?
Если вам нужно проверить кратные времена для любого ключа, преобразуйте arr to 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
производительность хэш#has_key? и массив#include?
Parameter Hash#has_key? Array#include
Time Complexity O(1) operation O(n) operation
Access Type Accesses Hash[key] if it Iterates through each element
returns any value then of the array till it
true is returned to the finds the value in Array
Hash#has_key? call
call
для проверки одного времени с помощью include? нормально
['Cat', 'Dog', 'Bird'].detect { |x| x == 'Dog'}
=> "Dog"
!['Cat', 'Dog', 'Bird'].detect { |x| x == 'Dog'}.nil?
=> true
Если вы не хотите использовать include? вы можете сначала обернуть элемент в массив, а затем проверить, равен ли обернутый элемент пересечению массива и обернутого элемента. Это возвращает логическое значение, основанное на равенстве.
def in_array?(array, item)
item = [item] unless item.is_a?(Array)
item == array & item
end
вот еще один способ сделать это:
arr = ['Cat', 'Dog', 'Bird']
e = 'Dog'
present = arr.size != (arr - [e]).size