класс Set

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

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

Метод to_set добавлен в Enumerable для удобства.

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

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

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

Сравнение

Операторы сравнения <, >, <=, и >= реализованы как сокращения для методов {proper_,}{subset?,superset?} . Оператор <=> отражает этот порядок или возвращает nil для множеств, которые оба имеют различные элементы (например, {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

Контакты

Акинори Муша <knu@iDaemons.org> (текущий основной разработчик)

Что здесь

Сначала, что где-то ещё. Класс Set:

Наследуется от класса Object.
Включает модуль Enumerable, который предоставляет десятки дополнительных методов.

В частности, класс Set не имеет много собственных методов для извлечения или итерации. Вместо этого он полагается на методы из Enumerable.

Здесь класс Set предоставляет методы, полезные для:

Создание множества
Операции над множествами
Сравнение
Запросы
Присвоение
Удаление
Преобразование
Итерация
И многое другое…

Методы для создания множества

::[]: Возвращает новое множество, содержащее заданные объекты.
::new: Возвращает новое множество, содержащее заданные объекты (если блок не задан) или значения, возвращаемые вызываемым блоком (если блок задан).

Методы для операций над множествами

| (алиас union и +): Возвращает новое множество, содержащее все элементы из self и все элементы из заданного перечислимого объекта (без дубликатов).
& (алиас intersection): Возвращает новое множество, содержащее все элементы, общие для self и заданного перечислимого объекта.
- (алиас difference): Возвращает копию self со всеми элементами из заданного перечислимого объекта, удалёнными.
^: Возвращает новое множество, содержащее все элементы из self и заданного перечислимого объекта, за исключением общих для них.

Методы для сравнения

<=>: Возвращает -1, 0 или 1, в зависимости от того, меньше, равно или больше, чем заданный объект.
==: Возвращает, равны ли self и заданный перечислимый объект, как определено методом Object#eql?.
compare_by_identity?: Возвращает, учитывает ли множество только идентичность при сравнении элементов.

Методы для запроса

length (алиас size): Возвращает количество элементов.
empty?: Возвращает, пусто ли множество.
include? (алиас member? и ===): Возвращает, является ли заданный объект элементом множества.
subset? (алиас <=): Возвращает, является ли заданный объект подмножеством множества.
proper_subset? (алиас <): Возвращает, является ли заданный перечислимый объект собственным подмножеством множества.
superset? (алиас >=): Возвращает, является ли заданный перечислимый объект надмножеством множества.
proper_superset? (алиас >): Возвращает, является ли заданный перечислимый объект собственным надмножеством множества.
disjoint?: Возвращает true если множество и заданный перечислимый объект не имеют общих элементов, false в противном случае.
intersect?: Возвращает true если у множества и заданного перечислимого объекта есть общие элементы, false в противном случае.
compare_by_identity?: Возвращает, учитывает ли множество только идентичность при сравнении элементов.

Методы для присвоения

add (алиас <<): Добавляет заданный объект в множество; возвращает self.
add?: Если заданный объект не является элементом множества, добавляет его и возвращает self; в противном случае, возвращает nil.
merge: Объединяет элементы каждого заданного перечислимого объекта в множество; возвращает self.
replace: Заменяет содержимое множества содержимым заданного перечислимого объекта.

Методы для удаления

clear: Удаляет все элементы из множества; возвращает self.
delete: Удаляет заданный объект из множества; возвращает self.
delete?: Если заданный объект является элементом множества, удаляет его и возвращает self; в противном случае, возвращает nil.
subtract: Удаляет каждый заданный объект из множества; возвращает self.
delete_if - Удаляет элементы, указанные заданным блоком.
select! (алиас filter!): Удаляет элементы, не указанные заданным блоком.
keep_if: Удаляет элементы, не указанные заданным блоком.
reject! Удаляет элементы, указанные заданным блоком.

Методы для преобразования

classify: Возвращает хэш, классифицирующий элементы, как определено заданным блоком.
collect! (алиас map!): Заменяет каждый элемент значением, возвращаемым блоком.
divide: Возвращает хэш, классифицирующий элементы, как определено заданным блоком; отличается от classify тем, что блок может принимать один или два аргумента.
flatten: Возвращает новое множество, которое является рекурсивным разглаживанием self. flatten!: Заменяет каждое вложенное множество в self элементами из этого множества.
inspect (алиас to_s): Возвращает строку, отображающую элементы.
join: Возвращает строку, содержащую все элементы, преобразованные в строки по мере необходимости, и соединённые заданным разделителем.
to_a: Возвращает массив, содержащий все элементы множества.
to_set: Возвращает self при отсутствии аргументов и блока; с заданным блоком возвращает новое множество, состоящее из значений, возвращаемых блоком.

Методы для итерации

each: Вызывает блок с каждым последующим элементом; возвращает self.

Другие методы

reset: Сбрасывает внутреннее состояние; полезно, если объект был изменён во время работы с элементом в множестве.

Константы

VERSION

Методы публичного класса

[] (*ary)

Исходный код

# File lib/set.rb, line 228
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 9
def self.json_create(object)
  new object['a']
end

См. as_json.

new (enum = nil) { |o| ... }

Исходный код

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

Методы экземпляра public

& (enum)

Исходный код

# File lib/set.rb, line 643
def &(enum)
  n = self.class.new
  if enum.is_a?(Set)
    if enum.size > size
      each { |o| n.add(o) if enum.include?(o) }
    else
      enum.each { |o| n.add(o) if include?(o) }
    end
  else
    do_with_enum(enum) { |o| n.add(o) if include?(o) }
  end
  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 633
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?

<=> (set)

Исходный код

# File lib/set.rb, line 456
def <=>(set)
  return unless set.is_a?(Set)

  case size <=> set.size
  when -1 then -1 if proper_subset?(set)
  when +1 then +1 if proper_superset?(set)
  else 0 if self.==(set)
  end
end

Возвращает 0, если наборы равны, -1/+1, если набор является надлежащим подмножеством/надмножеством заданного набора, или nil, если оба набора содержат уникальные элементы.

== (other)

Исходный код

# File lib/set.rb, line 677
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 664
def ^(enum)
  n = self.class.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"}>

| (enum)

Исходный код

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

add (o)

Исходный код

# File lib/set.rb, line 514
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 526
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 28
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'a'            => to_a,
  }
end

Методы Set#as_json и Set.json_create могут быть использованы для сериализации и десериализации объекта Set; см. Marshal.

Метод Set#as_json сериализует self, возвращая хеш из 2 элементов, представляющий self:

require 'json/add/set'
x = Set.new(%w/foo bar baz/).as_json
# => {"json_class"=>"Set", "a"=>["foo", "bar", "baz"]}

Метод JSON.create десериализует такой хеш, возвращая объект Set:

Set.json_create(x) # => #<Set: {"foo", "bar", "baz"}>

classify () { |o| ... }

Исходный код

# File lib/set.rb, line 746
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 316
def clear
  @hash.clear
  self
end

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

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

END_OF_DOCUMENT_MARKER

collect! () { |o| ... }

Исходный код

# File lib/set.rb, line 567
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 257
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 268
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 532
def delete(o)
  @hash.delete(o)
  self
end

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

delete? (o)

Исходный код

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

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

delete_if (&block)

Исходный код

# File lib/set.rb, line 546
def delete_if(&block)
  block_given? or return enum_for(__method__) { size }
  # Instead of directly using @hash.delete_if, perform enumeration
  # using self.each that subclasses may override.
  select(&block).each { |o| @hash.delete(o) }
  self
end

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

difference (enum)

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

disjoint? (set)

Исходный код

# File lib/set.rb, line 495
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
Set[1, 2, 3].disjoint? [3, 4]      #=> false
Set[1, 2, 3].disjoint? 4..5        #=> true

divide (&func)

Исходный код

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

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

each (&block)

Исходный код

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

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

empty? ()

Исходный код

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

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

filter! (&block)

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

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

flatten ()

Исходный код

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

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

flatten! ()

Исходный код

# File lib/set.rb, line 386
def flatten!
  replace(flatten()) if any?(Set)
end

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

include? (o)

Исходный код

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

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

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

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

Также известен как: member?, ===

initialize_clone (orig, **options)

Исходный код

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

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

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

initialize_dup (orig)

Исходный код

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

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

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

inspect ()

Исходный код

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

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

Также алиасировано как: to_s

intersect? (множество)

Исходный код

# File lib/set.rb, line 473
def intersect?(set)
  case set
  when Set
    if size < set.size
      any?(set)
    else
      set.any?(self)
    end
  when Enumerable
    set.any?(self)
  else
    raise ArgumentError, "value must be enumerable"
  end
end

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

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

intersection (enum)

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

join (разделитель=nil)

Исходный код

# File lib/set.rb, line 806
def join(separator=nil)
  to_a.join(separator)
end

Возвращает строку, созданную путем преобразования каждого элемента множества в строку. См. также: Array#join

keep_if (&блок)

Исходный код

# File lib/set.rb, line 557
def keep_if(&block)
  block_given? or return enum_for(__method__) { size }
  # Instead of directly using @hash.keep_if, perform enumeration
  # using self.each that subclasses may override.
  reject(&block).each { |o| @hash.delete(o) }
  self
end

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

length ()

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

map! ()

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

member? (o)

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

merge (*enums, **nil)

Исходный код

# File lib/set.rb, line 598
def merge(*enums, **nil)
  enums.each do |enum|
    if enum.instance_of?(self.class)
      @hash.update(enum.instance_variable_get(:@hash))
    else
      do_with_enum(enum) { |o| add(o) }
    end
  end

  self
end

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

proper_subset? (множество)

Исходный код

# File lib/set.rb, line 441
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?(set)
  else
    raise ArgumentError, "value must be a set"
  end
end

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

Также алиасировано как: <

proper_superset? (множество)

Исходный код

# File lib/set.rb, line 415
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?(self)
  else
    raise ArgumentError, "value must be a set"
  end
end

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

Также алиасировано как: >

reject! (&блок)

Исходный код

# File lib/set.rb, line 577
def reject!(&block)
  block_given? 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 327
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 702
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! (&блок)

Исходный код

# File lib/set.rb, line 586
def select!(&block)
  block_given? 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 301
def size
  @hash.size
end

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

Также алиасировано как: length

subset? (множество)

Исходный код

# File lib/set.rb, line 428
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?(set)
  else
    raise ArgumentError, "value must be a set"
  end
end

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

Также алиасировано как: <=

subtract (enum)

Исходный код

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

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

superset? (множество)

Исходный код

# File lib/set.rb, line 402
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?(self)
  else
    raise ArgumentError, "value must be a set"
  end
end

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

Также алиасировано как: >=

to_a ()

Исходный код

# File lib/set.rb, line 342
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 44
def to_json(*args)
  as_json.to_json(*args)
end

Возвращает строку JSON, представляющую self:

require 'json/add/set'
puts Set.new(%w/foo bar baz/).to_json

Вывод:

{"json_class":"Set","a":["foo","bar","baz"]}

to_s ()

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

to_set (klass = Set, *args, &block)

Исходный код

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

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

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