Ruby/Справочник/Set

Класс Set

Set реализует коллекцию неупорядоченных значений без дубликатов. Это гибрид интуитивно понятных средств взаимодействия Array и быстрого поиска Hash. Несколько методов принимают любой объект Enumerable (implementing each) для большей гибкости: new, replace, merge, subtract, |, &, -, ^. Равенство каждой пары элементов определяется в соответствии с Object#eql? и Object#hash, поскольку Set использует Hash в качестве хранилища. Наконец, если вы используете класс Set, вы также можете использовать Enumerable#to_set для удобства.

Example

 require 'set'
 s1 = Set.new [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: {6, 1, 2, "foo"}>
 s1.subset? s2                         # -> false
 s2.subset? s1                         # -> true

Примеси

Enumerable (all?, any?, collect, detect, each_cons, each_slice, each_with_index, entries, enum_cons, enum_slice, enum_with_index, find, find_all, grep, group_by, include?, index_by, inject, map, max, member?, min, partition, reject, select, sort, sort_by, sum, to_a, to_set, zip)

Методы класса

[], new

Методы объекта

&, +, -, <<, ==, ^, add?, add, classify, clear, collect!, delete?, delete_if, delete, difference, divide, each, empty?, flatten!, flatten_merge, flatten, include?, initialize_copy, inspect, intersection, length, map!, member?, merge, proper_subset?, proper_superset?, reject!, replace, size, subset?, subtract, superset?, to_a, union, ||

Set::[]

 Set::[](*ary)

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

Set::new

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

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

Set#&

 &(enum)

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

(еще известен как intersection)

Set#+

 +(enum)

Тоже самое что #|

Set#-

 -(enum)

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

(еще известен как difference)

Set#<<

 <<(o)

Тоже самое что #add

Set#==

 ==(set)

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

Set#^

 ^(enum)

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

Set#add

 add(o)

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

(еще известен как <<)

Set#add?

 add?(o)

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

Set#classify

 classify( {|o| ...}

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

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

Set#clear

 clear()

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

Set#collect!

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

Выполняет команду collect() заменяя значения в исходном множестве.

(еще известен как map!)

Set#delete

 delete(o)

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

Set#delete?

 delete?(o)

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

Set#delete_if

 delete_if() {|o| ...}

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

Set#difference

 difference(enum)

Тоже самое что #-

Set#divide

 divide(&func)

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

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

Set#each

 each() {|o| ...}

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

Set#empty?

 empty?()

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

Set#flatten

 flatten()

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

Set#flatten!

 flatten!()

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

Set#flatten_merge

 flatten_merge(set, seen = Set.new)

(нет описания...)

Set#include?

 include?(o)

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

(еще известен как member?)

Set#initialize_copy

 initialize_copy(orig)

Копирует внутренний хэш.(?)

Set#inspect

 inspect()

Возвращает строку, содержащую человекочитаемое представление множества. ("#<Set: {element1, element2, ...}>")

Set#intersection

 intersection(enum)

Тоже самое что #&

Set#length

 length()

Тоже самое что #size

Set#map!

 map!()

Тоже самое #collect!

Set#member?

 member?(o)

Тоже самое что #include?

Set#merge

 merge(enum)

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

Set#proper_subset?

 proper_subset?(set)

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

Set#proper_superset?

 proper_superset?(set)

Возвращает true, если данное множество является правильным супермножеством заданного множества.(?)

Set#reject!

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

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

Set#replace

 replace(enum)

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

Set#size

 size()

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

(еще известен как length)

Set#subset?

 subset?(set)

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

Set#subtract

 subtract(enum)

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

Set#superset?

 superset?(set)

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

Set#to_a

 to_a()

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

Set#union

 union(enum)

Тоже самое что #|

Set#|

 |(enum)

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

(еще известен как +, union)