Ruby/Справочник/Объединение

Материал из Викиучебника

[править] Класс Array

Массив — упорядоченная коллекция произвольных объектов с целочисленной индексацией. Нумерация элементов массива начинается с 0, как в языках Си или Java. Отрицательный индекс предполагает отсчет с конца массива, то есть индексу -1 соотвествует последний элемент массива, -2 — предпоследний, и так далее.

Примеси

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

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

[]=, [], &, |, *, +, -, <<, <=>, ==, abbrev, assoc, at, clear, collect!, collect, compact!, compact, concat, delete_at, delete_if, delete, each_index, each, empty?, eql?, fetch, fill, first, flatten!, flatten, frozen?, hash, include?, indexes, index, indices, insert, inspect, join, last, length, map!, map, nitems, pack, pop, push, rassoc, reject!, reject, replace, reverse!, reverse_each, reverse, rindex, select, shift, size, slice!, slice, sort!, sort, to_ary, to_a, to_s, transpose, uniq!, uniq, unshift, values_at, zip

[править] Array::[]

Array::[](...)

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

Array.[]( 1, 'a', /^A/ )
Array[ 1, 'a', /^A/ ]
[ 1, 'a', /^A/ ]

[править] Array::new

Array.new(size=0, obj=nil)
Array.new(array)
Array.new(size){|index| block }

Возвращает новый массив. В первой форме вызова, создается пустой массив. Во второй, создается массив размера size, заполненный копиями obj (то есть, size ссылок на obj). В третьей, создается копия массив, переданного в качестве параметра (массив создается при помощи вызова метода to_ary от массива-параметра). В последнем случае, создается массив указанного размера. Каждый элемент в этом массиве вычисляется в указанном блоке, которому передается индекс обрабатываемого элемента. Результат блока записывается в качестве значения элемента в массив.

Array.new
Array.new(2)
Array.new(5, "A")
 
# только одна копия объекта создается
a = Array.new(2, Hash.new)
a[0]['cat'] = 'feline'
a
a[1]['cat'] = 'Felix'
a
 
# здесь создается несколько копий объекта
a = Array.new(2) { Hash.new }
a[0]['cat'] = 'feline'
a
 
squares = Array.new(5) {|i| i*i}
squares
 
copy = Array.new(squares)

[править] Array#&

 array & other_array

Пересечение множеств — возвращает новый массив, состоящий из элементов, которые есть в обоих массивах, но без дубликатов.

  [ 1, 1, 3, 5 ] & [ 1, 2, 3 ]   #=> [ 1, 3 ]

[править] Array#|

 array | other_array     ->  an_array

Объединение множеств — возвращает новый массив, который объединяет элементы массивов array и other_array, но с удаленными дубликатами.

  [ "a", "b", "c" ] | [ "c", "d", "a" ]
         #=> [ "a", "b", "c", "d" ]

[править] Array#*

 array * int     ->    an_array
 array * str     ->    a_string

Повторение — со строковым аргументом эквивалентен коду array.join(str). Иначе, возвращает новый массив, состоящий из int сцепленных копий array.

  [ 1, 2, 3 ] * 3    #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]
  [ 1, 2, 3 ] * ","  #=> "1,2,3"

[править] Array#+

 array + other_array   -> an_array

Сцепление — возвращает новый массив, созданный из двух массивов путем добавления одного к другому.

  [ 1, 2, 3 ] + [ 4, 5 ]    #=> [ 1, 2, 3, 4, 5 ]

[править] Array#-

 array - other_array    -> an_array

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

  [ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]

Если вам необходима разность множеств, а не вычитание массивов, то смотрите в сторону класса Set

[править] Array#<<

 array << obj            -> array

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

  [ 1, 2 ] << "c" << "d" << [ 3, 4 ]
          #=>  [ 1, 2, "c", "d", [ 3, 4 ] ]

Метод push имеет примерно такую же функциональность

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод +

[править] Array#<=>

 array <=> other_array   ->  -1, 0, +1

Сравнение — возвращает целое число (-1, 0, или +1) если текущий массив меньше, равен или больше другого массива. Соответствующие элементы обоих массивов сравниваются (используется метод <=>). Если какая либо из пар элементов не совпадает, то возвращается результат этого сравнения. Если все пары элементов совпадают, то возвращается результат сравнения по длине. Таким образом, два массива считаются «равными» (по мнению метода Array#<=>) тогда и только тогда, когда их длины и соответствующие пары элементов совпадают.

  [ "a", "a", "c" ]    <=> [ "a", "b", "c" ]   #=> -1
  [ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ]            #=> +1

[править] Array#==

 array == other_array   ->   bool

Равенство — два массива считаются равными, если количество элементов и соответствующие пары элементов равны (используется метод ==).

  [ "a", "c" ]    == [ "a", "c", 7 ]     #=> false
  [ "a", "c", 7 ] == [ "a", "c", 7 ]     #=> true
  [ "a", "c", 7 ] == [ "a", "d", "f" ]   #=> false

[править] Array#[]

 array[index]                -> obj      или nil
 array[start, length]        -> an_array или nil
 array[range]                -> an_array или nil
 array.slice(index)          -> obj      или nil
 array.slice(start, length)  -> an_array или nil
 array.slice(range)          -> an_array или nil

Получение значения элемента — возвращает элемент с индексом index, или подмассив длины length, начиная с индекса start, или подмассив, который располагается в диапазоне range. Отрицательная индексация предполагает отчет с конца массива (по индексу -1 располагается последний элемент). Возвращает nil, если индекс выходит за диапазон допустимых значений.

  a = [ "a", "b", "c", "d", "e" ]
  a[2] +  a[0] + a[1]    #=> "cab"
  a[6]                   #=> nil
  a[1, 2]                #=> [ "b", "c" ]
  a[1..3]                #=> [ "b", "c", "d" ]
  a[4..7]                #=> [ "e" ]
  a[6..10]               #=> nil
  a[-3, 3]               #=> [ "c", "d", "e" ]
  # специальные случаи
  a[5]                   #=> nil
  a[5, 1]                #=> []
  a[5..10]               #=> []

Методы slice и [] — одно и тоже! Существует метод at, который обладает схожей, но меньшей функциональностью

[править] Array#[]=

 maccuB[uHgekc]        = obj                       ->  obj
 maccuB[cTapT, pa3mep] = obj или an_array или nil  ->  obj или an_array или nil
 maccuB[guana3oH]      = obj или an_array или nil  ->  obj или an_array или nil

Распределение элементов — помещает элемент в maccuB по uHgekcу, или заменяет подмассив некоторого pa3mepа, начиная с индекса cTapT, или заменяет подмассив в определенном guana3oHе. Если индексация превышает текущий размер массива, то массив увеличивается автоматически. Отрицательная индексация подразумевает отсчет с конца массива. Если для второго случая использовать pa3mep равный 0, то указанные элементы будут вставлены перед элементом с индексом cTapT. Если все параметры для второго и третьего случая задать равными nil, то из maccuBа будут удалены все элементы. Ошибка IndexError появляется тогда, когда отрицательный индекс указывает на элемент, расположенный перед началом массива.

  a = Array.new
  a[4] = "4";                 #=> [nil, nil, nil, nil, "4"]
  a[0, 3] = [ 'a', 'b', 'c' ] #=> ["a", "b", "c", nil, "4"]
  a[1..2] = [ 1, 2 ]          #=> ["a", 1, 2, nil, "4"]
  a[0, 2] = "?"               #=> ["?", 2, nil, "4"]
  a[0..2] = "A"               #=> ["A", "4"]
  a[-1]   = "Z"               #=> ["A", "Z"]
  a[1..-1] = nil              #=> ["A"]

Полезно знать, что добавления элементов в массив существуют еще методы push и unshift

[править] Array#abbrev

 maccuB.abbrev(pattern = nil)

Вычисляет набор однозначных сокращений для строк в maccuBe. Если в качестве pattern передается правило или строка, то будут обрабатываться только строки, которые соответствуют правилу или начинаются с данной строки.

 %w{ car cone }.abbrev   #=> { "ca" => "car", "car" => "car",
                               "co" => "cone", "con" => cone",
                               "cone" => "cone" }

Для использования метода abbrev необходимо подключение библиотеки abbrev.rb из стандартной библиотеки Руби: require 'abbrev'

[править] Array#assoc

 array.assoc(obj)   ->  an_array  или  nil

Ищет в двумерном массиве массив, первый элемент которого равен obj (для сравнения используется метод ==). Возвращает первый найденный массив (то есть, ассоциированный массив) или nil, если таковой найти не удалось

  s1 = [ "colors", "red", "blue", "green" ]
  s2 = [ "letters", "a", "b", "c" ]
  s3 = "foo"
  a  = [ s1, s2, s3 ]
  a.assoc("letters")  #=> [ "letters", "a", "b", "c" ]
  a.assoc("foo")      #=> nil

Для понимания происходящего, полезно взглянуть на метод rassoc

[править] Array#at

 array.at(index)   ->   obj  или  nil

Возвращает элемент массива array с индексом index. Отрицательная индексация подразумевает отсчет с конца массива. возвращает nil, если индекс выходит за пределы допустимого дианазона.

  a = [ "a", "b", "c", "d", "e" ]
  a.at(0)     #=> "a"
  a.at(-1)    #=> "e"

Рекомендуется также взглянуть на метод [] (aka «батарейка»), который обладает схожим функционалом Метод at работает чуть быстрей метода [] за счет того, что не обрабатывает ничего кроме целочисленных индексов, то есть за счет игнорирования диапазонов

[править] Array#clear

 array.clear    ->  array

Удаляет все элементы из массива array.

  a = [ "a", "b", "c", "d", "e" ]
  a.clear    #=> [ ]

[править] Array#collect

 array.collect {|item| block }  -> an_array
 array.map     {|item| block }  -> an_array

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

  a = [ "a", "b", "c", "d" ]
  a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]
  a                          #=> ["a", "b", "c", "d"]

Есть итераторы Enumerable#collect и Enumerable#map, которые имеют схожую функциональность Итераторы map и collect — одно и то же!

[править] Array#collect!

 array.collect! {|item| block }   ->   array
 array.map!     {|item| block }   ->   array

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

  a = [ "a", "b", "c", "d" ]
  a.collect! {|x| x + "!" }
  a             #=>  [ "a!", "b!", "c!", "d!" ]

Есть итераторы Enumerable#collect и Enumerable#map, которые имеют схожую функциональность Итераторы map! и collect! — одно и то же!

Будьте внимательны при использовании данного итератора, так как он изменяет исходный массив. Чтобы исключить это изменение используйте итераторы collect и map

.

[править] Array#compact

 array.compact     ->  an_array

Возвращает копию массива array из которого удалены все элементы nil.

  [ "a", nil, "b", nil, "c", nil ].compact
                    #=> [ "a", "b", "c" ]

[править] Array#compact!

 array.compact!    ->   array  или  nil

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

  [ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ]
  [ "a", "b", "c" ].compact!           #=> nil

Данный метод изменяет исходный массив. Методу compact эта «дурная привычка» не присуща

[править] Array#concat

 array.concat(other_array)   ->  array

Добавляет к массиву array элементы массива other_array.

  [ "a", "b" ].concat( ["c", "d"] ) #=> [ "a", "b", "c", "d" ]

[править] Array#delete

 array.delete(obj)           -> obj или nil 
 array.delete(obj){ block }  -> obj или nil

Удаляет все элементы массива array, которые равны obj. Если ничего не было удалено, то возвращает nil. Если задан блок, то, в случае отсутствия элементов для удаления, возвращает результат блока.

  a = [ "a", "b", "b", "b", "c" ]
  a.delete("b")                   #=> "b"
  a                               #=> ["a", "c"]
  a.delete("z")                   #=> nil
  a.delete("z") { "not found" }   #=> "not found"

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте итератор reject

[править] Array#delete_at

 array.delete_at(index)  -> obj или nil

Удаляет элемент из массива array, который имеет индекс index. Возвращает значение удаленного элемента или nil, если index находится вне допустимого диапазона.

  a = %w( ant bat cat dog )
  a.delete_at(2)    #=> "cat"
  a                 #=> ["ant", "bat", "dog"]
  a.delete_at(99)   #=> nil

Метод slice! имеет схожую функциональность

Будьте внимательны при использовании данного метода, так как он изменяет исходный массив. Чтобы исключить это изменение используйте метод slice

[править] Array#delete_if

 array.delete_if {|item| block }  -> array

Удаляет все элементы массива array для которых значение внутри блока block равно true.

  a = [ "a", "b", "c" ]
  a.delete_if {|x| x >= "b" }   #=> ["a"]
  a                             #=> ["a"]

Полезно посмотреть на следующие итераторы reject и reject!, которые имеют схожую функциональность

Данный итератор изменяет значение исходного массива. Рекомендуется использовать итератор reject, который не имеет такой «дурной» привычки, но название которого хуже запоминается

[править] Array#each

 array.each {|item| block }   ->   array

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

  a = [ "a", "b", "c" ]
  a.each {|x| print x, " -- " }

результат:

  a -- b -- c --

Данный итератор возвращает в качестве результата исходный массив. Это следует учитывать при построении цепочки методов Следует использовать данный метод только тогда, когда задачу невозможно решить при помощи других итераторов

[править] Array#each_index

 array.each_index {|index| block }  ->  array

Работает точно также, как и each, но передает в блок не текущий элемент, а индекс текущего элемента.

  a = [ "a", "b", "c" ]
  a.each_index {|x| print x, " -- " }

результат:

  0 -- 1 -- 2 --

[править] Array#empty?

 array.empty?   -> true или false

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

  [].empty?   #=> true

[править] Array#eql?

 array.eql?(other)  -> true или false

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

[править] Array#fetch

 array.fetch(index)                    -> obj
 array.fetch(index, default )          -> obj
 array.fetch(index) {|index| block }   -> obj

Попытка получить элемент массива array по индексу index. Если индекс выходит за пределы массива то, в первой форме вызова возникнет ошибка IndexError, во второй форме вызова будет возвращено значение default, и в третьей форме вызова будет возвращено значение блока block (в который передается запрашиваемый индекс в качестве параметра). Отрицательная индексация подразумевает отсчет с конца массива.

  a = [ 11, 22, 33, 44 ]
  a.fetch(1)               #=> 22
  a.fetch(-1)              #=> 44
  a.fetch(4, 'cat')        #=> "cat"
  a.fetch(4) { |i| i*i }   #=> 16

[править] Array#fill

 array.fill(obj)                                -> array
 array.fill(obj, start [, length])              -> array
 array.fill(obj, range )                        -> array
 array.fill {|index| block }                    -> array
 array.fill(start [, length] ) {|index| block } -> array
 array.fill(range) {|index| block }             -> array

Первые три формы вызова заменяют указанные элементы массива array на значение obj. Если значение start равно nil, то это эквивалентно start=0. Если значение length равно nil, то это эквивалентно lenght=array.lenght. Последние три формы вызова заполняют массив значением выражения в блоке block (в который передается индекс текущего заменяемого элемента).

  a = [ "a", "b", "c", "d" ]
  a.fill("x")              #=> ["x", "x", "x", "x"]
  a.fill("z", 2, 2)        #=> ["x", "x", "z", "z"]
  a.fill("y", 0..1)        #=> ["y", "y", "z", "z"]
  a.fill {|i| i*i}         #=> [0, 1, 4, 9]
  a.fill(-2) {|i| i*i*i}   #=> [0, 1, 8, 27]

[править] Array#first

 array.first    -> obj или nil
 array.first(n) -> an_array

Возвращает первый элемент или первые n элементов массива array. Если массив пуст, то для первой формы вызова (без n) возвращается nil, а для второй — пустой массив.

  a = [ "q", "r", "s", "t" ]
  a.first    #=> "q"
  a.first(1) #=> ["q"]
  a.first(3) #=> ["q", "r", "s"]

[править] Array#flatten

 array.flatten -> an_array

Преобразует многомерный массив array в одномерный.

  s = [ 1, 2, 3 ]           #=> [1, 2, 3]
  t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
  a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
  a.flatten                 #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10

[править] Array#flatten!

 array.flatten! -> array или nil

Преобразует многомерный массив array в одномерный. Возвращает nil, если массив array изначально был одномерным.

  a = [ 1, 2, [3, [4, 5] ] ]
  a.flatten!   #=> [1, 2, 3, 4, 5]
  a.flatten!   #=> nil
  a            #=> [1, 2, 3, 4, 5]

Будьте внимательны при использовании данного метода, так как он изменяет исходный массив. Чтобы исключить это изменение используйте метод flatten

[править] Array#frozen?

 array.frozen?  -> true или false

Возвращает true, если массив array заморожен (или временно заморожен, пока идет сортировка).

[править] Array#hash

 array.hash   -> fixnum

Вычисляет хеш-код для массива array. Два массива с одним и тем же содержимым будут иметь одинаковый хеш-код (именно его использует eql?).

[править] Array#include?

 array.include?(obj)   -> true или false

Возвращает true, если объект obj является элементом массива array (то есть какой-то из элементов массива == obj). Иначе — false.

  a = [ "a", "b", "c" ]
  a.include?("b")   #=> true
  a.include?("z")   #=> false

[править] Array#index

 array.index(obj)   ->  int или nil

Возвращает индекс первого вхождения элемента в массив array, который == obj. Возвращает nil, если такой элемент не был найден.

  a = [ "a", "b", "c" ]
  a.index("b")   #=> 1
  a.index("z")   #=> nil

Советую взглянуть на метод rindex, который не только похож по названию, но, в некоторых случаях, работает точно также, как и index

[править] Array#indexes

 array.indexes( i1, i2, ... iN )   -> an_array
 array.indices( i1, i2, ... iN )   -> an_array

Использование данного метода резко осуждается Руби-сообществом. Во время его использования интерпретатор будет выдавать предупреждение. Рекомендуется использовать метод values_at.

[править] Array#indices

 array.indexes( i1, i2, ... iN )   -> an_array
 array.indices( i1, i2, ... iN )   -> an_array

Использование данного метода резко осуждается Руби-сообществом. Во время его использования интерпретатор будет выдавать предупреждение. Рекомендуется использовать метод values_at.

[править] Array#insert

 array.insert(index, obj...)  -> array

Вставляет полученные значения перед элементом индексом index (может быть отрицательным).

  a = %w{ a b c d }
  a.insert(2, 99)         #=> ["a", "b", 99, "c", "d"]
  a.insert(-2, 1, 2, 3)   #=> ["a", "b", 99, "c", 1, 2, 3, "d"]

[править] Array#inspect

 array.inspect  -> string

Создает «печатную» версию массива array.

[править] Array#join

 array.join(sep=$,)    -> str

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

  [ "a", "b", "c" ].join        #=> "abc"
  [ "a", "b", "c" ].join("-")   #=> "a-b-c"

[править] Array#last

 array.last     ->  obj или nil
 array.last(n)  ->  an_array

Возвращает последний элемент или последние n элементов массива array. Если массив пуст, то для первой формы вызова (без n) возвращается nil, а для второй — пустой массив.

  [ "w", "x", "y", "z" ].last   #=> "z"

[править] Array#length

 array.length -> int
 array.size   -> int

Возвращает количество элементов в array. Может быть нулевым (для пустого массива).

  [ 1, 2, 3, 4, 5 ].length   #=> 5

Методы lenght и size — одно и то же!

[править] Array#map

 array.collect {|item| block }  -> an_array
 array.map     {|item| block }  -> an_array

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

  a = [ "a", "b", "c", "d" ]
  a.map {|x| x + "!" }       #=> ["a!", "b!", "c!", "d!"]
  a                          #=> ["a", "b", "c", "d"]

Есть итераторы Enumerable#collect и Enumerable#map, которые имеют схожую функциональность Итераторы map и collect — одно и то же!

[править] Array#map!

 array.collect! {|item| block }   ->   array
 array.map!     {|item| block }   ->   array

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

  a = [ "a", "b", "c", "d" ]
  a.map! {|x| x + "!" }
  a             #=>  [ "a!", "b!", "c!", "d!" ]

Есть итераторы Enumerable#collect и Enumerable#map, которые имеют схожую функциональность Итераторы map! и collect! — одно и то же!

Будьте внимательны при использовании данного итератора, так как он изменяет исходный массив. Чтобы исключить это изменение используйте итераторы collect и map

[править] Array#nitems

 array.nitems -> int

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

  [ 1, nil, 3, nil, 5 ].nitems   #=> 3

[править] Array#pack

 array.pack ( aTemplateString ) -> aBinaryString

Упаковывает содержимое массива array в двоичную последовательность (в виде строки) в соответствии с опциями в строке aTemplateString (см. таблицу ниже). После опций A, a и Z может идти число, которое указывает на ширину результирующего поля. Для остальных, число после опций означает — количество элементов массива которые необходимо обработать в соответствии с указанной опцией. Если в вместо числа после директивы стоит символ * («звездочка»), то все оставшиеся элементы массива необходимо обработать в соответствии с этой опцией. Любую из опций s, S, i, I, l и L можно завершать _ (знаком подчеркивания) для того, чтобы использовать размер для базовой платформы; иначе, будет использован платформонезависимый размер. В строке aTemplateString пробелы игнорируются.

  a = [ "a", "b", "c" ]
  n = [ 65, 66, 67 ]
  a.pack("A3A3A3")   #=> "a  b  c  "
  a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
  n.pack("ccc")      #=> "ABC"

Опции метода pack.

Данный метод обычно используется совместно с методом String#unpack, который выполняет обратные действия

[править] Array#pop

 array.pop  -> obj или nil

Удаляет последний элемент из массива array и возвращает его. Если на момент вызова массив был пуст, то возвращает nil.

  a = [ "a", "m", "z" ]
  a.pop   #=> "z"
  a       #=> ["a", "m"]

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод [] («батарейка»)

[править] Array#push

 array.push(obj, ... )   -> array

Добавить элемент — добавляет передаваемый объект (или несколько объектов) в конец массива. Возвращает массив с выполненным преобразованием.

  a = [ "a", "b", "c" ]
  a.push("d", "e", "f")    #=> ["a", "b", "c", "d", "e", "f"]
  a                        #=> ["a", "b", "c", "d", "e", "f"]

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод +

[править] Array#rassoc

 array.rassoc(key) -> an_array или nil

Ищет в двумерном массиве массив, последний элемент которого равен key (для сравнения используется метод ==). Возвращает первый найденный массив (то есть, ассоциированный массив) или nil, если таковой найти не удалось

  a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
  a.rassoc("two")    #=> [2, "two"]
  a.rassoc("four")   #=> nil

Для понимания происходящего, полезно взглянуть на метод assoc

[править] Array#reject

 array.reject {|item| block }  -> an_array

Возвращает новый массив, состоящий из элементов массива array, для которых значение внутри блока block равно false (или nil).

 a = [1,2,3,4,5]
 a.reject{ |item| item > 2 }    #-> [1,2]
 a                              #-> [1,2,3,4,5]

Полезно взглянуть на итераторы delete_if и reject!, которые отличается лишь тем, что изменяют исходный массив Данный метод реализован на базе метода Enumerable#reject

[править] Array#reject!

 array.reject! {|item| block }  -> array или nil

Подобно итератору delete_if удаляет из массива array элементы, для которых значение внутри блока block равно true, но возвращает nil, если изменений в массиве сделано не было.

 a = [1,2,3,4,5]
 a.reject!{ |item| item > 2 }    #-> [1,2]
 a                               #-> [1,2]
 a.reject!{ |item| item > 2 }    #-> nil

Полезно посмотреть описание итератора delete_if, который делает примерно тоже самое, но название которого лучше запоминается

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод [] («батарейка») или итератор reject

[править] Array#replace

 array.replace(other_array)  -> array

Заменяет содержимое массива array содержимым массива other_array.

  a = [ "a", "b", "c", "d", "e" ]
  a.replace([ "x", "y", "z" ])   #=> ["x", "y", "z"]
  a                              #=> ["x", "y", "z"]

Данный метод работает как присваивание, но может быть использован при построении цепочки методов (которую присваивание обычно разрывает)

Будьте внимательны при использовании данного метода, так как он изменяет исходный массив

.

[править] Array#reverse

 array.reverse -> an_array

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

  [ "a", "b", "c" ].reverse   #=> ["c", "b", "a"]
  [ 1 ].reverse               #=> [1]

[править] Array#reverse!

 array.reverse!   -> array 

Изменяет порядок элементов в массиве array на обратный.

  a = [ "a", "b", "c" ]
  a.reverse!       #=> ["c", "b", "a"]
  a                #=> ["c", "b", "a"]

Будьте внимательны при использовании данного метода, так как он изменяет исходный массив. Чтобы исключить это изменение используйте метод reverse

.

[править] Array#reverse_each

 array.reverse_each {|item| block } 

Работает точно также, как и итератор each, но элементы массива array обрабатываются в обратном порядке.

  a = [ "a", "b", "c" ]
  a.reverse_each {|x| print x, " " }

результат:

  c b a

Достичь точно такого же результата можно вот так: array.reverse.each {|item| block }

[править] Array#rindex

 array.rindex(obj)    ->  int или nil

Возвращает индекс последнего вхождения элемента в массив array, который == obj. Возвращает nil, если такой элемент не был найден Простым языком - находит obj с конца.

  a = [ "a", "b", "b", "b", "c" ]
  a.rindex("b")   #=> 3
  a.rindex("z")   #=> nil

Советую взглянуть на метод index, который не только похож по названию, но, в некоторых случаях, работает точно также, как и rindex

[править] Array#select

 array.select {|item| block } -> an_array

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

  a = %w{ a b c d e f }
  a.select {|v| v =~ /[aeiou]/}   #=> ["a", "e"]

Есть итераторы Enumerable#select и #Enumerable#find_all, которые имеют схожую функциональность

[править] Array#shift

 array.shift   ->   obj or nil

Удаляет первый элемент из массива array и возвращает его (как бы «сдвигает» массив влево на один элемент). Если на момент вызова массив был пуст, то возвращает nil.

  args = [ "-m", "-q", "filename" ]
  args.shift   #=> "-m"
  args         #=> ["-q", "filename"]

Данный метод обычно используют совместно с методами push, pop и unshift

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод [] («батарейка»)

[править] Array#size

 array.length -> int
 array.size   -> int

Возвращает количество элементов в array. Может быть нулевым (для пустого массива).

  [ 1, 2, 3, 4, 5 ].size   #=> 5

Методы lenght и size — одно и то же!

[править] Array#slice

 array[index]                -> obj      or nil
 array[start, length]        -> an_array or nil
 array[range]                -> an_array or nil
 array.slice(index)          -> obj      or nil
 array.slice(start, length)  -> an_array or nil
 array.slice(range)          -> an_array or nil

Получение значения элемента — возвращает элемент с индексом index, или подмассив длины length, начиная с индекса start, или подмассив, который располагается в диапазоне range. Отрицательная индексация предполагает отчет с конца массива (по индексу -1 располагается последний элемент). Возвращает nil, если индекс выходит за диапазон допустимых значений.

  a = [ "a", "b", "c", "d", "e" ]
  a.slice(2) +  a.slice(0) + a.slice[1]    #=> "cab"
  a.slice[6]                               #=> nil
  a.slice(1, 2)                            #=> [ "b", "c" ]
  a.slice(1..3)                            #=> [ "b", "c", "d" ]
  a.slice(4..7)                            #=> [ "e" ]
  a.slice(6..10)                           #=> nil
  a.slice(-3, 3)                           #=> [ "c", "d", "e" ]
  # специальные случаи
  a.slice(5)                               #=> nil
  a.slice(5, 1)                            #=> []
  a.slice(5..10)                           #=> []

Методы slice и [] — одно и тоже! Существует метод at, который обладает схожей, но меньшей функциональностью

[править] Array#slice!

 array.slice!(index)         -> obj или nil
 array.slice!(start, length) -> sub_array или nil
 array.slice!(range)         -> sub_array или nil 

Удаляет элемент или элементы массива array по индексу (иногда с продолжительностью lenght) или диапазону. Возвращает удаляемые объект, подмассив или nil (если указанный индекс выходит за предел допустимых значений).

  def slice!(*args)
    result = self[*args]
    self[*args] = nil
    result
  end

  a = [ "a", "b", "c" ]
  a.slice!(1)     #=> "b"
  a               #=> ["a", "c"]
  a.slice!(-1)    #=> "c"
  a               #=> ["a"]
  a.slice!(100)   #=> nil
  a               #=> ["a"]

Частными реализациями данного метода являются методы pop ( array.slice!(-1) ) и shift ( array.slice!(0) )

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте методы [] («батарейка»), values_at или итератор reject

[править] Array#sort

 array.sort                   -> an_array 
 array.sort {| a,b | block }  -> an_array 

Возвращает новый массив, который получен путем сортировки массива array (по возрастанию). Элементы массива должны допускать сравнение при помощи метода <=>, если это не обеспечивается, то можно использовать необязательный блок. Блок предназначенный для сравнения параметров a и b, должен возвращать значения -1, 0, или +1.

  a = [ "d", "a", "e", "c", "b" ]
  a.sort                    #=> ["a", "b", "c", "d", "e"]
  a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]

Более интересная и чаще используемая форма сортировки производится при помощи итератора Enumerable#sort_by

[править] Array#sort!

 array.sort!                   -> array
 array.sort! {| a,b | block }  -> array 

Сортирует массив array (по возрастанию). Элементы массива должны допускать сравнение при помощи метода <=>, если это не обеспечивается, то можно использовать необязательный блок. Блок предназначенный для сравнения параметров a и b, должен возвращать значения -1, 0, или +1.

  a = [ "d", "a", "e", "c", "b" ]
  a.sort                    #=> ["a", "b", "c", "d", "e"]
  a.sort {|x,y| y <=> x }   #=> ["e", "d", "c", "b", "a"]

Более интересная и чаще используемая форма сортировки производится при помощи метода Enumerable#sort_by

Будьте внимательны при использовании данного итератора, так как он изменяет исходный массив. Чтобы исключить это изменение используйте итераторы sort и Enumerable#sort_by

.

[править] Array#to_a

 array.to_a     -> array

Возвращает указатель на self. Если вызывается от потомка класса Array, то конвертирует указанный объект в массив (объект класса Array).

[править] Array#to_ary

 array.to_ary -> array

Возвращает указатель на self. По сути, ничего не делает.

[править] Array#to_s

 array.to_s -> string

Возвращает результат self.join.

  [ "a", "e", "i", "o" ].to_s   #=> "aeio"

[править] Array#transpose

 array.transpose -> an_array

Подразумевает, что array является массивом массивов (то есть с размерностью больше, чем один) и меняет местами столбцы со строками (транспонирует).

  a = [[1,2], [3,4], [5,6]]
  a.transpose   #=> [[1, 3, 5], [2, 4, 6]]

[править] Array#uniq

 array.uniq   -> an_array

Возвращает новый массив, который получен из массива array путем удаления всех повторяющихся элементов (то есть остаются только «uniq'альные элементы»).

  a = [ "a", "a", "b", "b", "c" ]
  a.uniq   #=> ["a", "b", "c"]

[править] Array#uniq!

 array.uniq! -> array или nil

Удаляет из массива array все повторяющиеся элементы (то есть остаются только «uniq'альные элементы»). Возвращает nil, если повторяющиеся элементы в массиве array отсутствовали.

  a = [ "a", "a", "b", "b", "c" ]
  a.uniq!   #=> ["a", "b", "c"]
  b = [ "a", "b", "c" ]
  b.uniq!   #=> nil

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод uniq

[править] Array#unshift

 array.unshift(obj, ...)  -> array

Добавляет элементы в начало массива array (со сдвигом вправо уже существующих).

  a = [ "b", "c", "d" ]
  a.unshift("a")   #=> ["a", "b", "c", "d"]
  a.unshift(1, 2)  #=> [ 1, 2, "a", "b", "c", "d"]
  a                #=> [ 1, 2, "a", "b", "c", "d"]

Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод +

[править] Array#values_at

 array.values_at(selector,... )  -> an_array

Возвращает массив, который состоит из элементов массива array, которые соответствуют передаваемым селекторам. Селекторы могут быть целыми числами (индексами) или целочисленными диапазонами.

  a = %w{ a b c d e f }
  a.values_at(1, 3, 5)
  a.values_at(1, 3, 5, 7)
  a.values_at(-1, -3, -5, -7)
  a.values_at(1..3, 2...5)

Для подобных целей также используются методы select и [] («батарейка»). Вот только в «батарейке» нельзя указывать несколько непоследовательных индексов или диапазонов, а select отбирает элементы по условию (а не по индексу)

[править] Array#zip

 array.zip(arg, ...)                   -> an_array
 array.zip(arg, ...) {| arr | block }  -> nil

Преобразует аргументы в массивы (при помощи метода to_a). Объединяет каждый элемент массива array с соответствующим массивом, переданным в качестве аргумента. В результате этого создается двумерный массив с array.size строками и с n столбцами, где n — максимальная из длин аргументов-массивов. Если длина какого либо из аргументов-массивов меньше n, то он расширяется до длины n (дополняется nil). Если задан блок, то получаемые массивы передаются в блок в качестве параметра, иначе — возвращается двумерный массив.

  a = [ 4, 5, 6 ]
  b = [ 7, 8, 9 ]

  [1,2,3].zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
  [1,2].zip(a,b)         #=> [[1, 4, 7], [2, 5, 8]]
  a.zip([1,2],[8])       #=> [[4,1,8], [5,2,nil], [6,nil,nil]]

Обычно используется совместно с методом assoc, то есть zip подготавливает для него массив, по которому будет осуществляться ассоциация

[править] Класс Bignum < Integer

Классу Bignum принадлежат целые числа, которые не умещаются в диапазон класса Fixnum. Объекты класса Bignum создаются автоматически, когда результат вычислений превышает (по модулю) предельное значение класса Fixnum. Когда, в результате вычислений, объект класса Bignum уменьшается настолько, что его значение можно хранить в объекте класса Fixnum, то он автоматически преобразуется в Fixnum. Для обеспечения работы побитовых операций и метода [], объект класса Bignum следует рассматривать как двоичную последовательность бесконечной длины. В отличие от Fixnum, объекты класса Bignum передаются не непосредственно, а по ссылке.

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

[], %, &, **, *, +, -@, -, /, <<, <=>, ==, >>, ^, abs, coerce, divmod, div, eql?, hash, modulo, power!, quo, rdiv, remainder, rpower, size, to_f, to_s, ||, ~

[править] Bignum#%

big % other         #-> numeric
big.modulo(other)   #-> numeric

Возвращает остаток от деления числа big на числоother.

1234567890 % 2      #-> 0
1234567890 % 1.2    #-> 4.56881898980299e-008
1234567890 % -2     #-> 0

Полезно взглянуть в описание метода Numeric#divmod для получения более детальной информации

Методы % и modulo — абсолютно идентичны, то есть являются именами одного и того же метода

Полезно посмотреть на методы **, +, -, / и *, которые имеют схожую функциональность

[править] Bignum#&

big & numeric   #->  integer

Побитовое И.

[править] Bignum#*

big * other  #-> numeric

Умножает число big на число other и возвращает результат.

1234567890 * 2      #-> 2469135780
1234567890 * 1.2    #-> 1481481468.0
1234567890 * -2     #-> -2469135780

Полезно посмотреть на методы **, +, -, / и %, которые имеют схожую функциональность

[править] Bignum#**

big ** other        #-> numeric
big.rpower(other)   #-> numeric

Возводит число big в степень other (которая может быть целым, дробным или любым другим числом). Результат может быть класса Fixnum, Bignum или Float.

123456789 ** 2      #-> 15241578750190521
123456789 ** 1.2    #-> 5126464716.09932
123456789 ** -2     #-> 6.5610001194102e-17

Полезно посмотреть на методы *, +, -, /, % и power!, которые имеют схожую функциональность

Методы ** и rpower — абсолютно идентичны, то есть являются именами одного и того же метода

[править] Bignum#+

big + other  #-> numeric

Складывает число big с числом other и возвращает результат.

1234567890 + 2      #-> 1234567892
1234567890 + 1.2    #-> 1234567891.2
1234567890 + (-2)   #-> 1234567888

Полезно посмотреть на методы **, *, -, / и %, которые имеют схожую функциональность

[править] Bignum#-

big - other  #-> numeric

Вычитает из числа big число other и возвращает результат.

1234567890 - 2      #-> 1234567888
1234567890 - 1.2    #-> 1234567888.8
1234567890 - (-2)   #-> 1234567892

Полезно посмотреть на методы **, +, *, / и %, которые имеют схожую функциональность

[править] Bignum#-@

-big   #->  other_big

Унарный минус (возвращает новый объект класса Bignum, значение которого равно 0-big)

[править] Bignum#/

big / other     #-> numeric
big.div(other)  #-> numeric

Делит число big на число other и возвращает результат.

1234567890 / 2      #-> 617283945
1234567890 / 1.2    #-> 1028806575.0
1234567890 / (-2)   #-> -617283945

Полезно посмотреть на методы **, *, -, +, % и quo, которые имеют схожую функциональность

Методы / и div — абсолютно идентичны, то есть являются именами одного и того же метода

[править] Bignum#<<

big << numeric   #->  integer

Побитовый сдвиг числа big влево на numeric позиций (вправо, если numeric меньше нуля).

Полезно посмотреть на метод >>, который имеет схожую функциональность

[править] Bignum#<=>

big <=> numeric   #-> -1, 0, +1

Сравнение -- возвращает -1, 0 или +1, если значение числа big меньше, равно или больше значения числа numeric, соотвественно. Это базис для тестов в примеси Comparable.

[править] Bignum#==

big == obj  #-> true или false

Возвращает true, если число obj имеет такое же значение, что и число big. В отличие от метода eql?, приводит число obj к классу Bignum.

68719476736 == 68719476736.0   #-> true

[править] Bignum#>>

big >> numeric   #->  integer

Побитовый сдвиг числа big вправо на numeric позиций (влево, если numeric меньше нуля).

Полезно посмотреть на метод <<, который имеет схожую функциональность

[править] Bignum#[]

big[n]   #-> 0, 1

Побитовый доступ -- возвращает nый бит (виртуальный) двоичного представления числа big, где big[0] -- младший значащий бит.

a = 9**15
50.downto(0) do |n|
  print a[n]
end

результат:

 000101110110100000111000011110010100111100010111001

[править] Bignum#^

big ^ numeric   #->  integer

Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ

[править] Bignum#abs

big.abs #-> bignum

Возвращает абсолютное значение числа big.

-1234567890987654321.abs   #-> 1234567890987654321

[править] Bignum#coerce

big.coerce(other)   #-> array

Возвращает массив, состоящий из чисел other и big, которые преобразованы к классу Bignum.

result = 1234567890.coerce( 1234 )   #-> [1234, 1234567890]
result[0]                            #-> 1234
result[0].class                      #-> Bignum

[править] Bignum#div

big / other     #-> numeric
big.div(other)  #-> numeric

Делит число big на число other и возвращает результат.

1234567890 / 2      #-> 617283945
1234567890 / 1.2    #-> 1028806575.0
1234567890 / (-2)   #-> -617283945

Полезно посмотреть на методы **, *, -, +, % и quo, которые имеют схожую функциональность

Методы / и div — абсолютно идентичны, то есть являются именами одного и того же метода

[править] Bignum#divmod

big.divmod(numeric)   #-> array

Полезно взглянуть в описание метода Numeric#divmod для получения более детальной информации

[править] Bignum#eql?

big.eql?(obj)   #-> true или false

Возвращает true, если число obj имеет такое же значение, что и число big. В отличие от метода ==, не занимается приведением типов.

68719476736.eql?(68719476736.0)   #-> false

[править] Bignum#hash

big.hash   #-> fixnum

Вычисляет контрольную сумму на основе значения числа big.

[править] Bignum#modulo

big % other         #-> numeric
big.modulo(other)   #-> numeric

Возвращает остаток от деления числа big на числоother.

Полезно взглянуть в описание метода Numeric#divmod для получения более детальной информации

Методы % и modulo — абсолютно идентичны, то есть являются именами одного и того же метода

Полезно посмотреть на методы **, +, -, / и *, которые имеют схожую функциональность

[править] Bignum#power!

big.power!(other)   #-> numeric

Производит возведение числа fix в степень other.

1234567890.power!( 2 )    #-> 1524157875019052100
1234567890.power!( -2 )   #-> 6.5610001194102e-019

Полезно посмотреть на методы ** и rpower, которые имеют схожую функциональность

[править] Bignum#quo

big.quo(other)    #-> numeric
big.rdiv(other)   #-> numeric

Делит число big на число other и в качестве результата возвращает рациональное число.

1234567890.quo(7)   #-> Rational(1234567890, 7)

Полезно посмотреть на методы / и div, которые имеют схожую функциональность

Методы quo и rdiv — абсолютно идентичны, то есть являются именами одного и того же метода

[править] Bignum#rdiv

big.quo(other)    #-> numeric
big.rdiv(other)   #-> numeric

Делит число big на число other и в качестве результата возвращает рациональное число.

1234567890.rdiv(7)   #-> Rational(1234567890, 7)

Полезно посмотреть на методы / и div, которые имеют схожую функциональность

Методы quo и rdiv — абсолютно идентичны, то есть являются именами одного и того же метода

[править] Bignum#remainder

big.remainder(numeric)    #-> number

Возвращает остаток от деления числа big на число numeric.

-1234567890987654321.remainder(13731)      #-> -6966
-1234567890987654321.remainder(13731.24)   #-> -9906.22531493148

Полезно посмотреть на методы quo, rdiv, % и modulo, которые имеют схожую функциональность

Результат работы данного метода и методов % и modulo (которые по идее делают тоже самое) существенно отлючаются

[править] Bignum#rpower

big ** other        #-> numeric
big.rpower(other)   #-> numeric

Производит возведение числа big в степень other. Возвращает рациональное число, если результат рациональный (то есть, когда other < 0).

1234567890.power!( 2 )    #-> 1524157875019052100
1234567890.power!( -2 )   #-> Rational(1, 1524157875019052100)

Методы ** и rpower — абсолютно идентичны, то есть являются именами одного и того же метода

Полезно посмотреть на метод power!, который имеет схожую функциональность

[править] Bignum#size

big.size #-> integer

Возвращает количество байт машинного представления числа big.

(256**10 - 1).size   #-> 12
(256**20 - 1).size   #-> 20
(256**40 - 1).size   #-> 40

[править] Bignum#to_f

big.to_f   #-> float

Преобразует число big в число класса Float. Если число big не может быть преобразовано к классу Float, то возвращает бесконечность.

Полезно посмотреть на метод to_s, который имеет схожую функциональность

[править] Bignum#to_s

big.to_s(base=10)   #->  string

Возвращает строку, где число big имеет основание системы счисления равное base (между 2 и 36). По умолчанию base=10 (то есть десятичная система счисления).

12345654321.to_s         #-> "12345654321"
12345654321.to_s(2)      #-> "1011011111110110111011110000110001"
12345654321.to_s(8)      #-> "133766736061"
12345654321.to_s(16)     #-> "2dfdbbc31"
78546939656932.to_s(36)  #-> "rubyrules"

Полезно посмотреть на метод to_f, который имеет схожую функциональность

[править] Bignum#|

big | numeric   #->  integer

Побитовое ИЛИ.

[править] Bignum#~

~big  #->  integer

Побитовое НЕ. Так как Bignum теоретически имеет бесконечную длину, то для вычисления результата берется число big на один бит длиннее старшего значащего бита (чтобы операция инверсии была обратимой).

sprintf("%X", ~0x499602d2)    #-> "-499602d3"
~~1234567890                  #-> 1234567890

[править] Класс Class < Module

Классы в Руби это уникальные объекты --- каждый из которых является экземпляром класса Class. Когда новый класс создается (обычно используется class Name ... end), объект типа Class создается и присваивается одноименной глобальной переменной (в данном случае Name). Когда вызывается Name.new для создания нового объекта, запускается метод new класса Class. Это можно продемонстрировать перегрузкой метода new в классе Class:

class Class
   alias oldNew  new
   def new(*args)
      print "Создается новый ", self.name, "\n"
      oldNew(*args)
   end
end
 
class Name
end
 
n = Name.new

результат:

Создается новый Name

Классы, модули и объекты взаимосвязаны. На следующей диаграмме, вертикальными стрелками обозначено наследование, а круглыми скобками --- метаклассы. Все метаклассы это объекты класса `Class'.

                         +------------------+
                         |                  |
           Object---->(Object)              |
            ^  ^        ^  ^                |
            |  |        |  |                |
            |  |  +-----+  +---------+      |
            |  |  |                  |      |
            |  +-----------+         |      |
            |     |        |         |      |
     +------+     |     Module--->(Module)  |
     |            |        ^         ^      |
OtherClass-->(OtherClass)  |         |      |
                           |         |      |
                         Class---->(Class)  |
                           ^                |
                           |                |
                           +----------------+

Объявленные атрибуты будут доступны в пределах иерархии наследования, где каждый потомок получает копию атрибутов своих родителей, вместо истинного указателя на него. Это означает, что потомок может добавить элементы, для примера, в массив без тех дополнений которые он делит со своим родителем, элементами одного с ним уровня (имеющими общего родителя) или потомками, которые не похожи на правильные атрибуты уровня класса и которые разделены поперек всей иерархии

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

new

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

allocate, inherited, new, superclass

[править] Class::new

Class.new(super_class=Object)   #->    a_class

Создание нового анонимного (безымянного) класса наследованного от super_class (или Object, если вызывается без параметров). Вы можете дать классу имя, присвоив его константе.

[править] Class#allocate

class.allocate   #->   obj

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

[править] Class#inherited

class.inherited( sub_class )

Вызывается Руби, когда происходит наследование от класса class. Новый подкласс передается в качестве параметра sub_class.

class Top
   def Top.inherited(sub)
      puts "Новый подкласс: #{sub}"
   end
end
 
class Middle < Top
end
 
class Bottom < Middle
end

результат:

Новый подкласс: Middle
Новый подкласс: Bottom

[править] Class#new

class.new(args, ...)    #->  obj

Вызывает allocate для создания нового объекта класса class, вызывается метод initialize, которому передается args. Этот метод вызывается каждый раз, когда создается объект при помощи метода .new.

[править] Class#superclass

class.superclass   #-> a_super_class или nil

Возвращает суперкласс (от которого произошло наследование) класса class, или nil.

File.superclass     #-> IO
IO.superclass       #-> Object
Object.superclass   #-> nil

[править] Примесь Comparable

Примесь Comparable используется классами, объекты которых должны сравниваться. Класс должен реализовать оператор <=>, который сравнивает полученные объекты и возвращает -1, 0, или +1, если левый объект меньше, равен или больше правого, соотвественно. Comparable использует метод <=> в реализации остальных операторов сравнения (<, <=, ==, >= и >) и метода between?.

class SizeMatters
   include Comparable
   attr :str
   def <=>(anOther)
      str.size <=> anOther.str.size
   end
   def initialize(str)
      @str = str
   end
   def inspect
     @str
   end
end
 
s1 = SizeMatters.new("Z")
s2 = SizeMatters.new("YY")
s3 = SizeMatters.new("XXX")
s4 = SizeMatters.new("WWWW")
s5 = SizeMatters.new("VVVVV")
 
s1 < s2                       #-> true
s4.between?(s1, s3)           #-> false
s4.between?(s3, s5)           #-> true
[ s3, s2, s5, s4, s1 ].sort   #-> [Z, YY, XXX, WWWW, VVVVV]

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

<=, <, ==, >=, >, between?

[править] Comparable#<

obj < other    #-> true или false

Сравнение двух объектов, основанное на результате вызова метода <=>, возвращает true если тот возвращает -1.

[править] Comparable#<=

obj <= other    #-> true или false

Сравнение двух объектов, основанное на результате вызова метода <=>, возвращает true если тот возвращает -1 или 0.

[править] Comparable#==

obj == other    #-> true или false

Сравнение двух объектов, основанное на результате вызова метода <=>, возвращает true если тот возвращает 0. Еще возвращает true если obj и other являются ссылками на один и тот же объект.

[править] Comparable#>

obj > other    #-> true или false

Сравнение двух объектов основанное на результате вызова метода <=>, возвращает true если тот возвращает 1.

[править] Comparable#>=

obj >= other    #-> true или false

Сравнение двух объектов, основанное на результате вызова метода <=>, возвращает true если тот возвращает 0 или 1.

[править] Comparable#between?

obj.between?(min, max)    #-> true или false

Возвращает false если obj <=> min меньше нуля или если obj <=> max больше нуля, true иначе.

3.between?(1, 5)               #-> true
6.between?(1, 5)               #-> false
'cat'.between?('ant', 'dog')   #-> true
'gnu'.between?('ant', 'dog')   #-> false

[править] Класс Dir

tmpdir - retrieve temporary directory path $Id: tmpdir.rb,v 1.5.2.1 2005/12/15 15:57:05 matz Exp $

Примеси

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),

Windows::DeviceIO (CTL_CODE, DeviceIoControl, FSCTL_SET_COMPRESSION, FSCTL_SET_SPARSE),

Windows::Directory (CreateDirectory, CreateDirectoryEx, CreateDirectoryExW, CreateDirectoryW, FindCloseChangeNotification, FindFirstChangeNotification, FindNextChangeNotification, GetCurrentDirectory, GetCurrentDirectoryW, ReadDirectoryChangesW, RemoveDirectory, RemoveDirectoryW, SetCurrentDirectory, SetCurrentDirectoryW),

Windows::Error (FormatMessage, FormatMessageW, GetLastError, SetErrorMode, SetLastError, SetLastErrorEx, get_last_error),

Windows::File (CopyFile, CopyFileEx, CreateFile, CreateHardLink, DecryptFile, DeleteFile, EncryptFile, GetBinaryType, GetFileAttributes, GetFileAttributesEx, GetFileSize, GetFileSizeEx, GetFileType, GetFullPathName, GetLongPathName, GetShortPathName, LockFile, LockFileEx, ReadFile, ReadFileEx, SetFileAttributes, UnlockFile, UnlockFileEx, WriteFile, WriteFileEx),

Windows::Shell (SHGetFolderPath, SHGetSpecialFolderLocation, SHGetSpecialFolderPath)

Константы

VERSION

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

[], chdir, chroot, create_junction, delete, empty?, entries, foreach, getwd, glob, junction?, mkdir, new, open, pwd, rmdir, tmpdir, unlink

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

close, each, path, pos=, pos, read, rewind, seek, tell

[править] Dir::[]

 Dir[ string ] => array

Equivalent to calling dir.glob(string,0).

[править] Dir::chdir

 Dir.chdir( [ string] ) => 0
 Dir.chdir( [ string] ) {| path | block }  => anObject

Changes the current working directory of the process to the given string. When called without an argument, changes the directory to the value of the environment variable HOME, or LOGDIR. SystemCallError (probably Errno::ENOENT) if the target directory does not exist. If a block is given, it is passed the name of the new current directory, and the block is executed with that as the current directory. The original working directory is restored when the block exits. The return value of chdir is the value of the block. chdir blocks can be nested, but in a multi-threaded program an error will be raised if a thread attempts to open a chdir block while another thread has one open.

  Dir.chdir("/var/spool/mail")
  puts Dir.pwd
  Dir.chdir("/tmp") do
    puts Dir.pwd
    Dir.chdir("/usr") do
      puts Dir.pwd
    end
    puts Dir.pwd
  end
  puts Dir.pwd

produces:

  /var/spool/mail
  /tmp
  /usr
  /tmp
  /var/spool/mail

[править] Dir::chroot

 Dir.chroot( string ) => 0

Changes this process's idea of the file system root. Only a privileged process may make this call. Not available on all platforms. On Unix systems, see chroot(2) for more information.

[править] Dir::create_junction

 Dir::create_junction(to, from)

Creates the symlink to, linked to the existing directory from. If the to directory already exists, it must be empty or an error is raised.

[править] Dir::delete

 Dir.delete( string ) => 0
 Dir.rmdir( string ) => 0
 Dir.unlink( string ) => 0

Deletes the named directory. Raises a subclass of SystemCallError if the directory isn't empty.

[править] Dir::empty?

 Dir::empty?(path)

Returns whether or not path is empty. Returns false if path is not a directory, or contains any files other than '.' or '..'.

[править] Dir::entries

 Dir.entries( dirname ) => array

Returns an array containing all of the filenames in the given directory. Will raise a SystemCallError if the named directory doesn't exist.

  Dir.entries("testdir")   #=> [".", "..", "config.h", "main.rb"]

[править] Dir::foreach

 Dir.foreach( dirname ) {| filename | block }  => nil

Calls the block once for each entry in the named directory, passing the filename of each entry as a parameter to the block.

  Dir.foreach("testdir") {|x| puts "Got #{x}" }

produces:

  Got .
  Got ..
  Got config.h
  Got main.rb

[править] Dir::getwd

 Dir.getwd => string
 Dir.pwd => string

Returns the path to the current working directory of this process as a string.

  Dir.chdir("/tmp")   #=> 0
  Dir.getwd           #=> "/tmp"

[править] Dir::glob

 Dir.glob( string, [flags] ) => array
 Dir.glob( string, [flags] ) {| filename | block }  => nil

Returns the filenames found by expanding the pattern given in string, either as an array or as parameters to the block. Note that this pattern is not a regexp (it's closer to a shell glob). See File::fnmatch for the meaning of the flags parameter.