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)