класс Set

Родитель:: Объект
Включенные модули:: Enumerable

Set реализует коллекцию неупорядоченных значений без дубликатов. Это гибрид интуитивных возможностей взаимной работы массивов и быстрых операций поиска словарей.

Set легко использовать с объектами Enumerable (реализующими each). Большинство методов инициализации и бинарных операторов принимают обобщённые объекты Enumerable помимо множеств и массивов. Объект Enumerable может быть преобразован в Set с помощью метода to_set.

Set использует Hash в качестве хранилища, поэтому необходимо учесть следующие моменты:

Равенство элементов определяется в соответствии с Object#eql? и Object#hash. Используйте Set#compare_by_identity, чтобы множество сравнивало элементы по их идентичности.
Set предполагает, что идентичность каждого элемента не меняется во время его хранения. Изменение элемента множества сделает состояние множества ненадежным.
Когда строка должна быть сохранена, вместо неё сохраняется замороженная копия строки, если только исходная строка уже не заморожена.

Сравнение

Операторы сравнения <, >, <= и >= реализованы как сокращения для методов {proper_,}{subset?,superset?}. Однако оператор <=> намеренно опущен, так как не все пары множеств сравнимы (например, {x, y} и {x, z}).

Пример

require 'set'
s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
s1 == s2                              #=> true
s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
s1.subset?(s2)                        #=> false
s2.subset?(s1)                        #=> true

Контакты

- Akinori MUSHA <knu@iDaemons.org> (current maintainer)

Публичные методы класса

[](*ary) Показать исходный код

# File lib/set.rb, line 78
def self.[](*ary)
  new(ary)
end

Создаёт новое множество, содержащее заданные объекты.

Set[1, 2]                   # => #<Set: {1, 2}>
Set[1, 2, 1]                # => #<Set: {1, 2}>
Set[1, 'c', :s]             # => #<Set: {1, "c", :s}>

json_create(object) Показать исходный код

# File ext/json/lib/json/add/set.rb, line 10
def self.json_create(object)
  new object['a']
end

Импортирует маршализованный объект JSON.

Метод используется для поддержки маршализации JSON.

new(enum = nil) { |o| ... } Показать исходный код

# File lib/set.rb, line 93
def initialize(enum = nil, &block) # :yields: o
  @hash ||= Hash.new(false)

  enum.nil? and return

  if block
    do_with_enum(enum) { |o| add(block[o]) }
  else
    merge(enum)
  end
end

Создаёт новое множество, содержащее элементы заданного объекта перечисления.

Если задан блок, элементы enum предварительно обрабатываются заданным блоком.

Set.new([1, 2])                       #=> #<Set: {1, 2}>
Set.new([1, 2, 1])                    #=> #<Set: {1, 2}>
Set.new([1, 'c', :s])                 #=> #<Set: {1, "c", :s}>
Set.new(1..5)                         #=> #<Set: {1, 2, 3, 4, 5}>
Set.new([1, 2, 3]) { |x| x * x }      #=> #<Set: {1, 4, 9}>

Методы экземпляра публичного интерфейса

&(enum) Показать исходный код

# File lib/set.rb, line 465
def &(enum)
  n = self.class.new
  do_with_enum(enum) { |o| n.add(o) if include?(o) }
  n
end

Возвращает новый набор, содержащий элементы, общие для набора и заданного перечислимого объекта.

Set[1, 3, 5] & Set[3, 2, 1]             #=> #<Set: {3, 1}>
Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> #<Set: {"a", "b"}>

Также алиасируется как: intersection

+(enum)

Псевдоним для: |

-(enum) Показать исходный код

# File lib/set.rb, line 455
def -(enum)
  dup.subtract(enum)
end

Возвращает новый набор, созданный путём дублирования набора, удаляя каждый элемент, который появляется в заданном перечислимом объекте.

Set[1, 3, 5] - Set[1, 5]                #=> #<Set: {3}>
Set['a', 'b', 'z'] - ['a', 'c']         #=> #<Set: {"b", "z"}>

Также алиасируется как: difference

<(set)

Псевдоним для: proper_subset?

<<(o)

Псевдоним для: add

<=(set)

Псевдоним для: subset?

==(other) Показать исходный код

# File lib/set.rb, line 491
def ==(other)
  if self.equal?(other)
    true
  elsif other.instance_of?(self.class)
    @hash == other.instance_variable_get(:@hash)
  elsif other.is_a?(Set) && self.size == other.size
    other.all? { |o| @hash.include?(o) }
  else
    false
  end
end

Возвращает true, если два набора равны. Равенство каждой пары элементов определяется в соответствии с Object#eql?.

Set[1, 2] == Set[2, 1]                       #=> true
Set[1, 3, 5] == Set[1, 5]                    #=> false
Set['a', 'b', 'c'] == Set['a', 'c', 'b']     #=> true
Set['a', 'b', 'c'] == ['a', 'c', 'b']        #=> false

===(o)

Возвращает true, если заданный объект является членом набора, и false в противном случае.

Используется в операторах case:

require 'set'

case :apple
when Set[:potato, :carrot]
  "vegetable"
when Set[:apple, :banana]
  "fruit"
end
# => "fruit"

Или по отдельности:

Set[1, 2, 3] === 2   #=> true
Set[1, 2, 3] === 4   #=> false

Псевдоним для: include?

>(set)

Псевдоним для: proper_superset?

>=(set)

Псевдоним для: superset?

^(enum) Показать исходный код

# File lib/set.rb, line 478
def ^(enum)
  n = Set.new(enum)
  each { |o| n.add(o) unless n.delete?(o) }
  n
end

Возвращает новый набор, содержащий элементы, эксклюзивные между набором и заданным перечислимым объектом. (set ^ enum) эквивалентно ((set | enum) - (set & enum)).

Set[1, 2] ^ Set[2, 3]                   #=> #<Set: {3, 1}>
Set[1, 'b', 'c'] ^ ['b', 'd']           #=> #<Set: {"d", 1, "c"}>

add(o) Показать исходный код

# File lib/set.rb, line 338
def add(o)
  @hash[o] = true
  self
end

Добавляет заданный объект в набор и возвращает self. Используйте merge для добавления сразу нескольких элементов.

Set[1, 2].add(3)                    #=> #<Set: {1, 2, 3}>
Set[1, 2].add([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
Set[1, 2].add(2)                    #=> #<Set: {1, 2}>

Также алиасируется как: <<

add?(o) Показать исходный код

# File lib/set.rb, line 350
def add?(o)
  add(o) unless include?(o)
end

Добавляет заданный объект в набор и возвращает self. Если объект уже присутствует в наборе, возвращает nil.

Set[1, 2].add?(3)                    #=> #<Set: {1, 2, 3}>
Set[1, 2].add?([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
Set[1, 2].add?(2)                    #=> nil

as_json(*) Показать исходный код

# File ext/json/lib/json/add/set.rb, line 17
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'a'            => to_a,
  }
end

Marshal объект в JSON.

Метод используется для поддержки JSON маршалинга.

classify() { |o| ... } Показать исходный код

# File lib/set.rb, line 560
def classify # :yields: o
  block_given? or return enum_for(__method__) { size }

  h = {}

  each { |i|
    (h[yield(i)] ||= self.class.new).add(i)
  }

  h
end

Классифицирует набор по возвращаемому значению данного блока и возвращает хеш пар {значение => множество элементов}. Блок вызывается один раз для каждого элемента набора, передавая элемент в качестве параметра.

require 'set'
files = Set.new(Dir.glob("*.rb"))
hash = files.classify { |f| File.mtime(f).year }
hash       #=> {2000=>#<Set: {"a.rb", "b.rb"}>,
           #    2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
           #    2002=>#<Set: {"f.rb"}>}

Возвращает перечислитель, если блок не задан.

clear() Показать исходный код

# File lib/set.rb, line 166
def clear
  @hash.clear
  self
end

Удаляет все элементы и возвращает self.

set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
set.clear                         #=> #<Set: {}>
set                               #=> #<Set: {}>

collect!() { |o| ... } Показать исходный код

# File lib/set.rb, line 391
def collect!
  block_given? or return enum_for(__method__) { size }
  set = self.class.new
  each { |o| set << yield(o) }
  replace(set)
end

Заменяет элементы элементами, возвращаемыми collect(). Возвращает перечислитель, если блок не задан.

Также алиасируется как: map!

compare_by_identity() Показать исходный код

# File lib/set.rb, line 107
def compare_by_identity
  if @hash.respond_to?(:compare_by_identity)
    @hash.compare_by_identity
    self
  else
    raise NotImplementedError, "#{self.class.name}\##{__method__} is not implemented"
  end
end

Заставляет набор сравнивать свои элементы по их идентификатору и возвращает self. Этот метод может не поддерживаться всеми подклассами Set.

compare_by_identity?() Показать исходный код

# File lib/set.rb, line 118
def compare_by_identity?
  @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
end

Возвращает true, если набор будет сравнивать свои элементы по их идентификатору. Также см. Set#compare_by_identity.

delete(o) Показать исходный код

# File lib/set.rb, line 356
def delete(o)
  @hash.delete(o)
  self
end

Удаляет заданный объект из набора и возвращает self. Используйте subtract для удаления сразу нескольких элементов.

delete?(o) Показать исходный код

# File lib/set.rb, line 363
def delete?(o)
  delete(o) if include?(o)
end

Удаляет заданный объект из набора и возвращает self. Если объекта нет в наборе, возвращает nil.

delete_if() { |o| ... } Показать исходный код

# File lib/set.rb, line 370
def delete_if
  block_given? or return enum_for(__method__) { size }
  # @hash.delete_if should be faster, but using it breaks the order
  # of enumeration in subclasses.
  select { |o| yield o }.each { |o| @hash.delete(o) }
  self
end

Удаляет каждый элемент набора, для которого блок возвращает true, и возвращает self. Возвращает перечислитель, если блок не задан.

difference(enum)

Псевдоним для: -

disjoint?(set) Показать исходный код

# File lib/set.rb, line 319
def disjoint?(set)
  !intersect?(set)
end

Возвращает true, если у набора и заданного набора нет общих элементов. Этот метод является противоположностью intersect?.

Set[1, 2, 3].disjoint? Set[3, 4]   #=> false
Set[1, 2, 3].disjoint? Set[4, 5]   #=> true

divide(&func) Показать исходный код

# File lib/set.rb, line 588
def divide(&func)
  func or return enum_for(__method__) { size }

  if func.arity == 2
    require 'tsort'

    class << dig = {}         # :nodoc:
      include TSort

      alias tsort_each_node each_key
      def tsort_each_child(node, &block)
        fetch(node).each(&block)
      end
    end

    each { |u|
      dig[u] = a = []
      each{ |v| func.call(u, v) and a << v }
    }

    set = Set.new()
    dig.each_strongly_connected_component { |css|
      set.add(self.class.new(css))
    }
    set
  else
    Set.new(classify(&func).values)
  end
end

Разбивает набор на набор подмножеств в соответствии с общностью, определяемой заданным блоком.

Если арность блока равна 2, элементы o1 и o2 являются общими, если block.call(o1, o2) равно true. В противном случае элементы o1 и o2 являются общими, если block.call(o1) == block.call(o2).

require 'set'
numbers = Set[1, 3, 4, 6, 9, 10, 11]
set = numbers.divide { |i,j| (i - j).abs == 1 }
set        #=> #<Set: {#<Set: {1}>,
           #           #<Set: {11, 9, 10}>,
           #           #<Set: {3, 4}>,
           #           #<Set: {6}>}>

Возвращает перечислитель, если блок не задан.

END_OF_DOCUMENT_MARKER

each(&block) Показать исходный код

# File lib/set.rb, line 326
def each(&block)
  block or return enum_for(__method__) { size }
  @hash.each_key(&block)
  self
end

Вызывает заданный блок один раз для каждого элемента в наборе, передавая элемент в качестве параметра. Возвращает перечислитель, если блок не задан.

empty?() Показать исходный код

# File lib/set.rb, line 157
def empty?
  @hash.empty?
end

Возвращает true, если набор не содержит элементов.

filter!(&block)

Эквивалентно Set#select!

Псевдоним для: select!

flatten() Показать исходный код

# File lib/set.rb, line 227
def flatten
  self.class.new.flatten_merge(self)
end

Возвращает новый набор, являющийся копией набора, рекурсивно сглаживая каждый содержащий набор.

flatten!() Показать исходный код

# File lib/set.rb, line 233
def flatten!
  replace(flatten()) if any? { |e| e.is_a?(Set) }
end

Эквивалентно Set#flatten, но заменяет получатель результатом на месте. Возвращает nil, если изменения не были внесены.

include?(o) Показать исходный код

# File lib/set.rb, line 243
def include?(o)
  @hash[o]
end

Возвращает true, если набор содержит данный объект.

Обратите внимание, что include? и member? не проверяют равенство элементов с использованием ==, как это делают другие Enumerables.

См. также Enumerable#include?

Также псевдоним для: member?, ===

initialize_clone(orig) Показать исходный код

# File lib/set.rb, line 140
def initialize_clone(orig)
  super
  @hash = orig.instance_variable_get(:@hash).clone
end

Клонирует внутренний хэш.

Вызывает метод суперкласса

initialize_dup(orig) Показать исходный код

# File lib/set.rb, line 134
def initialize_dup(orig)
  super
  @hash = orig.instance_variable_get(:@hash).dup
end

Дублирует внутренний хэш.

Вызывает метод суперкласса

inspect() Показать исходный код

# File lib/set.rb, line 622
def inspect
  ids = (Thread.current[InspectKey] ||= [])

  if ids.include?(object_id)
    return sprintf('#<%s: {...}>', self.class.name)
  end

  ids << object_id
  begin
    return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
  ensure
    ids.pop
  end
end

Возвращает строку, содержащую удобочитаемое представление набора (“#<Set: {элемент1, элемент2, …}>”).

Также псевдоним для: to_s

intersect?(set) Показать исходный код

# File lib/set.rb, line 305
def intersect?(set)
  set.is_a?(Set) or raise ArgumentError, "value must be a set"
  if size < set.size
    any? { |o| set.include?(o) }
  else
    set.any? { |o| include?(o) }
  end
end

Возвращает true, если набор и заданный набор имеют хотя бы один общий элемент.

Set[1, 2, 3].intersect? Set[4, 5]   #=> false
Set[1, 2, 3].intersect? Set[3, 4]   #=> true

intersection(enum)

Псевдоним для: &

keep_if() { |o| ... } Показать исходный код

# File lib/set.rb, line 381
def keep_if
  block_given? or return enum_for(__method__) { size }
  # @hash.keep_if should be faster, but using it breaks the order of
  # enumeration in subclasses.
  reject { |o| yield o }.each { |o| @hash.delete(o) }
  self
end

Удаляет каждый элемент набора, для которого блок возвращает false, и возвращает self. Возвращает перечислитель, если блок не задан.

length()

Псевдоним для: size

map!()

Псевдоним для: collect!

member?(o)

Псевдоним для: include?

merge(enum) Показать исходный код

# File lib/set.rb, line 422
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

Объединяет элементы заданного перечислимого объекта в набор и возвращает self.

proper_subset?(set) Показать исходный код

# File lib/set.rb, line 288
def proper_subset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:<)
    @hash < set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size < set.size && all? { |o| set.include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

Возвращает true, если набор является истинным подмножеством заданного набора.

Также псевдоним для: <

proper_superset?(set) Показать исходный код

# File lib/set.rb, line 262
def proper_superset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:>)
    @hash > set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size > set.size && set.all? { |o| include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

Возвращает true, если набор является истинным надмножеством заданного набора.

Также псевдоним для: >

reject!(&block) Показать исходный код

# File lib/set.rb, line 401
def reject!(&block)
  block or return enum_for(__method__) { size }
  n = size
  delete_if(&block)
  self if size != n
end

Эквивалентно Set#delete_if, но возвращает nil, если изменения не были внесены. Возвращает перечислитель, если блок не задан.

replace(enum) Показать исходный код

# File lib/set.rb, line 177
def replace(enum)
  if enum.instance_of?(self.class)
    @hash.replace(enum.instance_variable_get(:@hash))
    self
  else
    do_with_enum(enum)  # make sure enum is enumerable before calling clear
    clear
    merge(enum)
  end
end

Заменяет содержимое набора содержимым заданного перечислимого объекта и возвращает self.

set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
set.replace([1, 2])               #=> #<Set: {1, 2}>
set                               #=> #<Set: {1, 2}>

reset() Показать исходный код

# File lib/set.rb, line 516
def reset
  if @hash.respond_to?(:rehash)
    @hash.rehash # This should perform frozenness check.
  else
    raise FrozenError, "can't modify frozen #{self.class.name}" if frozen?
  end
  self
end

Сбрасывает внутреннее состояние после изменения существующих элементов и возвращает self.

Элементы будут переиндексированы и дедублицированы.

select!(&block) Показать исходный код

# File lib/set.rb, line 410
def select!(&block)
  block or return enum_for(__method__) { size }
  n = size
  keep_if(&block)
  self if size != n
end

Эквивалентно Set#keep_if, но возвращает nil, если изменения не были внесены. Возвращает перечислитель, если блок не задан.

Также псевдоним для: filter!

size() Показать исходный код

# File lib/set.rb, line 151
def size
  @hash.size
end

Возвращает количество элементов.

Также псевдоним для: length

subset?(set) Показать исходный код

# File lib/set.rb, line 275
def subset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:<=)
    @hash <= set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size <= set.size && all? { |o| set.include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

Возвращает true, если набор является подмножеством заданного набора.

Также псевдоним для: <=

subtract(enum) Показать исходный код

# File lib/set.rb, line 434
def subtract(enum)
  do_with_enum(enum) { |o| delete(o) }
  self
end

Удаляет каждый элемент, который присутствует в заданном перечислимом объекте, и возвращает self.

END_OF_DOCUMENT_MARKER

superset?(set) Показать исходный код

# File lib/set.rb, line 249
def superset?(set)
  case
  when set.instance_of?(self.class) && @hash.respond_to?(:>=)
    @hash >= set.instance_variable_get(:@hash)
  when set.is_a?(Set)
    size >= set.size && set.all? { |o| include?(o) }
  else
    raise ArgumentError, "value must be a set"
  end
end

Возвращает true, если множество является надмножеством данного множества.

Также алиас: >=

to_a() Показать исходный код

# File lib/set.rb, line 192
def to_a
  @hash.keys
end

Преобразует множество в массив. Порядок элементов неопределён.

Set[1, 2].to_a                    #=> [1, 2]
Set[1, 'c', :s].to_a              #=> [1, "c", :s]

to_json(*args) Показать исходный код

# File ext/json/lib/json/add/set.rb, line 25
def to_json(*args)
  as_json.to_json(*args)
end

Возвращает значение JSON.

to_s()

Псевдоним для: inspect

to_set(klass = Set, *args, &block) Показать исходный код

# File lib/set.rb, line 201
def to_set(klass = Set, *args, &block)
  return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
  klass.new(self, *args, &block)
end

Возвращает self, если аргументы не указаны. В противном случае преобразует множество в другое множество с помощью klass.new(self, *args, &block).

В подклассах возвращает klass.new(self, *args, &block), если не переопределено.

union(enum)

Псевдоним для: |

|(enum) Показать исходный код

# File lib/set.rb, line 444
def |(enum)
  dup.merge(enum)
end

Возвращает новое множество, полученное путём объединения текущего множества и элементов заданного перечислимого объекта.

Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>

Также алиас: +, union

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.