Класс 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::[](*ary)

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


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

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


 &(enum)

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

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


 +(enum)

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


 -(enum)

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

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


 <<(o)

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


 ==(set)

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


 ^(enum)

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


 add(o)

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

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


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

 clear()

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

Set#collect!

править

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

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

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


 delete(o)

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

Set#delete?

править

 delete?(o)

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

Set#delete_if

править

 delete_if() {|o| ...}

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

Set#difference

править

 difference(enum)

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


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

 each() {|o| ...}

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


 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)

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


 length()

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


 map!()

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

Set#member?

править

 member?(o)

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


 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)

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


 size()

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

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

Set#subset?

править

 subset?(set)

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

Set#subtract

править

 subtract(enum)

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

Set#superset?

править

 superset?(set)

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


 to_a()

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


 union(enum)

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


 |(enum)

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

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