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, count, 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, min, nitems, pack, pop, push, rassoc, reject!, reject, replace, reverse!, reverse_each, reverse, rindex, sample, select, shift, shuffle, 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(array)
Array.new(size=0, obj = nil)
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] <=> [1, 2, 3, 4, 5]  #=>  0
[1, 2, 3, 4, 5] <=> [1, 2, 3, 4]     #=> +1

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


array == other_array  #=> bool

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

["a", "b"]    == ["a", "b", 5]    #=> false
["a", "b", 5] == ["a", "b", 5]    #=> true
["a", "b", 5] == ["a", "b", "c"]  #=> 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#[]=[править]


array[index] = obj  #=> obj
array[start, length] = obj или an_array или nil  #=> obj или an_array или nil
array[range]         = obj или an_array или nil  #=> obj или an_array или nil

Распределение элементов — помещает элемент в array поindex, или заменяет подмассив некоторойlength (длины), начиная с индексаstart, или заменяет подмассив в определенномrenge (диапазоне). Если индексация превышает текущий размер массива, то массив увеличивается автоматически. Отрицательная индексация подразумевает отсчет с конца массива. Если для второго случая использоватьlength равную 0, то указанные элементы будут вставлены перед элементом с индексомindex. Если все параметры для второго и третьего случая задать равнымиnil, то изarray будут удалены все элементы. Ошибка 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[править]


array.abbrev(pattern = nil)

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

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

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"]
Информация

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!"]
Информация

.

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

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


array.concat(other_array)  #=> array

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

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

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


array.count                  #=> int
array.count(obj)             #=> int
array.count { |item| block } #=> int

Без аргументов возвращает количество элементов массива. Если задан аргумент, считает количество элементов которые равны obj через ==. Если передан блок, считает количество элементов для которых блок возвращает true.

ary = [1, 2, 4, 2]
ary.count                  #=> 4
ary.count(2)               #=> 2
ary.count { |x| x%2 == 0 } #=> 3

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"

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! имеет схожую функциональность

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!, которые имеют схожую функциональность

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, так же для предотвращения ошибки IndexError используется третья форма вызова, которой будет возвращено значение блока block (в который передается запрашиваемый индекс в качестве параметра). Если во второй и третьей форме вызова будет использован индекс существующего элемента, то fetch просто вернет значение этого элемента. Отрицательная индексация подразумевает отсчёт с конца массива.

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, то это эквивалентно

length = array.[[#Array#length|length]]

Последние три формы вызова заполняют массив значением выражения в блоке 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]

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, который возвращает первый соответствующий элемент с конца массива.

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


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

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


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

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.

 a = [ad, cc, xczxc, 1, 1..4]
 a.inspect	=> 	[\ad\, \cc\, \xczxc\, 1, 1..4]

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
Информация

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

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


array.collect {|item| block }  #=> an_array
array.map {|item| block }      #=> an_array

Перебирает массив и составляет новый массив из элементов, где каждый элемент - это "обработанный" элемент исходного массива. Исходный массив при этом не изменяется.

a = ["a", "b", "c", "d"]
a.map { |x| x + "!" }  #=> ["a!", "b!", "c!", "d!"]
a                      #=> ["a", "b", "c", "d"]
a = [1, 2, 3, 4]
a.map { |x| x * x }  #=> [1, 4, 9, 16]
a                      #=> [1, 2, 3, 4]
Информация

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


array.collect! { |item| block }  #=> array
array.map! { |item| block }      #=> array

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

a = ["a", "b", "c", "d"]
a.map! {|x| x + "!" } #=> ["a!", "b!", "c!", "d!"]
a  #=>  ["a!", "b!", "c!", "d!"]
Информация

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


array.min  #=> obj

Возвращает объект в ary с минимальным значением. Первая форма предполагает, что все объекты реализуют Comparable; вторая использует блок для возврата <=> b.

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.

Опция Описание
@
Переместиться на абсолютную позицию
A
Строка ASCII (дополненная пробелами до указанной ширины)
a
Строка ASCII (дополненная нулевыми символами до указанной ширины)
B
Двоичная строка (возрастающая двоичная последовательность)
b
Двоичная строка (убывающая двоичная последовательность)
C
Беззнаковый 8-битный символ (char)
c
8-битный символ (char)
D, d
Число с плавающей точкой двойной точности, собственный формат («нативный»)
E
Число с плавающей точкой двойной точности, прямой порядок двоичной последовательности
e
Число с плавающей точкой одинарной точности, прямой порядок двоичной последовательности
F, f
Число с плавающей точкой одинарной точности, собственный формат («нативный»)
G
Число с плавающей точкой двойной точности, «сетевая» (обратная) двоичная последовательность
g
Число с плавающей точкой одинарной точности, «сетевая» (обратная) двоичная последовательность
H
Двоичная строка (верхний полубайт идет первым)
h
Двоичная строка (нижний полубайт идет первым)
I
Беззнаковое целое (unsigned integer)
i
Целое (integer)
L
Большое беззнаковое целое (usigned long)
l
Большое целое (long)
M
Строка готовая к печати, закодированная MIME (см. RFC2045)
m
Строка закодированная Base64 (см. RFC4648)
N
Большое целое (long),«сетевая» (обратная) двоичная последовательность
n
Короткое целое (short), «сетевая» (обратная) двоичная последовательность
P
Указатель на структуру (строка фиксированной длины)
p
Указатель на строку (с завершающим нулевым символом)
Q, q
64-битное число
S
Беззнаковое короткое целое (unsigned short)
s
Короткое целое (short)
U
UTF-8
u
Строка UU-кодированная
V
Длинное целое (long), прямой порядок байт
v
Короткое целое (short), прямой порядок байт
w
BER-упакованное целое
X
Символ возврата коретки
x
Нулевой символ
Z
Тоже самое, что и директиваa, исключая то, что нулевой символ добавляется со* («звездочкой»)
Информация

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

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


array.pop  #=> obj или nil

Удаляет последний элемент из массива

array

и возвращает его. Если на момент вызова массив был пуст, то возвращаетnil.

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

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

Метод возвращает новый массив , содержащий элементы , которые не соответствуют условию. Вы можете думать об этом как о фильтре, который удаляет ненужные элементы. Вот пример, который отклоняет все записи, содержащие буквы a:).

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
results = sharks.reject {|item| item.include?("a")}
print results                          #=> ["Tiger"]
Информация
  • Полезно взглянуть на итераторы 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, который делает примерно тоже самое, но название которого лучше запоминается

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"]
Информация

Данный метод работает как присваивание, но может быть использован при построении цепочки методов (которую присваивание обычно разрывает). Также незаменим при необходимости изменения содержимого массива, передающегося в функцию или блок как аргумент:

def set_123(a)
  a.replace([1, 2, 3])
end

При обычном присваивании изменилась бы только ссылка a, а в вызывающем функцию коде массив остался бы неизменным.

.

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

.

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#sample[править]


array.sample  #=> obj or nil
array.sample(n) #=> an_array
array.sample(random: rng) #=> obj
array.sample(n, random: rng) #=> an_array

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

arr = [1, 2, 3, "R", "A", "M", "A"]
arr.sample  #=> R
arr.sample(4)  #=> ["R", 2, 1, "A"]
arr.sample(4)  #=> [2, 3, "M", 1]

Необязательный аргумент rng будет использоваться в качестве генератора случайных чисел.

arr.sample(random: Random.new(1))     #=> 3
arr.sample(4, random: Random.new(1))  #=> [3, 1, "A", "A"]

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"]
a = %w{ 1 2 3 }
a.select { |el| el.even? } #=> [2]

Перебирает массив и составляет новый массив из тех элементов, для которых условие, описанное в блоке выполнится как true [1, 2, 3].select { |el| el.even? } вернёт результат [2].

Информация

Есть итераторы 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#shuffle[править]


array.shuffle  #=> an_array
array.shuffle(random: rng) #=> an_array

Перемешивает элементы массива в случайном порядке.

arr = ["R", "A", "M", "A"]
arr.shuffle  #=> ["A", "A", "R", "M"]
arr #=> ["R", "A", "M", "A"]

Необязательный аргумент rng будет использоваться в качестве генератора случайных чисел.

arr.shuffle(random: Random.new(1))  #=> ["R", "A", "M", "A"]

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


array.length  #=> int
array.size    #=> int

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

[1, 2, 3, 4, 5].size   #=> 5
Информация

Методы length и 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 по индексу (иногда с продолжительностью length) или диапазону. Возвращает удаляемые объект, подмассив или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) )

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

.

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 путем удаления всех повторяющихся элементов (то есть остаются только «уникальные» элементы).

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

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         
big.modulo(other)   #-> numeric

Возвращает остаток от деления чис#-> numeric

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, которые имеют схожую функциональность

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

Похоже на вызов dir.glob(string,0).

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


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

Сменяет текущую директорию процесса на указанную в строке. Если вызвано без аргументов, сменяется значение равное HOME, или LOGDIR. SystemCallError (вероятно Errno::ENOENT) появляется когда директории нет.. Если задан блок, ему передается имя нового текущей директории, а блок выполняется с ним в качестве текущей директории. Исходный рабочий каталог восстанавливается при выходе из блока. Возвращаемое значение chdir - это значение блока. Блоки chdir могут быть вложеными, но в многопоточной программе может вылезти ошибка, если поток попытается открыть блок chdir, а другой поток - один.

  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

производит:

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

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


 Dir.chroot( string ) => 0

Изменяет представление процесса корня файловой системы. Только уполномоченные процессы могут её использовать. Не на всех платформах доступна эта функция. На Unix системах, См. chroot(2) для детальной информации.

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


 Dir::create_junction(to, from)

Создает символическую ссылку to, связанную с существующим каталогом from. Если каталог уже существует, он должен быть пустым, иначе выдаст ошибку.

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


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

Удаляет указанную директорию. Вызывается ошибка SystemCallError если директория не пуста.

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


 Dir::empty?(path)

Возвращает результат проверки пустоты директории path. Возвращает false если path это не директория, или имеет файлы отличающиеся от '.' или '..'.

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


 Dir.entries( dirname ) => array

Возвращает массив содержащий все имена файлов в указанной директории. Будет вызван SystemCallError если директории не существует.

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

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


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

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

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

производит:

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

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


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

Возвращает путь к директории исполняемого процесса.

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

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


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

Возвращает найденные имена файлов, расширяя шаблон, указанный в string, или как array, или как параметры блока. Обратите внимание, что этот шаблон не является регулярным выражением (он ближе к оболочке glob). См. File::fnmatch для обозначение параметра flags.

Соответствует любому файлу. Может быть ограничено другими значениями в glob.

* - будет соответствовать всем файлам;

c* - будет соответствовать всем файлам, начинающимся с c;

*c - будет соответствовать всем файлам, заканчивающимся на c;

c - будет соответствовать всем файлам, имеющими c (включая начальную или конечную).

Эквивалентно / .* /x в регулярном выражении. Соответствует рекурсивным каталогам. Соответствует любому знаку. Эквивалентно /.{1}/ в регулярном выражении. Соответствует любому символу в set. Ведет себя точно так же, как наборы символов в регулярном выражении, включая установление отрицания ([^a-z]). Соответствует литералам p или литералам q. Соответствующие литералы могут иметь длину более одного символа. Можно указать более двух литералов. Эквивалентно чередованию шаблонов в регулярном выражении.

Убирает следующий метасимвол.
  Dir["config.?"]                     #=> ["config.h"]
  Dir.glob("config.?")                #=> ["config.h"]
  Dir.glob("*.[a-z][a-z]")            #=> ["main.rb"]
  Dir.glob("*.[^r]*")                 #=> ["config.h"]
  Dir.glob("*.{rb,h}")                #=> ["main.rb", "config.h"]
  Dir.glob("*")                       #=> ["config.h", "main.rb"]
  Dir.glob("*", File::FNM_DOTMATCH)   #=> [".", "..", "config.h", "main.rb"]
  rbfiles = File.join("**", "*.rb")
  Dir.glob(rbfiles)                   #=> ["main.rb",
                                           "lib/song.rb",
                                           "lib/song/karaoke.rb"]
  libdirs = File.join("**", "lib")
  Dir.glob(libdirs)                   #=> ["lib"]
  librbfiles = File.join("**", "lib", "**", "*.rb")
  Dir.glob(librbfiles)                #=> ["lib/song.rb",
                                           "lib/song/karaoke.rb"]
  librbfiles = File.join("**", "lib", "*.rb")
  Dir.glob(librbfiles)                #=> ["lib/song.rb"]

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


 Dir::junction?(path)

Возвращает является ли path соединением или нет.

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


 Dir.mkdir( string [, integer] ) => 0

Создает папку, имя которой указано в string, с разрешениями, заданными необязательным параметром как Integer. TРазрешения могут быть изменены значением File::umask, и игнорируются на NT. Вызывает SystemCallError если директория не может быть создана. См. Также обсуждение разрешений в документации по классу для File.

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


 Dir.new( string ) -> aDir

Возвращает новый объект директории.

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


 Dir.open( string ) => aDir
 Dir.open( string ) {| aDir | block } => anObject

Без блока, open это синоним к Dir::new. Если присутствует блок, он передается в Dir как параметр. Директория закрывается при окончании блока, и Dir::open возвращает значения блока.

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


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

Возвращает путь к директории исполняемого процесса.

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

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


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

Удаляет указанную директорию. Вызывает субкласс SystemCallError если директория не пуста.

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


 Dir::tmpdir()

Возвращает временный путь к файловой системе операционной системы.

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


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

Удаляет указанную директорию. Вызывает подкласс SystemCallError если директория не пуста.

Dir#close[править]


 dir.close => nil

Закрывает директорию. Дальнейшие попытки вызова dir вызовут IOError.

  d = Dir.new("testdir")
  d.close   #=> nil

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


 dir.each { |filename| block }  => dir

Вызывает блок к каждому содержимому директории, передает значение файла/папки как входной параметр.

  d = Dir.new("testdir")
  d.each  {|x| puts "Got #{x}" }

производит:

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

Dir#path[править]


 dir.path => string or nil

Возвращает значение директори записанной в dir.

  d = Dir.new("..")
  d.path   #=> ".."

Dir#pos[править]


 dir.pos => integer
 dir.tell => integer

Возвращает текущее положение в dir. См. также Dir#seek.

  d = Dir.new("testdir")
  d.tell   #=> 0
  d.read   #=> "."
  d.tell   #=> 12

Dir#pos=[править]


 dir.pos( integer ) => integer

Синоним для Dir#seek, но возвращает параметр положения.

  d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
  d.read                   #=> "."
  i = d.pos                #=> 12
  d.read                   #=> ".."
  d.pos = i                #=> 12
  d.read                   #=> ".."

Dir#read[править]


 dir.read => string or nil

Читает следующую запись из dir и возвращает ее как строку. Возвращает nil в конце потока.

  d = Dir.new("testdir")
  d.read   #=> "."
  d.read   #=> ".."
  d.read   #=> "config.h"

Dir#rewind[править]


 dir.rewind => dir

Переход dir в начало.

  d = Dir.new("testdir")
  d.read     #=> "."
  d.rewind   #=> #<Dir:0x401b3fb0>
  d.read     #=> "."

Dir#seek[править]


 dir.seek( integer ) => dir

Обращается к определенному месту в dir.integer должен быть значением, возвращаемым в Dir#tell.

  d = Dir.new("testdir")   #=> #<Dir:0x401b3c40>
  d.read                   #=> "."
  i = d.tell               #=> 12
  d.read                   #=> ".."
  d.seek(i)                #=> #<Dir:0x401b3c40>
  d.read                   #=> ".."

Dir#tell[править]


 dir.pos => integer
 dir.tell => integer

Возвращает текущее положение в dir. См. также Dir#seek.

  d = Dir.new("testdir")
  d.tell   #=> 0
  d.read   #=> "."
  d.tell   #=> 12

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

Примесь Enumerable обеспечивает классы коллекций методами итерации(обхода), поиска и сортировки значений. Класс реализующий Enumerable должен определить метод each который вызывает (в yield) последовательно элементы коллекции. Если Enumerable#max, #min, или #sort необходимы, тогда объекты коллекции должны реализовывать оператор сравнения <=>, так как эти методы зависят от порядка элементов коллекции между друг другом.


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

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

Enumerable#all?[править]


 enum.all? [{|obj| block } ]   => true or false

Передаёт в указанный блок каждый элемент коллекции. Метод возвращает true если блок ни разу не вернул false или nil. Если блок не задан, Руби добавляет неявный блок {|obj| obj} (в результате чего all? вернёт true только при условии, если ни один из элементов коллекции не оказался ни false ни nil.)

  %w{ ant bear cat}.all? {|word| word.length >= 3}   #=> true
  %w{ ant bear cat}.all? {|word| word.length >= 4}   #=> false
  [ nil, true, 99 ].all?                             #=> false

Enumerable#any?[править]


 enum.any? [{|obj| block } ]   => true or false

Передаёт в указанный блок каждый элемент коллекции. Метод вернёт true если блок хотя бы один раз вернул значение, отличное от false или nil. Если блок не задан, Руби добавляет неявный блок {|obj| obj} (в результате чего any? вернёт true если по крайней мере один из элементов коллекции не окажется ни false ни nil.

  %w{ ant bear cat}.any? {|word| word.length >= 3}   #=> true
  %w{ ant bear cat}.any? {|word| word.length >= 4}   #=> true
  [ nil, true, 99 ].any?                             #=> true

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


 enum.collect {| obj | block }  => array
 enum.map     {| obj | block }  => array

Возвращает новый массив с результатом обработки блоком каждого элемента в исходном массиве enum.

  (1..4).collect {|i| i*i }   #=> [1, 4, 9, 16]
  (1..4).collect { "cat"  }   #=> ["cat", "cat", "cat", "cat"]

Enumerable#detect[править]


 enum.detect(ifnone = nil) {| obj | block }  => obj or nil
 enum.find(ifnone = nil)   {| obj | block }  => obj or nil

Передаёт в указанный блок каждый элемент коллекции enum. Возвращает первый элемент enum, для которого результат выполнения block не является false. Если не найдено ни одного соответствия, возвращается значение параметра ifnone (если определён) либо nil

  (1..10).detect  {|i| i % 5 == 0 and i % 7 == 0 }   #=> nil
  (1..100).detect {|i| i % 5 == 0 and i % 7 == 0 }   #=> 35

Enumerable#each_cons[править]


 each_cons(n) {...}

Выполняет указанный блок для каждого массива, составляемого из набора <n> последовательных элементов коллекции. Например:

   (1..10).each_cons(3) {|a| p a}
   # выведет следующее
   [1, 2, 3]
   [2, 3, 4]
   [3, 4, 5]
   [4, 5, 6]
   [5, 6, 7]
   [6, 7, 8]
   [7, 8, 9]
   [8, 9, 10]

Enumerable#each_slice[править]


 e.each_slice(n) {...}

Выполняет указанный блок для каждого подмассива из <n> элементов. Например:

   (1..10).each_slice(3) {|a| p a}
   # outputs below
   [1, 2, 3]
   [4, 5, 6]
   [7, 8, 9]
   [10]

Enumerable#each_with_index[править]


 enum.each_with_index {|obj, i| block }  -> enum

Для каждого элемента enum вызывает block с двумя аргументами - самим элементом и его индексом.

  hash = Hash.new
  %w(cat dog wombat).each_with_index {|item, index|
    hash[item] = index
  }
  hash   #=> {"cat"=>0, "wombat"=>2, "dog"=>1}

Enumerable#entries[править]


 enum.to_a      =>    array
 enum.entries   =>    array

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

  (1..7).to_a                       #=> [1, 2, 3, 4, 5, 6, 7]
  { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a   #=> [["a", 1], ["b", 2], ["c", 3]]

Enumerable#enum_cons[править]


 e.enum_cons(n)

Возвращает Enumerable::Enumerator.new(self, :each_cons, n).

Enumerable#enum_slice[править]


 e.enum_slice(n)

Возвращает Enumerable::Enumerator.new(self, :each_slice, n).

Enumerable#enum_with_index[править]


 enum_with_index

Возвращает Enumerable::Enumerator.new(self, :each_with_index).

Enumerable#find[править]


 enum.detect(ifnone = nil) {| obj | block }  => obj or nil
 enum.find(ifnone = nil)   {| obj | block }  => obj or nil

Передает в block каждый элемент enum. Возвращает первый элемент, для которого результат обработки block не false. Если не найдено ни одного соответствия, возвращается значение параметра ifnone (если определён) либо nil

  (1..10).detect  {|i| i % 5 == 0 and i % 7 == 0 }   #=> nil
  (1..100).detect {|i| i % 5 == 0 and i % 7 == 0 }   #=> 35

Enumerable#find_all[править]


 enum.find_all {| obj | block }  => array
 enum.select   {| obj | block }  => array

Возвращает массив, содержащий все элементы enum, для которых результат обработки block не является false (см.также Enumerable#reject).

  (1..10).find_all {|i|  i % 3 == 0 }   #=> [3, 6, 9]

Enumerable#grep[править]


 enum.grep(pattern)                   => array
 enum.grep(pattern) {| obj | block }  => array

Для каждого элемента enum возвращает массив, для элементов которого выполняется условие Pattern === element. Если задан необязательный block, каждый элемент возвращённого массива обрабатывается блоком и сохраняется в возвращённом массиве.

  (1..100).grep 38..44   #=> [38, 39, 40, 41, 42, 43, 44]
  c = IO.constants
  c.grep(/SEEK/)         #=> ["SEEK_END", "SEEK_SET", "SEEK_CUR"]
  res = c.grep(/SEEK/) {|v| IO.const_get(v) }
  res                    #=> [2, 0, 1]

Enumerable#group_by[править]


 group_by() {|element| ...}

Собирает Enumerable во множества, сгруппированные по результату обработки блоком. Применим, к примеру, для группирования записей по дате. Например:

 latest_transcripts.group_by(&:day).each do |day, transcripts|
   p "#{day} -> #{transcripts.map(&:class) * ', '}"
 end
 "2006-03-01 -> Transcript"
 "2006-02-28 -> Transcript"
 "2006-02-27 -> Transcript, Transcript"
 "2006-02-26 -> Transcript, Transcript"
 "2006-02-25 -> Transcript"
 "2006-02-24 -> Transcript, Transcript"
 "2006-02-23 -> Transcript"

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


 enum.include?(obj)     => true or false
 enum.member?(obj)      => true or false

Возвращает true если хотя бы один из элементов enum окажется равен obj. Равенство проверяется оператором ==.

  IO.constants.include? "SEEK_SET"          #=> true
  IO.constants.include? "SEEK_NO_FURTHER"   #=> false

Enumerable#index_by[править]


 index_by() {|elem| ...}

Преобразует Enumerable в Hash. Например:

 people.index_by(&:login)
   => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
 people.index_by { |person| "#{person.first_name} #{person.last_name}" }
   => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}

Enumerable#inject[править]


 enum.inject(initial) {| memo, obj | block }  => obj
 enum.inject          {| memo, obj | block }  => obj

Обрабатывает элементы enum применяя к ним блок, принимающий два параметра - аккумулятор (memo) и обрабатываемый элемент. На каждом шаге аккумулятору memo присваивается значение, возвращенное блоком. Первая форма позволяет присвоить аккумулятору некоторое исходное значение. Вторая форма в качестве исходного значения аккумулятора использует первый элемент коллекции (пропуская этот элемент при проходе).

  # Сложение нескольких чисел
  (5..10).inject {|sum, n| sum + n }              #=> 45
  # Умножение нескольких чисел
  (5..10).inject(1) {|product, n| product * n }   #=> 151200
  # Нахождение наиболее длинного слова
  longest = %w{ cat sheep bear }.inject do |memo,word|
     memo.length > word.length ? memo : word
  end
  longest                                         #=> "sheep"
  # Вычисление длины наиболее длинного слова
  longest = %w{ cat sheep bear }.inject(0) do |memo,word|
     memo >= word.length ? memo : word.length
  end
  longest                                         #=> 5

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


 enum.collect {| obj | block }  => array
 enum.map     {| obj | block }  => array

Возвращает новый массив с результатами однократной обработки блоком block каждого элемента enum.

  (1..4).collect {|i| i*i }   #=> [1, 4, 9, 16]
  (1..4).collect { "cat"  }   #=> ["cat", "cat", "cat", "cat"]

Enumerable#max[править]


 enum.max                   => obj
 enum.max {|a,b| block }    => obj

Возвращает элемент enum с максимальным значением. Первая форма предполагает что все элементы являются Comparable. Вторая использует блок, возвращающий a <=> b.

  a = %w(albatross dog horse)
  a.max                                  #=> "horse"
  a.max {|a,b| a.length <=> b.length }   #=> "albatross"

Enumerable#member?[править]


 enum.include?(obj)     => true или false
 enum.member?(obj)      => true или false

Возвращает true если один из членов перечисления равен obj. Соответствие проверяется с использованием ==.

  IO.constants.include? "SEEK_SET"          #=> true
  IO.constants.include? "SEEK_NO_FURTHER"   #=> false

Enumerable#min[править]


 enum.min                    => obj
 enum.min {| a,b | block }   => obj

Возвращает элемент enum с минимальным значением. Первая форма предполагает что все элементы являются Comparable. Вторая использует блок, возвращающий a <=>

  a = %w(albatross dog horse)
  a.min                                  #=> "albatross"
  a.min {|a,b| a.length <=> b.length }   #=> "dog"

Enumerable#partition[править]


 enum.partition {| obj | block }  => [ true_array, false_array ]

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

  (1..6).partition {|i| (i&1).zero?}   #=> [[2, 4, 6], [1, 3, 5]]

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


 enum.reject {| obj | block }  => array

Возвращает массив, содержащий все элементы enum, для которых результат обработки block является false (см.также Enumerable#find_all). Иными словами выталкивает из массива все элементы обработав которые блок вернет истину. Избавиться от свидетелей.

  (1..10).reject {|i|  i % 3 == 0 }   #=> [1, 2, 4, 5, 7, 8, 10]

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


 enum.find_all {| obj | block }  => array
 enum.select   {| obj | block }  => array

Возвращает массив, содержащий все элементы enum, для которых результат обработки block не является false (см.также Enumerable#reject).

  (1..10).find_all {|i|  i % 3 == 0 }   #=> [3, 6, 9]

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


 enum.sort                     => array
 enum.sort {| a, b | block }   => array

Возвращает массив элементов enum, отсортированных либо собственным методом <=>, либо обработанных блоком. Блок возвращает -1, 0, or +1 в зависимости от результата сравнения a и b. Т.к. в Ruby 1.8, метод Enumerable#sort_by реализован на основе преобразования Шварца, он полезен для вычисления ключей или когда операции сравнения весьма ресурсоёмки.

  %w(rhea kea flea).sort         #=> ["flea", "kea", "rhea"]
  (1..10).sort {|a,b| b <=> a}   #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Enumerable#sort_by[править]


 enum.sort_by {| obj | block }    => array

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

  %w{ apple pear fig }.sort_by {|word| word.length}
               #=> ["fig", "pear", "apple"]

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

  require 'benchmark'
  include Benchmark
  
  a = (1..100000).map {rand(100000)}
  
  bm(10) do |b|
    b.report("Sort")    { a.sort }
    b.report("Sort by") { a.sort_by {|a| a} }
  end

вывод:

  user     system      total        real
  Sort        0.180000   0.000000   0.180000 (  0.175469)
  Sort by     1.980000   0.040000   2.020000 (  2.013586)

Однако рассмотрим случай, когда сравнение ключей является нетривиальной операцией. Следующий код сортирует несколько файлов по времени модификации используя основной метод sort.

  files = Dir["*"]
  sorted = files.sort {|a,b| File.new(a).mtime <=> File.new(b).mtime}
  sorted   #=> ["mon", "tues", "wed", "thurs"]

Такая сортирвка неэффективна: для каждой операции сравнения генерируется два новых объекта File. Немного лучший способ - использовать метод Kernel#test для генерации времени модификации напрямую.

  files = Dir["*"]
  sorted = files.sort { |a,b|
    test(?M, a) <=> test(?M, b)
  }
  sorted   #=> ["mon", "tues", "wed", "thurs"]

Это всё ещё порождает множество ненужных объектов Time. Более эффективный метод - кеширование ключей сортировки (в данном случае времени модификации) перед сортировкой. Пользователи Perl часто называют этот метод преобразованием Шварца. Мы создаем временный массив, в котором каждый элемент - это массив, содержащий наши ключи сортировки и имя файла. Сортируем этот массив и извлекаем из результата имя файла.

  sorted = Dir["*"].collect { |f|
     [test(?M, f), f]
  }.sort.collect { |f| f[1] }
  sorted   #=> ["mon", "tues", "wed", "thurs"]

Это в точности то, что реализовано внутри sort_by.

  sorted = Dir["*"].sort_by {|f| test(?M, f)}
  sorted   #=> ["mon", "tues", "wed", "thurs"]

Enumerable#sum[править]


 sum(identity = 0, &block)

Вычисляет сумму элементов. напимер:

payments.sum { |p| p.price * p.tax_rate }
payments.sum(&:price)

Пример выше равнозначен payments.inject { |sum, p| sum + p.price } Также вычисляет суммы без использования блока:

 [5, 15, 10].sum # => 30

Значение по умолчанию (сумма пустого списка) равна нулю. Но это можно переопределить:

   [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)

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


 enum.to_a      =>    array
 enum.entries   =>    array

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

  (1..7).to_a                       #=> [1, 2, 3, 4, 5, 6, 7]
  { 'a'=>1, 'b'=>2, 'c'=>3 }.to_a   #=> [["a", 1], ["b", 2], ["c", 3]]

Enumerable#to_set[править]


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

Создает набор из Enumerable объекта с указанными аргументами. Для использования метода необходим require "set".

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


 enum.zip(arg, ...)                   => array
 enum.zip(arg, ...) {|arr| block }    => nil

Преобразует любые элементы в массивы, затем объединяет элементы enum с соответствующими элементами каждого из аргументов. Генерируется последовательность enum#size n-элементных массивов, где n - количество аргументов (1 или более). Если размер любого аргумента менее enum#size, то присваивается nil. Если задан блок, то он обрабатывает каждый результирующий массив. Иначе возвращается массив массивов.

  a = [ 4, 5, 6 ]
  b = [ 7, 8, 9 ]
  (1..3).zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
  "cat\ndog".zip([1])   #=> [["cat\n", 1], ["dog", nil]]
  (1..3).zip            #=> [[1], [2], [3]]

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

Глобальное значение false является единственным экземпляром класса FalseClass и означает логическое «НЕТ» в алгебре логики. Класс содержит операторы, которые позволяют false корректно вести себя в логических выражениях.


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

&, ^, to_s, ||

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


false & obj   #-> false
nil & obj     #-> false

Логическое «И» всегда возвращает false. obj всегда вычисляется, так как является аргументом метода. В этом случае нет никакого сокращенного вычисления.

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


false ^ obj    #-> true или false
nil   ^ obj    #-> true или false

Логическое «ИЛИ НЕ». Если obj равен nil или false, возвращает false; иначе возвращает true.

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


false.to_s   #->  "false"

Всегда возвращает строку "false".

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


false | obj   #->   true или false
nil   | obj   #->   true или false

Логическое «ИЛИ» возвращает false, если obj равен nil или false; true иначе.

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

ftools adds several (class, not instance) methods to the File class, for copying, moving, deleting, installing, and comparing files, as well as creating a directory path. See the File class for details. FileUtils contains all or nearly all the same functionality and more, and is a recommended option over ftools When you

 require 'ftools'

then the File class aquires some utility methods for copying, moving, and deleting files, and more. See the method descriptions below, and consider using FileUtils as it is more comprehensive.


Примеси

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

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::Limits (),

Windows::Security (AddAce, CopySid, GetAce, GetFileSecurity, GetLengthSid, GetSecurityDescriptorControl, GetSecurityDescriptorDacl, InitializeAcl, InitializeSecurityDescriptor, LookupAccountName, LookupAccountSid, SetFileSecurity, SetSecurityDescriptorDacl)

Константы

ADD, ALT_SEPARATOR, ARCHIVE, BUFSIZE, CHANGE, COMPRESSED, CONTENT_INDEXED, FULL, HIDDEN, INDEXED, MAX_PATH, NORMAL, OFFLINE, PATH_SEPARATOR, READ, READONLY, SECURITY_RIGHTS, SEPARATOR, SYSTEM, Separator, TEMPORARY, VERSION

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

archive?, atime, attributes, basename, blksize, blockdev?, catname, chardev?, chmod, chown, compare, compressed?, copy, ctime, decrypt, delete, directory?, dirname, encrypted?, encrypt, executable?, executable_real?, exist?, exists?, expand_path, extname, file?, fnmatch?, fnmatch, ftype, get_permissions, grpowned?, hidden?, identical?, indexed?, install, join, lchmod, lchown, link, long_path, lstat, makedirs, move, mtime, new, normal?, offline?, owned?, pipe?, readable?, readable_real?, readlink, readonly?, remove_attributes, rename, reparse_point?, safe_unlink, securities, set_attributes, set_permissions, setgid?, setuid?, short_path, size?, size, socket?, sparse?, split, stat, sticky?, symlink?, symlink, syscopy, system?, temporary?, truncate, umask, unlink, utime, writable?, writable_real?, zero?

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

archive=, atime, chmod, chown, compressed=, content_indexed=, ctime, flock, hidden=, indexed=, lstat, mtime, normal=, o_chmod, offline=, path, readonly=, sparse=, stat, system=, temporary=, truncate

File::archive?[править]


 File::archive?(file)

Возвращает true если файл или директория являются архивом. Приложения используют этот атрибут для маркировки файлов для резервного копирования или удаления.

File::atime[править]


 File.atime(file_name)  =>  time

Возвращает последнее время доступа для указанного файла как объект Time.

  File.atime("testfile")   #=> Wed Apr 09 08:51:48 CDT 2003

File::attributes[править]


 File::attributes(file)

Возвращает массив строк с указанием атрибутов для этого файла. Возможные значения: архив сжатый каталог зашифрованный скрытый индексированный нормальный автономный только чтнение точка повторной обработки разреженная система временная Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, используя метод: File::basename

File::blksize[править]


 File::blksize(file)

Возвращает блок файловой системы. Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, используя метод: File::blockdev?

File::catname[править]


 File::catname(from, to)

If to is a valid directory, from will be appended to to, adding and escaping backslashes as necessary. Otherwise, to will be returned. Useful for appending from to to only if the filename was not specified in to. Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, используя метод: : File::chardev?

File::chmod===[править]


 File::chmod(mode, *files)

Changes permission bits on files to the bit pattern represented by mode. If the last parameter isn't a String, verbose mode will be enabled.

 File.chmod 0755, 'somecommand'
 File.chmod 0644, 'my.rb', 'your.rb', true

File::chown[править]


 File.chown(owner_int, group_int, file_name,... ) -> integer

Changes the owner and group of the named file(s) to the given numeric owner and group id's. Only a process with superuser privileges may change the owner of a file. The current owner of a file may change the file's group to any group to which the owner belongs. A nil or -1 owner or group id is ignored. Returns the number of files processed.

  File.chown(nil, 100, "testfile")

File::compare[править]


 File::compare(from, to, verbose = false)

Returns true if and only if the contents of files from and to are identical. If verbose is true, from <=> to is printed.

File::compressed?[править]


 File::compressed?(file)

Returns true if the file or directory is compressed. For a file, this means that all of the data in the file is compressed. For a directory, this means that compression is the default for newly created files and subdirectories.

File::copy[править]


 File::copy(from, to, verbose = false)

Copies a file from to to using #syscopy. If to is a directory, copies from to to/from. If verbose is true, from -> to is printed.

File::ctime[править]


 File.ctime(file_name)  => time

Returns the change time for the named file (the time at which directory information about the file was changed, not the file itself).

  File.ctime("testfile")   #=> Wed Apr 09 08:53:13 CDT 2003

File::decrypt[править]


 File::decrypt(file)

Decrypts an encrypted file or directory. The caller must have the FILE_READ_DATA, FILE_WRITE_DATA, FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES, and SYNCHRONIZE access rights. Requires exclusive access to the file being decrypted, and will fail if another process is using the file. If the file is not encrypted an error is NOT raised. Windows 2000 or later only.

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


 File.delete(file_name, ...)  => integer
 File.unlink(file_name, ...)  => integer

Deletes the named files, returning the number of names passed as arguments. Raises an exception on any error. See also Dir::rmdir.

File::directory?[править]


 File.directory?(file_name)   =>  true or false

Returns true if the named file is a directory, false otherwise.

  File.directory?(".")

Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:

File::dirname, File::dirname

File::encrypt[править]


 File::encrypt(file)

Encrypts a file or directory. All data streams in a file are encrypted. All new files created in an encrypted directory are encrypted. The caller must have the FILE_READ_DATA, FILE_WRITE_DATA, FILE_READ_ATTRIBUTES, FILE_WRITE_ATTRIBUTES, and SYNCHRONIZE access rights. Requires exclusive access to the file being encrypted, and will fail if another process is using the file. If the file is compressed, EncryptFile will decompress the file before encrypting it. Windows 2000 or later only.

File::encrypted?[править]


 File::encrypted?(file)

Returns true if the file or directory is encrypted. For a file, this means that all data in the file is encrypted. For a directory, this means that encryption is the default for newly created files and subdirectories.

File::executable?[править]


 File.executable?(file_name)   => true or false

Returns true if the named file is executable by the effective user id of this process.

File::executable_real?[править]


 File.executable_real?(file_name)   => true or false

Returns true if the named file is executable by the real user id of this process.

File::exist?[править]


 File.exist?(file_name)    =>  true or false
 File.exists?(file_name)   =>  true or false    (obsolete)

Return true if the named file exist

File::exists?[править]


 File.exist?(file_name)    =>  true or false
 File.exists?(file_name)   =>  true or false    (obsolete)

Return true if the named file exists. Метод возвращает true , если указанный файл file_name существует

File::expand_path[править]


 File.expand_path(file_name [, dir_string] ) -> abs_file_name

Converts a pathname to an absolute pathname. Relative paths are referenced from the current working directory of the process unless dir_string is given, in which case it will be used as the starting point. The given pathname may start with a ``~, which expands to the process owner's home directory (the environment variable HOME must be set correctly). ``~user expands to the named user's home directory.

  File.expand_path("~oracle/bin")           #=> "/home/oracle/bin"
  File.expand_path("../../bin", "/tmp/x")   #=> "/bin"

File::extname[править]


 File.extname(path) -> string

Returns the extension (the portion of file name in path after the period).

  File.extname("test.rb")         #=> ".rb"
  File.extname("a/b/d/test.rb")   #=> ".rb"
  File.extname("test")            #=> ""
  File.extname(".profile")        #=> ""

File::file?[править]


 File.file?(file_name)   => true or false

Returns true if the named file exists and is a regular file.

File::fnmatch[править]


 File.fnmatch( pattern, path, [flags] ) => (true or false)
 File.fnmatch?( pattern, path, [flags] ) => (true or false)

Returns true if path matches against pattern The pattern is not a regular expression; instead it follows rules similar to shell filename globbing. It may contain the following metacharacters:

Matches any file. Can be restricted by other values in the glob. * will match all files; c* will match all files beginning with c; *c will match all files ending with c; and c will match all files that have c in them (including at the beginning or end). Equivalent to / .* /x in regexp. Matches any one character. Equivalent to /.{1}/ in regexp. Matches any one character in set. Behaves exactly like character sets in Regexp, including set negation ([^a-z]).

Escapes the next metacharacter.

flags is a bitwise OR of the FNM_xxx parameters. The same glob pattern and flags are used by Dir::glob.

  File.fnmatch('cat',       'cat')        #=> true
  File.fnmatch('cat',       'category')   #=> false
  File.fnmatch('c{at,ub}s', 'cats')       #=> false
  File.fnmatch('c{at,ub}s', 'cubs')       #=> false
  File.fnmatch('c{at,ub}s', 'cat')        #=> false
  File.fnmatch('c?t',    'cat')                       #=> true
  File.fnmatch('c\?t',   'cat')                       #=> false
  File.fnmatch('c??t',   'cat')                       #=> false
  File.fnmatch('c*',     'cats')                      #=> true
  File.fnmatch('c/ * FIXME * /t', 'c/a/b/c/t')                 #=> true
  File.fnmatch('c*t',    'cat')                       #=> true
  File.fnmatch('c\at',   'cat')                       #=> true
  File.fnmatch('c\at',   'cat', File::FNM_NOESCAPE)   #=> false
  File.fnmatch('a?b',    'a/b')                       #=> true
  File.fnmatch('a?b',    'a/b', File::FNM_PATHNAME)   #=> false
  File.fnmatch('*',   '.profile')                            #=> false
  File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)        #=> true
  File.fnmatch('*',   'dave/.profile')                       #=> true
  File.fnmatch('*',   'dave/.profile', File::FNM_DOTMATCH)   #=> true
  File.fnmatch('*',   'dave/.profile', File::FNM_PATHNAME)   #=> false
  File.fnmatch('* / FIXME *', 'dave/.profile', File::FNM_PATHNAME)   #=> false
  STRICT = File::FNM_PATHNAME | File::FNM_DOTMATCH
  File.fnmatch('* / FIXME *', 'dave/.profile', STRICT)               #=> true

File::fnmatch?[править]


 File.fnmatch( pattern, path, [flags] ) => (true or false)
 File.fnmatch?( pattern, path, [flags] ) => (true or false)

Returns true if path matches against pattern The pattern is not a regular expression; instead it follows rules similar to shell filename globbing. It may contain the following metacharacters:

Matches any file. Can be restricted by other values in the glob. * will match all files; c* will match all files beginning with c; *c will match all files ending with c; and c will match all files that have c in them (including at the beginning or end). Equivalent to / .* /x in regexp. Matches any one character. Equivalent to /.{1}/ in regexp. Matches any one character in set. Behaves exactly like character sets in Regexp, including set negation ([^a-z]).

Escapes the next metacharacter.

flags is a bitwise OR of the FNM_xxx parameters. The same glob pattern and flags are used by Dir::glob.

  File.fnmatch('cat',       'cat')        #=> true
  File.fnmatch('cat',       'category')   #=> false
  File.fnmatch('c{at,ub}s', 'cats')       #=> false
  File.fnmatch('c{at,ub}s', 'cubs')       #=> false
  File.fnmatch('c{at,ub}s', 'cat')        #=> false
  File.fnmatch('c?t',    'cat')                       #=> true
  File.fnmatch('c\?t',   'cat')                       #=> false
  File.fnmatch('c??t',   'cat')                       #=> false
  File.fnmatch('c*',     'cats')                      #=> true
  File.fnmatch('c/ * FIXME * /t', 'c/a/b/c/t')                 #=> true
  File.fnmatch('c*t',    'cat')                       #=> true
  File.fnmatch('c\at',   'cat')                       #=> true
  File.fnmatch('c\at',   'cat', File::FNM_NOESCAPE)   #=> false
  File.fnmatch('a?b',    'a/b')                       #=> true
  File.fnmatch('a?b',    'a/b', File::FNM_PATHNAME)   #=> false
  File.fnmatch('*',   '.profile')                            #=> false
  File.fnmatch('*',   '.profile', File::FNM_DOTMATCH)        #=> true
  File.fnmatch('*',   'dave/.profile')                       #=> true
  File.fnmatch('*',   'dave/.profile', File::FNM_DOTMATCH)   #=> true
  File.fnmatch('*',   'dave/.profile', File::FNM_PATHNAME)   #=> false
  File.fnmatch('* / FIXME *', 'dave/.profile', File::FNM_PATHNAME)   #=> false
  STRICT = File::FNM_PATHNAME | File::FNM_DOTMATCH
  File.fnmatch('* / FIXME *', 'dave/.profile', STRICT)               #=> true

File::ftype[править]


 File.ftype(file_name)   => string

Identifies the type of the named file; the return string is one of ``file, ``directory, ``characterSpecial, ``blockSpecial, ``fifo, ``link, ``socket, or ``unknown.

  File.ftype("testfile")            #=> "file"
  File.ftype("/dev/tty")            #=> "characterSpecial"
  File.ftype("/tmp/.X11-unix/X0")   #=> "socket"

File::get_permissions[править]


 File::get_permissions(file, host=nil)

Returns a hash describing the current file permissions for the given file. The account name is the key, and the value is an integer representing an or'd value that corresponds to the security permissions for that file. To get a human readable version of the permissions, pass the value to the +File.securities+ method.

File::grpowned?[править]


 File.grpowned?(file_name)   => true or false

Returns true if the named file exists and the effective group id of the calling process is the owner of the file. Returns false on Windows.

File::hidden?[править]


 File::hidden?(file)

Returns true if the file or directory is hidden. It is not included in an ordinary directory listing.

File::identical?[править]


 File.identical?(file_1, file_2)   =>  true or false

Returns true if the named files are identical.

   open("a", "w") {}
   p File.identical?("a", "a")      #=> true
   p File.identical?("a", "./a")    #=> true
   File.link("a", "b")
   p File.identical?("a", "b")      #=> true
   File.symlink("a", "c")
   p File.identical?("a", "c")      #=> true
   open("d", "w") {}
   p File.identical?("a", "d")      #=> false

File::indexed?[править]


 File::indexed?(file)

Returns true if the file or directory is indexed by the content indexing service.

File::install[править]


 File::install(from, to, mode = nil, verbose = false)

If src is not the same as dest, copies it and changes the permission mode to mode. If dest is a directory, destination is dest/src. If mode is not set, default is used. If verbose is set to true, the name of each file copied will be printed.

File::join[править]


 File.join(string, ...) -> path

Returns a new string formed by joining the strings using File::SEPARATOR.

  File.join("usr", "mail", "gumby")   #=> "usr/mail/gumby"

File::lchmod[править]


 File.lchmod(mode_int, file_name, ...)  => integer

Equivalent to File::chmod, but does not follow symbolic links (so it will change the permissions associated with the link, not the file referenced by the link). Often not available.

File::lchown[править]


 file.lchown(owner_int, group_int, file_name,..) => integer

Equivalent to File::chown, but does not follow symbolic links (so it will change the owner associated with the link, not the file referenced by the link). Often not available. Returns number of files in the argument list.

File::link[править]


 File.link(old_name, new_name)    => 0

Creates a new name for an existing file using a hard link. Will not overwrite new_name if it already exists (raising a subclass of SystemCallError). Not available on all platforms.

  File.link("testfile", ".testfile")   #=> 0
  IO.readlines(".testfile")[0]         #=> "This is line one\n"

File::long_path[править]


 File::long_path(file)

Returns file in long format. For example, if 'SOMEFI~1.TXT' was the argument provided, and the short representation for 'somefile.txt', then this method would return 'somefile.txt'. Note that certain file system optimizations may prevent this method from working as expected. In that case, you will get back the file name in 8.3 format. Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:

File::lstat, File::lstat===File::makedirs===


 File::makedirs(*dirs)

Creates a directory and all its parent directories. For example,

   File.makedirs '/usr/lib/ruby'

causes the following directories to be made, if they do not exist.

   * /usr
   * /usr/lib
   * /usr/lib/ruby

You can pass several directories, each as a parameter. If the last parameter isn't a String, verbose mode will be enabled.

File::move[править]


 File::move(from, to, verbose = false)

Moves a file from to to using #syscopy. If to is a directory, copies from from to to/from. If verbose is true, from -> to is printed.

File::mtime[править]


 File.mtime(file_name)  =>  time

Returns the modification time for the named file as a Time object.

  File.mtime("testfile")   #=> Tue Apr 08 12:58:04 CDT 2003

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


 File.new(filename, mode="r")            => file
 File.new(filename [, mode [, perm]])    => file

Opens the file named by filename according to mode (default is ``r) and returns a new File object. See the description of class IO for a description of mode. The file mode may optionally be specified as a Fixnum by or-ing together the flags (O_RDONLY etc, again described under IO). Optional permission bits may be given in perm. These mode and permission bits are platform dependent; on Unix systems, see open(2) for details.

  f = File.new("testfile", "r")
  f = File.new("newfile",  "w+")
  f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)

File::normal?[править]


 File::normal?(file)

Returns true if the file or directory has no other attributes set.

File::offline?[править]


 File::offline?(file)

Returns true if the data of the file is not immediately available. This attribute indicates that the file data has been physically moved to offline storage. This attribute is used by Remote Storage, the hierarchical storage management software. Applications should not arbitrarily change this attribute.

File::owned?[править]


 File.owned?(file_name)   => true or false

Returns true if the named file exists and the effective used id of the calling process is the owner of the file.

File::pipe?[править]


 File.pipe?(file_name)   =>  true or false

Returns true if the named file is a pipe.

File::readable?[править]


 File.readable?(file_name)   => true or false

Returns true if the named file is readable by the effective user id of this process.

File::readable_real?[править]


 File.readable_real?(file_name)   => true or false

Returns true if the named file is readable by the real user id of this process.

File::readlink[править]


 File.readlink(link_name) -> file_name

Returns the name of the file referenced by the given link. Not available on all platforms.

  File.symlink("testfile", "link2test")   #=> 0
  File.readlink("link2test")              #=> "testfile"

File::readonly?[править]


 File::readonly?(file)

Returns true if The file or directory is read-only. Applications can read the file but cannot write to it or delete it. In the case of a directory, applications cannot delete it.

File::remove_attributes[править]


 File::remove_attributes(file, flags)

Removes the file attributes based on the given (numeric) flags.

File::rename[править]


 File.rename(old_name, new_name)   => 0

Renames the given file to the new name. Raises a SystemCallError if the file cannot be renamed.

  File.rename("afile", "afile.bak")   #=> 0

File::reparse_point?[править]


 File::reparse_point?(file)

Returns true if the file or directory has an associated reparse point. A reparse point is a collection of user defined data associated with a file or directory. For more on reparse points, search http://msdn.microsoft.com.

File::safe_unlink[править]


 File::safe_unlink(*files)

Removes a list of files. Each parameter should be the name of the file to delete. If the last parameter isn't a String, verbose mode will be enabled. Returns the number of files deleted.

File::securities[править]


 File::securities(mask)

Returns an array of human-readable strings that correspond to the permission flags.

File::set_attributes[править]


 File::set_attributes(file, flags)

Sets the file attributes based on the given (numeric) flags. This does not remove existing attributes, it merely adds to them.

File::set_permissions[править]


 File::set_permissions(file, perms)

Sets the file permissions for the given file name. The 'permissions' argument is a hash with an account name as the key, and the various permission constants as possible values. The possible constant values are: FILE_READ_DATA FILE_WRITE_DATA FILE_APPEND_DATA FILE_READ_EA FILE_WRITE_EA FILE_EXECUTE FILE_DELETE_CHILD FILE_READ_ATTRIBUTES FILE_WRITE_ATTRIBUTES STANDARD_RIGHTS_ALL FULL READ ADD CHANGE DELETE READ_CONTROL WRITE_DAC WRITE_OWNER SYNCHRONIZE STANDARD_RIGHTS_REQUIRED STANDARD_RIGHTS_READ STANDARD_RIGHTS_WRITE STANDARD_RIGHTS_EXECUTE STANDARD_RIGHTS_ALL SPECIFIC_RIGHTS_ALL ACCESS_SYSTEM_SECURITY MAXIMUM_ALLOWED GENERIC_READ GENERIC_WRITE GENERIC_EXECUTE GENERIC_ALL

File::setgid?[править]


 File.setgid?(file_name)   =>  true or false

Returns true if the named file has the setgid bit set.

File::setuid?[править]


 File.setuid?(file_name)   =>  true or false

Returns true if the named file has the setuid bit set.

File::short_path[править]


 File::short_path(file)

Returns 'file_name' in 8.3 format. For example, 'c:\documentation.doc' would be returned as 'c:\docume~1.doc'. Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:

File::size?, File::size, File::blksize, File::size===File::size?===


 File.file?(file_name)   => integer  or  nil

Returns nil if file_name doesn't exist or has zero size, the size of the file otherwise.

File::socket?[править]


 File.socket?(file_name)   =>  true or false

Returns true if the named file is a socket.

File::sparse?[править]


 File::sparse?(file)

Returns true if the file is a sparse file. A sparse file is a file in which much of the data is zeros, typically image files. See http://msdn.microsoft.com for more details. Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:

File::split, File::splitБолее одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:

File::lstat, File::stat, File::lstat, File::stat===File::sticky?===


 File.sticky?(file_name)   =>  true or false

Returns true if the named file has the sticky bit set.

File::symlink[править]


 File.symlink(old_name, new_name)   => 0

Creates a symbolic link called new_name for the existing file old_name. Raises a NotImplemented exception on platforms that do not support symbolic links.

  File.symlink("testfile", "link2test")   #=> 0

File::symlink?[править]


 File.symlink?(file_name)   =>  true or false

Returns true if the named file is a symbolic link.

File::syscopy[править]


 File::syscopy(from, to)

Copies a file from to to. If to is a directory, copies from to to/from.

File::system?[править]


 File::system?(file)

Returns true if the file or directory is part of the operating system or is used exclusively by the operating system.

File::temporary?[править]


 File::temporary?(file)

Returns true if the file is being used for temporary storage. File systems avoid writing data back to mass storage if sufficient cache memory is available, because often the application deletes the temporary file shortly after the handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data will be written after the handle is closed.

File::truncate[править]


 File.truncate(file_name, integer)  => 0

Truncates the file file_name to be at most integer bytes long. Not available on all platforms.

  f = File.new("out", "w")
  f.write("1234567890")     #=> 10
  f.close                   #=> nil
  File.truncate("out", 5)   #=> 0
  File.size("out")          #=> 5

File::umask[править]


 File.umask()          => integer
 File.umask(integer)   => integer

Returns the current umask value for this process. If the optional argument is given, set the umask to that value and return the previous value. Umask values are subtracted from the default permissions, so a umask of 0222 would make a file read-only for everyone.

  File.umask(0006)   #=> 18
  File.umask         #=> 6

File::unlink[править]


 File.delete(file_name, ...)  => integer
 File.unlink(file_name, ...)  => integer

Deletes the named files, returning the number of names passed as arguments. Raises an exception on any error. See also Dir::rmdir.

File::utime[править]


 File.utime(atime, mtime, file_name,...)   =>  integer

Sets the access and modification times of each named file to the first two arguments. Returns the number of file names in the argument list.

File::writable?[править]


 File.writable?(file_name)   => true or false

Returns true if the named file is writable by the effective user id of this process.

File::writable_real?[править]


 File.writable_real?(file_name)   => true or false

Returns true if the named file is writable by the real user id of this process.

File::zero?[править]


 File.zero?(file_name)   => true or false

Returns true if the named file exists and has a zero size.

File#archive=[править]


 archive=(bool)

Sets whether or not the file is an archive file.

File#atime[править]


 file.atime    => time

Returns the last access time (a Time object)

for file, or epoch if file has not been accessed.
  File.new("testfile").atime   #=> Wed Dec 31 18:00:00 CST 1969

File#chmod[править]


 file.chmod(mode_int)   => 0

Changes permission bits on file to the bit pattern represented by mode_int. Actual effects are platform dependent; on Unix systems, see chmod(2) for details. Follows symbolic links. Also see File#lchmod.

  f = File.new("out", "w");
  f.chmod(0644)   #=> 0

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

File#chown[править]


 file.chown(owner_int, group_int )   => 0

Changes the owner and group of file to the given numeric owner and group id's. Only a process with superuser privileges may change the owner of a file. The current owner of a file may change the file's group to any group to which the owner belongs. A nil or -1 owner or group id is ignored. Follows symbolic links. See also File#lchown.

  File.new("testfile").chown(502, 1000)

File#compressed=[править]


 compressed=(bool)

Sets whether or not the file is a compressed file.

File#content_indexed=[править]


 content_indexed=(bool)

Alias for #indexed=

File#ctime[править]


 file.ctime -> time

Returns the change time for file (that is, the time directory information about the file was changed, not the file itself).

  File.new("testfile").ctime   #=> Wed Apr 09 08:53:14 CDT 2003

File#flock[править]


 file.flock (locking_constant ) =>  0 or false

Locks or unlocks a file according to locking_constant (a logical or of the values in the table below). Returns false if File::LOCK_NB is specified and the operation would otherwise have blocked. Not available on all platforms. Locking constants (in class File):

  LOCK_EX   | Exclusive lock. Only one process may hold an
            | exclusive lock for a given file at a time.
  ----------+------------------------------------------------
  LOCK_NB   | Don't block when locking. May be combined
            | with other lock options using logical or.
  ----------+------------------------------------------------
  LOCK_SH   | Shared lock. Multiple processes may each hold a
            | shared lock for a given file at the same time.
  ----------+------------------------------------------------
  LOCK_UN   | Unlock.

Example:

  File.new("testfile").flock(File::LOCK_UN)   #=> 0

File#hidden=[править]


 hidden=(bool)

Sets the hidden attribute to true or false. Setting this attribute to true means that the file is not included in an ordinary directory listing.

File#indexed=[править]


 indexed=(bool)

Sets the 'indexed' attribute to true or false. Setting this to false means that the file will not be indexed by the content indexing service.

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

File#lstat[править]


 file.lstat   =>  stat

Same as IO#stat, but does not follow the last symbolic link. Instead, reports on the link itself.

  File.symlink("testfile", "link2test")   #=> 0
  File.stat("testfile").size              #=> 66
  f = File.new("link2test")
  f.lstat.size                            #=> 8
  f.stat.size                             #=> 66

File#mtime[править]


 file.mtime -> time

Returns the modification time for file.

  File.new("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003

File#normal=[править]


 normal=(bool)

Sets the normal attribute. Note that only 'true' is a valid argument, which has the effect of removing most other attributes. Attempting to pass any value except true will raise an ArgumentError.

File#o_chmod[править]


 o_chmod(p1)

Alias for #chmod

File#offline=[править]


 offline=(bool)

Sets whether or not a file is online or not. Setting this to false means that the data of the file is not immediately available. This attribute indicates that the file data has been physically moved to offline storage. This attribute is used by Remote Storage, the hierarchical storage management software. Applications should not arbitrarily change this attribute.

File#path[править]


 file.path -> filename

Returns the pathname used to create file as a string. Does not normalize the name.

  File.new("testfile").path               #=> "testfile"
  File.new("/tmp/../tmp/xxx", "w").path   #=> "/tmp/../tmp/xxx"

File#readonly=[править]


 readonly=(bool)

Sets the readonly attribute. If set to true the the file or directory is readonly. Applications can read the file but cannot write to it or delete it. In the case of a directory, applications cannot delete it.

File#sparse=[править]


 sparse=(bool)

Sets the file to a sparse (usually image) file. Note that you cannot remove the sparse property from a file.

File#stat[править]


 stat()

Instance methods

File#system=[править]


 system=(bool)

Set whether or not the file is a system file. A system file is a file that is part of the operating system or is used exclusively by it.

File#temporary=[править]


 temporary=(bool)

Sets whether or not the file is being used for temporary storage. File systems avoid writing data back to mass storage if sufficient cache memory is available, because often the application deletes the temporary file shortly after the handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data will be written after the handle is closed.

File#truncate[править]


 file.truncate(integer)    => 0

Truncates file to at most integer bytes. The file must be opened for writing. Not available on all platforms.

  f = File.new("out", "w")
  f.syswrite("1234567890")   #=> 10
  f.truncate(5)              #=> 0
  f.close()                  #=> nil
  File.size("out")           #=> 5

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

FileTest implements file test operations similar to those used in File::Stat. It exists as a standalone module, and its methods are also insinuated into the File class. (Note that this is not done by inclusion: the interpreter cheats).


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

blockdev?, chardev?, directory?, executable?, executable_real?, exist?, exists?, file?, grpowned?, identical?, owned?, pipe?, readable?, readable_real?, setgid?, setuid?, size?, size, socket?, sticky?, symlink?, writable?, writable_real?, zero?

FileTest#blockdev?[править]


 File.blockdev?(file_name)   =>  true or false

Returns true if the named file is a block device.

FileTest#chardev?[править]


 File.chardev?(file_name)   =>  true or false

Returns true if the named file is a character device.

FileTest#directory?[править]


 File.directory?(file_name)   =>  true or false

Returns true if the named file is a directory, false otherwise.

  File.directory?(".")

FileTest#executable?[править]


 File.executable?(file_name)   => true or false

Returns true if the named file is executable by the effective user id of this process.

FileTest#executable_real?[править]


 File.executable_real?(file_name)   => true or false

Returns true if the named file is executable by the real user id of this process.

FileTest#exist?[править]


 File.exist?(file_name)    =>  true or false
 File.exists?(file_name)   =>  true or false    (obsolete)

Return true if the named file exists.

FileTest#exists?[править]


 File.exist?(file_name)    =>  true or false
 File.exists?(file_name)   =>  true or false    (obsolete)

Return true if the named file exists.

FileTest#file?[править]


 File.file?(file_name)   => true or false

Returns true if the named file exists and is a regular file.

FileTest#grpowned?[править]


 File.grpowned?(file_name)   => true or false

Returns true if the named file exists and the effective group id of the calling process is the owner of the file. Returns false on Windows.

FileTest#identical?[править]


 File.identical?(file_1, file_2)   =>  true or false

Returns true if the named files are identical.

   open("a", "w") {}
   p File.identical?("a", "a")      #=> true
   p File.identical?("a", "./a")    #=> true
   File.link("a", "b")
   p File.identical?("a", "b")      #=> true
   File.symlink("a", "c")
   p File.identical?("a", "c")      #=> true
   open("d", "w") {}
   p File.identical?("a", "d")      #=> false

FileTest#owned?[править]


 File.owned?(file_name)   => true or false

Returns true if the named file exists and the effective used id of the calling process is the owner of the file.

FileTest#pipe?[править]


 File.pipe?(file_name)   =>  true or false

Returns true if the named file is a pipe.

FileTest#readable?[править]


 File.readable?(file_name)   => true or false

Returns true if the named file is readable by the effective user id of this process.

FileTest#readable_real?[править]


 File.readable_real?(file_name)   => true or false

Returns true if the named file is readable by the real user id of this process.

FileTest#setgid?[править]


 File.setgid?(file_name)   =>  true or false

Returns true if the named file has the setgid bit set.

FileTest#setuid?[править]


 File.setuid?(file_name)   =>  true or false

Returns true if the named file has the setuid bit set.

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


 File.size(file_name)   => integer

Returns the size of file_name.

FileTest#size?[править]


 File.file?(file_name)   => integer  or  nil

Returns nil if file_name doesn't exist or has zero size, the size of the file otherwise.

FileTest#socket?[править]


 File.socket?(file_name)   =>  true or false

Returns true if the named file is a socket.

FileTest#sticky?[править]


 File.sticky?(file_name)   =>  true or false

Returns true if the named file has the sticky bit set.

FileTest#symlink?[править]


 File.symlink?(file_name)   =>  true or false

Returns true if the named file is a symbolic link.

FileTest#writable?[править]


 File.writable?(file_name)   => true or false

Returns true if the named file is writable by the effective user id of this process.

FileTest#writable_real?[править]


 File.writable_real?(file_name)   => true or false

Returns true if the named file is writable by the real user id of this process.

FileTest#zero?[править]


 File.zero?(file_name)   => true or false

Returns true if the named file exists and has a zero size.

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

Класс Fixnum - это целые числа (Integer), которые умещаются в одно машинное слово (минус 1 бит). Если в результате какой либо операции число класса Fixnum выходит за пределы этого диапазона, то значение автоматически преобразуется к классу Bignum. Объекты класса Fixnum имеют непосредственное значение. Это значит, что, когда они присваиваются или передаются в качестве параметра, происходит передача фактического объекта, не не ссылки. Присваивание не работает с ссылками на объекты Fixnum. Существует лишь один объект Fixnum для каждого целочисленного значения. Именно поэтому вы не можете добавить метод-одиночку для объекта Fixnum.


Примеси

Precision (prec, prec_f, prec_i)

Константы

XChar

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

induced_from

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

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

Fixnum::induced_from[править]


Fixnum.induced_from(obj)   #->  fixnum

Преобразует obj в объект класса Fixnum. Работает с числовыми параметрами. Еще работает с символами, но рекомендуется не использовать данную возможность.

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


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

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

5 % 2      #-> 1
5 % -2     #-> -1
5 % -2.2   #-> -1.6
Информация

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

Информация

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

Информация

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

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


fix & other    #-> integer

Побитовое И.

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


fix * numeric  #->  numeric_result

Производит умножение: результат является одним из потомков класса Numeric и зависит от величины результата.

Информация

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

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


fix ** other       #-> rational или numeric
fix.rpower(other)  #-> numeric или rational

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

2 ** 8    #-> 256
2 ** -8   #-> Rational(1,256)
Информация

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

Информация

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

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


fix + numeric  #->  numeric_result

Производит сложение: результат является одним из потомков класса Numeric и зависит от величины результата.

Информация

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

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


fix - numeric  #->  numeric_result

Производит вычитание: результат является одним из потомков класса Numeric и зависит от величины результата.

Информация

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

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


-fix  #->  integer

Отрицание fix (может вернуть значение класса Bignum).

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


fix / numeric     #->  numeric_result
fix.div(numeric)  #->  numeric_result

Производит целочисленное деление: результат является одним из потомков класса Numeric и зависит от величины результата.

Информация

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

Информация

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

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


fix < other    #-> true или false

Возвращает true, если значение числа fix меньше, чем значение числа other.

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


fix << count    #-> integer

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

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


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

Возвращает true, если значение числа fix меньше или равно значению числа other.

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


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

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

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


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

Возвращает true, если значение числа fix равно значению числа other.

1 == 2      #-> false
1 == 1.0    #-> true

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


fix > other    #-> true или false

Возвращает true, если значение числа fix больше, чем значение числа other.

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


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

Возвращает true, если значение числа fix больше или равно, чем значение числа other.

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


fix >> count    #-> integer

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

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


fix[n]    #-> 0, 1

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

a = 0b11001100101010
30.downto(0) do |n| print a[n] end

результат:

 0000000000000000011001100101010

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


fix ^ other    #-> integer

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

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


fix.abs   #-> fixnum

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

-12345.abs   #-> 12345
12345.abs    #-> 12345

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


fix / numeric     #->  numeric_result
fix.div(numeric)  #->  numeric_result

Производит целочисленное деление: результат является одним из потомков класса Numeric и зависит от величины результата.

Информация

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

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


fix.divmod(numeric)   #-> array

Информация

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

Fixnum#id2name[править]


fix.id2name    #-> string или nil

Возвращает имя объекта с id равным fix. Возвращает nil, если в символьной таблице не найдено ни одного символа, соответствующего значению fix.

symbol = :@inst_var    #-> :@inst_var
id     = symbol.to_i   #-> 9818
id.id2name             #-> "@inst_var"
Информация
  • Для более полного представления о работе данного метода советуем взглянуть на описания методов to_sym, String#intern и описание класса Symbol
  • Метод id2name никак не взаимодействует с методом Object#id

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


fix % other        #-> Numeric
fix.modulo(other)  #-> Numeric

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

Информация

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

Информация

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

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


fix.power!( other )  #-> numeric

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

2.power!( 8 )    #-> 256
2.power( -8 )   #-> 0.00390625
Информация

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

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


fix.quo(numeric)   #-> float
fix.rdiv(numeric)  #-> float

Возвращает дробный результат деления числа fix на число numeric.

654321.quo(13731)      #-> 47.6528293642124
654321.quo(13731.24)   #-> 47.6519964693647
Информация

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

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


fix.quo(numeric)   #-> float
fix.rdiv(numeric)  #-> float

Возвращает дробный результат деления числа fix на число numeric.

654321.rdiv(13731)      #-> 47.6528293642124
654321.rdiv(13731.24)   #-> 47.6519964693647
Информация

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

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


fix ** other       #-> rational или numeric
fix.rpower(other)  #-> rational или numeric

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

2.rpower( 8 )    #-> 256
2.rpower( -8 )   #-> Rational(1,256)
Информация

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

Информация

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

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


fix.size   #-> fixnum

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

1.size            #-> 4
-1.size           #-> 4
2147483647.size   #-> 4

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


fix.to_f   #-> float

Преобразует значение числа fix к классу Float.

Информация

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

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


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

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

12345.to_s       #-> "12345"
12345.to_s(2)    #-> "11000000111001"
12345.to_s(8)    #-> "30071"
12345.to_s(10)   #-> "12345"
12345.to_s(16)   #-> "3039"
12345.to_s(36)   #-> "9ix"
Информация

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

Fixnum#to_sym[править]


fix.to_sym   #-> symbol

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

fred = :fred.to_i
fred.id2name   #-> "fred"
fred.to_sym    #-> :fred
Информация

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


Fixnum#zero?[править]


fix.zero?   #-> true или false

Возвращает true, если значение fix равно нулю.

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


fix | other    #-> integer

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

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


~fix    #-> integer

Побитовое НЕ.

Класс Float < Numeric[править]

Объекты класса Float представляют собой вещественные числа, то есть дробные числа с плавающей точкой двойной точности (аналог типа double в языке Си).


Примеси

Precision (prec, prec_f, prec_i)

Константы

DIG, EPSILON, MANT_DIG, MAX, MAX_10_EXP, MAX_EXP, MIN, MIN_10_EXP, MIN_EXP, RADIX, ROUNDS

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

induced_from

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

%, **, *, +, -@, -, /, <->, <=, <, ==, >=, >, abs, ceil, coerce, divmod, eql?, finite?, floor, hash, infinite?, modulo, nan?, round, to_f, to_int, to_i, to_s, truncate, zero?

Float::induced_from[править]


Float.induced_from(obj)    #->  float

Преобразует obj в вещественное число.

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


flt % other         #-> float
flt.modulo(other)   #-> float

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

6543.21 % 137      #-> 104.21
6543.21 % 137.24   #-> 92.9299999999996
Информация

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

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


flt * other   #-> float

Возвращает вещественное число, которое является результатом произведения flt на other.

Информация

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

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


flt ** other   #-> float

Возвращает вещественное число, которое является результатом возведения числа flt в степень other.

Информация

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

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


flt + other   #-> float

Возвращает вещественное число, которое является суммой чисел flt и other.

Информация

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

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


flt - other   #-> float

Возвращает вещественное число, которое является разностью чисел flt и other.

Информация

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

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


-flt   #-> float

Возвращает вещественное число, обратное по знаку (по отношению к flt).

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


float / other   #-> float

Возвращает вещественное число, которое является частным чисел flt и other.

Информация

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

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


flt < other    #->  true или false

Возвращает true, если число flt меньше, чем число other.

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


flt <= other    #->  true or false

Возвращает true, если число flt меньше или равно по отношению к числу other.

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


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

Возвращает -1, 0 или +1, когда число flt меньше, равно или больше числа numeric, соответственно. Этот метод необходим для нормальной работы примеси Comparable.

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


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

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

1.0 == 1   #-> true

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


flt > other    #->  true или false

Возвращает true, если число flt больше, чем число other.

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


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

Возвращает true, если число flt больше или равно по отношению к числу other.

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


flt.abs    #-> float

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

(-34.56).abs   #-> 34.56
-34.56.abs     #-> 34.56

Float#ceil[править]


flt.ceil    #-> integer

Возвращает наименьшее целое число большее или равное числу flt.

1.2.ceil      #-> 2
2.0.ceil      #-> 2
(-1.2).ceil   #-> -1
(-2.0).ceil   #-> -2
Информация

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

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


flt.coerce(other)    #-> array

Возвращает массив, состоящий из чисел other и flt, которые преобразованы к вещественному типу. Этот метод используется при обработке арифметических операций со смешанными типами.

1.2.coerce(3)   #-> [3.0, 1.2]
1.0.coerce(2.0)     #-> [2.0, 1.0]

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


flt.divmod(numeric)    #-> array

См. описание метода Numeric#divmod.

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


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

Возвращает true, если obj является вещественным числом и имеет значение равное flt. В отличие от метода ==, преобразований типов не производится.

1.0.eql?(1)   #-> false

Float#finite?[править]


flt.finite?   #-> true или false

Возвращает true, если flt является правильным вещественным числом по стандартам IEEE (то есть не является бесконечностью и метод nan? возвращает false).

Float#floor[править]


flt.floor    #-> integer

Возвращает наибольшее целое, меньшее или равное flt.

1.2.floor      #-> 1
2.0.floor      #-> 2
(-1.2).floor   #-> -2
(-2.0).floor   #-> -2
Информация

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

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


flt.hash    #-> integer

Возвращает хеш-код вещественного числа flt.

Float#infinite?[править]


flt.infinite?   #-> nil, -1, +1

Возвращает nil, -1 или +1, если вещественное число flt конечно, устремлено в или в , соответственно.

(0.0).infinite?        #-> nil
(-1.0/0.0).infinite?   #-> -1
(+1.0/0.0).infinite?   #-> 1

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


flt % other         #-> float
flt.modulo(other)   #-> float

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

6543.21.modulo(137)      #-> 104.21
6543.21.modulo(137.24)   #-> 92.9299999999996

Float#nan?[править]


flt.nan? -> true или false

Возвращает true, если число flt не удовлетворяет стандарту IEEE на вещественные числа.

a = -1.0      #-> -1.0
a.nan?        #-> false
a = 0.0/0.0   #-> NaN
a.nan?        #-> true

Float#round[править]


flt.round   #-> integer

Возвращает ближайшее целое число к вещественному числу flt. Метод эквивалентен следующей записи:

def round
  return floor(self+0.5) if self > 0.0
  return ceil(self-0.5)  if self < 0.0
  return 0.0
end

1.5.round      #-> 2
(-1.5).round   #-> -2
Информация

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

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


flt.to_f   #-> flt

Так как flt уже является вещественным числом, то данный метод всегда возвращает ftl.

Float#to_i[править]


flt.to_i       #-> integer
flt.to_int     #-> integer
flt.truncate   #-> integer

Возвращает целое число, которое является целой частью вещественного числа flt.

Информация

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

Float#to_int[править]


flt.to_i       #-> integer
  flt.to_int     #-> integer
 flt.truncate   #-> integer

Возвращает целое число, которое является целой частью вещественного числа flt.

Информация

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

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


flt.to_s    #-> string

Возвращает строку, которая содержит строковое представление вещественного числа flt. Число flt может быть представлено как в обычной, так и в экспоненциальной форме записи, а также иметь значения NaN, Infinity, -Infinity.

Float#truncate[править]


flt.to_i       #-> integer
  flt.to_int     #-> integer
  flt.truncate   #-> integer

Возвращает целое число, которое является целой частью вещественного числа flt.

Информация

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

Информация

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

Float#zero?[править]


flt.zero? -> true или false

Возвращает true, если вещественное число flt является числом 0.0.

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

Модуль GC обеспечивает Руби-интерфейс, который позволяет управлять механизмом сборки мусора. Некоторые из методов также доступны через модуль ObjectSpace.


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

disable, enable, start

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

garbage_collect

GC::disable[править]


GC.disable    #-> true или false

Отключает сборку мусора, возвращает true если сборка мусора уже была отключена.

GC.disable   #-> false
GC.disable   #-> true

GC::enable[править]


GC.enable    #-> true или false

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

GC.disable   #-> false
GC.enable    #-> true
GC.enable    #-> false

GC::start[править]


GC.start                     #-> nil
gc.garbage_collect           #-> nil
ObjectSpace.garbage_collect  #-> nil

Начинает сборку мусора, пока не отключена вручную.

GC#garbage_collect[править]


GC.start                     #-> nil
gc.garbage_collect           #-> nil
ObjectSpace.garbage_collect  #-> nil

Начинает сборку мусора, пока не отключена вручную.

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

Хеш - коллекция пар ключ-значение. Хеш подобен классу Array, за исключением того, что индексация осуществляется через ключи (объекты любого типа), а не через целочисленные индексы. Последовательность перечисления пар ключ-значений хеша может оказаться произвольной, и обычно не совпадает с той, в которой вы заполняли хеш. При обращении к хешу по ключу, которого не существует, возвращается значение по-умолчанию. Изначально, этим значением является nil.


Примеси

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

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

[]=, [], ==, clear, default=, default_proc, default, delete_if, delete, each_key, each_pair, each_value, each, empty?, fetch, has_key?, has_value?, include?, indexes, index, indices, inspect, invert, key?, keys, length, member?, merge!, merge, rehash, reject!, reject, replace, select, shift, size, sort, store, to_a, to_hash, to_s, update, value?, values_at, values

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


Hash [key =>|, value]* ]   #-> hash

Создает новый хеш, заполненный заданными объектами. Эквивалентно литералу { key, value, ... }.

Hash["a", 100, "b", 200]       #-> {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200]   #-> {"a"=>100, "b"=>200}
{ "a" => 100, "b" => 200 }     #-> {"a"=>100, "b"=>200}

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


Hash.new                          #-> hash
Hash.new(obj)                     #-> aHash
Hash.new {|hash, key| block }     #-> aHash

Возвращает новый хеш. При последующем обращении к хешу по ключу, которого не существует в этом хеше, возвращаемое значение зависит от формы вызова метода new. В первой форме вызова вернется значение nil. Если указан объект obj, то этот единственный объект будет использоваться для всех значений по-умолчанию. Если указан блок, тогда значение по-умолчанию вычисляется в данном блоке, которому передаются хеш (текущий) и ключ. В блоке можно записать значение в хеш, если это необходимо.

h = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"]           #-> 100
h["c"]           #-> "Go Fish"
# Изменяется единственный объект по-умолчанию
h["c"].upcase!   #-> "GO FISH"
h["d"]           #-> "GO FISH"
h.keys           #-> ["a", "b"]

# Создается новый объект по умолчанию каждый раз
h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
h["c"]           #-> "Go Fish: c"
h["c"].upcase!   #-> "GO FISH: C"
h["d"]           #-> "Go Fish: d"
h.keys           #-> ["c", "d"]

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


hsh == other_hash    #-> true или false

Равенство — два хеша считаются равными, если они содержат одинаковое число ключей, и если каждая пара ключ-значение эквивалентна (согласно методу Object#==) соответствующим элементам в другом хеше.

h1 = { "a" => 1, "c" => 2 }
h2 = { 7 => 35, "c" => 2, "a" => 1 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2   #-> false
h2 == h3   #-> true
h3 == h4   #-> false

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


hash[key]    #->  value

Получение элемента — возвращает значение соответствующее ключу key. Если ключа не существует, то возвращается значение по-умолчанию (см. Hash::new).

h = { "a" => 100, "b" => 200 }
h["a"]   #-> 100
h["c"]   #-> nil

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


hsh[key] = value        #-> value

Присваивание - ассоциирует значение value с ключем key.

h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h   #-> {"a"=>9, "b"=>200, "c"=>4}
Информация

Данный метод и метод store — абсолютно идентичны, то есть являются именами одного и того же метода

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


hsh.clear #-> hsh

Удаляет все пары ключ-значение из хеша hsh.

h = { "a" => 100, "b" => 200 }   #-> {"a"=>100, "b"=>200}
h.clear                          #-> {}

Hash#default[править]


hsh.default(key=nil)   #-> obj

Возвращает значение по-умолчанию, т.е. значение, которое будет возвращать hsh[key], если ключа key не существует в хеше hsh.

h = Hash.new                            #-> {}
h.default                               #-> nil
h.default(2)                            #-> nil

h = Hash.new("cat")                     #-> {}
h.default                               #-> "cat"
h.default(2)                            #-> "cat"

h = Hash.new {|h,k| h[k] = k.to_i*10}   #-> {}
h.default                               #-> 0
h.default(2)                            #-> 20
Информация

Полезно взглянуть также на методы Hash::new и Hash#default=

Hash#default=[править]


hsh.default = obj     #-> hsh

Устанавливает значение по-умолчанию, т.е. значение, которое возвращает hsh[key], если ключа key не существует в хеше hsh.

h = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h["a"]     #-> 100
h["z"]     #-> "Go fish"

# Это не сделает того, на что вы надеятесь...
h.default = proc do |hash, key|
   hash[key] = key + key
end
h[2]       #-> #<Proc:0x401b3948@-:6>
h["cat"]   #-> #<Proc:0x401b3948@-:6>

Hash#default_proc[править]


hsh.default_proc  #-> anObject

Если метод Hash::new был вызван с блоком, то возвращает блок, иначе возвращает nil.

h = Hash.new {|h,k| h[k] = k*k }   #-> {}
p = h.default_proc                 #-> #<Proc:0x401b3d08@-:1>
a = []                             #-> []
p.call(a, 2)
a                                  #-> [nil, nil, 4]

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


hsh.delete(key)                   #-> value
hsh.delete(key) {| key | block }  #-> value

Удаляет пару ключ-значение из хеша hsh, которая соответствует ключу key. Возвращается значение, соответствующее ключу. Если ключ не был найден, тогда возвращается "значение по-умолчанию". Если используется конструкция с блоком и ключ не был найден, то возвращается результат выполнения блока block, которому передается ключ key.

h = { "a" => 100, "b" => 200 }
h.delete("a")                              #-> 100
h.delete("z")                              #-> nil
h.delete("z") { |el| "#{el} не найден" }   #-> "z не найден"

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


hsh.delete_if {| key, value | block }  #-> hsh

Удаляет все пары ключ-значение из хеша hsh для которых блок block вычисляет значение true.

h = { "a" => 100, "b" => 200, "c" => 300 }
h.delete_if {|key, value| key >= "b" }   #-> {"a"=>100}

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


hsh.each {| key, value | block }   #-> hsh

Вызывает блок для каждый пары ключ-значение хеша hsh и передает в блок текущую пару ключ-значение в виде массива из двух элементов. В виду семантических особенностей параметров блока, эти параметры могут быть представлены не массивом, а двумя элементами с различными именами. Еще существует метод each_pair, который чуть более эффективен для блоков с двумя параметрами.

h = { "a" => 100, "b" => 200 }
h.each {|key, value| puts "#{key} => #{value}" }

результат:

 a => 100
 b => 200

Hash#each_key[править]


hsh.each_key {| key | block } #-> hsh

Выполняет блок block для каждого ключа в хеше hsh, передавая в блок ключ key в качестве параметра.

h = { "a" => 100, "b" => 200 }
h.each_key {|key| puts key }

результат:

a
b

Hash#each_pair[править]


hsh.each_pair {| key_value_array | block } #-> hsh

Выполняет блок block для каждого ключа в хеше hsh, передавая в блок ключ и значение в качестве параметров.

h = { "a" => 100, "b" => 200 }
h.each_pair {|key, value| puts "#{key} => #{value}" }

результат:

a => 100
b => 200

Hash#each_value[править]


hsh.each_value {| value | block } #-> hsh

Выполняет блок block для каждого ключа в хеше hsh, передавая в блок значение value, соответствующее ключу, в качестве параметра.

h = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }

результат:

100
200

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


hsh.empty?    #-> true или false

Возвращает true, если хеш hsh не содержит пар ключ-значение вовсе.

{}.empty?   #-> true

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


hsh.fetch(key [, default] )       #-> obj
hsh.fetch(key) {| key | block }   #-> obj

Возвращает значение, соответствующее ключу key. Если ключ не был найден, тогда есть несколько ситуаций: Без иных аргументов будет подниматься исключение IndexError; Если задан параметр default, тогда он и будет возвращен; Если конструкция определена с блоком, тогда будет выполняться блок, которому в качестве аргумента будет передан ключ.

h = { "a" => 100, "b" => 200 }
h.fetch("a")                            #-> 100
h.fetch("z", "go fish")                 #-> "go fish"
h.fetch("z") { |el| "go fish, #{el}"}   #-> "go fish, z"

Следующий пример показывает, что если ключ не найден и значение по-умолчанию не поставляется, то поднимается исключение.

h = { "a" => 100, "b" => 200 }
h.fetch("z")

результат:

prog.rb:2:in `fetch': key not found (IndexError)
 from prog.rb:2

Hash#has_key?[править]


hsh.has_key?(key)    #-> true или false

Возвращает true, если заданный ключ находится в хеше hsh.

h = { "a" => 100, "b" => 200 }
h.has_key?("a")   #-> true
h.has_key?("z")   #-> false
Информация

Методы has_key?, include?, key? и member? — абсолютно идентичны, то есть являются именами одного и того же метода

Hash#has_value?[править]


hsh.has_value?(value)    #-> true или false

Возвращает true, если заданное значение принадлежит некоторому ключу в хеше hsh.

h = { "a" => 100, "b" => 200 }
h.has_value?(100)   #-> true
h.has_value?(999)   #-> false
Информация

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

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


hsh.include?(key)    #-> true или false

Возвращает true, если заданный ключ находится в хеше hsh.

h = { "a" => 100, "b" => 200 }
h.include?("a")   #-> true
h.include?("z")   #-> false
Информация

Методы include?, has_key?, key? и member? — абсолютно идентичны, то есть являются именами одного и того же метода

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


hsh.index(value)    #-> key

Возвращает ключ для заданного значения. Если значение не найдено, возвращает nil.

h = { "a" => 100, "b" => 200 }
h.index(200)   #-> "b"
h.index(999)   #-> nil

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


hsh.indexes(key, ...)    #-> array

Информация

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

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


hsh.indices(key, ...)    #-> array

Информация

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


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


hsh.inspect  #-> string

Возвращает содержимое хеша в виде строки.

Hash#invert[править]


hsh.invert #-> aHash

Возвращает новый хеш, созданный путем использования значений хеша hsh в качестве ключей, а ключей в качестве значений.

h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
h.invert   #-> {0=>"a", 100=>"n", 200=>"d", 300=>"y"}

Hash#key[править]


hsh.key(value)    #-> key

Возвращает ключ для заданного значения. Если значение не найдено, возвращает nil.

h = { "a" => 100, "b" => 200 }
h.key(200)   #-> "b"
h.key(999)   #-> nil
Информация

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

Hash#key?[править]


hsh.key?(key)    #-> true или false

Возвращает true, если заданный ключ находится в хеше hsh.

h = { "a" => 100, "b" => 200 }
h.key?("a")   #-> true
h.key?("z")   #-> false
Информация

Методы key?, has_key?, include? и member? — абсолютно идентичны, то есть являются именами одного и того же метода

Hash#keys[править]


hsh.keys    #-> array

Возвращает новый массив, состоящий из ключей данного хеша.

h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
h.keys   #-> ["a", "b", "c", "d"]
Информация

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

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


hsh.length    #->  fixnum

Возвращает количество пар ключ-значение в данном хеше.

h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.length        #-> 4
h.delete("a")   #-> 200
h.length        #-> 3
Информация

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

Hash#member?[править]


hsh.member?(key)    #-> true или false

Возвращает true, если заданный ключ находится в хеше hsh.

h = { "a" => 100, "b" => 200 }
h.member?("a")   #-> true
h.member?("z")   #-> false
Информация

Методы member?, has_key?, include? и key? — абсолютно идентичны, то есть являются именами одного и того же метода

Hash#merge[править]


hsh.merge(other_hash)                                #-> a_hash
hsh.merge(other_hash){|key, oldval, newval| block}   #-> a_hash

Возвращает новый хеш, который состоит из содержимого хешей other_hash и hsh. Если в результате слияния обнаружатся одинаковые ключи, то для него будет записано значение из хеша other_hash (если задан блок, то будет записано значение, которое получится в результате выполнения блока).

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}
h1             #=> {"a"=>100, "b"=>200}

Hash#merge![править]


hsh.merge!(other_hash)                                 #-> hsh
hsh.update(other_hash)                                 #-> hsh
hsh.merge!(other_hash){|key, oldval, newval| block}    #-> hsh
hsh.update(other_hash){|key, oldval, newval| block}    #-> hsh

Добавляет содержимое хеша other_hash к хешу hsh. Если обнаружатся дублирующие ключи, то значение для него будет взято из other_hash (или получено в результате выполнения блока, если он задан).

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge!(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}
Информация

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

Hash#rehash[править]


hsh.rehash   #-> hsh

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

a = [ "a", "b" ]
c = [ "c", "d" ]
h = { a => 100, c => 300 }
h[a]       #-> 100
a[0] = "z"
h[a]       #-> nil
h.rehash   #-> {["z", "b"]=>100, ["c", "d"]=>300}
h[a]       #-> 100

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


hsh.reject {| key, value | block }  #-> a_hash

То же самое, что и метод delete_if, но обрабатывает (и возвращает) копию хеша hsh. По сути, данный метод эквивалентен hsh.dup.delete_if.

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


hsh.reject! {| key, value | block }  #-> hsh или nil

Эквивалентно delete_if, но возвращает nil, если хеш не был изменен в результате работы данного метода.

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


hsh.replace(other_hash) #-> hsh

Заменяет содержимое хеша hsh на содержимое хеша other_hash.

h = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 })   #-> {"c"=>300, "d"=>400}

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


hsh.select {|key, value| block}   #-> hash

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

h = { "a" => 100, "b" => 200, "c" => 300 }
h.select {|k,v| v > 100}  #-> {"b" => 200, "c" => 300}
h.select {|k,v| v < 200}  #-> {"a" => 100}

А вот так выбираем только гласные:

hash_1 = {a: 1, e: 5, i: 9, o: 15, u: 21, y: 25, b: 2, c: 3, d: 4, f: 6, g: 7, h: 8, j: 10, k: 11, l: 12, m: 13, n: 14, p: 16, q: 17, r: 18, s: 19, t: 20, v: 22, w: 23, x: 24, z: 26}

hash_2 = hash_1.select! { |k, v| [:a, :e, :i, :o, :u, :y].include?(k) }

p hash_2

На выходе {:a=>1, :e=>5, :i=>9, :o=>15, :u=>21, :y=>25}

Осторожно с ! после select ...

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


hsh.shift #-> anArray или obj

Удаляет первую пару ключ-значение из хеша hsh и возвращает эту пару в виде массива [ key, value ]. Если хеш пуст, то возвращает значение по-умолчанию.

h = { 1 => "a", 2 => "b", 3 => "c" }
h.shift   #-> [1, "a"]
h         #-> {2=>"b", 3=>"c"}

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


hsh.size    #->  fixnum

Возвращает количество пар ключ-значение в данном хеше.

h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.size          #-> 4
h.delete("a")   #-> 200
h.size          #-> 3
Информация

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

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


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

Преобразует хеш hsh в массив массивов - [ key, value ] и сортирует его, используя Array#sort.

h = { "a" => 20, "b" => 30, "c" => 10  }
h.sort                       #-> [["a", 20], ["b", 30], ["c", 10]]
h.sort {|a,b| a[1]<=>b[1]}   #-> [["c", 10], ["a", 20], ["b", 30]]

Hash#store[править]


hsh.store(key, value)   #-> value

Присваивание - ассоциирует значение value с ключем key. Идентичен методу []=.

h = { "a" => 100, "b" => 200 }
h.store("a", 9)
h.store("c", 4)
h   #-> {"a"=>9, "b"=>200, "c"=>4}

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


hsh.to_a #-> array

Конвертирует хеш hsh в массив, состоящий из массивов [ key, value ].

h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
h.to_a   #-> [["a", 100], ["c", 300], ["d", 400]]

Hash#to_hash[править]


hsh.to_hash   #-> hsh

Возвращает hsh.

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


hsh.to_s   #-> string

Преобразует хеш hsh в строку путем преобразования хеша в массив массивов [ key, value ], и преобразования этого массива в строку, используя Array#join со стандартным разделителем.

h = { "c" => 300, "a" => 100, "d" => 400 }
h.to_s   #-> "a100c300d400"

Hash#update[править]


hsh.merge!(other_hash)                                 #-> hsh
hsh.update(other_hash)                                 #-> hsh
hsh.merge!(other_hash){|key, oldval, newval| block}    #-> hsh
hsh.update(other_hash){|key, oldval, newval| block}    #-> hsh

Добавляет содержимое хеша other_hash к хешу hsh. Если обнаружатся дублирующие ключи, то значение для него будет взято из other_hash (или получено в результате выполнения блока, если он задан).

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.update(h2)   #=> {"a"=>100, "b"=>254, "c"=>300}
Информация

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

Hash#value?[править]


hsh.value?(value)    #-> true или false

Возвращает true, если заданное значение принадлежит некоторому ключу в хеше hsh.

h = { "a" => 100, "b" => 200 }
h.value?(100)   #-> true
h.value?(999)   #-> false
Информация

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

Hash#values[править]


hsh.values    #-> array

Возвращает новый массив, состоящий из значений данного хеша.

h = { "a" => 100, "b" => 200, "c" => 300 }
h.values   #=> [100, 200, 300]
Информация

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

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


hsh.values_at(key, ...)   #-> array

Возвращает массив содержащий значения, соответствующие заданным ключам. (См. Hash.select).

h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
h.values_at("cow", "cat")  #-> ["bovine", "feline"]

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

Class IO Является базовым для ввода и вывода в Ruby. An I/O stream may be duplexed (that is, bidirectional), and so may use more than one native operating system stream. Many of the examples in this section use class File, the only standard subclass of IO. The two classes are closely associated. As used in this section, portname may take any of the following forms.

  • A plain string represents a filename suitable for the underlying operating system.
  • A string starting with ``| indicates a subprocess. The remainder of the string following the ``| is invoked as a process with appropriate input/output channels connected to it.
  • A string equal to ``|- will create another Ruby instance as a subprocess.

Ruby will convert pathnames between different operating system conventions if possible. For instance, on a Windows system the filename ``/gumby/ruby/test.rb will be opened as ``\gumby\ruby\test.rb. When specifying a Windows-style filename in a Ruby string, remember to escape the backslashes:

  "c:\gumby\ruby\test.rb"

Our examples here will use the Unix-style forward slashes; File::SEPARATOR can be used to get the platform-specific separator character. I/O ports may be opened in any one of several different modes, which are shown in this section as mode. The mode may either be a Fixnum or a String. If numeric, it should be one of the operating system specific constants (O_RDONLY, O_WRONLY, O_RDWR, O_APPEND and so on). See man open(2) for more information. If the mode is given as a String, it must be one of the values listed in the following table.

 Mode |  Meaning
 -----+--------------------------------------------------------
 "r"  |  Read-only, starts at beginning of file  (default mode).
 -----+--------------------------------------------------------
 "r+" |  Read-write, starts at beginning of file.
 -----+--------------------------------------------------------
 "w"  |  Write-only, truncates existing file
      |  to zero length or creates a new file for writing.
 -----+--------------------------------------------------------
 "w+" |  Read-write, truncates existing file to zero length
      |  or creates a new file for reading and writing.
 -----+--------------------------------------------------------
 "a"  |  Write-only, starts at end of file if file exists,
      |  otherwise creates a new file for writing.
 -----+--------------------------------------------------------
 "a+" |  Read-write, starts at end of file if file exists,
      |  otherwise creates a new file for reading and
      |  writing.
 -----+--------------------------------------------------------
  "b" |  (DOS/Windows only) Binary file mode (may appear with
      |  any of the key letters listed above).

The global constant ARGF (also accessible as $<) provides an IO-like stream which allows access to all files mentioned on the command line (or STDIN if no files are mentioned). ARGF provides the methods #path and #filename to access the name of the file currently being read.


Примеси


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

File::Constants ()

Константы

SEEK_CUR, SEEK_END, SEEK_SET

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

for_fd, foreach, new, new, open, pipe, popen, readlines, read, select, sysopen

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

<<, binmode, block_scanf, close_read, close_write, closed?, close, each_byte, each_line, each, eof?, eof, fcntl, fileno, flush, fsync, getc, gets, inspect, ioctl, isatty, lineno=, lineno, pid, pos=, pos, printf, print, putc, puts, read_nonblock, readbytes, readchar, readlines, readline, readpartial, read, reopen, rewind, scanf, seek, soak_up_spaces, stat, sync=, sync, sysread, sysseek, syswrite, tell, to_io, to_i, tty?, ungetc, write_nonblock, write

IO::for_fd[править]


 IO.for_fd(fd, mode)    => io

Synonym for IO::new.

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


 IO.foreach(name, sep_string=$/) {|line| block }   => nil

Executes the block for every line in the named I/O port, where lines are separated by sep_string.

  IO.foreach("testfile") {|x| print "GOT ", x }

produces:

  GOT This is line one
  GOT This is line two
  GOT This is line three
  GOT And so on...

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


 IO.new(fd, mode_string)   => io

Returns a new IO object (a stream) for the given integer file descriptor and mode string. See also IO#fileno and IO::for_fd.

  a = IO.new(2,"w")      # '2' is standard error
  $stderr.puts "Hello"
  a.puts "World"

produces:

  Hello
  World

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


 IO.new(fd, mode_string)   => io

Returns a new IO object (a stream) for the given integer file descriptor and mode string. See also IO#fileno and IO::for_fd.

  a = IO.new(2,"w")      # '2' is standard error
  $stderr.puts "Hello"
  a.puts "World"

produces:

  Hello
  World

IO::open[править]


 IO.open(fd, mode_string="r" )               => io
 IO.open(fd, mode_string="r" ) {|io| block } => obj

With no associated block, open is a synonym for IO::new. If the optional code block is given, it will be passed io as an argument, and the IO object will automatically be closed when the block terminates. In this instance, IO::open returns the value of the block.

IO::pipe[править]


 IO.pipe -> array

Creates a pair of pipe endpoints (connected to each other) and returns them as a two-element array of IO objects: [ read_file, write_file ]. Not available on all platforms. In the example below, the two processes close the ends of the pipe that they are not using. This is not just a cosmetic nicety. The read end of a pipe will not generate an end of file condition if there are any writers with the pipe still open. In the case of the parent process, the rd.read will never return if it does not first issue a wr.close.

rd, wr = IO.pipe

if fork
  wr.close
  puts "Parent got: <#{rd.read}>"
  rd.close
  Process.wait
else
  rd.close
  puts "Sending message to parent"
  wr.write "Hi Dad"
  wr.close
end

produces:

  Sending message to parent
  Parent got: <Hi Dad>

IO::popen[править]


 IO.popen(cmd_string, mode="r" )               => io
 IO.popen(cmd_string, mode="r" ) {|io| block } => obj

Runs the specified command string as a subprocess; the subprocess's standard input and output will be connected to the returned IO object. If cmd_string starts with a ``-, then a new instance of Ruby is started as the subprocess. The default mode for the new file object is ``r, but mode may be set to any of the modes listed in the description for class IO. If a block is given, Ruby will run the command as a child connected to Ruby with a pipe. Ruby's end of the pipe will be passed as a parameter to the block. At the end of block, Ruby close the pipe and sets $?. In this case IO::popen returns the value of the block. If a block is given with a cmd_string of ``-, the block will be run in two separate processes: once in the parent, and once in a child. The parent process will be passed the pipe object as a parameter to the block, the child version of the block will be passed nil, and the child's standard in and standard out will be connected to the parent through the pipe. Not available on all platforms.

  f = IO.popen("uname")
  p f.readlines
  puts "Parent is #{Process.pid}"
  IO.popen ("date") { |f| puts f.gets }
  IO.popen("-") {|f| $stderr.puts "#{Process.pid} is here, f is #{f}"}
  p $?

produces:

  ["Linux\n"]
  Parent is 26166
  Wed Apr  9 08:53:52 CDT 2003
  26169 is here, f is
  26166 is here, f is #<IO:0x401b3d44>
  #<Process::Status: pid=26166,exited(0)>

IO::read[править]


 IO.read(name, [length [, offset]] )   => string

Opens the file, optionally seeks to the given offset, then returns length bytes (defaulting to the rest of the file). read ensures the file is closed before returning.

  IO.read("testfile")           #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
  IO.read("testfile", 20)       #=> "This is line one\nThi"
  IO.read("testfile", 20, 10)   #=> "ne one\nThis is line "

IO::readlines[править]


 IO.readlines(name, sep_string=$/)   => array

Reads the entire file specified by name as individual lines, and returns those lines in an array. Lines are separated by sep_string.

  a = IO.readlines("testfile")
  a[0]   #=> "This is line one\n"

IO::select[править]


 IO.select(read_array 
 [, write_array 
 [, error_array 
 [, timeout]]] ) =>  array  or  nil

See Kernel#select.

IO::sysopen[править]


 IO.sysopen(path, [mode, [perm]])  => fixnum

Opens the given path, returning the underlying file descriptor as a Fixnum.

  IO.sysopen("testfile")   #=> 3

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


 ios << obj     => ios

String Output---Writes obj to ios. obj will be converted to a string using to_s.

  $stdout << "Hello " << "world!\n"

produces:

  Hello world!

IO#binmode[править]


 ios.binmode    => ios

Puts ios into binary mode. This is useful only in MS-DOS/Windows environments. Once a stream is in binary mode, it cannot be reset to nonbinary mode.

IO#block_scanf[править]


 block_scanf(str) {|current| ...}

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

IO#close[править]


 ios.close   => nil

Closes ios and flushes any pending writes to the operating system. The stream is unavailable for any further data operations; an IOError is raised if such an attempt is made. I/O streams are automatically closed when they are claimed by the garbage collector. If ios is opened by IO.popen, close sets $?.

IO#close_read[править]


 ios.close_read    => nil

Closes the read end of a duplex I/O stream (i.e., one that contains both a read and a write stream, such as a pipe). Will raise an IOError if the stream is not duplexed.

  f = IO.popen("/bin/sh","r+")
  f.close_read
  f.readlines

produces:

  prog.rb:3:in `readlines': not opened for reading (IOError)
   from prog.rb:3

IO#close_write[править]


 ios.close_write   => nil

Closes the write end of a duplex I/O stream (i.e., one that contains both a read and a write stream, such as a pipe). Will raise an IOError if the stream is not duplexed.

  f = IO.popen("/bin/sh","r+")
  f.close_write
  f.print "nowhere"

produces:

  prog.rb:3:in `write': not opened for writing (IOError)
   from prog.rb:3:in `print'
   from prog.rb:3

IO#closed?[править]


 ios.closed?    => true or false

Returns true if ios is completely closed (for duplex streams, both reader and writer), false otherwise.

  f = File.new("testfile")
  f.close         #=> nil
  f.closed?       #=> true
  f = IO.popen("/bin/sh","r+")
  f.close_write   #=> nil
  f.closed?       #=> false
  f.close_read    #=> nil
  f.closed?       #=> true

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


 ios.each(sep_string=$/)      {|line| block }  => ios
 ios.each_line(sep_string=$/) {|line| block }  => ios

Executes the block for every line in ios, where lines are separated by sep_string. ios must be opened for reading or an IOError will be raised.

  f = File.new("testfile")
  f.each {|line| puts "#{f.lineno}: #{line}" }

produces:

  1: This is line one
  2: This is line two
  3: This is line three
  4: And so on...

IO#each_byte[править]


 ios.each_byte {|byte| block }  => nil

Calls the given block once for each byte (0..255) in ios, passing the byte as an argument. The stream must be opened for reading or an IOError will be raised.

  f = File.new("testfile")
  checksum = 0
  f.each_byte {|x| checksum ^= x }   #=> #<File:testfile>
  checksum                           #=> 12

IO#each_line[править]


 ios.each(sep_string=$/)      {|line| block }  => ios
 ios.each_line(sep_string=$/) {|line| block }  => ios

Executes the block for every line in ios, where lines are separated by sep_string. ios must be opened for reading or an IOError will be raised.

  f = File.new("testfile")
  f.each {|line| puts "#{f.lineno}: #{line}" }

produces:

  1: This is line one
  2: This is line two
  3: This is line three
  4: And so on...

IO#eof[править]


 ios.eof     => true or false
 ios.eof?    => true or false

Returns true if ios is at end of file that means there are no more data to read. The stream must be opened for reading or an IOError will be raised.

  f = File.new("testfile")
  dummy = f.readlines
  f.eof   #=> true

If ios is a stream such as pipe or socket, IO#eof? blocks until the other end sends some data or closes it.

  r, w = IO.pipe
  Thread.new { sleep 1; w.close }
  r.eof?  #=> true after 1 second blocking
  r, w = IO.pipe
  Thread.new { sleep 1; w.puts "a" }
  r.eof?  #=> false after 1 second blocking
  r, w = IO.pipe
  r.eof?  # blocks forever

Note that IO#eof? reads data to a input buffer. So IO#sysread doesn't work with IO#eof?.

IO#eof?[править]


 ios.eof     => true or false
 ios.eof?    => true or false

Returns true if ios is at end of file that means there are no more data to read. The stream must be opened for reading or an IOError will be raised.

  f = File.new("testfile")
  dummy = f.readlines
  f.eof   #=> true

If ios is a stream such as pipe or socket, IO#eof? blocks until the other end sends some data or closes it.

  r, w = IO.pipe
  Thread.new { sleep 1; w.close }
  r.eof?  #=> true after 1 second blocking
  r, w = IO.pipe
  Thread.new { sleep 1; w.puts "a" }
  r.eof?  #=> false after 1 second blocking
  r, w = IO.pipe
  r.eof?  # blocks forever

Note that IO#eof? reads data to a input buffer. So IO#sysread doesn't work with IO#eof?.

IO#fcntl[править]


 ios.fcntl(integer_cmd, arg)    => integer

Provides a mechanism for issuing low-level commands to control or query file-oriented I/O streams. Arguments and results are platform dependent. If arg is a number, its value is passed directly. If it is a string, it is interpreted as a binary sequence of bytes (Array#pack might be a useful way to build this string). On Unix platforms, see fcntl(2) for details. Not implemented on all platforms.

IO#fileno[править]


 ios.fileno    => fixnum
 ios.to_i      => fixnum

Returns an integer representing the numeric file descriptor for ios.

  $stdin.fileno    #=> 0
  $stdout.fileno   #=> 1

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

IO#flush[править]


 ios.flush    => ios

Flushes any buffered data within ios to the underlying operating system (note that this is Ruby internal buffering only; the OS may buffer the data as well).

  $stdout.print "no newline"
  $stdout.flush

produces:

  no newline

IO#fsync[править]


 ios.fsync   => 0 or nil

Immediately writes all buffered data in ios to disk. Returns nil if the underlying operating system does not support fsync(2). Note that fsync differs from using IO#sync=. The latter ensures that data is flushed from Ruby's buffers, but doesn't not guarantee that the underlying operating system actually writes it to disk.

IO#getc[править]


 ios.getc   => fixnum or nil

Gets the next 8-bit byte (0..255) from ios. Returns nil if called at end of file.

  f = File.new("testfile")
  f.getc   #=> 84
  f.getc   #=> 104

IO#gets[править]


 ios.gets(sep_string=$/)   => string or nil

Reads the next ``line from the I/O stream; lines are separated by sep_string. A separator of nil reads the entire contents, and a zero-length separator reads the input a paragraph at a time (two successive newlines in the input separate paragraphs). The stream must be opened for reading or an IOError will be raised. The line read in will be returned and also assigned to $_. Returns nil if called at end of file.

  File.new("testfile").gets   #=> "This is line one\n"
  $_                          #=> "This is line one\n"

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


 ios.inspect   => string

Return a string describing this IO object.

IO#ioctl[править]


 ios.ioctl(integer_cmd, arg)    => integer

Provides a mechanism for issuing low-level commands to control or query I/O devices. Arguments and results are platform dependent. If arg is a number, its value is passed directly. If it is a string, it is interpreted as a binary sequence of bytes. On Unix platforms, see ioctl(2) for details. Not implemented on all platforms.

IO#isatty[править]


 ios.isatty   => true or false
 ios.tty?     => true or false

Returns true if ios is associated with a terminal device (tty), false otherwise.

  File.new("testfile").isatty   #=> false
  File.new("/dev/tty").isatty   #=> true

IO#lineno[править]


 ios.lineno    => integer

Returns the current line number in ios. The stream must be opened for reading. lineno counts the number of times gets is called, rather than the number of newlines encountered. The two values will differ if gets is called with a separator other than newline. See also the $. variable.

  f = File.new("testfile")
  f.lineno   #=> 0
  f.gets     #=> "This is line one\n"
  f.lineno   #=> 1
  f.gets     #=> "This is line two\n"
  f.lineno   #=> 2

IO#lineno=[править]


 ios.lineno = integer    => integer

Manually sets the current line number to the given value. $. is updated only on the next read.

  f = File.new("testfile")
  f.gets                     #=> "This is line one\n"
  $.                         #=> 1
  f.lineno = 1000
  f.lineno                   #=> 1000
  $. # lineno of last read   #=> 1
  f.gets                     #=> "This is line two\n"
  $. # lineno of last read   #=> 1001

IO#pid[править]


 ios.pid    => fixnum

Returns the process ID of a child process associated with ios. This will be set by IO::popen.

  pipe = IO.popen("-")
  if pipe
    $stderr.puts "In parent, child pid is #{pipe.pid}"
  else
    $stderr.puts "In child, pid is #{$$}"
  end

produces:

  In child, pid is 26209
  In parent, child pid is 26209

IO#pos[править]


 ios.pos     => integer
 ios.tell    => integer

Returns the current offset (in bytes) of ios.

  f = File.new("testfile")
  f.pos    #=> 0
  f.gets   #=> "This is line one\n"
  f.pos    #=> 17

IO#pos=[править]


 ios.pos = integer    => integer

Seeks to the given position (in bytes) in ios.

  f = File.new("testfile")
  f.pos = 17
  f.gets   #=> "This is line two\n"

IO#print[править]


 ios.print()             => nil
 ios.print(obj, ...)     => nil

Writes the given object(s) to ios. The stream must be opened for writing. If the output record separator ($\) is not nil, it will be appended to the output. If no arguments are given, prints $_. Objects that aren't strings will be converted by calling their to_s method. With no argument, prints the contents of the variable $_. Returns nil.

  $stdout.print("This is ", 100, " percent.\n")

produces:

  This is 100 percent.

IO#printf[править]


 ios.printf(format_string [, obj, ...] )   => nil

Formats and writes to ios, converting parameters under control of the format string. See Kernel#sprintf for details.

IO#putc[править]


 ios.putc(obj)    => obj

If obj is Numeric, write the character whose code is obj, otherwise write the first character of the string representation of obj to ios.

  $stdout.putc "A"
  $stdout.putc 65

produces:

  AA

IO#puts[править]


 ios.puts(obj, ...)    => nil

Writes the given objects to ios as with IO#print. Writes a record separator (typically a newline) after any that do not already end with a newline sequence. If called with an array argument, writes each element on a new line. If called without arguments, outputs a single record separator.

  $stdout.puts("this", "is", "a", "test")

produces:

  this
  is
  a
  test

IO#read[править]


 ios.read([length [, buffer]])    => string, buffer, or nil

Reads at most length bytes from the I/O stream, or to the end of file if length is omitted or is nil. length must be a non-negative integer or nil. If the optional buffer argument is present, it must reference a String, which will receive the data. At end of file, it returns nil or "" depend on length. ios.read() and ios.read(nil) returns "". ios.read(positive-integer) returns nil.

  f = File.new("testfile")
  f.read(16)   #=> "This is line one"

IO#read_nonblock[править]


 ios.read_nonblock(maxlen)              => string
 ios.read_nonblock(maxlen, outbuf)      => outbuf

Reads at most maxlen bytes from ios using read(2) system call after O_NONBLOCK is set for the underlying file descriptor. If the optional outbuf argument is present, it must reference a String, which will receive the data. read_nonblock just calls read(2). It causes all errors read(2) causes: EAGAIN, EINTR, etc. The caller should care such errors. read_nonblock causes EOFError on EOF. If the read buffer is not empty, read_nonblock reads from the buffer like readpartial. In this case, read(2) is not called.

IO#readbytes[править]


 readbytes(n)

Reads exactly n bytes. If the data read is nil an EOFError is raised. If the data read is too short a TruncatedDataError is raised and the read data is obtainable via its #data method.

IO#readchar[править]


 ios.readchar   => fixnum

Reads a character as with IO#getc, but raises an EOFError on end of file.

IO#readline[править]


 ios.readline(sep_string=$/)   => string

<