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)
Методы класса
Методы объекта
[]=, [], &, |, *, +, -, <<, <=>, ==, abbrev, assoc, append, at, bsearch, bsearch_index, clear, collect!, collect, combination, 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, rotate, rotate!, 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] #=> []
|
|
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, или заменяет подмассив в определенномrange (диапазоне). Если индексация превышает текущий размер массива, то массив увеличивается автоматически. Отрицательная индексация подразумевает отсчет с конца массива. Если для второго случая использовать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" }
| |
Внимание! Для использования методаabbrev необходимо подключение библиотекиabbrev.rb из стандартной библиотеки Руби:require 'abbrev'
|
Array#assoc
правитьarray.assoc(obj) #=> an_array или nil
Ищет в двумерном массиве массив, первый элемент которого равен obj (для сравнения используется метод==). Возвращает первый найденный массив (то есть, ассоциированный массив) или nil, если таковой найти не удалось.
s1 = ["colors", "red", "blue", "green"]
s2 = ["letters", "a", "b", "c"]
s3 = "foo"
a = [s1, s2, s3]
a.assoc("letters") #=> ["letters", "a", "b", "c"]
a.assoc("foo") #=> nil
|
|
Для понимания происходящего, полезно взглянуть на метод rassoc |
Array#append
правитьarray.append(*args) #=> array
Добавить элемент — добавляет передаваемый объект (или несколько объектов) в конец массива. Возвращает массив с выполненным преобразованием.
a = ["a", "b", "c"]
a.push("d", "e", "f") #=> ["a", "b", "c", "d", "e", "f"]
a #=> ["a", "b", "c", "d", "e", "f"]
Добавляет каждый аргумент как один элемент, даже если это другой массив:
a = [:jay, "shri", 108]
a1 = a.push([:om, :tat], [:sat, :rama])
a1 # => [:jay, "shri", 108, [:om, :tat], [:sat, :rama]]
|
|
| |
Внимание! Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод + |
Array#at
правитьarray.at(index) #=> obj или nil
Возвращает элемент массива array с индексом index. Отрицательная индексация подразумевает отсчет с конца массива. возвращаетnil, если индекс выходит за пределы допустимого диапазона.
a = ["a", "b", "c", "d", "e"]
a.at(0) #=> "a"
a.at(-1) #=> "e"
|
|
|
Array#bsearch
правитьarray.bsearch{|element| ... } #=> obj
array.bsearch #=> an_enumerator
Возвращает элемент из self, выбранного бинарным поиском. self следует отсортировать, но это не проверяется.
Используя двоичный поиск, находит значение из этого array, которое удовлетворяет заданному условию в O (log n), где n - размер массива.
Есть два режима поиска:
Режим поиска-минимум: блок должен возвращать true или false.
Режим любого поиска: блок должен возвращать числовое значение.
Блок не должен смешивать режимы, иногда возвращая true или false, а иногда и возвращая числовое значение, но это не проверяется.
Режим поиска минимума
В режиме минимального поиска блок всегда возвращает true или false. Дальнейшее требование (хотя и не проверяемое) состоит в том, что не существует таких индексов i и j, что:
0 <= i < j <= self.size
Блок возвращает true для self[i] и false для self[j]
В режиме минимального поиска метод bsearch возвращает первый элемент, для которого блок возвращает true.
Примеры:
a = [0, 4, 7, 10, 12]
a.bsearch {|x| x >= 4 } # => 4
a.bsearch {|x| x >= 6 } # => 7
a.bsearch {|x| x >= -1 } # => 0
a.bsearch {|x| x >= 100 } # => nil
Продолжение следует... https://ruby-doc.org/core-3.0.2/Array.html
|
|
Рекомендуется также взглянуть на метод bsearch_index, который обладает схожим функционалом |
Array#bsearch_index
правитьarray.bsearch_index{|element| ... } #=> int или nil
bsearch_index #=> an_enumerator
Ищет себя, как описано в методе bsearch, но возвращает индекс найденного элемента вместо самого элемента.
|
|
Рекомендуется также взглянуть на метод bsearch, который обладает схожим функционалом |
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!"]
|
|
|
| |
Внимание! Будьте внимательны при использовании данного итератора, так как он изменяет исходный массив. Чтобы исключить это изменение используйте итераторы collect и map |
Array#combination
правитьarray.combination(n) {|element| ... } #=> self
combination(n) #=> new_enumerator
Вызывает block, если он задан, с комбинациями элементов self; возвращает self. Порядок комбинаций не определен.
Когда заданы block и входящий в диапазон положительный целочисленный аргумент n (0 <n <= self.size), вызывает block со всеми комбинациями кортежей из n элементов self.
Пример:
a = [0, 1, 2]
a.combination(2) {|combination| p combination }
#=>
[0, 1]
[0, 2]
[1, 2]
a #=> [0, 1, 2]
Другие примеры:
a = [0, 1, 2]
a.combination(3) {|combination| p combination }
Output:
[0, 1, 2]
When n is zero, calls the block once with a new empty Array:
a = [0, 1, 2]
a1 = a.combination(0) {|combination| p combination }
Output:
[]
When n is out of range (negative or larger than self.size), does not call the block:
a = [0, 1, 2]
a.combination(-1) {|combination| fail 'Cannot happen' }
a.combination(4) {|combination| fail 'Cannot happen' }
Returns a new Enumerator if no block given:
a = [0, 1, 2]
a.combination(2) # => #<Enumerator: [0, 1, 2]:combination(2)>Array#compact
правитьarray.compact #=> an_array
Возвращает копию массива array из которого удалены все элементы nil.
["a", nil, "b", nil, "c", nil].compact #=> ["a", "b", "c"]
Array#compact!
правитьarray.compact! #=> array или nil
Удаляет все элементы nil из массива array. Возвращает nil, если изменять ничего не потребовалось.
["a", nil, "b", nil, "c"].compact! #=> ["a", "b", "c"]
["a", "b", "c"].compact! #=> nil
| |
Внимание! Данный метод изменяет исходный массив. Методу compact эта «дурная привычка» не присуща |
Array#concat
правитьarray.concat(other_array) #=> array
Добавляет к массиву array элементы массива other_array.
["a", "b"].concat(["c", "d"]) #=> ["a", "b", "c", "d"]
Array#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"
| |
Внимание! Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте итератор reject |
Array#delete_at
правитьarray.delete_at(index) #=> obj или nil
Удаляет элемент из массива array, который имеет индекс index. Возвращает значение удаленного элемента илиnil, если index находится вне допустимого диапазона.
a = %w(ant bat cat dog)
a.delete_at(2) #=> "cat"
a #=> ["ant", "bat", "dog"]
a.delete_at(99) #=> nil
|
|
Метод slice! имеет схожую функциональность |
| |
Внимание! Будьте внимательны при использовании данного метода, так как он изменяет исходный массив. Чтобы исключить это изменение используйте метод slice |
Array#delete_if
правитьarray.delete_if {|item| block } #=> array
Удаляет все элементы массива array для которых значение внутри блока block равно true.
a = ["a", "b", "c"]
a.delete_if {|x| x >= "b" } #=> ["a"]
a #=> ["a"]
|
|
Полезно посмотреть на следующие итераторы reject и reject!, которые имеют схожую функциональность |
| |
Внимание! Данный итератор изменяет значение исходного массива. Рекомендуется использовать итератор reject, который не имеет такой «дурной» привычки, но название которого хуже запоминается |
Array#each
правитьarray.each {|item| block } #=> array
Выполняет код в block для каждого элемента массива array, передавая в блок текущий элемент в качестве параметра.
a = ["a", "b", "c"]
a.each { |x| print x, " -- " }
результат:
a -- b -- c --
|
|
|
Array#each_index
правитьarray.each_index { |index| block } #=> array
Работает точно также, как и each, но передает в блок не текущий элемент, а индекс текущего элемента.
a = ["a", "b", "c"]
a.each_index { |x| print x, " -- " }
результат:
0 -- 1 -- 2 --
Array#empty?
правитьarray.empty? #=> true или false
Возвращаетtrue, если array не содержит элементов.
[].empty? #=> true
Array#eql?
правитьarray.eql?(other) #=> true или false
Возвращаетtrue, если array и other являются одним и тем же объектом или оба массива обладают одинаковым содержимым
Array#fetch
правитьarray.fetch(index) #=> obj
array.fetch(index, default ) #=> obj
array.fetch(index) { |index| block } #=> obj
Попытка получить элемент массива array по индексу index. Если индекс выходит за пределы массива то, в первой форме вызова возникнет ошибка IndexError, чтобы это предотвратить используется вторая форма вызова, которой будет возвращено значение default, так же для предотвращения ошибки 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]
| |
Внимание! Будьте внимательны при использовании данного метода, так как он изменяет исходный массив. Чтобы исключить это изменение используйте метод flatten |
Array#frozen?
правитьarray.frozen? #=> true или false
Возвращаетtrue, если массив array заморожен (или временно заморожен, пока идет сортировка).
Array#hash
правитьarray.hash #=> fixnum
Вычисляет хеш-код для массива array. Два массива с одним и тем же содержимым будут иметь одинаковый хеш-код (именно его использует eql?).
Array#include?
правитьarray.include?(obj) #=> true или false
Возвращаетtrue, если объект obj является элементом массива array (то есть какой-то из элементов массива== obj). Иначе —false.
a = ["a", "b", "c"]
a.include?("b") #=> true
a.include?("z") #=> false
Array#index
правитьarray.index(obj) #=> int или nil
Возвращает индекс первого вхождения элемента в массив array, который== obj. Возвращаетnil, если такой элемент не был найден.
a = ["a", "b", "c"]
a.index("b") #=> 1
a.index("z") #=> nil
|
|
Существует так же метод rindex, который возвращает первый соответствующий элемент с конца массива. |
Array#indexes
правитьarray.indexes(i1, i2, ... iN) #=> an_array
array.indices(i1, i2, ... iN ) #=> an_array
| |
Внимание! Использование данного метода резко осуждается Руби-сообществом. Во время его использования интерпретатор будет выдавать предупреждение. Рекомендуется использовать метод values_at. |
Array#indices
правитьarray.indexes(i1, i2, ... iN) #=> an_array
array.indices(i1, i2, ... iN) #=> an_array
| |
Внимание! Использование данного метода резко осуждается Руби-сообществом. Во время его использования интерпретатор будет выдавать предупреждение. Рекомендуется использовать метод values_at. |
Array#insert
правитьarray.insert(index, obj...) #=> array
Вставляет полученные значения перед элементом индексом index (может быть отрицательным).
a = %w{ a b c d }
a.insert(2, 99) #=> ["a", "b", 99, "c", "d"]
a.insert(-2, 1, 2, 3) #=> ["a", "b", 99, "c", 1, 2, 3, "d"]
Array#inspect
правитьarray.inspect #=> string
Создает «печатную» версию массива array.
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
|
|
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!"]
|
|
|
| |
Внимание! Будьте внимательны при использовании данного итератора, так как он изменяет исходный массив. Чтобы исключить это изменение используйте итераторы collect и map |
Array#min
правитьarray.min #=> obj
Возвращает объект в ary с минимальным значением. Первая форма предполагает, что все объекты реализуют Comparable; вторая использует блок для возврата <=> b.
Array#nitems
править| |
Внимание! Данный метод удален из Ruby, начиная с версии 1.9. Вместо него можно использовать выражение: array.compact.size |
array.nitems #=> int
Возвращает количество элементов массива array, значение которых не равноnil. Может быть нулевым (для пустого массива или массива, который заполненnil.
[ 1, nil, 3, nil, 5 ].nitems #=> 3
Array#pack
правитьarray.pack(aTemplateString) #=> aBinaryString
Упаковывает содержимое массива array в двоичную последовательность (в виде строки) в соответствии с опциями в строке aTemplateString (см. таблицу ниже). После опцийA, a, иZ может идти число, которое указывает на ширину результирующего поля. Для остальных, число после опций означает — количество элементов массива которые необходимо обработать в соответствии с указанной опцией. Если в вместо числа после директивы стоит символ* («звездочка»), то все оставшиеся элементы массива необходимо обработать в соответствии с этой опцией. Любую из опцийs, S, i, I, l и L можно завершать_ (знаком подчеркивания) для того, чтобы использовать размер для базовой платформы; иначе, будет использован платформонезависимый размер. В строке aTemplateString пробелы игнорируются.
a = ["a", "b", "c"]
n = [ 65, 66, 67 ]
a.pack("A3A3A3") #=> "a b c "
a.pack("a3a3a3") #=> "a\000\000b\000\000c\000\000"
n.pack("ccc") #=> "ABC"
Опции методаpack.
| Опция | Описание |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Данный метод обычно используется совместно с методом String#unpack, который выполняет обратные действия |
Array#pop
правитьarray.pop #=> obj или nil
Удаляет последний элемент из массива
array
и возвращает его. Если на момент вызова массив был пуст, то возвращаетnil.
a = ["a", "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"]
Добавляет каждый аргумент как один элемент, даже если это другой массив:
a = [:jay, "shri", 108]
a1 = a.push([:om, :tat], [:sat, :rama])
a1 # => [:jay, "shri", 108, [:om, :tat], [:sat, :rama]]
|
|
| |
Внимание! Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод + |
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"]
|
|
|
Array#reject!
правитьarray.reject! {|item| block } #=> array или nil
Подобно итератору delete_if удаляет из массива array элементы, для которых значение внутри блока block равно true, но возвращает nil, если изменений в массиве сделано не было.
a = [1, 2, 3, 4, 5]
a.reject!{ |item| item > 2 } #=> [1, 2]
a #=> [1, 2]
a.reject!{ |item| item > 2 } #=> nil
|
|
Полезно посмотреть описание итератора delete_if, который делает примерно тоже самое, но название которого лучше запоминается |
| |
Внимание! Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод [] («батарейка») или итератор reject |
Array#replace
правитьarray.replace(other_array) #=> self
Заменяет содержимое массива 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"]
| |
Внимание! Будьте внимательны при использовании данного метода, так как он изменяет исходный массив. Чтобы исключить это изменение используйте метод reverse |
Array#reverse_each
правитьarray.reverse_each {|item| block }
Работает точно также, как и итератор each, но элементы массива array обрабатываются в обратном порядке.
a = ["a", "b", "c"]
a.reverse_each { |x| print x, " " }
результат:
c b a
|
|
Достичь точно такого же результата можно вот так: |
Array#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, который не только похож по названию, но, в некоторых случаях, работает точно также, как и |
Array#rotate
правитьarray.rotate #=> an_array
array.rotate(count) #=> an_array
Возвращает новый массив, сформированный из себя(self) с элементами, повернутыми от одного конца к другому. Если аргумент не указан, возвращает новый массив, который похож на self, за исключением того, что первый элемент был повернут в последнюю позицию.
a = [:foo, 'bar', 2, 'bar']
a1 = a.rotate
a1 # => ["bar", 2, "bar", :foo]
Когда задано неотрицательное целое число счетчик(count), возвращает новый массив с элементами count, повернутыми от начала до конца:
a = [:foo, 'bar', 2]
a1 = a.rotate(2)
a1 # => [2, :foo, "bar"]
Если count большое, в качестве счетчика используется count% array.size:
a = [:foo, 'bar', 2]
a1 = a.rotate(20)
a1 # => [2, :foo, "bar"]
Если count равно нулю, возвращает копию self без изменений:
a = [:foo, 'bar', 2]
a1 = a.rotate(0)
a1 # => [:foo, "bar", 2]
Когда задано отрицательное целое число, вращается в противоположном направлении, от конца к началу:
a = [:foo, 'bar', 2]
a1 = a.rotate(-2)
a1 # => ["bar", 2, :foo]
Если count мало (далеко от нуля), в качестве count используется count% array.size:
a = [:foo, 'bar', 2]
a1 = a.rotate(-5)
a1 # => ["bar", 2, :foo]
|
|
Полезно взглянуть на rotate!, которые отличается лишь тем, что изменяют исходный массив |
Array#rotate!
правитьarray.rotate! #=> array
array.rotate!(count) #=> array
Поворачивает себя(self) на месте, перемещая элементы с одного конца на другой; возвращает self. Если аргумент не указан, поворачивает первый элемент в последнюю позицию:
a = [:foo, 'bar', 2, 'bar']
a.rotate! # => ["bar", 2, "bar", :foo]
Когда задано неотрицательное целое число счетчик(count), вращает элементы count от начала до конца:
a = [:foo, 'bar', 2]
a.rotate!(2)
a # => [2, :foo, "bar"]
Если count большое, в качестве count используется count% array.size:
a = [:foo, 'bar', 2]
a.rotate!(20)
a # => [2, :foo, "bar"]
Если count равен нулю, возвращается без изменений:
a = [:foo, 'bar', 2]
a.rotate!(0)
a # => [:foo, "bar", 2]
Когда задано отрицательное целое число, вращается в противоположном направлении, от конца к началу:
a = [:foo, 'bar', 2]
a.rotate!(-2)
a # => ["bar", 2, :foo]
Если count мало (далеко от нуля), в качестве count используется count% array.size:
a = [:foo, 'bar', 2]
a.rotate!(-5)
a # => ["bar", 2, :foo]
| |
Внимание! Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод rotate |
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 или 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
|
|
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) #=> []
|
|
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 ( |
| |
Внимание! Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте методы [] («батарейка»), values_at или итератор reject |
Array#sort
правитьarray.sort #=> an_array
array.sort { |a, b| block } #=> an_array
Возвращает новый массив, который получен путем сортировки массива array (по возрастанию). Элементы массива должны допускать сравнение при помощи метода <=>, если это не обеспечивается, то можно использовать необязательный блок. Блок предназначенный для сравнения параметров a и b, должен возвращать значения -1, 0, или +1.
a = ["d", "a", "e", "c", "b"]
a.sort #=> ["a", "b", "c", "d", "e"]
a.sort {|x, y| y <=> x } #=> ["e", "d", "c", "b", "a"]
|
|
Более интересная и чаще используемая форма сортировки производится при помощи итератора Enumerable#sort_by |
Array#sort!
правитьarray.sort! #=> array
array.sort! { |a, b| block } #=> array
Сортирует массив array (по возрастанию). Элементы массива должны допускать сравнение при помощи метода <=>, если это не обеспечивается, то можно использовать необязательный блок. Блок предназначенный для сравнения параметров a и b, должен возвращать значения -1, 0, или +1.
a = ["d", "a", "e", "c", "b"]
a.sort! #=> ["a", "b", "c", "d", "e"]
a.sort! {|x,y| y <=> x } #=> ["e", "d", "c", "b", "a"]
|
|
Более интересная и чаще используемая форма сортировки производится при помощи метода Enumerable#sort_by |
| |
Внимание! Будьте внимательны при использовании данного итератора, так как он изменяет исходный массив. Чтобы исключить это изменение используйте итераторы sort и Enumerable#sort_by |
Array#to_a
правитьarray.to_a #=> array
Возвращает указатель на self. Если вызывается от потомка классаArray, то конвертирует указанный объект в массив (объект классаArray).
Array#to_ary
правитьarray.to_ary #=> array
Возвращает указатель на self. По сути, ничего не делает.
Array#to_s
правитьarray.to_s #=> string
Возвращает результат self.join.
["a", "e", "i", "o"].to_s #=> "aeio"
Array#transpose
правитьarray.transpose #=> an_array
Подразумевает, что array является массивом массивов (то есть с размерностью больше, чем один) и меняет местами столбцы со строками (транспонирует).
a = [[1,2], [3,4], [5,6]]
a.transpose #=> [[1, 3, 5], [2, 4, 6]]
Array#uniq
правитьarray.uniq #=> an_array
Возвращает новый массив, который получен из массива array путем удаления всех повторяющихся элементов (то есть остаются только «уникальные» элементы).
a = ["a", "a", "b", "b", "c"]
a.uniq #=> ["a", "b", "c"]
Array#uniq!
правитьarray.uniq! #=> array или nil
Удаляет из массива array все повторяющиеся элементы (то есть остаются только «uniq'альные элементы»). Возвращаетnil, если повторяющиеся элементы в массиве array отсутствовали.
a = ["a", "a", "b", "b", "c"]
a.uniq! #=> ["a", "b", "c"]
b = ["a", "b", "c"]
b.uniq! #=> nil
| |
Внимание! Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод uniq |
Array#unshift
правитьarray.unshift(obj, ...) #=> array
Добавляет элементы в начало массива array (со сдвигом вправо уже существующих).
a = ["b", "c", "d"]
a.unshift("a") #=> ["a", "b", "c", "d"]
a.unshift(1, 2) #=> [ 1, 2, "a", "b", "c", "d"]
a #=> [ 1, 2, "a", "b", "c", "d"]
| |
Внимание! Данный метод изменяет исходный массив. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод + |
Array#values_at
правитьarray.values_at(selector,... ) #=> an_array
Возвращает массив, который состоит из элементов массива array, которые соответствуют передаваемым селекторам. Селекторы могут быть целыми числами (индексами) или целочисленными диапазонами.
a = %w{ a b c d e f }
a.values_at(1, 3, 5)
a.values_at(1, 3, 5, 7)
a.values_at(-1, -3, -5, -7)
a.values_at(1..3, 2...5)
|
|
Для подобных целей также используются методы select и [] («батарейка»). Вот только в «батарейке» нельзя указывать несколько непоследовательных индексов или диапазонов, а select отбирает элементы по условию (а не по индексу) |
Array#zip
правитьarray.zip(arg, ...) #=> an_array
array.zip(arg, ...) {| arr | block } #=> nil
Преобразует аргументы в массивы (при помощи методаto_a). Объединяет каждый элемент массива array с соответствующим массивом, переданным в качестве аргумента. В результате этого создается двумерный массив с array.size строками и сn столбцами, гдеn — максимальная из длин аргументов-массивов. Если длина какого либо из аргументов-массивов меньшеn, то он расширяется до длиныn (дополняетсяnil). Если задан блок, то получаемые массивы передаются в блок в качестве параметра, иначе — возвращается двумерный массив.
a = [4, 5, 6]
b = [7, 8, 9]
[1,2,3].zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1,2].zip(a,b) #=> [[1, 4, 7], [2, 5, 8]]
a.zip([1,2],[8]) #=> [[4,1,8], [5,2,nil], [6,nil,nil]]
|
|
Обычно используется совместно с методом assoc, то есть |
Класс 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, которые имеют схожую функциональность |
| |
Внимание! Результат работы данного метода и методов % и 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) |
^ |
| |
+----------------+
Объявленные атрибуты будут доступны в пределах иерархии наследования, где каждый потомок получает копию атрибутов своих родителей, вместо истинного указателя на него. Это означает, что потомок может добавить элементы, для примера, в массив без тех дополнений которые он делит со своим родителем, элементами одного с ним уровня (имеющими общего родителя) или потомками, которые не похожи на правильные атрибуты уровня класса и которые разделены поперек всей иерархии
Методы класса
Методы объекта
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]
Методы объекта
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}
arr_result = []
arr = ['cat', 'dog', 'wombat', 'horse']
arr.each_with_index {|item, index|
arr_result << [item, index]
}
arr_result #=> [ ['cat', 0], ['dog', 1], ['wombat', 2], ['horse', 3] ]
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 корректно вести себя в логических выражениях.
Методы объекта
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
Методы класса
Методы объекта
[], %, &, **, *, +, -@, -, /, <<, <=>, <=, <, ==, >=, >>, >, ^, 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"
|
|
|
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
Методы класса
Методы объекта
%, **, *, +, -@, -, /, <->, <=, <, ==, >=, >, 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.
Методы класса
Методы объекта
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)
Методы класса
Методы объекта
[]=, [], ==, 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>
| |
Внимание! Таким способом в качестве значения по-умолчанию нельзя установить Proc, который будет выполняться при каждом обращении по ключу |
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
| |
Внимание! Использование данного метода резко осуждается Руби-сообществом. Во время его использования интерпретатор будет выдавать предупреждение. Рекомендуется использовать метод key. |
Hash#indexes
правитьhsh.indexes(key, ...) #-> array
| |
Внимание! Данный метод является «устаревшим» и его использование осуждается разработчиками. В следующих версиях языка он будет удален и ваша программа перестанет работать. Используйте метод select, который имеет схожий функционал, но не является «устаревшим» |
|
|
Методы indexes и indices — абсолютно идентичны, то есть являются именами одного и того же метода |
Hash#indices
правитьhsh.indices(key, ...) #-> array
| |
Внимание! Данный метод является «устаревшим» и его использование осуждается разработчиками. В следующих версиях языка он будет удален и ваша программа перестанет работать. Используйте метод select, который имеет схожий функционал, но не является «устаревшим» |
|
|
Методы 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 — абсолютно идентичны, то есть являются именами одного и того же метода |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод merge, который не имеет данного побочного эффекта |
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 — абсолютно идентичны, то есть являются именами одного и того же метода |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод merge, который не имеет данного побочного эффекта |
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),
Константы
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
Reads a line as with IO#gets, but raises an EOFError on end of file.
IO#readlines
правитьios.readlines(sep_string=$/) => array
Reads all of the lines in ios, and returns them in anArray. Lines are separated by the optional sep_string. If sep_string is nil, the rest of the stream is returned as a single record. The stream must be opened for reading or an IOError will be raised.
f = File.new("testfile")
f.readlines[0] #=> "This is line one\n"
IO#readpartial
правитьios.readpartial(maxlen) => string ios.readpartial(maxlen, outbuf) => outbuf
Reads at most maxlen bytes from the I/O stream. It blocks only if ios has no data immediately available. It doesn't block if some data available. If the optional outbuf argument is present, it must reference a String, which will receive the data. It raises EOFError on end of file. readpartial is designed for streams such as pipe, socket, tty, etc. It blocks only when no data immediately available. This means that it blocks only when following all conditions hold.
- the buffer in the IO object is empty.
- the content of the stream is empty.
- the stream is not reached to EOF.
When readpartial blocks, it waits data or EOF on the stream. If some data is reached, readpartial returns with the data. If EOF is reached, readpartial raises EOFError. When readpartial doesn't blocks, it returns or raises immediately. If the buffer is not empty, it returns the data in the buffer. Otherwise if the stream has some content, it returns the data in the stream. Otherwise if the stream is reached to EOF, it raises EOFError.
r, w = IO.pipe # buffer pipe content
w << "abc" # "" "abc".
r.readpartial(4096) #=> "abc" "" ""
r.readpartial(4096) # blocks because buffer and pipe is empty.
r, w = IO.pipe # buffer pipe content
w << "abc" # "" "abc"
w.close # "" "abc" EOF
r.readpartial(4096) #=> "abc" "" EOF
r.readpartial(4096) # raises EOFError
r, w = IO.pipe # buffer pipe content
w << "abc\ndef\n" # "" "abc\ndef\n"
r.gets #=> "abc\n" "def\n" ""
w << "ghi\n" # "def\n" "ghi\n"
r.readpartial(4096) #=> "def\n" "" "ghi\n"
r.readpartial(4096) #=> "ghi\n" "" ""
Note that readpartial behaves similar to sysread. The differences are:
- If the buffer is not empty, read from the buffer instead of "sysread for buffered IO (IOError)".
- It doesn't cause Errno::EAGAIN and Errno::EINTR. When readpartial meets EAGAIN and EINTR by read system call, readpartial retry the system call.
The later means that readpartial is nonblocking-flag insensitive. It blocks on the situation IO#sysread causes Errno::EAGAIN as if the fd is blocking mode.
IO#reopen
правитьios.reopen(other_IO) => ios ios.reopen(path, mode_str) => ios
Reassociates ios with the I/O stream given in other_IO or to a new stream opened on path. This may dynamically change the actual class of this stream.
f1 = File.new("testfile")
f2 = File.new("testfile")
f2.readlines[0] #=> "This is line one\n"
f2.reopen(f1) #=> #<File:testfile>
f2.readlines[0] #=> "This is line one\n"
IO#rewind
правитьios.rewind => 0
Positions ios to the beginning of input, resetting lineno to zero.
f = File.new("testfile")
f.readline #=> "This is line one\n"
f.rewind #=> 0
f.lineno #=> 0
f.readline #=> "This is line one\n"
IO#scanf
правитьscanf(str,&b)
The trick here is doing a match where you grab one line of input at a time. The linebreak may or may not occur at the boundary where the string matches a format specifier. And if it does, some rule about whitespace may or may not be in effect... That's why this is much more elaborate than the string version. For each line: Match succeeds (non-emptily) and the last attempted spec/string sub-match succeeded:
could the last spec keep matching?
yes: save interim results and continue (next line)
The last attempted spec/string did not match: are we on the next-to-last spec in the string?
yes:
is fmt_string.string_left all spaces?
yes: does current spec care about input space?
yes: fatal failure
no: save interim results and continue
no: continue [this state could be analyzed further]
IO#seek
правитьios.seek(amount, whence=SEEK_SET) -> 0
Seeks to a given offset anInteger in the stream according to the value of whence:
IO::SEEK_CUR | Seeks to amount plus current position
--------------+----------------------------------------------------
IO::SEEK_END | Seeks to amount plus end of stream (you probably
| want a negative value for amount)
--------------+----------------------------------------------------
IO::SEEK_SET | Seeks to the absolute location given by amount
Example:
f = File.new("testfile")
f.seek(-13, IO::SEEK_END) #=> 0
f.readline #=> "And so on...\n"
IO#soak_up_spaces
правитьsoak_up_spaces()
(нет описания...)
IO#stat
правитьios.stat => stat
Returns status information for ios as an object of type File::Stat.
f = File.new("testfile")
s = f.stat
"%o" % s.mode #=> "100644"
s.blksize #=> 4096
s.atime #=> Wed Apr 09 08:53:54 CDT 2003
IO#sync
правитьios.sync => true or false
Returns the current ``sync mode of ios. When sync mode is true, all output is immediately flushed to the underlying operating system and is not buffered by Ruby internally. See also IO#fsync.
f = File.new("testfile")
f.sync #=> false
IO#sync=
правитьios.sync = boolean => boolean
Sets the ``sync mode to true or false. When sync mode is true, all output is immediately flushed to the underlying operating system and is not buffered internally. Returns the new state. See also IO#fsync.
f = File.new("testfile")
f.sync = true
(produces no output)
IO#sysread
правитьios.sysread(integer ) => string
Reads integer bytes from ios using a low-level read and returns them as a string. Do not mix with other methods that read from ios or you may get unpredictable results. Raises SystemCallError on error and EOFError at end of file.
f = File.new("testfile")
f.sysread(16) #=> "This is line one"
IO#sysseek
правитьios.sysseek(offset, whence=SEEK_SET) => integer
Seeks to a given offset in the stream according to the value of whence (see IO#seek for values of whence). Returns the new offset into the file.
f = File.new("testfile")
f.sysseek(-13, IO::SEEK_END) #=> 53
f.sysread(10) #=> "And so on."
IO#syswrite
правитьios.syswrite(string) => integer
Writes the given string to ios using a low-level write. Returns the number of bytes written. Do not mix with other methods that write to ios or you may get unpredictable results. Raises SystemCallError on error.
f = File.new("out", "w")
f.syswrite("ABCDEF") #=> 6
IO#tell
править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#to_i
правитьto_i()
Alias for #fileno
IO#to_io
правитьios.to_io -> ios
Returns ios.
IO#tty?
править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#ungetc
правитьios.ungetc(integer) => nil
Pushes back one character (passed as a parameter) onto ios, such that a subsequent buffered read will return it. Only one character may be pushed back before a subsequent read operation (that is, you will be able to read only the last of several characters that have been pushed back). Has no effect with unbuffered reads (such as IO#sysread).
f = File.new("testfile") #=> #<File:testfile>
c = f.getc #=> 84
f.ungetc(c) #=> nil
f.getc #=> 84
IO#write
правитьios.write(string) => integer
Writes the given string to ios. The stream must be opened for writing. If the argument is not a string, it will be converted to a string using to_s. Returns the number of bytes written.
count = $stdout.write( "This is a test\n" )
puts "That was #{count} bytes of data"
produces:
This is a test
That was 15 bytes of data
IO#write_nonblock
правитьios.write_nonblock(string) => integer
Writes the given string to ios using write(2) system call after O_NONBLOCK is set for the underlying file descriptor. write_nonblock just calls write(2). It causes all errors write(2) causes: EAGAIN, EINTR, etc. The result may also be smaller than string.length (partial write). The caller should care such errors and partial write.
Класс Integer < Numeric
правитьInteger — это родительский класс для классов Bignum и Fixnum, которые отвечают за работу с целыми числами.
Примеси
Precision (prec, prec_f, prec_i)
Методы класса
from_prime_division, induced_from
Методы объекта
ceil, chr, denominator, downto, even?, floor, gcdlcm, gcd, integer?, lcm, next, numerator, odd?, prime_division, round, succ, times, to_f, to_int, to_i, to_r, to_s, truncate, upto
Integer::from_prime_division
правитьInteger::from_prime_division( ''array'' ) #-> integer
Преобразует двумерный массив array из простых делителей и их степеней обратно в целое число.
require 'mathn'
Integer.from_prime_division( [[5,1], [7,1]] ) #-> 35
Integer.from_prime_division( 122.prime_division ) #-> 122
|
|
Полезно посмотреть на метод prime_division, который имеет схожую функциональность |
| |
Внимание! Для работы данного метода необходимо подключение библиотеки mathn |
Integer::induced_from
правитьInteger.induced_from(obj) #-> integer
Преобразует obj в целое число.
Integer#ceil
правитьint.to_i #-> int
int.to_int #-> int
int.floor #-> int
int.ceil #-> int
int.round #-> int
int.truncate #-> int
В виду того, что int уже целое число, а данный метод производит округление к целому числу, то он просто возвращает значение int.
|
|
Полезно посмотреть на методы ceil, floor, round, to_i, to_int и truncate, которые имеют схожую функциональность |
Integer#chr
правитьint.chr #-> string
Возвращает строку, состоящую из ASCII-символа с кодом равным значению int.
65.chr #-> "A"
?a.chr #=> "a"
230.chr #=> "\346"
Integer#denominator
правитьnum.denominator #-> 1
Для целого числа знаменатель всегда равен 1. Поэтому, данный метод возвращает 1.
|
|
Знаменатель отличен от 1 только у рациональных дробей. Данный метод создан для совместимости, так как целые числа — это частный случай рациональных дробей. Формально, целое число — это рациональная дробь у которой знаменатель равен 1 |
Integer#downto
правитьint.downto(limit) {|i| block } #-> int
Выполняет блок для всех чисел с int по limit с шагом -1 (то есть число int должно быть больше числа limit).
5.downto(1) { |n| print n, ".. " }
print " Liftoff!\n"
результат:
5.. 4.. 3.. 2.. 1.. Liftoff!
Integer#even?
правитьnum.even? #-> true или false
Возвращает true, если int - четное число.
Integer#floor
правитьint.to_i #-> int
int.to_int #-> int
int.floor #-> int
int.ceil #-> int
int.round #-> int
int.truncate #-> int
В виду того, что int уже целое число, а данный метод производит округление к целому числу, то он просто возвращает значение int.
|
|
Полезно посмотреть на методы ceil, floor, round, to_i, to_int и truncate, которые имеют схожую функциональность |
Integer#gcd
правитьnum.gcd(other)
Возвращает наибольший общий делитель двух чисел (num и other).
72.gcd 168 #-> 24
19.gcd 36 #-> 1
|
|
Результат данного метода — положительное целое число, независимо от знака аргументов |
|
|
Полезно посмотреть на методы gcd и gcdlcm, которые имеют схожую функциональность |
Integer#gcdlcm
правитьnum.gcdlcm(other)
Возвращает НОД и НОК (см. gcd и lcm) двух чисел (num и other). Этот метод особенно эффективен, когда необходимо посчитать НОД и НОК одновременно.
6.gcdlcm 9 #-> [3, 18]
|
|
Полезно посмотреть на методы gcd и lcm, которые имеют схожую функциональность |
Integer#integer?
правитьint.integer? #-> true
Всегда возвращает true.
Integer#lcm
правитьnum.lcm(other) #-> integer
Возвращает наименьшее общее кратное двух чисел (num и other).
6.lcm 7 #-> 42
6.lcm 9 #-> 18
|
|
Результат данного метода — положительное целое число, независимо от знака каждого из аргументов |
|
|
Полезно посмотреть на методы gcd и gcdlcm, которые имеют схожую функциональность |
Integer#next
правитьint.next #-> int
int.succ #-> int
Возвращает целое число, которое равно int + 1.
1.next #-> 2
(-1).next #-> 0
|
|
Методы succ и next — абсолютно идентичны, то есть являются именами одного и того же метода |
Integer#numerator
правитьnum.numerator #-> num
Для целого числа числитель всегда равен его значению. Поэтому данный метод возвращает значение num.
|
|
Полезно посмотреть на метод denominator, который имеет схожую функциональность |
Integer#odd?
правитьnum.odd? #-> true или false
Возвращает true, если int - нечетное число.
Integer#prime_division
правитьnum.prime_division #-> array
Возвращает двумерный массив, состоящий из простых делителей числа и их степеней.
require 'mathn'
35.prime_division #-> [[5, 1], [7, 1]]
256.prime_division #-> [[2, 8]]
|
|
Полезно посмотреть на метод from_prime_division, который имеет схожую функциональность |
| |
Внимание! Для работы данного метода необходимо подключение библиотеки mathn |
Integer#round
правитьint.to_i #-> int
int.to_int #-> int
int.floor #-> int
int.ceil #-> int
int.round #-> int
int.truncate #-> int
В виду того, что int уже целое число, а данный метод производит округление к целому числу, то он просто возвращает значение int.
|
|
Полезно посмотреть на методы ceil, floor, round, to_i, to_int и truncate, которые имеют схожую функциональность |
Integer#succ
правитьint.next #-> int
int.succ #-> int
Возвращает целое число, которое равно int + 1.
1.next #-> 2
(-1).next #-> 0
|
|
Методы succ и next — абсолютно идентичны, то есть являются именами одного и того же метода |
Integer#times
правитьint.times {|i| block } #-> int
Выполняет блок int раз, передавая в него значения от 0 до int - 1.
5.times do |i|
print i, " "
end
результат:
0 1 2 3 4
Integer#to_f
правитьint.to_f #-> float
Преобразует int в Float. Если int не помещается в Float, результатом будет бесконечность.
108.to_f #-> 108.0
|
|
Подробнее об Float |
Integer#to_i
правитьint.to_i #-> int
int.to_int #-> int
int.floor #-> int
int.ceil #-> int
int.round #-> int
int.truncate #-> int
В виду того, что int уже целое число, а данный метод производит округление к целому числу, то он просто возвращает значение int.
|
|
Полезно посмотреть на методы ceil, floor, round, to_i, to_int и truncate, которые имеют схожую функциональность |
Integer#to_int
правитьint.to_i #-> int
int.to_int #-> int
int.floor #-> int
int.ceil #-> int
int.round #-> int
int.truncate #-> int
В виду того, что int уже целое число, а данный метод производит округление к целому числу, то он просто возвращает значение int.
|
|
Полезно посмотреть на методы ceil, floor, round, to_i, to_int и truncate, которые имеют схожую функциональность |
Integer#to_r
правитьnum.to_r #-> rational
Возвращает число num в виде рациональной дроби.
35.to_r #-> Rational(35, 1)
Integer#to_s
правитьint.to_s(base=10) #-> string
Возвращает строку, содержащую представление разряда int с основанием системы счисления (от 2 до 36).
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"
78546939656932.to_s(36) #=> "rubyrules"
|
|
Также имеет псевдоним: инспектировать |
Integer#truncate
правитьint.to_i #-> int
int.to_int #-> int
int.floor #-> int
int.ceil #-> int
int.round #-> int
int.truncate #-> int
В виду того, что int уже целое число, а данный метод производит округление к целому числу, то он просто возвращает значение int.
|
|
Полезно посмотреть на методы ceil, to_i, to_int, floor, round и truncate, которые имеют схожую функциональность |
Integer#upto
правитьint.upto(limit) {|i| block } #-> int
Выполняет блок для всех целых чисел с int по limit, включительно.
5.upto(10) { |i| print i, " " }
результат:
5 6 7 8 9 10
Примесь Kernel
правитьSince Ruby is very dynamic, methods added to the ancestors of BlankSlate after BlankSlate is defined will show up in the list of available BlankSlate methods. We handle this by defining a hook in the Object and Kernel classes that will hide any defined
Some objects are dupable, some are not. So we define a version of dup (called rake_dup) that returns self on the handful of classes that are not dupable.
Create a global fork method
Методы объекта
Array, Float, Integer, Pathname, String, URI, `, abort, at_exit, autoload?, autoload, binding, block_given?, callcc, caller, catch, chomp!, chomp, chop!, chop, eval, exec, exit!, exit, fail, fork, format, gem, getc, gets, global_variables, gsub!, gsub, iterator?, lambda, load, local_variables, loop, method_missing, open_uri_original_open, open, pp, pretty_inspect, printf, print, proc, putc, puts, p, raise, rake_dup, rand, readlines, readline, require_gem, require, scanf, scan, select, set_trace_func, sleep, split, sprintf, srand, sub!, sub, syscall, system, test, throw, to_ptr, trace_var, trap, untrace_var, warn, y
Kernel#Array
правитьArray(arg) => array
Returns arg as an Array. First tries to call arg.to_ary, then arg.to_a. If both fail, creates a single element array containing arg (unless arg is nil).
Array(1..5) #=> [1, 2, 3, 4, 5]
Kernel#Float
правитьFloat(arg) => float
Returns arg converted to a float. Numeric types are converted directly, the rest are converted using arg.to_f. As of Ruby 1.8, converting nil generates a TypeError.
Float(1) #=> 1.0
Float("123.456") #=> 123.456
Kernel#Integer
правитьInteger(arg) => integer
Converts arg to a Fixnum or Bignum. Numeric types are converted directly (with floating point numbers being truncated). If arg is a String, leading radix indicators (0, 0b, and 0x) are honored. Others are converted using to_int and to_i. This behavior is different from that of String#to_i.
Integer(123.999) #=> 123
Integer("0x1a") #=> 26
Integer(Time.new) #=> 1049896590
Kernel#Pathname
правитьPathname(path)
create a pathname object. This method is available since 1.8.5.
Kernel#String
правитьString(arg) => string
Converts arg to a String by calling its to_s method.
String(self) #=> "main"
String(self.class #=> "Object"
String(123456) #=> "123456"
Kernel#URI
правитьURI(uri_str)
alias for URI.parse. This method is introduced at 1.8.2.
Kernel#`
править`cmd` => string
Returns the standard output of running cmd in a subshell. The built-in syntax %x{...} uses this method. Sets $? to the process status.
`date` #=> "Wed Apr 9 08:56:30 CDT 2003\n"
`ls testdir`.split[1] #=> "main.rb"
`echo oops && exit 99` #=> "oops\n"
$?.exitstatus #=> 99
Kernel#abort
правитьabort Kernel::abort Process::abort
Terminate execution immediately, effectively by calling Kernel.exit(1). If msg is given, it is written to STDERR prior to terminating.
Kernel#at_exit
править at_exit { block } -> proc
Converts block to a Proc object (and therefore binds it at the point of call) and registers it for execution when the program exits. If multiple handlers are registered, they are executed in reverse order of registration.
def do_at_exit(str1)
at_exit { print str1 }
end
at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit
produces:
goodbye cruel world
Kernel#autoload
правитьautoload(module, filename) => nil
Registers filename to be loaded (using Kernel::require) the first time that module (which may be a String or a symbol) is accessed.
autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
Kernel#autoload?
правитьautoload(module, filename) => nil
Registers filename to be loaded (using Kernel::require) the first time that module (which may be a String or a symbol) is accessed.
autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
Kernel#binding
правитьbinding -> a_binding
Returns a Binding object, describing the variable and method bindings at the point of call. This object can be used when calling eval to execute the evaluated command in this environment. Also see the description of class Binding.
def getBinding(param)
return binding
end
b = getBinding("hello")
eval("param", b) #=> "hello"
Kernel#block_given?
правитьblock_given? => true or false iterator? => true or false
Returns true if yield would execute a block in the current context. The iterator? form is mildly deprecated.
def try
if block_given?
yield
else
"no block"
end
end
try #=> "no block"
try { "hello" } #=> "hello"
try do "hello" end #=> "hello"
Kernel#callcc
править callcc {|cont| block } => obj
Generates a Continuation object, which it passes to the associated block. Performing a cont.call will cause the callcc to return (as will falling through the end of the block). The value returned by the callcc is the value of the block, or the value passed to cont.call. See class Continuation for more details. Also see Kernel::throw for an alternative mechanism for unwinding a call stack.
Kernel#caller
правитьcaller(start=1) => array
Returns the current execution stack---an array containing strings in the form ``file:line or ``file:line: in `method'. The optional start parameter determines the number of initial stack entries to omit from the result.
def a(skip)
caller(skip)
end
def b(skip)
a(skip)
end
def c(skip)
b(skip)
end
c(0) #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10"]
c(1) #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11"]
c(2) #=> ["prog:8:in `c'", "prog:12"]
c(3) #=> ["prog:13"]
Kernel#catch
править catch(symbol) {| | block } > obj
catch executes its block. If a throw is executed, Ruby searches up its stack for a catch block with a tag corresponding to the throw's symbol. If found, that block is terminated, and catch returns the value given to throw. If throw is not called, the block terminates normally, and the value of catch is the value of the last expression evaluated. catch expressions may be nested, and the throw call need not be in lexical scope.
def routine(n)
puts n
throw :done if n <= 0
routine(n-1)
end
catch(:done) { routine(3) }
produces:
3
2
1
0
Kernel#chomp
правитьchomp => $_ chomp(string) => $_
Equivalent to $_ = $_.chomp(string). See String#chomp.
$_ = "now\n"
chomp #=> "now"
$_ #=> "now"
chomp "ow" #=> "n"
$_ #=> "n"
chomp "xxx" #=> "n"
$_ #=> "n"
Kernel#chomp!
правитьchomp! => $_ or nil chomp!(string) => $_ or nil
Equivalent to $_.chomp!(string). See String#chomp!
$_ = "now\n"
chomp! #=> "now"
$_ #=> "now"
chomp! "x" #=> nil
$_ #=> "now"
Kernel#chop
правитьchop => string
Equivalent to ($_.dup).chop!, except nil is never returned. See String#chop!.
a = "now\r\n"
$_ = a
chop #=> "now"
$_ #=> "now"
chop #=> "no"
chop #=> "n"
chop #=> ""
chop #=> ""
a #=> "now\r\n"
Kernel#chop!
правитьchop! => $_ or nil
Equivalent to $_.chop!.
a = "now\r\n"
$_ = a
chop! #=> "now"
chop! #=> "no"
chop! #=> "n"
chop! #=> ""
chop! #=> nil
$_ #=> ""
a #=> ""
Kernel#eval
правитьeval(string [, binding [, filename [,lineno]]]) => obj
Evaluates the Ruby expression(s) in string. If binding is given, the evaluation is performed in its context. The binding may be a Binding object or a Proc object. If the optional filename and lineno parameters are present, they will be used when reporting syntax errors.
def getBinding(str)
return binding
end
str = "hello"
eval "str + ' Fred'" #=> "hello Fred"
eval "str + ' Fred'", getBinding("bye") #=> "bye Fred"
Kernel#exec
правитьexec(command [, arg, ...])
Replaces the current process by running the given external command. If exec is given a single argument, that argument is taken as a line that is subject to shell expansion before being executed. If multiple arguments are given, the second and subsequent arguments are passed as parameters to command with no shell expansion. If the first argument is a two-element array, the first element is the command to be executed, and the second argument is used as the argv[0] value, which may show up in process listings. In MSDOS environments, the command is executed in a subshell; otherwise, one of the exec(2) system calls is used, so the running command may inherit some of the environment of the original program (including open file descriptors).
exec "echo *" # echoes list of files in current directory
# never get here
exec "echo", "*" # echoes an asterisk
# never get here
Kernel#exit
правитьexit(integer=0) Kernel::exit(integer=0) Process::exit(integer=0)
Initiates the termination of the Ruby script by raising the SystemExit exception. This exception may be caught. The optional parameter is used to return a status code to the invoking environment.
begin
exit
puts "never get here"
rescue SystemExit
puts "rescued a SystemExit exception"
end
puts "after begin block"
produces:
rescued a SystemExit exception
after begin block
Just prior to termination, Ruby executes any at_exit functions (see Kernel::at_exit) and runs any object finalizers (see ObjectSpace::define_finalizer).
at_exit { puts "at_exit function" }
ObjectSpace.define_finalizer("string", proc { puts "in finalizer" })
exit
produces:
at_exit function
in finalizer
Kernel#exit!
правитьProcess.exit!(fixnum=-1)
Exits the process immediately. No exit handlers are run. fixnum is returned to the underlying system as the exit status.
Process.exit!(0)
Kernel#fail
правитьraise raise(string) raise(exception [, string [, array]]) fail fail(string) fail(exception [, string [, array]])
With no arguments, raises the exception in $! or raises a RuntimeError if $! is nil. With a single String argument, raises a RuntimeError with the string as a message. Otherwise, the first parameter should be the name of an Exception class (or an object that returns an Exception object when sent an exception message). The optional second parameter sets the message associated with the exception, and the third parameter is an array of callback information. Exceptions are caught by the rescue clause of begin...end blocks.
raise "Failed to create socket"
raise ArgumentError, "No parameters", caller
Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:
Kernel#fork, Kernel#fork===Kernel#format===
format(format_string [, arguments...] ) => string sprintf(format_string [, arguments...] ) => string
Returns the string resulting from applying format_string to any additional arguments. Within the format string, any characters other than format sequences are copied to the result. A format sequence consists of a percent sign, followed by optional flags, width, and precision indicators, then terminated with a field type character. The field type controls how the corresponding sprintf argument is to be interpreted, while the flags modify that interpretation. The field type characters are listed in the table at the end of this section. The flag characters are:
Flag | Applies to | Meaning
---------+--------------+-----------------------------------------
space | bdeEfgGiouxX | Leave a space at the start of
| | positive numbers.
---------+--------------+-----------------------------------------
(digit)$ | all | Specifies the absolute argument number
| | for this field. Absolute and relative
| | argument numbers cannot be mixed in a
| | sprintf string.
---------+--------------+-----------------------------------------
# | beEfgGoxX | Use an alternative format. For the
| | conversions `o', `x', `X', and `b',
| | prefix the result with ``0, ``0x, ``0X,
| | and ``0b, respectively. For `e',
| | `E', `f', `g', and 'G', force a decimal
| | point to be added, even if no digits follow.
| | For `g' and 'G', do not remove trailing zeros.
---------+--------------+-----------------------------------------
+ | bdeEfgGiouxX | Add a leading plus sign to positive numbers.
---------+--------------+-----------------------------------------
- | all | Left-justify the result of this conversion.
---------+--------------+-----------------------------------------
0 (zero) | bdeEfgGiouxX | Pad with zeros, not spaces.
---------+--------------+-----------------------------------------
* | all | Use the next argument as the field width.
| | If negative, left-justify the result. If the
| | asterisk is followed by a number and a dollar
| | sign, use the indicated argument as the width.
The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field. For numeric fields, the precision controls the number of decimal places displayed. For string fields, the precision determines the maximum number of characters to be copied from the string. (Thus, the format sequence %10.10s will always contribute exactly ten characters to the result.) The field types are:
Field | Conversion
------+--------------------------------------------------------------
b | Convert argument as a binary number.
c | Argument is the numeric code for a single character.
d | Convert argument as a decimal number.
E | Equivalent to `e', but uses an uppercase E to indicate
| the exponent.
e | Convert floating point argument into exponential notation
| with one digit before the decimal point. The precision
| determines the number of fractional digits (defaulting to six).
f | Convert floating point argument as [-]ddd.ddd,
| where the precision determines the number of digits after
| the decimal point.
G | Equivalent to `g', but use an uppercase `E' in exponent form.
g | Convert a floating point number using exponential form
| if the exponent is less than -4 or greater than or
| equal to the precision, or in d.dddd form otherwise.
i | Identical to `d'.
o | Convert argument as an octal number.
p | The valuing of argument.inspect.
s | Argument is a string to be substituted. If the format
| sequence contains a precision, at most that many characters
| will be copied.
u | Treat argument as an unsigned decimal number. Negative integers
| are displayed as a 32 bit two's complement plus one for the
| underlying architecture; that is, 2 ** 32 + n. However, since
| Ruby has no inherent limit on bits used to represent the
| integer, this value is preceded by two dots (..) in order to
| indicate a infinite number of leading sign bits.
X | Convert argument as a hexadecimal number using uppercase
| letters. Negative numbers will be displayed with two
| leading periods (representing an infinite string of
| leading 'FF's.
x | Convert argument as a hexadecimal number.
| Negative numbers will be displayed with two
| leading periods (representing an infinite string of
| leading 'ff's.
Examples:
sprintf("%d %04x", 123, 123) #=> "123 007b"
sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'"
sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello"
sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8"
sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23"
sprintf("%u", -123) #=> "..4294967173"
Kernel#gem
правитьgem(gem_name, *version_requirements)
Adds a Ruby Gem to the $LOAD_PATH. Before a Gem is loaded, its required Gems are loaded. If the version information is omitted, the highest version Gem of the supplied name is loaded. If a Gem is not found that meets the version requirement and/or a required Gem is not found, a Gem::LoadError is raised. More information on version requirements can be found in the Gem::Version documentation. The gem directive should be executed before any require statements (otherwise rubygems might select a conflicting library version). You can define the environment variable GEM_SKIP as a way to not load specified gems. you might do this to test out changes that haven't been intsalled yet. Example:
GEM_SKIP=libA:libB ruby-I../libA -I../libB ./mycode.rb
[String or Gem::Dependency] The gem name or dependency instance. [default=">= 0.0.0"] The version requirement. [Boolean] true if the Gem is loaded, otherwise false.
[Gem::LoadError] if Gem cannot be found, is listed in GEM_SKIP, or version requirement not met.Kernel#getc
правитьgetc()
obsolete
Kernel#gets
правитьgets(separator=$/) => string or nil
Returns (and assigns to $_) the next line from the list of files in ARGV (or $*), or from standard input if no files are present on the command line. Returns nil at end of file. The optional argument specifies the record separator. The separator is included with the contents of each record. A separator of nil reads the entire contents, and a zero-length separator reads the input one paragraph at a time, where paragraphs are divided by two consecutive newlines. If multiple filenames are present in ARGV, +gets(nil)+ will read the contents one file at a time.
ARGV << "testfile"
print while gets
produces:
This is line one
This is line two
This is line three
And so on...
The style of programming using $_ as an implicit parameter is gradually losing favor in the Ruby community.
Kernel#global_variables
правитьglobal_variables => array
Returns an array of the names of global variables.
global_variables.grep /std/ #=> ["$stderr", "$stdout", "$stdin"]
Kernel#gsub
править gsub(pattern, replacement) => string
gsub(pattern) {|...| block } => string
Equivalent to $_.gsub..., except that $_ receives the modified result.
$_ = "quick brown fox"
gsub /[aeiou]/, '*' #=> "q**ck br*wn f*x"
$_ #=> "q**ck br*wn f*x"
Kernel#gsub!
править gsub!(pattern, replacement) => string or nil
gsub!(pattern) {|...| block } => string or nil
Equivalent to Kernel::gsub, except nil is returned if $_ is not modified.
$_ = "quick brown fox"
gsub! /cat/, '*' #=> nil
$_ #=> "quick brown fox"
Kernel#iterator?
правитьblock_given? => true or false iterator? => true or false
Returns true if yield would execute a block in the current context. The iterator? form is mildly deprecated.
def try
if block_given?
yield
else
"no block"
end
end
try #=> "no block"
try { "hello" } #=> "hello"
try do "hello" end #=> "hello"
Kernel#lambda
править proc { |...| block } => a_proc
lambda { |...| block } => a_proc
Equivalent to Proc.new, except the resulting Proc objects check the number of parameters passed when called.
Kernel#load
правитьload(filename, wrap=false) => true
Loads and executes the Ruby program in the file filename. If the filename does not resolve to an absolute path, the file is searched for in the library directories listed in $:. If the optional wrap parameter is true, the loaded script will be executed under an anonymous module, protecting the calling program's global namespace. In no circumstance will any local variables in the loaded file be propagated to the loading environment.
Kernel#local_variables
правитьlocal_variables => array
Returns the names of the current local variables.
fred = 1
for i in 1..10
# ...
end
local_variables #=> ["fred", "i"]
Kernel#loop
править loop {|| block }
Repeatedly executes the block.
loop do
print "Input: "
line = gets
break if !line or line =~ /^qQ/
# ...
end
Kernel#method_missing
правитьobj.method_missing(symbol [, *args] ) => result
Invoked by Ruby when obj is sent a message it cannot handle. symbol is the symbol for the method called, and args are any arguments that were passed to it. By default, the interpreter raises an error when this method is called. However, it is possible to override the method to provide more dynamic behavior. The example below creates a class Roman, which responds to methods with names consisting of roman numerals, returning the corresponding integer values.
class Roman
def romanToInt(str)
# ...
end
def method_missing(methId)
str = methId.id2name
romanToInt(str)
end
end
r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000
Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:
Kernel#open, Kernel#open_uri_original_open, Kernel#open===Kernel#open_uri_original_open===
open_uri_original_open(...)
Alias for #open
Kernel#p
правитьp(obj, ...) => nil
For each object, directly writes obj.inspect followed by the current output record separator to the program's standard output.
S = Struct.new(:name, :state)
s = S['dave', 'TX']
p s
produces:
#<S name="dave", state="TX">
Kernel#pp
правитьpp(*objs)
prints arguments in pretty form. pp returns nil.
Kernel#pretty_inspect
правитьpretty_inspect()
returns a pretty printed object as a string.
Kernel#print
правитьprint(obj, ...) => nil
Prints each object in turn to $stdout. If the output field separator ($,) is not nil, its contents will appear between each field. 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.
print "cat", [1,2,3], 99, "\n"
$, = ", "
$\ = "\n"
print "cat", [1,2,3], 99
produces:
cat12399
cat, 1, 2, 3, 99
Kernel#printf
правитьprintf(io, string [, obj ... ] ) => nil printf(string [, obj ... ] ) => nil
Equivalent to:
io.write(sprintf(string, obj, ...)
or
$stdout.write(sprintf(string, obj, ...)
Kernel#proc
править proc { |...| block } => a_proc
lambda { |...| block } => a_proc
Equivalent to Proc.new, except the resulting Proc objects check the number of parameters passed when called.
Kernel#putc
правитьputc(int) => int
Equivalent to:
$stdout.putc(int)
Kernel#puts
правитьputs(obj, ..., ...) => nil
Equivalent to
$stdout.puts(obj, ...)
Kernel#raise
правитьraise raise(string) raise(exception [, string [, array]]) fail fail(string) fail(exception [, string [, array]])
With no arguments, raises the exception in $! or raises a RuntimeError if $! is nil. With a single String argument, raises a RuntimeError with the string as a message. Otherwise, the first parameter should be the name of an Exception class (or an object that returns an Exception object when sent an exception message). The optional second parameter sets the message associated with the exception, and the third parameter is an array of callback information. Exceptions are caught by the rescue clause of begin...end blocks.
raise "Failed to create socket"
raise ArgumentError, "No parameters", caller
Kernel#rake_dup
правитьrake_dup()
Duplicate an object if it can be duplicated. If it can not be cloned or duplicated, then just return the original object.
Kernel#rand
правитьrand(max=0) => number
Converts max to an integer using max1 = max.to_i.abs. If the result is zero, returns a pseudorandom floating point number greater than or equal to 0.0 and less than 1.0. Otherwise, returns a pseudorandom integer greater than or equal to zero and less than max1. Kernel::srand may be used to ensure repeatable sequences of random numbers between different runs of the program. Ruby currently uses a modified Mersenne Twister with a period of 219937-1.
srand 1234 #=> 0
[ rand, rand ] #=> [0.191519450163469, 0.49766366626136]
[ rand(10), rand(1000) ] #=> [6, 817]
srand 1234 #=> 1234
[ rand, rand ] #=> [0.191519450163469, 0.49766366626136]
Kernel#readline
правитьreadline(separator=$/) => string
Equivalent to Kernel::gets, except readline raises EOFError at end of file.
Kernel#readlines
правитьreadlines(separator=$/) => array
Returns an array containing the lines returned by calling Kernel.gets(separator) until the end of file.
Kernel#require
правитьrequire(string) => true or false
Ruby tries to load the library named string, returning true if successful. If the filename does not resolve to an absolute path, it will be searched for in the directories listed in $:. If the file has the extension ``.rb, it is loaded as a source file; if the extension is ``.so, ``.o, or ``.dll, or whatever the default shared library extension is on the current platform, Ruby loads the shared library as a Ruby extension. Otherwise, Ruby tries adding ``.rb, ``.so, and so on to the name. The name of the loaded feature is added to the array in $". A feature will not be loaded if it's name already appears in $". However, the file name is not converted to an absolute path, so that ``require 'a';require './a' will load a.rb twice.
require "my-library.rb"
require "db-driver"
Kernel#require_gem
правитьrequire_gem(gem_name, *version_requirements)
Same as the gem command, but will also require a file if the gem provides an auto-required file name. DEPRECATED! Use gem instead.
Kernel#scan
править scan(pattern) => array
scan(pattern) {|///| block } => $_
Equivalent to calling $_.scan. See String#scan.
Kernel#scanf
правитьscanf(fs,&b)
(нет описания...)
Kernel#select
правитьIO.select(read_array [, write_array [, error_array [, timeout]]] ) => array or nil
See Kernel#select.
Kernel#set_trace_func
правитьset_trace_func(proc) => proc set_trace_func(nil) => nil
Establishes proc as the handler for tracing, or disables tracing if the parameter is nil. proc takes up to six parameters: an event name, a filename, a line number, an object id, a binding, and the name of a class. proc is invoked whenever an event occurs. Events are: c-call (call a C-language routine), c-return (return from a C-language routine), call (call a Ruby method), class (start a class or module definition), end (finish a class or module definition), line (execute code on a new line), raise (raise an exception), and return (return from a Ruby method). Tracing is disabled within the context of proc.
class Test
def test
a = 1
b = 2
end
end
set_trace_func proc { |event, file, line, id, binding, classname|
printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
}
t = Test.new
t.test
line prog.rb:11 false
c-call prog.rb:11 new Class
c-call prog.rb:11 initialize Object
c-return prog.rb:11 initialize Object
c-return prog.rb:11 new Class
line prog.rb:12 false
call prog.rb:2 test Test
line prog.rb:3 test Test
line prog.rb:4 test Test
return prog.rb:4 test Test
Kernel#sleep
правитьsleep([duration]) => fixnum
Suspends the current thread for duration seconds (which may be any number, including a Float with fractional seconds). Returns the actual number of seconds slept (rounded), which may be less than that asked for if another thread calls Thread#run. Zero arguments causes sleep to sleep forever.
Time.new #=> Wed Apr 09 08:56:32 CDT 2003
sleep 1.2 #=> 1
Time.new #=> Wed Apr 09 08:56:33 CDT 2003
sleep 1.9 #=> 2
Time.new #=> Wed Apr 09 08:56:35 CDT 2003
Kernel#split
правитьsplit([pattern [, limit]]) => array
Equivalent to $_.split(pattern, limit). See String#split.
Kernel#sprintf
правитьformat(format_string [, arguments...] ) => string sprintf(format_string [, arguments...] ) => string
Returns the string resulting from applying format_string to any additional arguments. Within the format string, any characters other than format sequences are copied to the result. A format sequence consists of a percent sign, followed by optional flags, width, and precision indicators, then terminated with a field type character. The field type controls how the corresponding sprintf argument is to be interpreted, while the flags modify that interpretation. The field type characters are listed in the table at the end of this section. The flag characters are:
Flag | Applies to | Meaning
---------+--------------+-----------------------------------------
space | bdeEfgGiouxX | Leave a space at the start of
| | positive numbers.
---------+--------------+-----------------------------------------
(digit)$ | all | Specifies the absolute argument number
| | for this field. Absolute and relative
| | argument numbers cannot be mixed in a
| | sprintf string.
---------+--------------+-----------------------------------------
# | beEfgGoxX | Use an alternative format. For the
| | conversions `o', `x', `X', and `b',
| | prefix the result with ``0, ``0x, ``0X,
| | and ``0b, respectively. For `e',
| | `E', `f', `g', and 'G', force a decimal
| | point to be added, even if no digits follow.
| | For `g' and 'G', do not remove trailing zeros.
---------+--------------+-----------------------------------------
+ | bdeEfgGiouxX | Add a leading plus sign to positive numbers.
---------+--------------+-----------------------------------------
- | all | Left-justify the result of this conversion.
---------+--------------+-----------------------------------------
0 (zero) | bdeEfgGiouxX | Pad with zeros, not spaces.
---------+--------------+-----------------------------------------
* | all | Use the next argument as the field width.
| | If negative, left-justify the result. If the
| | asterisk is followed by a number and a dollar
| | sign, use the indicated argument as the width.
The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field. For numeric fields, the precision controls the number of decimal places displayed. For string fields, the precision determines the maximum number of characters to be copied from the string. (Thus, the format sequence %10.10s will always contribute exactly ten characters to the result.) The field types are:
Field | Conversion
------+--------------------------------------------------------------
b | Convert argument as a binary number.
c | Argument is the numeric code for a single character.
d | Convert argument as a decimal number.
E | Equivalent to `e', but uses an uppercase E to indicate
| the exponent.
e | Convert floating point argument into exponential notation
| with one digit before the decimal point. The precision
| determines the number of fractional digits (defaulting to six).
f | Convert floating point argument as [-]ddd.ddd,
| where the precision determines the number of digits after
| the decimal point.
G | Equivalent to `g', but use an uppercase `E' in exponent form.
g | Convert a floating point number using exponential form
| if the exponent is less than -4 or greater than or
| equal to the precision, or in d.dddd form otherwise.
i | Identical to `d'.
o | Convert argument as an octal number.
p | The valuing of argument.inspect.
s | Argument is a string to be substituted. If the format
| sequence contains a precision, at most that many characters
| will be copied.
u | Treat argument as an unsigned decimal number. Negative integers
| are displayed as a 32 bit two's complement plus one for the
| underlying architecture; that is, 2 ** 32 + n. However, since
| Ruby has no inherent limit on bits used to represent the
| integer, this value is preceded by two dots (..) in order to
| indicate a infinite number of leading sign bits.
X | Convert argument as a hexadecimal number using uppercase
| letters. Negative numbers will be displayed with two
| leading periods (representing an infinite string of
| leading 'FF's.
x | Convert argument as a hexadecimal number.
| Negative numbers will be displayed with two
| leading periods (representing an infinite string of
| leading 'ff's.
Examples:
sprintf("%d %04x", 123, 123) #=> "123 007b"
sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'"
sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello"
sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8"
sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23"
sprintf("%u", -123) #=> "..4294967173"
Kernel#srand
правитьsrand(number=0) => old_seed
Seeds the pseudorandom number generator to the value of number.to_i.abs. If number is omitted or zero, seeds the generator using a combination of the time, the process id, and a sequence number. (This is also the behavior if Kernel::rand is called without previously calling srand, but without the sequence.) By setting the seed to a known value, scripts can be made deterministic during testing. The previous seed value is returned. Also see Kernel::rand.
Kernel#sub
править sub(pattern, replacement) => $_
sub(pattern) { block } => $_
Equivalent to $_.sub(args), except that $_ will be updated if substitution occurs.
Kernel#sub!
править sub!(pattern, replacement) => $_ or nil
sub!(pattern) {|...| block } => $_ or nil
Equivalent to $_.sub!(args).
Kernel#syscall
правитьsyscall(fixnum [, args...]) => integer
Calls the operating system function identified by fixnum, passing in the arguments, which must be either String objects, or Integer objects that ultimately fit within a native long. Up to nine parameters may be passed (14 on the Atari-ST). The function identified by fixnum is system dependent. On some Unix systems, the numbers may be obtained from a header file called syscall.h.
syscall 4, 1, "hello\n", 6 # '4' is write(2) on our box
produces:
hello
Kernel#system
правитьsystem(cmd [, arg, ...]) => true or false
Executes cmd in a subshell, returning true if the command was found and ran successfully, false otherwise. An error status is available in $?. The arguments are processed in the same way as for Kernel::exec.
system("echo *")
system("echo", "*")
produces:
config.h main.rb
*
Kernel#test
правитьtest(int_cmd, file1 [, file2] ) => obj
Uses the integer aCmd to perform various tests on
file1 (first table below) or on file1 and
file2 (second table).
File tests on a single file:
Test Returns Meaning
?A | Time | Last access time for file1
?b | boolean | True if file1 is a block device
?c | boolean | True if file1 is a character device
?C | Time | Last change time for file1
?d | boolean | True if file1 exists and is a directory
?e | boolean | True if file1 exists
?f | boolean | True if file1 exists and is a regular file
?g | boolean | True if file1 has the \CF{setgid} bit
| | set (false under NT)
?G | boolean | True if file1 exists and has a group
| | ownership equal to the caller's group
?k | boolean | True if file1 exists and has the sticky bit set
?l | boolean | True if file1 exists and is a symbolic link
?M | Time | Last modification time for file1
?o | boolean | True if file1 exists and is owned by
| | the caller's effective uid
?O | boolean | True if file1 exists and is owned by
| | the caller's real uid
?p | boolean | True if file1 exists and is a fifo
?r | boolean | True if file1 is readable by the effective
| | uid/gid of the caller
?R | boolean | True if file is readable by the real
| | uid/gid of the caller
?s | int/nil | If file1 has nonzero size, return the size,
| | otherwise return nil
?S | boolean | True if file1 exists and is a socket
?u | boolean | True if file1 has the setuid bit set
?w | boolean | True if file1 exists and is writable by
| | the effective uid/gid
?W | boolean | True if file1 exists and is writable by
| | the real uid/gid
?x | boolean | True if file1 exists and is executable by
| | the effective uid/gid
?X | boolean | True if file1 exists and is executable by
| | the real uid/gid
?z | boolean | True if file1 exists and has a zero length
Tests that take two files:
?- | boolean | True if file1 and file2 are identical
?= | boolean | True if the modification times of file1
| | and file2 are equal
?< | boolean | True if the modification time of file1
| | is prior to that of file2
?> | boolean | True if the modification time of file1
| | is after that of file2
Kernel#throw
правитьthrow(symbol [, obj])
Transfers control to the end of the active catch block waiting for symbol. Raises NameError if there is no catch block for the symbol. The optional second parameter supplies a return value for the catch block, which otherwise defaults to nil. For examples, see Kernel::catch.
Kernel#to_ptr
правитьto_ptr()
Allows arbitrary objects to be passed as a pointer to functions. (Probably not very GC safe, but by encapsulating it like this we can change the implementation later.)
Kernel#trace_var
править trace_var(symbol, cmd ) => nil
trace_var(symbol) {|val| block } => nil
Controls tracing of assignments to global variables. The parameter +symbol_ identifies the variable (as either a string name or a symbol identifier). cmd (which may be a string or a Proc object) or block is executed whenever the variable is assigned. The block or Proc object receives the variable's new value as a parameter. Also see Kernel::untrace_var.
trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
$_ = "hello"
$_ = ' there'
produces:
$_ is now 'hello'
$_ is now ' there'
Kernel#trap
править Signal.trap( signal, proc ) => obj
Signal.trap( signal ) {| | block } => obj
Specifies the handling of signals. The first parameter is a signal name (a string such as ``SIGALRM, ``SIGUSR1, and so on) or a signal number. The characters ``SIG may be omitted from the signal name. The command or block specifies code to be run when the signal is raised. If the command is the string ``IGNORE or ``SIG_IGN, the signal will be ignored. If the command is ``DEFAULT or ``SIG_DFL, the operating system's default handler will be invoked. If the command is ``EXIT, the script will be terminated by the signal. Otherwise, the given command or block will be run. The special signal name ``EXIT or signal number zero will be invoked just prior to program termination. trap returns the previous handler for the given signal.
Signal.trap(0, proc { puts "Terminating: #{$$}" })
Signal.trap("CLD") { puts "Child died" }
fork && Process.wait
produces:
Terminating: 27461
Child died
Terminating: 27460
Kernel#untrace_var
правитьuntrace_var(symbol [, cmd] ) => array or nil
Removes tracing for the specified command on the given global variable and returns nil. If no command is specified, removes all tracing for that variable and returns an array containing the commands actually removed.
Kernel#warn
правитьwarn(msg)
(нет описания...)
Kernel#y
правитьy( object, *objects )
Prints any supplied objects out in YAML. Intended as a variation on +Kernel::p+.
S = Struct.new(:name, :state)
s = S['dave', 'TX']
y s
_produces:_
--- !ruby/struct:S
name: dave
state: TX
Примесь Math
правитьПримесь Math содержит методы вычисления простейших тригонометрических и трансцендентных функций. Смотри список констант в классе Float, чтобы определить погрешность для чисел с плавающей точкой.
Константы
E, PI
Методы класса
acosh, acos, asinh, asin, atan2, atanh, atan, cosh, cos, erfc, erf, exp, frexp, hypot, ldexp, log10, log, sinh, sin, sqrt, tanh, tan
Math::acos
правитьMath.acos(x) #-> float
Вычисляет арккосинус числа x. Возвращает значения в диапазоне 0..PI.
Math::acosh
правитьMath.acosh(x) #-> float
Вычисляет значение обратной функции для гиперболического косинуса числа x.
Math::asin
правитьMath.asin(x) #-> float
Вычисляет арксинус числа x. Возвращает значения в диапазоне 0..PI.
Math::asinh
правитьMath.asinh(x) #-> float
Вычисляет значение обратной функции для гиперболического синуса числа x.
Math::atan
правитьMath.atan(x) #-> float
Вычисляет арктангенс числа x. Возвращает значения в диапазоне -{PI/2} .. {PI/2}.
Math::atan2
правитьMath.atan2(y, x) #-> float
Вычисляет арктангенс отношения, заданного числами y и x. Возвращает значения в диапазоне -PI..PI.
Math::atanh
правитьMath.atanh(x) #-> float
Вычисляет значение обратной функции гиперболического тангенса числа x.
Math::cos
правитьMath.cos(x) #-> float
Вычисляет косинус угла x (заданного в радианах). Возвращает значения в диапазоне -1..1.
Math::cosh
правитьMath.cosh(x) #-> float
Вычисляет гиперболический косинус угла x (заданного в радианах).
Math::erf
правитьMath.erf(x) #-> float
Вычисляет функцию ошибок x.
Math::erfc
правитьMath.erfc(x) #-> float
Вычисляет дополнительную функцию ошибок x.
Math::exp
правитьMath.exp(x) #-> float
Возвращает e**x (экспоненту числа х).
Math::frexp
правитьMath.frexp(numeric) #-> [ fraction, exponent ]
Представляет число numeric в виде приведенного дробного числа (типа Float) и экспоненты (типа Fixnum). Возвращает массив из двух элементов, где первый элемент — дробное число, а второй — экспонента.
fraction, exponent = Math.frexp(1234) #-> [0.6025390625, 11]
fraction * 2**exponent #-> 1234.0
Math::hypot
правитьMath.hypot(x, y) #-> float
Возвращает sqrt(x**2 + y**2), то есть гипотенузу прямоугольного треугольника с катетами x и y.
Math.hypot(3, 4) #-> 5.0
Math::ldexp
правитьMath.ldexp(flt, int) #-> float
Возвращает результат выражения flt*(2**int).
fraction, exponent = Math.frexp(1234)
Math.ldexp(fraction, exponent) #-> 1234.0
Math::log
правитьMath.log(numeric) #-> floatВозвращает натуральный логарифм числа numeric.
Math::log10
правитьMath.log10(numeric) #-> floatВозвращает десятичный логарифм числа numeric.
Math::sin
правитьMath.sin(x) #-> floatВычисляет синус угла x (заданного в радианах). Returns -1..1.
Math::sinh
правитьMath.sinh(x) #-> floatВычисляет гиперболический синус угла x (заданного в радианах).
Math::sqrt
правитьMath.sqrt(numeric) #-> floatИзвлекает квадратный корень из неотрицательного числа numeric.
Math::tan
правитьMath.tan(x) #-> floatВычисляет тангенс угла x (заданного в радианах).
Math::tanh
правитьMath.tanh() #-> floatВычисляет гиперболический тангенс угла x (заданного в радианах).
Класс Module
правитьModule является коллекцией из методов и констант. Методы в модуле могут быть методами экземпляра или методами модуля. Метод экземпляра появляется как метод в классе, когда модуль подключен директивой include, методы модуля не выполняются. Напротив, методы модуля могут быть вызваны без создания инкапсулирующего объекта, в то время как методы экземпляра не могут. (См. Module#module_function)
В описании ниже, под параметром syml будем понимать символ, который является строкой в кавычках или объектом класса Symbol (таким, как, например, :name).
module Mod
include Math
CONST = 1
def meth
# ...
end
end
Mod.class #=> Module
Mod.constants #=> ["E", "PI", "CONST"]
Mod.instance_methods #=> ["meth"]
Extends the module object with module and instance accessors for class attributes, just like the native attr* accessors for instance attributes.
Also, modules included into Object need to be scanned and have their instance methods removed from blank slate. In theory, modules included into Kernel would have to be removed as well, but a "feature" of Ruby prevents late includes into modules from being exposed in the first place.
Методы класса
Методы объекта
<=>, <=, <, ===, ==, >=, >, alias_method, ancestors, append_features, attr_accessor, attr_reader, attr_writer, attr, autoload?, autoload, class_eval, class_variable_get, class_variable_set, class_variables, const_defined?, const_get, const_missing, const_set, constants, define_method, extend_object, extended, freeze, include?, included_modules, included, include, instance_methods, instance_method, method_added, method_defined?, method_removed, method_undefined, module_eval, module_function, name, private_class_method, private_instance_methods, private_method_defined?, private, protected_instance_methods, protected_method_defined?, protected, public_class_method, public_instance_methods, public_method_defined?, public, remove_class_variable, remove_const, remove_method, to_s, undef_method
Module::constants
правитьModule.constants => array
Returns an array of the names of all constants defined in the system. This list includes the names of all modules and classes.
p Module.constants.sort[1..5]
produces:
["ARGV", "ArgumentError", "Array", "Bignum", "Binding"]
Module::nesting
правитьModule.nesting => array
Returns the list of Modules nested at the point of call.
module M1
module M2
$a = Module.nesting
end
end
$a #=> [M1::M2, M1]
$a[0].name #=> "M1::M2"
Module::new
править Module.new => mod
Module.new {|mod| block } => mod
Creates a new anonymous module. If a block is given, it is passed the module object, and the block is evaluated in the context of this module using module_eval.
Fred = Module.new do
def meth1
"hello"
end
def meth2
"bye"
end
end
a = "my string"
a.extend(Fred) #=> "my string"
a.meth1 #=> "hello"
a.meth2 #=> "bye"
Module#<
правитьmod < other => true, false, or nil
Returns true if mod is a subclass of other. Returns nil if there's no relationship between the two. (Think of the relationship in terms of the class definition: "class A<B" implies "A<B").
Module#<=
правитьmod <= other => true, false, or nil
Returns true if mod is a subclass of other or is the same as other. Returns nil if there's no relationship between the two. (Think of the relationship in terms of the class definition: "class A<B" implies "A<B").
Module#<=>
правитьmod <=> other_mod => -1, 0, +1, or nil
Comparison---Returns -1 if mod includes other_mod, 0 if mod is the same as other_mod, and +1 if mod is included by other_mod or if mod has no relationship with other_mod. Returns nil if other_mod is not a module.
Module#==
правитьobj == other => true or false obj.equal?(other) => true or false obj.eql?(other) => true or false
Equality---At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning. Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b). The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:
1 == 1.0 #=> true
1.eql? 1.0 #=> false
Module#===
правитьmod === obj => true or false
Case Equality---Returns true if anObject is an instance of mod or one of mod's descendents. Of limited use for modules, but can be used in case statements to classify objects by class.
Module#>
правитьmod > other => true, false, or nil
Returns true if mod is an ancestor of other. Returns nil if there's no relationship between the two. (Think of the relationship in terms of the class definition: "class A<B" implies "B>A").
Module#>=
правитьmod >= other => true, false, or nil
Returns true if mod is an ancestor of other, or the two modules are the same. Returns nil if there's no relationship between the two. (Think of the relationship in terms of the class definition: "class A<B" implies "B>A").
Module#alias_method
правитьalias_method(new_name, old_name) => self
Makes new_name a new copy of the method old_name. This can be used to retain access to methods that are overridden.
module Mod
alias_method :orig_exit, :exit
def exit(code=0)
puts "Exiting with code #{code}"
orig_exit(code)
end
end
include Mod
exit(99)
produces:
Exiting with code 99
Module#ancestors
правитьmod.ancestors -> array
Returns a list of modules included in mod (including mod itself).
module Mod
include Math
include Comparable
end
Mod.ancestors #=> [Mod, Comparable, Math]
Math.ancestors #=> [Math]
Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:
Module#append_features, Module#append_features===Module#attr===
attr(symbol, writable=false) => nil
Defines a named attribute for this module, where the name is symbol.id2name, creating an instance variable (@name) and a corresponding access method to read it. If the optional writable argument is true, also creates a method called name= to set the attribute.
module Mod
attr :size, true
end
is equivalent to:
module Mod
def size
@size
end
def size=(val)
@size = val
end
end
Module#attr_accessor
правитьattr_accessor(symbol, ...) => nil
Equivalent to calling ``attrsymbol, true on each symbol in turn.
module Mod
attr_accessor(:one, :two)
end
Mod.instance_methods.sort #=> ["one", "one=", "two", "two="]
Module#attr_reader
правитьattr_reader(symbol, ...) => nil
Creates instance variables and corresponding methods that return the value of each instance variable. Equivalent to calling ``attr:name on each name in turn.
Module#attr_writer
правитьattr_writer(symbol, ...) => nil
Creates an accessor method to allow assignment to the attribute aSymbol.id2name.
Module#autoload
правитьmod.autoload(name, filename) => nil
Registers filename to be loaded (using Kernel::require) the first time that name (which may be a String or a symbol) is accessed in the namespace of mod.
module A
end
A.autoload(:B, "b")
A::B.doit # autoloads "b"
Module#autoload?
правитьmod.autoload?(name) => String or nil
Returns filename to be loaded if name is registered as autoload in the namespace of mod.
module A
end
A.autoload(:B, "b")
A.autoload?(:B) # => "b"
Module#class_eval
править mod.class_eval(string [, filename [, lineno]]) => obj
mod.module_eval {|| block } => obj
Evaluates the string or block in the context of mod. This can be used to add methods to a class. module_eval returns the result of evaluating its argument. The optional filename and lineno parameters set the text for error messages.
class Thing
end
a = %q{def hello() "Hello there!" end}
Thing.module_eval(a)
puts Thing.new.hello()
Thing.module_eval("invalid code", "dummy", 123)
produces:
Hello there!
dummy:123:in `module_eval': undefined local variable
or method `code' for Thing:Class
Module#class_variable_get
правитьmod.class_variable_get(symbol) => obj
Returns the value of the given class variable (or throws a NameError exception). The @@ part of the variable name should be included for regular class variables
class Fred
@@foo = 99
end
def Fred.foo
class_variable_get(:@@foo) #=> 99
end
Module#class_variable_set
правитьobj.class_variable_set(symbol, obj) => obj
Sets the class variable names by symbol to object.
class Fred
@@foo = 99
def foo
@@foo
end
end
def Fred.foo
class_variable_set(:@@foo, 101) #=> 101
end
Fred.foo
Fred.new.foo #=> 101
Module#class_variables
правитьmod.class_variables => array
Returns an array of the names of class variables in mod and the ancestors of mod.
class One
@@var1 = 1
end
class Two < One
@@var2 = 2
end
One.class_variables #=> ["@@var1"]
Two.class_variables #=> ["@@var2", "@@var1"]
Module#const_defined?
правитьmod.const_defined?(sym) => true or false
Returns true if a constant with the given name is defined by mod.
Math.const_defined? "PI" #=> true
Module#const_get
правитьmod.const_get(sym) => obj
Returns the value of the named constant in mod.
Math.const_get(:PI) #=> 3.14159265358979
Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:
Module#const_missing, Module#const_missing===Module#const_set===
mod.const_set(sym, obj) => obj
Sets the named constant to the given object, returning that object. Creates a new constant if no constant with the given name previously existed.
Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0) #=> 3.14285714285714
Math::HIGH_SCHOOL_PI - Math::PI #=> 0.00126448926734968
Module#constants
правитьmod.constants => array
Returns an array of the names of the constants accessible in mod. This includes the names of constants in any included modules (example at start of section).
Module#define_method
править define_method(symbol, method) => new_method
define_method(symbol) { block } => proc
Defines an instance method in the receiver. The method parameter can be a Proc or Method object. If a block is specified, it is used as the method body. This block is evaluated using instance_eval, a point that is tricky to demonstrate because define_method is private. (This is why we resort to the send hack in this example.)
class A
def fred
puts "In Fred"
end
def create_method(name, &block)
self.class.send(:define_method, name, &block)
end
define_method(:wilma) { puts "Charge it!" }
end
class B < A
define_method(:barney, instance_method(:fred))
end
a = B.new
a.barney
a.wilma
a.create_method(:betty) { p self }
a.betty
produces:
In Fred
Charge it!
#<B:0x401b39e8>
Module#extend_object
правитьextend_object(obj) => obj
Extends the specified object by adding this module's constants and methods (which are added as singleton methods). This is the callback method used by Object#extend.
module Picky
def Picky.extend_object(o)
if String === o
puts "Can't add Picky to a String"
else
puts "Picky added to #{o.class}"
super
end
end
end
(s = Array.new).extend Picky # Call Object.extend
(s = "quick brown fox").extend Picky
produces:
Picky added to Array
Can't add Picky to a String
Module#extended
правитьextended(p1)
Not documented
Module#freeze
правитьmod.freeze
Prevents further modifications to mod.
Module#include
правитьinclude(module, ...) => self
Invokes Module.append_features on each parameter in turn.
Module#include?
правитьmod.include?(module) => true or false
Returns true if module is included in mod or one of mod's ancestors.
module A
end
class B
include A
end
class C < B
end
B.include?(A) #=> true
C.include?(A) #=> true
A.include?(A) #=> false
Module#included
правитьincluded( othermod )
Callback invoked whenever the receiver is included in another module or class. This should be used in preference to Module.append_features if your code wants to perform some action when a module is included in another.
module A
def A.included(mod)
puts "#{self} included in #{mod}"
end
end
module Enumerable
include A
end
Module#included_modules
правитьmod.included_modules -> array
Returns the list of modules included in mod.
module Mixin
end
module Outer
include Mixin
end
Mixin.included_modules #=> []
Outer.included_modules #=> [Mixin]
Module#instance_method
правитьmod.instance_method(symbol) => unbound_method
Returns an UnboundMethod representing the given instance method in mod.
class Interpreter
def do_a() print "there, "; end
def do_d() print "Hello "; end
def do_e() print "!\n"; end
def do_v() print "Dave"; end
Dispatcher = {
?a => instance_method(:do_a),
?d => instance_method(:do_d),
?e => instance_method(:do_e),
?v => instance_method(:do_v)
}
def interpret(string)
string.each_char {|b| Dispatcher[b].bind(self).call }
end
end
interpreter = Interpreter.new
interpreter.interpret('dave')
produces:
Hello there, Dave!
Module#instance_methods
правитьmod.instance_methods(include_super=true) => array
Returns an array containing the names of public instance methods in the receiver. For a module, these are the public methods; for a class, they are the instance (not singleton) methods. With no argument, or with an argument that is false, the instance methods in mod are returned, otherwise the methods in mod and mod's superclasses are returned.
module A
def method1() end
end
class B
def method2() end
end
class C < B
def method3() end
end
A.instance_methods #=> ["method1"]
B.instance_methods(false) #=> ["method2"]
C.instance_methods(false) #=> ["method3"]
C.instance_methods(true).length #=> 43
Module#method_added
правитьmethod_added(p1)
Not documented
Module#method_defined?
правитьmod.method_defined?(symbol) => true or false
Returns true if the named method is defined by mod (or its included modules and, if mod is a class, its ancestors). Public and protected methods are matched.
module A
def method1() end
end
class B
def method2() end
end
class C < B
include A
def method3() end
end
A.method_defined? :method1 #=> true
C.method_defined? "method1" #=> true
C.method_defined? "method2" #=> true
C.method_defined? "method3" #=> true
C.method_defined? "method4" #=> false
Module#method_removed
правитьmethod_removed(p1)
Not documented
Module#method_undefined
правитьmethod_undefined(p1)
Not documented
Module#module_eval
править mod.class_eval(string [, filename [, lineno]]) => obj
mod.module_eval {|| block } => obj
Evaluates the string or block in the context of mod. This can be used to add methods to a class. module_eval returns the result of evaluating its argument. The optional filename and lineno parameters set the text for error messages.
class Thing
end
a = %q{def hello() "Hello there!" end}
Thing.module_eval(a)
puts Thing.new.hello()
Thing.module_eval("invalid code", "dummy", 123)
produces:
Hello there!
dummy:123:in `module_eval': undefined local variable
or method `code' for Thing:Class
Module#module_function
правитьmodule_function(symbol, ...) => self
Creates module functions for the named methods. These functions may be called with the module as a receiver, and also become available as instance methods to classes that mix in the module. Module functions are copies of the original, and so may be changed independently. The instance-method versions are made private. If used with no arguments, subsequently defined methods become module functions.
module Mod
def one
"This is one"
end
module_function :one
end
class Cls
include Mod
def callOne
one
end
end
Mod.one #=> "This is one"
c = Cls.new
c.callOne #=> "This is one"
module Mod
def one
"This is the new one"
end
end
Mod.one #=> "This is one"
c.callOne #=> "This is the new one"
Module#name
правитьmod.name => string
Returns the name of the module mod.
Module#private
правитьprivate => self private(symbol, ...) => self
With no arguments, sets the default visibility for subsequently defined methods to private. With arguments, sets the named methods to have private visibility.
module Mod
def a() end
def b() end
private
def c() end
private :a
end
Mod.private_instance_methods #=> ["a", "c"]
Module#private_class_method
правитьmod.private_class_method(symbol, ...) => mod
Makes existing class methods private. Often used to hide the default constructor new.
class SimpleSingleton # Not thread safe
private_class_method :new
def SimpleSingleton.create(*args, &block)
@me = new(*args, &block) if ! @me
@me
end
end
Module#private_instance_methods
правитьmod.private_instance_methods(include_super=true) => array
Returns a list of the private instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.
module Mod
def method1() end
private :method1
def method2() end
end
Mod.instance_methods #=> ["method2"]
Mod.private_instance_methods #=> ["method1"]
Module#private_method_defined?
правитьmod.private_method_defined?(symbol) => true or false
Returns true if the named private method is defined by _ mod_ (or its included modules and, if mod is a class, its ancestors).
module A
def method1() end
end
class B
private
def method2() end
end
class C < B
include A
def method3() end
end
A.method_defined? :method1 #=> true
C.private_method_defined? "method1" #=> false
C.private_method_defined? "method2" #=> true
C.method_defined? "method2" #=> false
Module#protected
правитьprotected => self protected(symbol, ...) => self
With no arguments, sets the default visibility for subsequently defined methods to protected. With arguments, sets the named methods to have protected visibility.
Module#protected_instance_methods
правитьmod.protected_instance_methods(include_super=true) => array
Returns a list of the protected instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.
Module#protected_method_defined?
правитьmod.protected_method_defined?(symbol) => true or false
Returns true if the named protected method is defined by mod (or its included modules and, if mod is a class, its ancestors).
module A
def method1() end
end
class B
protected
def method2() end
end
class C < B
include A
def method3() end
end
A.method_defined? :method1 #=> true
C.protected_method_defined? "method1" #=> false
C.protected_method_defined? "method2" #=> true
C.method_defined? "method2" #=> true
Module#public
правитьpublic => self public(symbol, ...) => self
With no arguments, sets the default visibility for subsequently defined methods to public. With arguments, sets the named methods to have public visibility.
Module#public_class_method
правитьmod.public_class_method(symbol, ...) => mod
Makes a list of existing class methods public.
Module#public_instance_methods
правитьmod.public_instance_methods(include_super=true) => array
Returns a list of the public instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.
Module#public_method_defined?
правитьmod.public_method_defined?(symbol) => true or false
Returns true if the named public method is defined by mod (or its included modules and, if mod is a class, its ancestors).
module A
def method1() end
end
class B
protected
def method2() end
end
class C < B
include A
def method3() end
end
A.method_defined? :method1 #=> true
C.public_method_defined? "method1" #=> true
C.public_method_defined? "method2" #=> false
C.method_defined? "method2" #=> true
Module#remove_class_variable
правитьremove_class_variable(sym) => obj
Removes the definition of the sym, returning that constant's value.
class Dummy
@@var = 99
puts @@var
remove_class_variable(:@@var)
puts(defined? @@var)
end
produces:
99
nil
Module#remove_const
правитьremove_const(sym) => obj
Removes the definition of the given constant, returning that constant's value. Predefined classes and singleton objects (such as true) cannot be removed.
Module#remove_method
правитьremove_method(symbol) => self
Removes the method identified by symbol from the current class. For an example, see Module.undef_method.
Module#to_s
правитьmod.to_s => string
Return a string representing this module or class. For basic classes and modules, this is the name. For singletons, we show information on the thing we're attached to as well.
Module#undef_method
правитьundef_method(symbol) => self
Prevents the current class from responding to calls to the named method. Contrast this with remove_method, which deletes the method from the particular class; Ruby will still search superclasses and mixed-in modules for a possible receiver.
class Parent
def hello
puts "In parent"
end
end
class Child < Parent
def hello
puts "In child"
end
end
c = Child.new
c.hello
class Child
remove_method :hello # remove from child, still in parent
end
c.hello
class Child
undef_method :hello # prevent any calls to 'hello'
end
c.hello
produces:
In child
In parent
prog.rb:23: undefined method `hello' for #<Child:0x401b3bb4> (NoMethodError)
Класс NilClass
правитьГлобальное значение nil является единственным экземпляром класса NilClass и означает «отсутствие значения». В логическом контексте эквивалентно false. Методы, которые хотят сказать, что им нечего вернуть — возвращают nil. Переменные, значение которым не присвоено — имеют значение nil.
Методы объекта
&, ^, inspect, nil?, to_a, to_f, to_i, to_s, ||
NilClass#&
правитьfalse & obj #-> false
nil & obj #-> falseЛогическое «И» всегда возвращает false. obj всегда вычисляется, так как является агрументом метода. В этом случае нет никакого сокращенного вычисления.
NilClass#^
правитьfalse ^ obj #-> true или false
nil ^ obj #-> true или falseЛогическое «ИЛИ НЕ». Если obj равен nil или false, возвращает false; иначе возвращает true.
NilClass#inspect
правитьnil.inspect #-> "nil"Всегда возвращает строку "nil".
NilClass#nil?
правитьnil.nil? #-> trueВсегда возвращает true.
NilClass#to_a
правитьnil.to_a #-> []Всегда возвращает пустой массив.
NilClass#to_f
правитьnil.to_f #-> 0.0Всегда возвращает нуль.
NilClass#to_i
правитьnil.to_i #-> 0Всегда возвращает нуль.
NilClass#to_s
правитьnil.to_s #-> ""Всегда возвращает пустую строку.
NilClass#|
правитьfalse | obj #-> true или false
nil | obj #-> true или falseЛогическое «ИЛИ» возвращает false, если obj равен nil или false; true иначе.
Класс Numeric
правитьNumeric — это базовый класс для всех видов чисел (Fixnum, Float и так далее). Его методы добавляются ко всем классам, которые отвечают за числа.
Примеси
Comparable (<, <=, ==, >, >=, between?)
Методы объекта
+@, -@, <=>, abs, ceil, coerce, divmod, div, eql?, floor, integer?, modulo, nonzero?, quo, remainder, round, singleton_method_added, step, to_int, truncate, zero?
Numeric#+@
править+num #-> numУнарный плюс — возвращает число num в качестве результата.
Numeric#-@
править-num #-> numericУнарный минус — возвращает число num с противоположным знаком в качестве результата.
Numeric#<=>
правитьfirst <=> second #-> -1 или 0 или 1Возвращает:
- first > second #=> 1
- first == second #=> 0
- first < second #=> −1.
Numeric#abs
правитьnum.abs #-> num или numericВозвращает абсолютное значение («по модулю») числа num.
12.abs #-> 12
(-34.56).abs #-> 34.56
-34.56.abs #-> 34.56Numeric#ceil
правитьnum.ceil #-> integerВозвращает наименьшее целое число, которое больше или равно num. Класс Numeric добивается этого конвертацией num в дробное число и вызова метода Float#ceil.
1.ceil #-> 1
1.2.ceil #-> 2
(-1.2).ceil #-> -1
(-1.0).ceil #-> -1|
|
Полезно посмотреть на методы round, floor и truncate, которые имеют схожую функциональность |
Numeric#coerce
правитьnum.coerce(numeric) #-> arrayЕсли numeric такого же типа, что и num, то возвращает массив, состоящий из numeric и num. Иначе, возвращает массив с numeric и num преобразованных в дробные числа. Этот метод используется при обработке арифметических операций со смешанными типами.
1.coerce(2.5) #-> [2.5, 1.0]
1.2.coerce(3) #-> [3.0, 1.2]
1.coerce(2) #-> [2, 1]Numeric#div
правитьnum.div(numeric) #-> integerИспользует оператор / для выполнения деления числа num на число numeric, после чего конвертирует результат в целое число. В классе Numeric отсутствует оператор /; вызывается оператор, реализованный в его подклассах.
Numeric#divmod
правитьnum.divmod( aNumeric ) #-> anArrayВозвращает массив, состоящий из результата целочисленного деления и остатка от деления числа num на число aNumeric. То есть, если
q, r = x.divmod(y)тогда действительно следующее равенство
q = floor(float(x)/float(y))
x = q*y + rЧастное округляется в меньшую сторону, как показано в таблице:
| a | b | a.divmod(b) | a/b | a.modulo(b) | a.remainder(b) |
|---|---|---|---|---|---|
| 13 | 4 | [3, 1] | 3 | 1 | 1 |
| 13 | -4 | [-4, -3] | -3 | -3 | 1 |
| -13 | 4 | [-4, 3] | -4 | 3 | -1 |
| -13 | -4 | [3, -1] | 3 | -1 | -1 |
| 11.5 | 4 | [2, 3.5] | 2.875 | 3.5 | 3.5 |
| 11.5 | -4 | [-3, -0.5] | -2.875 | -0.5 | 3.5 |
| -11.5 | 4 | [-3, 0.5] | -2.875 | 0.5 | -3.5 |
| -11.5 | -4 | [2, -3.5] | 2.875 | -3.5 | -3.5 |
11.divmod(3) #-> [3, 2]
11.divmod(-3) #-> [-4, -1]
11.divmod(3.5) #-> [3, 0.5]
-11.divmod(3.5) #-> [-4, 3.0]
11.5.divmod(3.5) #-> [3, 1.0]|
|
Полезно посмотреть на методы modulo и remainder, которые имеют схожую функциональность |
Numeric#eql?
правитьnum.eql?(numeric) #-> true или falseВозвращает true, если num и numeric одного и того же типа и имеют одинаковые значения.
1 == 1.0 #-> true
1.eql?(1.0) #-> false
(1.0).eql?(1.0) #-> trueNumeric#floor
правитьnum.floor #-> integerВозвращает наибольшее целое число, которое меньше или равно num. Класс Numeric добивается этого конвертацией num в дробное число и вызова метода Float#floor.
0.3.floor #-> 0
(-0.3).floor #-> -1
(12345.54321).floor(3) #-> 12345.543
(12345.54321).floor(-3) #-> 12000|
|
Полезно посмотреть на методы round, ceil и truncate, которые имеют схожую функциональность |
Numeric#integer?
правитьnum.integer? #-> true или falseВозвращает true, если num является целым числом.
Numeric#modulo
правитьnum.modulo(numeric) #-> resultПолучение остатка от деления числа num на число numeric. Эквивалентен вызову num.divmod(numeric)[1].
|
|
Полезно посмотреть на методы divmod и remainder, которые имеют схожую функциональность |
Numeric#nonzero?
правитьnum.nonzero? #-> num или nilВозвращает num, если num не является нулем, если num это ноль, то возвращает nil. Данный метод обычно используется совместно с оператором сравнения:
a = %w( z Bb bB bb BB a aA Aa AA A )
b = a.sort {|a,b| (a.downcase <=> b.downcase).nonzero? || a <=> b }
b #-> ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"]Numeric#quo
правитьnum.quo(numeric) #-> resultЭквивалентен оператору /, но переопределяется в подклассах.
Numeric#remainder
правитьnum.remainder(numeric) #-> resultЕсли num и numeric имеют разные знаки, то возвращает разность mod-numeric; иначе, возвращает mod. Для обоих случаев mod вычисляется по формуле:
num.modulo(numeric)|
|
Различия между remainder и modulo (%) можно посмотреть в таблице, которая прилагается к методу divmod |
Numeric#round
правитьnum.round #-> integerОкругляет число num до ближайшего целого. Класс Numeric добивается этого конвертацией num в дробное число и вызова метода Float#round.
|
|
Полезно посмотреть на методы ceil, floor и truncate, которые имеют схожую функциональность |
Numeric#singleton_method_added
правитьnum.singleton_method_added( new_method )Перехватывает попытки добавления метода к объекту класса Numeric (и его наследников). Всегда вызывает ошибку типа TypeError.
Numeric#step
правитьnum.step(limit, step ) {|i| block } #-> numВыполняет блок для всех чисел с шагом step, начиная с num и заканчивая limit. Значение step может быть как положительное, так и отрицательное. Главное, чтобы значение step согласовывалось с значением limit (если step < 0, то limit должен быть меньше num). Если все аргументы метода — целые числа, то счетчик итератора (который передается параметром в блок), тоже будет целочисленным. Если хотя бы один из аргументов метода — дробный, то все остальные преобразуются в дробное число и блок выполняется floor(n + n*epsilon)+ 1 раз, где n = (limit - num)/step.
1.step(10, 2) { |i| print i, " " }
Math::E.step(Math::PI, 0.2) { |f| print f, " " }результат:
1 3 5 7 9 2.71828182845905 2.91828182845905 3.11828182845905
Numeric#to_int
правитьnum.to_int #-> integerВызывает метод to_i (реализованный в подклассах) для преобразования num в целое число.
Numeric#truncate
правитьnum.truncate #-> integerВозвращает целую часть числа num. Класс Numeric добивается этого конвертацией num в дробное число и вызова метода Float#trancate.
|
|
Полезно посмотреть на методы round, floor и ceil, которые имеют схожую функциональность |
Numeric#zero?
правитьnum.zero? #-> true или falseВозвращает true, если num равен нулю.
Класс Object
правитьObject is the parent class of all classes in Ruby. Its methods are therefore available to all objects unless explicitly overridden. Object mixes in the Kernel module, making the built-in kernel functions globally accessible. Although the instance methods of Object are defined by the Kernel module, we have chosen to document them here for clarity. In the descriptions of Object's methods, the parameter symbol refers to a symbol, which is either a quoted string or a Symbol (such as :name).
Same as above, except in Object.
metaprogramming assistant -- metaid.rb
Примеси
Kernel (Array, Float, Integer, Pathname, String, URI, `, abort, at_exit, autoload, autoload?, binding, block_given?, callcc, caller, catch, chomp, chomp!, chop, chop!, eval, exec, exit, exit!, fail, fork, format, gem, getc, gets, global_variables, gsub, gsub!, iterator?, lambda, load, local_variables, loop, method_missing, open, open_uri_original_open, p, pp, pretty_inspect, print, printf, proc, putc, puts, raise, rake_dup, rand, readline, readlines, require, require_gem, scan, scanf, select, set_trace_func, sleep, split, sprintf, srand, sub, sub!, syscall, system, test, throw, to_ptr, trace_var, trap, untrace_var, warn, y),
PP::ObjectMixin (pretty_print, pretty_print_cycle, pretty_print_inspect, pretty_print_instance_variables)
Константы
ARGF, ARGV, DATA, ENV, FALSE, IPsocket, MatchingData, NIL, PLATFORM, RELEASE_DATE, RUBY_PATCHLEVEL, RUBY_PLATFORM, RUBY_RELEASE_DATE, RUBY_VERSION, SOCKSsocket, STDERR, STDIN, STDOUT, TCPserver, TCPsocket, TOPLEVEL_BINDING, TRUE, UDPsocket, UNIXserver, UNIXsocket, VERSION
Методы класса
find_hidden_method, method_added, new
Методы объекта
===, ==, =~, __id__, __send__, class_def, class, clone, dclone, display, dup, enum_for, eql?, equal?, extend, freeze, frozen?, hash, id, inspect, instance_eval, instance_of?, instance_variable_get, instance_variable_set, instance_variables, is_a?, kind_of?, meta_def, meta_eval, metaclass, methods, method, nil?, object_id, private_methods, protected_methods, public_methods, remove_instance_variable, respond_to?, send, singleton_method_added, singleton_method_removed, singleton_method_undefined, singleton_methods, tainted?, taint, to_a, to_enum, to_s, to_yaml_properties, to_yaml_style, to_yaml, type, untaint
Object::find_hidden_method
правитьObject::find_hidden_method(name)
(нет описания...)
Object::method_added
правитьObject::method_added(name)
Detect method additions to Object and remove them in the BlankSlate class.
Object::new
правитьObject::new()
Not documented
Object#==
правитьobj == other => true or false obj.equal?(other) => true or false obj.eql?(other) => true or false
Equality---At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning. Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b). The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:
1 == 1.0 #=> true
1.eql? 1.0 #=> false
Object#===
правитьobj === other => true or false
Case Equality---For class Object, effectively the same as calling #==, but typically overridden by descendents to provide meaningful semantics in case statements.
Object#=~
правитьobj =~ other => false
Pattern Match---Overridden by descendents (notably Regexp and String) to provide meaningful pattern-match semantics.
Object#__id__
правитьobj.__id__ => fixnum obj.object_id => fixnum
Document-method: object_id Returns an integer identifier for obj. The same number will be returned on all calls to id for a given object, and no two active objects will share an id. Object#object_id is a different concept from the :name notation, which returns the symbol id of name. Replaces the deprecated Object#id.
Object#__send__
правитьobj.send(symbol [, args...]) => obj obj.__send__(symbol [, args...]) => obj
Invokes the method identified by symbol, passing it any arguments specified. You can use __send__ if the name send clashes with an existing method in obj.
class Klass
def hello(*args)
"Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
Object#class
правитьobj.class => class
Returns the class of obj, now preferred over Object#type, as an object's type in Ruby is only loosely tied to that object's class. This method must always be called with an explicit receiver, as class is also a reserved word in Ruby.
1.class #=> Fixnum
self.class #=> Object
Object#class_def
правитьclass_def(name, &blk)
Defines an instance method within a class
Object#clone
правитьobj.clone -> an_object
Produces a shallow copy of obj---the instance variables of obj are copied, but not the objects they reference. Copies the frozen and tainted state of obj. See also the discussion under Object#dup.
class Klass
attr_accessor :str
end
s1 = Klass.new #=> #<Klass:0x401b3a38>
s1.str = "Hello" #=> "Hello"
s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello">
s2.str[1,4] = "i" #=> "i"
s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">"
This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.
Object#dclone
правитьdclone()
(нет описания...)
Object#display
правитьobj.display(port=$>) => nil
Prints obj on the given port (default $>). Equivalent to:
def display(port=$>)
port.write self
end
For example:
1.display
"cat".display
[ 4, 5, 6 ].display
puts
produces:
1cat456
Object#dup
правитьobj.dup -> an_object
Produces a shallow copy of obj---the instance variables of obj are copied, but not the objects they reference. dup copies the tainted state of obj. See also the discussion under Object#clone. In general, clone and dup may have different semantics in descendent classes. While clone is used to duplicate an object, including its internal state, dup typically uses the class of the descendent object to create the new instance. This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.
Object#enum_for
правитьobj.to_enum(method = :each, *args) obj.enum_for(method = :each, *args)
Returns Enumerable::Enumerator.new(self, method, *args). e.g.:
str = "xyz"
enum = str.enum_for(:each_byte)
a = enum.map {|b| '%02x' % b } #=> ["78", "79", "7a"]
# protects an array from being modified
a = [1, 2, 3]
some_method(a.to_enum)
Object#eql?
правитьobj == other => true or false obj.equal?(other) => true or false obj.eql?(other) => true or false
Equality---At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning. Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b). The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:
1 == 1.0 #=> true
1.eql? 1.0 #=> false
Object#equal?
правитьobj == other => true or false obj.equal?(other) => true or false obj.eql?(other) => true or false
Equality---At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning. Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b). The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:
1 == 1.0 #=> true
1.eql? 1.0 #=> false
Object#extend
правитьobj.extend(module, ...) => obj
Adds to obj the instance methods from each module given as a parameter.
module Mod
def hello
"Hello from Mod.\n"
end
end
class Klass
def hello
"Hello from Klass.\n"
end
end
k = Klass.new
k.hello #=> "Hello from Klass.\n"
k.extend(Mod) #=> #<Klass:0x401b3bc8>
k.hello #=> "Hello from Mod.\n"
Object#freeze
правитьobj.freeze => obj
Prevents further modifications to obj. A TypeError will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also Object#frozen?.
a = [ "a", "b", "c" ]
a.freeze
a << "z"
produces:
prog.rb:3:in `<<': can't modify frozen array (TypeError)
from prog.rb:3
Object#frozen?
правитьobj.frozen? => true or false
Returns the freeze status of obj.
a = [ "a", "b", "c" ]
a.freeze #=> ["a", "b", "c"]
a.frozen? #=> true
Object#hash
правитьobj.hash => fixnum
Generates a Fixnum hash value for this object. This function must have the property that a.eql?(b) implies a.hash == b.hash. The hash value is used by class Hash. Any hash value that exceeds the capacity of a Fixnum will be truncated before being used.
Object#id
правитьobj.id => fixnum
Soon-to-be deprecated version of Object#object_id.
Object#inspect
правитьobj.inspect => string
Returns a string containing a human-readable representation of obj. If not overridden, uses the to_s method to generate the string.
[ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]"
Time.new.inspect #=> "Wed Apr 09 08:54:39 CDT 2003"
Object#instance_eval
править obj.instance_eval(string [, filename [, lineno]] ) => obj
obj.instance_eval {| | block } => obj
Evaluates a string containing Ruby source code, or the given block, within the context of the receiver (obj). In order to set the context, the variable self is set to obj while the code is executing, giving the code access to obj's instance variables. In the version of instance_eval that takes a String, the optional second and third parameters supply a filename and starting line number that are used when reporting compilation errors.
class Klass
def initialize
@secret = 99
end
end
k = Klass.new
k.instance_eval { @secret } #=> 99
Object#instance_of?
правитьobj.instance_of?(class) => true or false
Returns true if obj is an instance of the given class. See also Object#kind_of?.
Object#instance_variable_get
правитьinstance_variable_get(ivarname)
(нет описания...)
Object#instance_variable_set
правитьinstance_variable_set(ivarname, value)
(нет описания...)
Object#instance_variables
правитьobj.instance_variables => array
Returns an array of instance variable names for the receiver. Note that simply defining an accessor does not create the corresponding instance variable.
class Fred
attr_accessor :a1
def initialize
@iv = 3
end
end
Fred.new.instance_variables #=> ["@iv"]
Object#is_a?
правитьobj.is_a?(class) => true or false obj.kind_of?(class) => true or false
Returns true if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.
module M; end
class A
include M
end
class B < A; end
class C < B; end
b = B.new
b.instance_of? A #=> false
b.instance_of? B #=> true
b.instance_of? C #=> false
b.instance_of? M #=> false
b.kind_of? A #=> true
b.kind_of? B #=> true
b.kind_of? C #=> false
b.kind_of? M #=> true
Object#kind_of?
правитьobj.is_a?(class) => true or false obj.kind_of?(class) => true or false
Returns true if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.
module M; end
class A
include M
end
class B < A; end
class C < B; end
b = B.new
b.instance_of? A #=> false
b.instance_of? B #=> true
b.instance_of? C #=> false
b.instance_of? M #=> false
b.kind_of? A #=> true
b.kind_of? B #=> true
b.kind_of? C #=> false
b.kind_of? M #=> true
Object#meta_def
правитьmeta_def(name, &blk)
Adds methods to a metaclass
Object#meta_eval
правитьmeta_eval(&blk;)
(нет описания...)
Object#metaclass
правитьmetaclass()
The hidden singleton lurks behind everyone
Object#method
правитьobj.method(sym) => method
Looks up the named method as a receiver in obj, returning a Method object (or raising NameError). The Method object acts as a closure in obj's object instance, so instance variables and the value of self remain available.
class Demo
def initialize(n)
@iv = n
end
def hello()
"Hello, @iv = #{@iv}"
end
end
k = Demo.new(99)
m = k.method(:hello)
m.call #=> "Hello, @iv = 99"
l = Demo.new('Fred')
m = l.method("hello")
m.call #=> "Hello, @iv = Fred"
Object#methods
правитьobj.methods => array
Returns a list of the names of methods publicly accessible in obj. This will include all the methods accessible in obj's ancestors.
class Klass
def kMethod()
end
end
k = Klass.new
k.methods[0..9] #=> ["kMethod", "freeze", "nil?", "is_a?",
"class", "instance_variable_set",
"methods", "extend", "send", "instance_eval"]
k.methods.length #=> 42
Object#nil?
правитьnil?()
call_seq:
nil.nil? => true
<anything_else>.nil? => false
Only the object nil responds true to nil?.
Object#object_id
правитьobj.__id__ => fixnum obj.object_id => fixnum
Returns an integer identifier for obj. The same number will be returned on all calls to id for a given object, and no two active objects will share an id. Object#object_id is a different concept from the :name notation, which returns the symbol id of name. Replaces the deprecated Object#id.
Object#private_methods
правитьobj.private_methods(all=true) => array
Returns the list of private methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.
Object#protected_methods
правитьobj.protected_methods(all=true) => array
Returns the list of protected methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.
Object#public_methods
правитьobj.public_methods(all=true) => array
Returns the list of public methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.
Object#remove_instance_variable
правитьobj.remove_instance_variable(symbol) => obj
Removes the named instance variable from obj, returning that variable's value.
class Dummy
attr_reader :var
def initialize
@var = 99
end
def remove
remove_instance_variable(:@var)
end
end
d = Dummy.new
d.var #=> 99
d.remove #=> 99
d.var #=> nil
Object#respond_to?
правитьobj.respond_to?(symbol, include_private=false) => true or false
Возвращает значение true, если объект отвечает на данный метод. Частные методы включены в поиск только тогда, когда необязательный второй параметр вычисляется как true.
Object#send
правитьobj.send(symbol [, args...]) => obj obj.__send__(symbol [, args...]) => obj
Invokes the method identified by symbol, passing it any arguments specified. You can use __send__ if the name send clashes with an existing method in obj.
class Klass
def hello(*args)
"Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
Object#singleton_method_added
правитьsingleton_method_added(symbol)
Invoked as a callback whenever a singleton method is added to the receiver.
module Chatty
def Chatty.singleton_method_added(id)
puts "Adding #{id.id2name}"
end
def self.one() end
def two() end
def Chatty.three() end
end
produces:
Adding singleton_method_added
Adding one
Adding three
Object#singleton_method_removed
правитьsingleton_method_removed(symbol)
Invoked as a callback whenever a singleton method is removed from the receiver.
module Chatty
def Chatty.singleton_method_removed(id)
puts "Removing #{id.id2name}"
end
def self.one() end
def two() end
def Chatty.three() end
class <<self
remove_method :three
remove_method :one
end
end
produces:
Removing three
Removing one
Object#singleton_method_undefined
правитьsingleton_method_undefined(symbol)
Invoked as a callback whenever a singleton method is undefined in the receiver.
module Chatty
def Chatty.singleton_method_undefined(id)
puts "Undefining #{id.id2name}"
end
def Chatty.one() end
class << self
undef_method(:one)
end
end
produces:
Undefining one
Object#singleton_methods
правитьobj.singleton_methods(all=true) => array
Returns an array of the names of singleton methods for obj. If the optional all parameter is true, the list will include methods in modules included in obj.
module Other
def three() end
end
class Single
def Single.four() end
end
a = Single.new
def a.one()
end
class << a
include Other
def two()
end
end
Single.singleton_methods #=> ["four"]
a.singleton_methods(false) #=> ["two", "one"]
a.singleton_methods #=> ["two", "one", "three"]
Object#taint
правитьobj.taint -> obj
Marks obj as tainted---if the $SAFE level is set appropriately, many method calls which might alter the running programs environment will refuse to accept tainted strings.
Object#tainted?
правитьobj.tainted? => true or false
Returns true if the object is tainted.
Object#to_a
правитьobj.to_a -> anArray
Returns an array representation of obj. For objects of class Object and others that don't explicitly override the method, the return value is an array containing self. However, this latter behavior will soon be obsolete.
self.to_a #=> -:1: warning: default `to_a' will be obsolete
"hello".to_a #=> ["hello"]
Time.new.to_a #=> [39, 54, 8, 9, 4, 2003, 3, 99, true, "CDT"]
Object#to_enum
правитьobj.to_enum(method = :each, *args) obj.enum_for(method = :each, *args)
Returns Enumerable::Enumerator.new(self, method, *args). e.g.:
str = "xyz"
enum = str.enum_for(:each_byte)
a = enum.map {|b| '%02x' % b } #=> ["78", "79", "7a"]
# protects an array from being modified
a = [1, 2, 3]
some_method(a.to_enum)
Object#to_s
правитьobj.to_s => string
Returns a string representing obj. The default to_s prints the object's class and an encoding of the object id. As a special case, the top-level object that is the initial execution context of Ruby programs returns ``main.
Object#type
правитьobj.type => class
Deprecated synonym for Object#class.
Object#untaint
правитьobj.untaint => obj
Removes the taint from obj.
Класс Proc
правитьОбъекты Proc являются блоками кода, которые связаны с локальными переменными. Блок кода может быть выполнен в другом контексте.
def gen_times(factor)
return Proc.new {|n| n*factor }
end
times3 = gen_times(3)
times5 = gen_times(5)
times3.call(12) #-> 36
times5.call(5) #-> 25
times3.call(times5.call(4)) #-> 60Методы класса
Методы объекта
[], ==, arity, binding, call, clone, dup, to_proc, to_s
Proc::new
правитьProc.new {|...| block } #-> a_proc
Proc.new #-> a_procСоздает новый объект класса Proc и запоминает в нем текущий контекст. Proc::new может быть вызван без блока только в пределах метода к которому прицеплен блок (во время вызова). В этом случае блок будет преобразован в объект класса Proc.
def proc_from
Proc.new
end
proc = proc_from { "hello" }
proc.call #-> "hello"Proc#==
правитьprc == other_proc #-> true или falseВозвращает true, если prc и other_proc --- один и тот же объект, или если оба блока имеют одинаковое тело.
Proc#[]
правитьprc.call(params,...) #-> obj
prc[params,...] #-> objВыполняет блок, присваивая параметрам блока значения params и остальных переменных, обозначенных троеточием. Выдает предупреждение, если блок ожидает лишь одно значение, а ему передается больше (тем не менее, он преобразует список параметров в массив и попытается выполнить блок). Для блоков, создаваемых с использованием Kernel.proc, генерируется ошибка если число параметров передаваемых в блок превышает число параметров объявленных во время его создания. Для блоков, созданных при помощи Proc.new, дополнительные параметры просто отбрасываются. Возвращает значение последнего вычисленного выражения в блоке. Смотри еще Proc#yield.
a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
a_proc.call(9, 1, 2, 3) #-> [9, 18, 27]
a_proc[9, 1, 2, 3] #-> [9, 18, 27]
a_proc = Proc.new {|a,b| a}
a_proc.call(1,2,3)результат:
prog.rb:5: wrong number of arguments (3 for 2) (ArgumentError) from prog.rb:4:in `call' from prog.rb:5
(еще известен как .call)
Proc#arity
правитьprc.arity #-> fixnumВозвращает количество аргументов, которые могут быть восприняты блоком. Если блок объявлен без указания аргументов, то возвращает 0. Если число агрументов точно равно n, то возвращает n. Если блок имеет оциональный аргумент, то возвращает -n-1, где n --- количество обязательных аргументов. Блок proc без аргументов обычно содержит || вместо аргументов.
Proc.new {}.arity #-> 0
Proc.new {||}.arity #-> 0
Proc.new {|a|}.arity #-> 1
Proc.new {|a,b|}.arity #-> 2
Proc.new {|a,b,c|}.arity #-> 3
Proc.new {|*a|}.arity #-> -1
Proc.new {|a,*b|}.arity #-> -2Proc#binding
правитьprc.binding #-> bindingВозвращает объект класса Binding ассоциированный с prc. Например, Kernel#eval принимает объекты Proc или Binding в качестве второго аргумента.
def fred(param)
proc {}
end
b = fred(99)
eval("param", b.binding) #-> 99
eval("param", b) #-> 99Proc#call
правитьprc.call(params,...) #-> obj
prc[params,...] #-> objВыполняет блок, присваивая параметрам блока значения params и остальных переменных, обозначенных троеточием. Выдает предупреждение, если блок ожидает лишь одно значение, а ему передается больше (тем не менее, он преобразует список параметров в массив и попытается выполнить блок). Для блоков, создаваемых с использованием Kernel.proc, генерируется ошибка если число параметров передаваемых в блок превышает число параметров объявленных во время его создания. Для блоков, созданных при помощи Proc.new, дополнительные параметры просто отбрасываются. Возвращает значение последнего вычисленного выражения в блоке. Смотри еще Proc#yield.
a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
a_proc.call(9, 1, 2, 3) #-> [9, 18, 27]
a_proc[9, 1, 2, 3] #-> [9, 18, 27]
a_proc = Proc.new {|a,b| a}
a_proc.call(1,2,3)результат:
prog.rb:5: wrong number of arguments (3 for 2) (ArgumentError) from prog.rb:4:in `call' from prog.rb:5
(еще известен как [])
Proc#clone
правитьprc.clone #-> other_procСоздает копию блока prc.
Proc#dup
правитьprc.dup #-> other_procСоздает копию блока prc.
Proc#to_proc
правитьprc.to_proc #-> prcЧасть соглашения о преобразованиии других объектов в объекты класса Proc. Внутри класса Proc он просто возвращает сам себя.
Proc#to_s
правитьprc.to_s #-> stringВозвращает строку с уникальным идентификатором для prc, вместе с указателем на место, где блок был объявлен.
Класс Process
правитьThe Process module is a collection of methods used to manipulate processes.
Примеси
Windows::Console (AddConsoleAlias, AllocConsole, AttachConsole, CreateConsoleScreenBuffer, FillConsoleOutputAttribute, FlushConsoleInputBuffer, FreeConsole, GenerateConsoleCtrlEvent, GetConsoleAliasExes, GetConsoleAliasExesLength, GetConsoleAliases, GetConsoleAliasesLength, GetConsoleCP, GetConsoleCursorInfo, GetConsoleDisplayMode, GetConsoleFontSize, GetConsoleMode, GetConsoleOutputCP, GetConsoleProcessList, GetConsoleScreenBufferInfo, GetConsoleSelectionInfo, GetConsoleTitle, GetConsoleWindow, GetCurrentConsoleFont, GetLargestConsoleWindowSize, GetNumberOfConsoleInputEvents, GetNumberOfConsoleMouseButtons, GetStdHandle, PeekConsoleInput, ReadConsole, ReadConsoleInput, ReadConsoleOutput, ReadConsoleOutputAttribute, ReadConsoleOutputCharacter, ScrollConsoleScreenBuffer, SetConsoleActiveScreenBuffer, SetConsoleCP, SetConsoleCommandHistoryMode, SetConsoleCtrlHandler, SetConsoleCursorInfo, SetConsoleCursorPosition, SetConsoleDisplayMode, SetConsoleHistoryInfo, SetConsoleMode, SetConsoleOutputCP, SetConsoleScreenBufferSize, SetConsoleTextAttribute, SetConsoleTitle, SetConsoleWindowInfo, SetStdHandle, WriteConsole, WriteConsoleInput, WriteConsoleOutput, WriteConsoleOutputAttribute, WriteConsoleOutputCharacter),
Windows::Error (FormatMessage, FormatMessageW, GetLastError, SetErrorMode, SetLastError, SetLastErrorEx, get_last_error),
Windows::Handle (CloseHandle, DuplicateHandle, GetHandleInformation, SetHandleInformation, get_osfhandle, open_osfhandle),
Windows::Library (DisableThreadLibraryCalls, FreeLibrary, GetDllDirectory, GetModuleFileName, GetModuleHandle, GetModuleHandleEx, GetProcAddress, LoadLibrary, LoadLibraryEx, LoadModule, SetDllDirectory),
Windows::Process (CreateProcess, CreateRemoteThread, CreateThread, ExitProcess, GetCommandLine, GetCurrentProcess, GetCurrentProcessId, GetEnvironmentStrings, GetEnvironmentVariable, GetExitCodeProcess, GetPriorityClass, GetProcessHandleCount, GetProcessId, GetProcessTimes, GetStartupInfo, OpenProcess, SetEnvironmentVariable, Sleep, SleepEx, TerminateProcess, WaitForInputIdle),
Windows::Synchronize (CreateEvent, CreateMutex, CreateSemaphore, GetOverlappedResult, MsgWaitForMultipleObjects, MsgWaitForMultipleObjectsEx, OpenEvent, OpenMutex, OpenSemaphore, ReleaseMutex, ReleaseSemaphore, ResetEvent, SetEvent, WaitForMultipleObjects, WaitForMultipleObjectsEx, WaitForSingleObject, WaitForSingleObjectEx),
Windows::Window (GetClientRect, GetForegroundWindow, GetWindowRect)
Константы
PRIO_PGRP, PRIO_PROCESS, PRIO_USER, ProcessInfo, RLIMIT_AS, RLIMIT_CORE, RLIMIT_CPU, RLIMIT_DATA, RLIMIT_FSIZE, RLIMIT_MEMLOCK, RLIMIT_NOFILE, RLIMIT_NPROC, RLIMIT_RSS, RLIMIT_SBSIZE, RLIMIT_STACK, RLIM_INFINITY, RLIM_SAVED_CUR, RLIM_SAVED_MAX, WIN32_PROCESS_VERSION, WNOHANG, WUNTRACED
Методы класса
abort, detach, egid=, egid, euid=, euid, exit!, exit, fork, getpgid, getpriority, getrlimit, gid=, gid, groups=, groups, initgroups, kill, maxgroups=, maxgroups, pid, ppid, setpgid, setpgrp, setpriority, setrlimit, setsid, times, uid=, uid, wait2, waitall, waitpid2, waitpid, wait
Методы объекта
create, fork, kill, wait2, waitpid2, waitpid, wait
Process::abort
правитьabort Kernel::abort Process::abort
Terminate execution immediately, effectively by calling Kernel.exit(1). If msg is given, it is written to STDERR prior to terminating.
Process::detach
правитьProcess.detach(pid) => thread
Some operating systems retain the status of terminated child processes until the parent collects that status (normally using some variant of wait(). If the parent never collects this status, the child stays around as a zombie process. Process::detach prevents this by setting up a separate Ruby thread whose sole job is to reap the status of the process pid when it terminates. Use detach only when you do not intent to explicitly wait for the child to terminate. detach only checks the status periodically (currently once each second). In this first example, we don't reap the first child process, so it appears as a zombie in the process status display.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
produces:
27389 Z
In the next example, Process::detach is used to reap the child automatically.
p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.detach(p1)
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")
(produces no output)
Process::egid
правитьProcess.egid => fixnum Process::GID.eid => fixnum Process::Sys.geteid => fixnum
Returns the effective group ID for this process. Not available on all platforms.
Process.egid #=> 500
Process::egid=
правитьProcess.egid = fixnum => fixnum
Sets the effective group ID for this process. Not available on all platforms.
Process::euid
правитьProcess.euid => fixnum Process::UID.eid => fixnum Process::Sys.geteuid => fixnum
Returns the effective user ID for this process.
Process.euid #=> 501
Process::euid=
правитьProcess.euid= integer
Sets the effective user ID for this process. Not available on all platforms.
Process::exit
правитьexit(integer=0) Kernel::exit(integer=0) Process::exit(integer=0)
Initiates the termination of the Ruby script by raising the SystemExit exception. This exception may be caught. The optional parameter is used to return a status code to the invoking environment.
begin
exit
puts "never get here"
rescue SystemExit
puts "rescued a SystemExit exception"
end
puts "after begin block"
produces:
rescued a SystemExit exception
after begin block
Just prior to termination, Ruby executes any at_exit functions (see Kernel::at_exit) and runs any object finalizers (see ObjectSpace::define_finalizer).
at_exit { puts "at_exit function" }
ObjectSpace.define_finalizer("string", proc { puts "in finalizer" })
exit
produces:
at_exit function
in finalizer
Process::exit!
правитьProcess.exit!(fixnum=-1)
Exits the process immediately. No exit handlers are run. fixnum is returned to the underlying system as the exit status.
Process.exit!(0)
Process::fork
править Kernel.fork [{ block }] => fixnum or nil
Process.fork [{ block }] => fixnum or nil
Creates a subprocess. If a block is specified, that block is run in the subprocess, and the subprocess terminates with a status of zero. Otherwise, the fork call returns twice, once in the parent, returning the process ID of the child, and once in the child, returning nil. The child process can exit using Kernel.exit! to avoid running any at_exit functions. The parent process should use Process.wait to collect the termination statuses of its children or use Process.detach to register disinterest in their status; otherwise, the operating system may accumulate zombie processes. The thread calling fork is the only thread in the created child process. fork doesn't copy other threads.
Process::getpgid
правитьProcess.getpgid(pid) => integer
Returns the process group ID for the given process id. Not available on all platforms.
Process.getpgid(Process.ppid()) #=> 25527
Process::getpriority
правитьProcess.getpriority(kind, integer) => fixnum
Gets the scheduling priority for specified process, process group, or user. kind indicates the kind of entity to find: one of Process::PRIO_PGRP, Process::PRIO_USER, or Process::PRIO_PROCESS. integer is an id indicating the particular process, process group, or user (an id of 0 means current). Lower priorities are more favorable for scheduling. Not available on all platforms.
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
Process::getrlimit
правитьProcess.getrlimit(resource) => [cur_limit, max_limit]
Gets the resource limit of the process. cur_limit means current (soft) limit and max_limit means maximum (hard) limit. resource indicates the kind of resource to limit: such as Process::RLIMIT_CORE, Process::RLIMIT_CPU, etc. See Process.setrlimit for details. cur_limit and max_limit may be Process::RLIM_INFINITY, Process::RLIM_SAVED_MAX or Process::RLIM_SAVED_CUR. See Process.setrlimit and the system getrlimit(2) manual for details.
Process::gid
правитьProcess.gid => fixnum Process::GID.rid => fixnum Process::Sys.getgid => fixnum
Returns the (real) group ID for this process.
Process.gid #=> 500
Process::gid=
правитьProcess.gid= fixnum => fixnum
Sets the group ID for this process.
Process::groups
правитьProcess.groups => array
Get an Array of the gids of groups in the supplemental group access list for this process.
Process.groups #=> [27, 6, 10, 11]
Process::groups=
правитьProcess.groups= array => array
Set the supplemental group access list to the given Array of group IDs.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11]
Process.groups #=> [27, 6, 10, 11]
Process::initgroups
правитьProcess.initgroups(username, gid) => array
Initializes the supplemental group access list by reading the system group database and using all groups of which the given user is a member. The group with the specified gid is also added to the list. Returns the resulting Array of the gids of all the groups in the supplementary group access list. Not available on all platforms.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11]
Process.groups #=> [30, 6, 10, 11]
Process::kill
правитьProcess.kill(signal, pid, ...) => fixnum
Sends the given signal to the specified process id(s), or to the current process if pid is zero. signal may be an integer signal number or a POSIX signal name (either with or without a SIG prefix). If signal is negative (or starts with a minus sign), kills process groups instead of processes. Not all signals are available on all platforms.
pid = fork do
Signal.trap("HUP") { puts "Ouch!"; exit }
# ... do some work ...
end
# ...
Process.kill("HUP", pid)
Process.wait
produces:
Ouch!
Process::maxgroups
правитьProcess.maxgroups => fixnum
Returns the maximum number of gids allowed in the supplemental group access list.
Process.maxgroups #=> 32
Process::maxgroups=
правитьProcess.maxgroups= fixnum => fixnum
Sets the maximum number of gids allowed in the supplemental group access list.
Process::pid
правитьProcess.pid => fixnum
Returns the process id of this process. Not available on all platforms.
Process.pid #=> 27415
Process::ppid
правитьProcess.ppid => fixnum
Returns the process id of the parent of this process. Always returns 0 on NT. Not available on all platforms.
puts "I am #{Process.pid}"
Process.fork { puts "Dad is #{Process.ppid}" }
produces:
I am 27417
Dad is 27417
Process::setpgid
правитьProcess.setpgid(pid, integer) => 0
Sets the process group ID of pid (0 indicates this process) to integer. Not available on all platforms.
Process::setpgrp
правитьProcess.setpgrp => 0
Equivalent to setpgid(0,0). Not available on all platforms.
Process::setpriority
правитьProcess.setpriority(kind, integer, priority) => 0
See Process#getpriority.
Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0
Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0
Process.getpriority(Process::PRIO_USER, 0) #=> 19
Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19
Process::setrlimit
правитьProcess.setrlimit(resource, cur_limit, max_limit) => nil Process.setrlimit(resource, cur_limit) => nil
Sets the resource limit of the process. cur_limit means current (soft) limit and max_limit means maximum (hard) limit. If max_limit is not given, cur_limit is used. resource indicates the kind of resource to limit. The list of resources are OS dependent. Ruby may support following resources.
- Process::RLIMIT_CORE
- core size (bytes) (SUSv3)
- Process::RLIMIT_CPU
- CPU time (seconds) (SUSv3)
- Process::RLIMIT_DATA
- data segment (bytes) (SUSv3)
- Process::RLIMIT_FSIZE
- file size (bytes) (SUSv3)
- Process::RLIMIT_NOFILE
- file descriptors (number) (SUSv3)
- Process::RLIMIT_STACK
- stack size (bytes) (SUSv3)
- Process::RLIMIT_AS
- total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)
- Process::RLIMIT_MEMLOCK
- total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
- Process::RLIMIT_NPROC
- number of processes for the user (number) (4.4BSD, GNU/Linux)
- Process::RLIMIT_RSS
- resident memory size (bytes) (4.2BSD, GNU/Linux)
- Process::RLIMIT_SBSIZE
- all socket buffers (bytes) (NetBSD, FreeBSD)
Other Process::RLIMIT_??? constants may be defined.
cur_limit and max_limit may be Process::RLIM_INFINITY, which means that the resource is not limited. They may be Process::RLIM_SAVED_MAX or Process::RLIM_SAVED_CUR too. See system setrlimit(2) manual for details.
Process::setsid
правитьProcess.setsid => fixnum
Establishes this process as a new session and process group leader, with no controlling tty. Returns the session id. Not available on all platforms.
Process.setsid #=> 27422
Process::times
правитьProcess.times => aStructTms
Returns a Tms structure (see Struct::Tms on page 388) that contains user and system CPU times for this process.
t = Process.times
[ t.utime, t.stime ] #=> [0.0, 0.02]
Process::uid
правитьProcess.uid => fixnum Process::UID.rid => fixnum Process::Sys.getuid => fixnum
Returns the (real) user ID of this process.
Process.uid #=> 501
Process::uid=
правитьProcess.uid= integer => numeric
Sets the (integer) user ID for this process. Not available on all platforms.
Process::wait
правитьProcess.wait() => fixnum Process.wait(pid=-1, flags=0) => fixnum Process.waitpid(pid=-1, flags=0) => fixnum
Waits for a child process to exit, returns its process id, and sets $? to a Process::Status object containing information on that process. Which child it waits on depends on the value of pid:
Waits for the child whose process ID equals pid. Waits for any child whose process group ID equals that of the calling process. Waits for any child process (the default if no pid is given).
Waits for any child whose process group ID equals the absolute value of pid.The flags argument may be a logical or of the flag values Process::WNOHANG (do not block if no child available) or Process::WUNTRACED (return stopped children that haven't been reported). Not all flags are available on all platforms, but a flag value of zero will work on all platforms. Calling this method raises a SystemError if there are no child processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> Wed Apr 09 08:57:09 CDT 2003
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> Wed Apr 09 08:57:09 CDT 2003
waitpid(pid, 0) #=> 27440
Time.now #=> Wed Apr 09 08:57:12 CDT 2003
Process::wait2
правитьProcess.wait2(pid=-1, flags=0) => [pid, status] Process.waitpid2(pid=-1, flags=0) => [pid, status]
Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing the process id and the exit status (a Process::Status object) of that child. Raises a SystemError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
Process::waitall
правитьProcess.waitall => [ [pid1,status1], ...]
Waits for all children, returning an array of pid/status pairs (where status is a Process::Status object).
fork { sleep 0.2; exit 2 } #=> 27432
fork { sleep 0.1; exit 1 } #=> 27433
fork { exit 0 } #=> 27434
p Process.waitall
produces:
[[27434, #<Process::Status: pid=27434,exited(0)>],
[27433, #<Process::Status: pid=27433,exited(1)>],
[27432, #<Process::Status: pid=27432,exited(2)>]]
Process::waitpid
правитьProcess.wait() => fixnum Process.wait(pid=-1, flags=0) => fixnum Process.waitpid(pid=-1, flags=0) => fixnum
Waits for a child process to exit, returns its process id, and sets $? to a Process::Status object containing information on that process. Which child it waits on depends on the value of pid:
Waits for the child whose process ID equals pid. Waits for any child whose process group ID equals that of the calling process. Waits for any child process (the default if no pid is given).
Waits for any child whose process group ID equals the absolute value of pid.The flags argument may be a logical or of the flag values Process::WNOHANG (do not block if no child available) or Process::WUNTRACED (return stopped children that haven't been reported). Not all flags are available on all platforms, but a flag value of zero will work on all platforms. Calling this method raises a SystemError if there are no child processes. Not available on all platforms.
include Process
fork { exit 99 } #=> 27429
wait #=> 27429
$?.exitstatus #=> 99
pid = fork { sleep 3 } #=> 27440
Time.now #=> Wed Apr 09 08:57:09 CDT 2003
waitpid(pid, Process::WNOHANG) #=> nil
Time.now #=> Wed Apr 09 08:57:09 CDT 2003
waitpid(pid, 0) #=> 27440
Time.now #=> Wed Apr 09 08:57:12 CDT 2003
Process::waitpid2
правитьProcess.wait2(pid=-1, flags=0) => [pid, status] Process.waitpid2(pid=-1, flags=0) => [pid, status]
Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing the process id and the exit status (a Process::Status object) of that child. Raises a SystemError if there are no child processes.
Process.fork { exit 99 } #=> 27437
pid, status = Process.wait2
pid #=> 27437
status.exitstatus #=> 99
Process#create
правитьcreate(args)
Process.create(key => value, ...) => ProcessInfo This is a wrapper for the CreateProcess() function. It executes a process, returning a ProcessInfo struct. It accepts a hash as an argument. There are six primary keys:
- app_name (mandatory)
- inherit (default: false)
- process_inherit (default: false)
- thread_inherit (default: false)
- creation_flags (default: 0)
- cwd (default: Dir.pwd)
- startup_info (default: nil)
- environment (default: nil)
Of these, the 'app_name' must be specified or an error is raised. The startup_info key takes a hash. Its keys are attributes that are part of the StartupInfo struct, and are generally only meaningful for GUI or console processes. See the documentation on CreateProcess() and the StartupInfo struct on MSDN for more information.
- desktop
- title
- x
- y
- x_size
- y_size
- x_count_chars
- y_count_chars
- fill_attribute
- sw_flags
- startf_flags
The relevant constants for 'creation_flags', 'sw_flags' and 'startf_flags' are included in the Windows::Process, Windows::Console and Windows::Window modules. These come with the windows-pr package, a prerequisite of this package. The ProcessInfo struct contains the following members:
- process_handle - The handle to the newly created process
- thread_handle - The handle to the primary thread of the newly created
process.- process_id - Process ID.
- thread_id - Thread ID.
Process#fork
править fork() {|| ...}
Creates the equivalent of a subshell via the CreateProcess() function. This behaves in a manner that is similar, but not identical to, the Kernel.fork method for Unix.
Process#kill
правитьkill(signal, *pids)
Sends the given signal to an array of process id's. The signal may be any value from 0 to 9, or the special strings 'SIGINT' (or 'INT'), 'SIGBRK' (or 'BRK') and 'SIGKILL' (or 'KILL'). An array of successfully killed pids is returned. Signal 0 merely tests if the process is running without killing it. Signal 2 sends a CTRL_C_EVENT to the process. Signal 3 sends a CTRL_BRK_EVENT to the process. Signal 9 kills the process in a harsh manner. Signals 1 and 4-8 kill the process in a nice manner. SIGINT/INT corresponds to signal 2 SIGBRK/BRK corresponds to signal 3 SIGKILL/KILL corresponds to signal 9 Signals 2 and 3 only affect console processes, and then only if the process was created with the CREATE_NEW_PROCESS_GROUP flag.
Process#wait
правитьwait()
Waits for any child process to exit and returns the process id of that child. Note that the $? (Process::Status) global variable is NOT set. This may be addressed in a future release.
Process#wait2
правитьwait2()
Waits for any child process to exit and returns an array containing the process id and the exit status of that child. Note that the $? (Process::Status) global variable is NOT set. This may be addressed in a future release.
Process#waitpid
правитьwaitpid(pid)
Waits for the given child process to exit and returns that pid. Note that the $? (Process::Status) global variable is NOT set. This may be addressed in a future release.
Process#waitpid2
правитьwaitpid2(pid)
Waits for the given child process to exit and returns an array containing the process id and the exit status. Note that the $? (Process::Status) global variable is NOT set. This may be addressed in a future release.
Класс Range
правитьОбъекты класса Range представляют собой интервал - множество значений между началом и концом интервала. Интервалы могу быть созданы с использованием литералов s..e и s...e, или при помощи метода Range::new. Интервалы, созданные при помощи .., идут с начала по конец включительно. Напротив, интервалы, которые созданы при помощи ... исключают последнее значение. Когда интервалы используются в итераторах, они возвращают каждое значение из заданного диапазона.
(-1..-5).to_a #-> []
(-5..-1).to_a #-> [-5, -4, -3, -2, -1]
('a'..'e').to_a #-> ["a", "b", "c", "d", "e"]
('a'...'e').to_a #-> ["a", "b", "c", "d"]Интервалы могут быть созданы с использованием объектов любого типа, при условии, что они сравнимы при помощи оператора <=> и содержат метод succ, который возвращает следующий объект последовательности.
class Xs # represent a string of 'x's
include Comparable
attr :length
def initialize(n)
@length = n
end
def succ
Xs.new(@length + 1)
end
def <=>(other)
@length <=> other.length
end
def to_s
sprintf "%2d #{inspect}", @length
end
def inspect
'x' * @length
end
end
r = Xs.new(3)..Xs.new(6) #-> xxx..xxxxxx
r.to_a #-> [xxx, xxxx, xxxxx, xxxxxx]
r.member?(Xs.new(5)) #-> trueВ предыдущем примере, класс Xs подключает примесь Comparable. Поэтому метод Enumerable#member? имеет возможность использовать оператор == для проверки эквивалентности. Подключенная примесь Comparable реализует оператор ==, но для его корректной работы в классе Xs должен быть реализован оператор <=>.
Примеси
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)
Методы класса
Методы объекта
===, ==, begin, each, end, eql?, exclude_end?, first, hash, include?, inspect, last, member?, step, to_s
Range::new
правитьRange.new(start, end, exclusive=false) #-> rangeСоздает интервал, используя start и end. Если третий параметр пропущен или равен false, то range будет включать конечный объект (равный end); иначе он будет исключен.
Range#==
правитьrng == obj #-> true or falseВозвращает true только если obj является интервалом, начальный и конечный объект которого эквивалентны соответствующим параметрам rng (сравнивается при помощи ==), и результат метода #exclude_end? такой же, как и у rng.
(0..2) == (0..2) #-> true
(0..2) == Range.new(0,2) #-> true
(0..2) == (0...2) #-> falseRange#===
правитьrng === obj #-> true или false
rng.member?(val) #-> true или false
rng.include?(val) #-> true или falseВозвращает true если obj является элементом rng, false иначе. Оператор сравнения === используется для сопоставления в конструкции case.
case 79
when 1..50 then print "низко\n"
when 51..75 then print "средне\n"
when 76..100 then print "высоко\n"
endрезультат:
высоко
(еще известен как member?, include?)
Range#begin
правитьrng.first #-> obj
rng.begin #-> objВозвращает первый объект из интервала rng.
(еще известен как first)
Range#each
правитьrng.each {| i | block } #-> rngПеребирает элементы rng, которые передаются каждую итерацию внутрь блока. Вы можете осуществить перебор только в том случае, если начальный объект поддерживает метод succ (таким образом перебор элементов из интервала, состоящего из объектов Float невозможен).
(10..15).each do |n|
print n, ' '
endрезультат:
10 11 12 13 14 15
Range#end
правитьrng.end #-> obj
rng.last #-> objВозвращает элемент, который в rng объявлен как последний.
(1..10).end #-> 10
(1...10).end #-> 10(еще известен как last)
Range#eql?
правитьrng.eql?(obj) #-> true или falseВозвращает true только если obj является интервалом, начальный и конечный объект которого эквивалентны соответствующим параметрам rng (сравнивается при помощи #eql?), и результат метода #exclude_end? такой же, как и у rng.
(0..2) == (0..2) #-> true
(0..2) == Range.new(0,2) #-> true
(0..2) == (0...2) #-> falseRange#exclude_end?
правитьrng.exclude_end? #-> true или falseВозвращает true если rng не включает последний элемент (создан при помощи ...).
Range#first
правитьrng.first #-> obj
rng.begin #-> objВозвращает первый объект из интервала rng.
(еще известен как begin)
Range#hash
правитьrng.hash #-> fixnumВозвращает контрольную сумму, которая для двух диапазонов с одинаковыми начальными и конечными объектами, а также с одинаковыми значениями метода #exclude_end? --- будет совпадать.
Range#include?
правитьrng === obj #-> true или false
rng.member?(val) #-> true или false
rng.include?(val) #-> true или falseВозвращает true если obj является элементом rng, false иначе. Оператор сравнения === используется для сопоставления в конструкции case.
case 79
when 1..50 then print "низко\n"
when 51..75 then print "средне\n"
when 76..100 then print "высоко\n"
endрезультат:
высоко
(еще известен как ===, member?)
Range#inspect
правитьrng.inspect #-> stringПреобразует инретвал rng в печатную форму (использует метод inspect для преобразования начального и конечного объектов).
Range#last
правитьrng.end #-> obj
rng.last #-> objВозвращает элемент, который в rng объявлен как последний.
(1..10).end #-> 10
(1...10).end #-> 10(еще известен как end)
Range#member?
правитьrng === obj #-> true или false
rng.member?(val) #-> true или false
rng.include?(val) #-> true или falseВозвращает true если obj является элементом rng, false иначе. Оператор сравнения === используется для сопоставления в конструкции case.
case 79
when 1..50 then print "низко\n"
when 51..75 then print "средне\n"
when 76..100 then print "высоко\n"
endрезультат:
высоко
(еще известен как ===, include?)
Range#step
правитьrng.step(n=1) {| obj | block } #-> rngПеребирает элементы из диапазона rng, передавая каждый n-ый элемент в блок. Если диапазон состоит из целых чисел или строк, то элементы вычисляются целочисленным делением. Иначе step использует метод succ для перебора элментов. Следующий код использует класс Xs, который использовался нами ранее (см. Range).
range = Xs.new(1)..Xs.new(10)
range.step(2) {|x| puts x}
range.step(3) {|x| puts x}результат:
1 x 3 xxx 5 xxxxx 7 xxxxxxx 9 xxxxxxxxx 1 x 4 xxxx 7 xxxxxxx 10 xxxxxxxxxx
Range#to_s
правитьrng.to_s #-> stringПреобразует интервал rng в печатную форму.
Класс Regexp
правитьДокумент-класс: Regexp Regexp содержит регулярные выражения, используется для сопоставления шаблона с строками. Регулярные выражения создаются с помощью /.../ и %r{...} знаков, а также с конструктором Regexp::new.
Константы
EXTENDED, IGNORECASE, MULTILINE
Методы класса
compile, escape, last_match, new, quote, union, yaml_new
Методы объекта
&, ===, ==, =~, casefold?, eql?, hash, inspect, kcode, match, options, source, to_s, to_yaml, ||, ~
Regexp::compile
правитьRegexp::compile(...)
Синоним для Regexp.new
Regexp::escape
правитьRegexp.escape(str) => a_str Regexp.quote(str) => a_str
Вытесняет любые символы, которые имеют особое значение в регулярном выражении. Возвращает новую экранированную строку или self, если никакие символы не экранированы. Для любой строки, Regexp.escape(str)=~str будет true.
Regexp.escape('\*?{}.') #=> \\*\?\{\}\.
Regexp::last_match
правитьRegexp.last_match => matchdata Regexp.last_match(fixnum) => str
The first form returns the MatchData object generated by the last successful pattern match. Equivalent to reading the global variable $~. The second form returns the nth field in this MatchData object.
/c(.)t/ =~ 'cat' #=> 0
Regexp.last_match #=> #<MatchData:0x401b3d30>
Regexp.last_match(0) #=> "cat"
Regexp.last_match(1) #=> "a"
Regexp.last_match(2) #=> nil
Regexp::new
правитьRegexp.new(string [, options [, lang]]) => regexp Regexp.new(regexp) => regexp Regexp.compile(string [, options [, lang]]) => regexp Regexp.compile(regexp) => regexp
Constructs a new regular expression from pattern, which can be either a String or a Regexp (in which case that regexp's options are propagated, and new options may not be specified (a change as of Ruby 1.8). If options is a Fixnum, it should be one or more of the constants Regexp::EXTENDED, Regexp::IGNORECASE, and Regexp::MULTILINE, or-ed together. Otherwise, if options is not nil, the regexp will be case insensitive. The lang parameter enables multibyte support for the regexp: `n', `N' = none, `e', `E' = EUC, `s', `S' = SJIS, `u', `U' = UTF-8.
r1 = Regexp.new('^a-z+:\s+\w+') #=> /^a-z+:\s+\w+/
r2 = Regexp.new('cat', true) #=> /cat/i
r3 = Regexp.new('dog', Regexp::EXTENDED) #=> /dog/x
r4 = Regexp.new(r2) #=> /cat/i
Regexp::quote
правитьRegexp.escape(str) => a_str Regexp.quote(str) => a_str
Escapes any characters that would have special meaning in a regular expression. Returns a new escaped string, or self if no characters are escaped. For any string, Regexp.escape(str)=~str will be true.
Regexp.escape('\*?{}.') #=> \\*\?\{\}\.
Regexp::union
правитьRegexp.union([pattern]*) => new_str
Return a Regexp object that is the union of the given patterns, i.e., will match any of its parts. The patterns can be Regexp objects, in which case their options will be preserved, or Strings. If no arguments are given, returns /(?!)/.
Regexp.union #=> /(?!)/
Regexp.union("penzance") #=> /penzance/
Regexp.union("skiing", "sledding") #=> /skiing|sledding/
Regexp.union(/dogs/, /cats/i) #=> /(?-mix:dogs)|(?i-mx:cats)/
Regexp::yaml_new
правитьRegexp::yaml_new( klass, tag, val )
(нет описания...)
Regexp#&
править&(other)
(нет описания...)
Regexp#==
правитьrxp == other_rxp => true or false rxp.eql?(other_rxp) => true or false
Equality---Two regexps are equal if their patterns are identical, they have the same character set code, and their casefold? values are the same.
/abc/ == /abc/x #=> false
/abc/ == /abc/i #=> false
/abc/u == /abc/n #=> false
Regexp#===
правитьrxp === str => true or false
Case Equality---Synonym for Regexp#=~ used in case statements.
a = "HELLO"
case a
when /^[a-z]*$/; print "Lower case\n"
when /^[A-Z]*$/; print "Upper case\n"
else; print "Mixed case\n"
end
produces:
Upper case
Regexp#=~
правитьrxp.match(str) => matchdata or nil
Returns a MatchData object describing the match, or nil if there was no match. This is equivalent to retrieving the value of the special variable $~ following a normal match.
/(.)(.)(.)/.match("abc")[2] #=> "b"
Regexp#casefold?
правитьrxp.casefold? => true or false
Returns the value of the case-insensitive flag.
Regexp#eql?
правитьrxp == other_rxp => true or false rxp.eql?(other_rxp) => true or false
Equality---Two regexps are equal if their patterns are identical, they have the same character set code, and their casefold? values are the same.
/abc/ == /abc/x #=> false
/abc/ == /abc/i #=> false
/abc/u == /abc/n #=> false
Regexp#hash
правитьrxp.hash => fixnum
Produce a hash based on the text and options of this regular expression.
Regexp#inspect
правитьrxp.inspect => string
Produce a nicely formatted string-version of rxp. Perhaps surprisingly, #inspect actually produces the more natural version of the string than #to_s.
/ab+c/ix.to_s #=> /ab+c/ix
Regexp#kcode
правитьrxp.kcode => str
Returns the character set code for the regexp.
Regexp#match
правитьrxp.match(str) => matchdata or nil
Returns a MatchData object describing the match, or nil if there was no match. This is equivalent to retrieving the value of the special variable $~ following a normal match.
/(.)(.)(.)/.match("abc")[2] #=> "b"
Regexp#options
правитьrxp.options => fixnum
Returns the set of bits corresponding to the options used when creating this Regexp (see Regexp::new for details. Note that additional bits may be set in the returned options: these are used internally by the regular expression code. These extra bits are ignored if the options are passed to Regexp::new.
Regexp::IGNORECASE #=> 1
Regexp::EXTENDED #=> 2
Regexp::MULTILINE #=> 4
/cat/.options #=> 128
/cat/ix.options #=> 131
Regexp.new('cat', true).options #=> 129
Regexp.new('cat', 0, 's').options #=> 384
r = /cat/ix
Regexp.new(r.source, r.options) #=> /cat/ix
Regexp#source
правитьrxp.source => str
Returns the original string of the pattern.
/ab+c/ix.source #=> "ab+c"
Regexp#to_s
правитьrxp.to_s => str
Returns a string containing the regular expression and its options (using the (?xxx:yyy) notation. This string can be fed back in to Regexp::new to a regular expression with the same semantics as the original. (However, Regexp#== may not return true when comparing the two, as the source of the regular expression itself may differ, as the example shows). Regexp#inspect produces a generally more readable version of rxp.
r1 = /ab+c/ix #=> /ab+c/ix
s1 = r1.to_s #=> "(?ix-m:ab+c)"
r2 = Regexp.new(s1) #=> /(?ix-m:ab+c)/
r1 == r2 #=> false
r1.source #=> "ab+c"
r2.source #=> "(?ix-m:ab+c)"
Regexp#to_yaml
править to_yaml( opts = {} )
(нет описания...)
Regexp#|
править|(other)
(нет описания...)
Regexp#~
править~ rxp => integer or nil
Match---Matches rxp against the contents of $_. Equivalent to rxp =~ $_.
$_ = "input data"
~ /at/ #=> 7
Класс String
правитьСтроки хранят и манипулируют произвольными последовательностями байт (обычно это символы). Строки могут быть созданы при помощи метода String::new или как литералы. Для избежания трудноуловимых ошибок в коде, необходимо знать методы, которые меняют исходную строку (а не создают новую). Обычно имена этих методов заканчиваются на !. Если имя метода не заканчивается на !, то данный метод создает новую строку, а не модифицирует исходную. Правда, как и у любого правила, есть исключения. Например, метод String#[]=.
Примеси
Comparable (<, <=, ==, >, >=, between?),
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)
Константы
DeletePatternCache, HashCache, PATTERN_EUC, PATTERN_SJIS, PATTERN_UTF8, RE_EUC, RE_SJIS, RE_UTF8, SUCC, SqueezePatternCache, TrPatternCache
Методы класса
Методы объекта
[]=, [], %, *, +, <<, <=>, ==, =~, ascii_only?, capitalize!, capitalize, casecmp, center, chars, chomp!, chomp, chop!, chop, clear, concat, count, crypt, delete!, delete, delete_prefix, delete_prefix!, downcase!, downcase, dump, each_byte, each_char, each_line, each, empty?, eql?, gsub!, gsub, hash, hex, include?, index, insert, inspect, intern, length, ljust, lstrip!, lstrip, match, next!, next, nstrip, oct, ord, replace, reverse!, reverse, rindex, rjust, rstrip!, rstrip, scanf, scan, size, slice!, slice, split, squeeze!, squeeze, strip!, strip, sub!, sub, succ!, succ, sum, swapcase!, swapcase, to_blob, to_a, to_c, to_f, to_i, to_str, to_sym, to_s, tr!, tr_s!, tr_s, tr, unpack, upcase!, upcase, upto
String::new
правитьString.new(str="") #-> new_strВозвращает новую строку, которая содержит копию строки str, передаваемой в качестве параметра.
String#%
правитьstr % arg #-> new_strФорматирование строки. В управляющую строку str вместо спецификаторов преобразования подставляются данные из arg. Если в строке str указано несколько спецификаторов преобразования, то arg должен быть массивом.
"%05d" % 123 #-> "00123"
"%-5s: %08x" % [ "ID", self.id ] #-> "ID : 200e14d6"|
|
Описание формата управляющей строки и спецификаторов можно посмотреть в описании метода Kernel::sprintf |
String#*
правитьstr * integer #-> new_strПовторение — возвращает новую строку, которая состоит из integer-копий строки str.
"Ho! " * 3 #-> "Ho! Ho! Ho! "String#+
правитьstr + other_str #-> new_strСцепление — возвращает новую строку, состоящую из строк str и other_str.
"Hello from " + self.to_s #-> "Hello from main"|
|
Полезно посмотреть на методы << и concat, которые имеют схожую функциональность |
String#<<
правитьstr << fixnum #-> str
str.concat(fixnum) #-> str
str << obj #-> str
str.concat(obj) #-> strДобавление — присоединяет аргумент к str. Если аргумент типа Fixnum в диапазоне от 0 до 255, то он перед присоединением конвертируется в символ.
a = "hello ";
a << "world" #-> "hello world"
a << 33 #-> "hello world!"|
|
Методы << и concat — абсолютно идентичны, то есть являются именами одного и того же метода |
String#<=>
правитьstr <=> other_str #-> -1, 0, +1Сравнение — возвращает -1, если other_str меньше str; возвращает 0, если other_str и str равны; возвращает +1, если other_str больше str. Если строки различаются по длине, но эквивалентны на длине самой короткой из двух, то большей считается та, которая длиннее. Если переменная $= равна false, то сравнение базируется на сравнении двоичных значений каждого символа в строке. В старых версиях Руби, изменением $= можно было добиться регистронезависимого сравнения, но теперь эту функцию выполняет метод casecmp, который и рекомендуется использовать для этих целей.
"abcdef" <=> "abcde" #-> 1
"abcdef" <=> "abcdef" #-> 0
"abcdef" <=> "abcdefg" #-> -1
"abcdef" <=> "ABCDEF" #-> 1|
|
Полезно посмотреть на метод casecmp, который имеет схожую функциональность |
|
|
Метод <=> служит основой для таких методов, как: <, <=, >, >= и between?, которые подключаются вместе с модулем Comparable |
String#==
правитьstr == obj #-> true или falseЭквивалентность — если строки str и obj не совпадают, то возвращается false. Возвращается true только в случае, когда код str <=> obj возвращает 0.
String#=~
правитьstr =~ obj #-> fixnum или nilСопоставление с шаблоном — если obj является правилом, то он используется как шаблон для сопоставления с str и возвращает позицию с которой найдено соспоставление или nil, если такого сопоставления найти не удалось. Иначе, происходит вызов метода obj.=~, которому передается str как аргумент. По умолчанию, метод =~ в классе Object возвращает false.
"cat o' 9 tails" =~ /\d/ #-> 7
"cat o' 9 tails" =~ 9 #-> false|
|
Полезно посмотреть на метод match, который имеет схожую функциональность |
String#[]
правитьstr[index] #-> символ или nil
str[start, length] #-> new_str или nil
str[range] #-> new_str или nil
str[regexp] #-> new_str или nil
str[regexp, index] #-> new_str или nil
str[other_str] #-> new_str или nil
str.slice(index) #-> fixnum или nil
str.slice(start, length) #-> new_str или nil
str.slice(range) #-> new_str или nil
str.slice(regexp) #-> new_str или nil
str.slice(regexp, index) #-> new_str или nil
str.slice(other_str) #-> new_str или nilПолучение подстроки или символа — возвращает код символа с индексом index, или подстроку длины length, начиная с индекса start, или подстроку, которая располагается в диапазоне range. Во всех этих вариантах вызова отрицательная индексация подразумевает отсчет с конца строки str. Возвращается nil, если индекс index выходит за пределы допустимого диапазона, размер length запрашиваемой подстроки отрицательный или начало диапазона range попадает после конца строки str. Если передается правило regexp, то возвращается фрагмент строки str, который удовлетворяет правилу regexp (или nil, если такого совпадения найти не удалось). Если задан дополнительный параметр index, то возвращается содержимое группировки правила с номером index (если index равен 0, то возвращается фрагмент строки, который удовлетворяет правилу regexp). Если в качестве аргумента передается строка other_str, то возвращается строка other_str, если она является подстрокой строки str (или nil, иначе).
a = "hello there"
a[1] #-> "e"
a[1,3] #-> "ell"
a[1..3] #-> "ell"
a[-3,2] #-> "er"
a[-4..-2] #-> "her"
a[12..-1] #-> nil
a[-2..-4] #-> ""
a[/[aeiou](.)\1/] #-> "ell"
a[/[aeiou](.)\1/, 0] #-> "ell"
a[/[aeiou](.)\1/, 1] #-> "l"
a[/[aeiou](.)\1/, 2] #-> nil
a["lo"] #-> "lo"
a["bye"] #-> nil|
|
String#[]=
правитьstr[index] = fixnum
str[index] = new_str
str[start, length] = new_str
str[range] = new_str
str[regexp] = new_str
str[regexp, index] = new_str
str[other_str] = new_strПрисваивание значения элементу — заменяет часть или все содержимое строки str. Внутри квадратных скобок используются те же самые параметры, что и в [] («батарейка»). Если заменяемая строка не совпадает по размеру с заменяющей, то происходит соответствующая адаптация. Если правило или строка или индекс не позволяют определить позицию для замены, то возникает ошибка IndexError. Если используется форма вызова с regexp и index, то происходит замена подстроки, которая совпадает группировкой в regexp с номером index. Формы вызова, которым передается index или start могут вызвать ошибку IndexError, если их значение выходит за пределы индексации строки; форма вызова с range может вызвать ошибку RangeError, а форма вызова с regexp или other_str тихо реагируют на возможные ошибки (отсутствие совпадение с правилом или строкой).
String#ascii_only?
правитьstr.ascii_only? #-> true или falseВозвращает true для строки, которая содержит только ASCII символы. В противном случае возвращает false.
"abc".force_encoding("UTF-8").ascii_only? #=> true
"abc\u{6666}".force_encoding("UTF-8").ascii_only? #=> falseString#bytesize
правитьbytesize #-> integerВозвращает количество байтов в себе:
"\x80\u3042".bytesize #=> 4
"hello".bytesize #=> 5|
|
Полезно посмотреть на методы length и size, которые имеют схожую функциональность |
String#byteslice
правитьbyteslice(integer) #-> new_str или nil
byteslice(integer, integer) #-> new_str или nil
byteslice(range) #-> new_str или nilБайтовая ссылка - если передано одно целое число, возвращает подстроку из одного байта в этой позиции. Если переданы два объекта Integer, возвращает подстроку, начиная со смещения, заданного первым, и длину, заданную вторым. Если задан диапазон, возвращается подстрока, содержащая байты со смещениями, заданными диапазоном. Во всех трех случаях, если смещение отрицательное, оно отсчитывается от конца str. Возвращает nil, если начальное смещение выходит за пределы строки, длина отрицательна или начало диапазона больше конца. Кодировка полученной строки сохраняет исходную кодировку.
"hello".byteslice(1) #=> "e"
"hello".byteslice(-1) #=> "o"
"hello".byteslice(1, 2) #=> "el"
"\x80\u3042".byteslice(1, 3) #=> "\u3042"
"\x03\u3042\xff".byteslice(1..3) #=> "\u3042"String#capitalize
правитьstr.capitalize #-> new_strВозвращает копию строки str в которой первый символ преобразуется в верхний регистр, а остальные — в нижний.
"hello".capitalize #-> "Hello"
"HELLO".capitalize #-> "Hello"
"123ABC".capitalize #-> "123abc"|
|
Полезно посмотреть на методы upcase, downcase и swapcase, которые имеют схожую функциональность |
| |
Внимание! У всех символов, кроме латиницы, на эти изменения устойчивый иммунитет. Это не значит, что будет возникать ошибка. Просто, они не будут преобразованы по вышеописанному правилу |
String#capitalize!
правитьstr.capitalize! #-> str или nilМодифицирует строку str по правилу: первый символ преобразуется в верхний регистр, а остальные — в нижний. Возвращает nil, если изменения не требуются.
a = "hello"
a.capitalize! #-> "Hello"
a #-> "Hello"
a.capitalize! #-> nil|
|
Полезно посмотреть на методы upcase!, downcase! и swapcase!, которые имеют схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод capitalize, который не имеет данного побочного эффекта |
| |
Внимание! У всех символов, кроме латиницы на эти изменения устойчивый иммунитет. Это не значит, что будет возникать ошибка. Просто, они не будут преобразованы по вышеописанному правилу |
String#casecmp
правитьstr.casecmp(other_str) #-> -1, 0, +1Регистронезависимая версия метода <=>.
"abcdef".casecmp("abcde") #-> 1
"aBcDeF".casecmp("abcdef") #-> 0
"abcdef".casecmp("abcdefg") #-> -1
"abcdef".casecmp("ABCDEF") #-> 0String#center
правитьstr.center(integer, padstr) #-> new_strЕсли integer больше, чем str.length, то возвращает новую строку, длина которой равна integer, строка str располагается посередине, обитая символами строки padstr; иначе, возвращает str.
"hello".center(4) #-> "hello"
"hello".center(20) #-> " hello "
"hello".center(20, '123') #-> "1231231hello12312312"|
|
Полезно посмотреть на методы ljust и rjust, которые имеют схожую функциональность |
String#chars
правитьstr.chars #-> arrayВозвращает массив, содержащий символы строки, из которой вызывается метод.
"hello".chars #-> ["h", "e", "l", "l", "o"]String#chomp
правитьstr.chomp(separator=$/) #-> new_strВозвращает новую строку, которая является копией строки str в которой удален последний символ separator. Если системная переменная $/ не была изменена и не передается параметр separator, то метод chomp удалит завершающие символы строки (такие как \n, \r и \r\n).
"hello".chomp #-> "hello"
"hello\n".chomp #-> "hello"
"hello\r\n".chomp #-> "hello"
"hello\n\r".chomp #-> "hello\n"
"hello\r".chomp #-> "hello"
"hello \n there".chomp #-> "hello \n there"
"hello".chomp("llo") #-> "he"|
|
Полезно посмотреть на метод chop, который имеет схожую функциональность |
String#chomp!
правитьstr.chomp!(separator=$/) #-> str или nilМодифицирует строку str по алгоритму, описанному в методе chomp. Возвращает обработанную строку str или nil, если изменения не требуются.
"hello".chomp! #-> nil
"hello\n".chomp! #-> "hello"
"hello".chomp!("llo") #-> "he"|
|
Полезно посмотреть на метод chop!, который имеет схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод chomp, который не имеет данного побочного эффекта |
String#chop
правитьstr.chop #-> new_strВозвращает копию строки str из которой удален последний символ. Если строка заканчивается комбинацией символов \r\n, то будет удалена вся комбинация. Вызов метода chop от пустой строки возвращает пустую строку.
"string\r\n".chop #-> "string"
"string\n\r".chop #-> "string\n"
"".chop #-> ""
"string".chop #-> "strin"
"x".chop.chop #-> ""|
|
В качестве альтернативы методу chop лучше использовать метод chomp, который удаляет только символы перевода строки, а не просто последний символ. Это позволит избежать многих трудновыявляемых ошибок в будущем |
String#chop!
правитьstr.chop! #-> new_str или nilМодифицирует строку str по алгоритму, описанному в методе chop. Возвращает обработанную строку str или nil, если изменения не требуются (например, если метод chop! был вызван от пустой строки).
"string\r\n".chop! #-> "string"
"string\n\r".chop! #-> "string\n"
"".chop! #-> nil
"string".chop! #-> "strin"
"x".chop.chop! #-> ""|
|
В качестве альтернативы методу chop! лучше использовать метод chomp!, который удаляет только символы перевода строки, а не просто последний символ. Это позволит избежать многих трудновыявляемых ошибок в будущем |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод chop, который не имеет данного побочного эффекта |
String#chr
правитьstr.chr #-> stringВозвращает односимвольную строку с начала строки.
str = "abcde"
str.chr #-> "a"
str = "bcde"
str.chr #-> "b"String#clear
правитьstr.clear #-> empty stringДелает строку, из которой вызывается, пустой.
str = "abcde"
str.clear #-> ""String#concat
правитьstr << fixnum #-> str
str.concat(fixnum) #-> str
str << obj #-> str
str.concat(obj) #-> strДобавление — присоединяет аргумент к str. Если аргумент типа Fixnum в диапазоне от 0 до 255, то он перед присоединением конвертируется в символ.
a = "hello ";
a.concat("world") #-> "hello world"
a.concat(33) #-> "hello world!"|
|
Методы << и concat — абсолютно идентичны, то есть являются именами одного и того же метода |
String#count
правитьstr.count(other_str*) #-> fixnumКаждый параметр other_str преобразуется в множество символов. Метод подсчитывает количество символов str, которые принадлежат этому множеству. При помощи символа "галочка" (^) задаются исключения из множества. Выражения типа c1-c2 задают множество символов, которые располагаются между символами c1 и c2.
a = "hello world"
a.count "lo" #-> 5
a.count "lo", "o" #-> 2
a.count "hello", "^l" #-> 4
a.count "ej-m" #-> 4String#crypt
правитьstr.crypt(salt_str) #-> new_strПрименяет однопроходное криптографическое хеширование к строке str посредством функции crypt из стандартной библиотеки языка Си. Аргументом метода является строка salt_str, которая содержит "шумовые" символы. Она должна быть длиннее двух символов, каждый из которых должен принадлежать множеству [a-zA-Z0-9./].
String#delete
правитьstr.delete(other_str*) #-> new_strВозвращает копию строки str, в которой удалены все символы, передаваемые параметром.
"hello".delete "l","lo" #-> "heo"
"hello".delete "lo" #-> "he"
"hello".delete "aeiou", "^e" #-> "hell"
"hello".delete "ej-m" #-> "ho"|
|
Использует те же самые правила создания множеств символов, что и в методе count |
String#delete!
правитьstr.delete!(other_str*) #-> str или nilУдаляет из строки str все символы, передаваемые параметром. Возвращает модифицированную строку str или nil, если строка str не была модифицирована.
str="hello"
str.delete! "l","lo" #-> "heo"
str #-> "heo"
str.delete! "l","lo" #-> nil|
|
Использует те же самые правила создания множеств символов, что и в методе count |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод delete, который не имеет данного побочного эффекта |
String#delete_prefix
правитьstr.delete_prefix(prefix) #-> new_strВозвращает копию str с удаленным начальным префиксом.
str="hello"
str.delete_prefix("hel") #-> "lo"
str #-> "hello"
str.delete_prefix("llo") #-> "hello"
str #-> "hello"String#delete_prefix!
правитьstr.delete_prefix!(prefix) #-> self или nilУдаляет начальный префикс из строки, возвращая nil, если не было сделано никаких изменений.
str="hello"
str.delete_prefix!("hel") #-> "lo"
str #-> "lo"
str.delete_prefix!("llo") #-> nil
str #-> "hello"|
|
Полезно посмотреть на метод delete_prefix, который имеет схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод delete_prefix, который не имеет данного побочного эффекта |
String#delete_suffix
правитьstr.delete_suffix(suffix) #-> new_strВозвращает копию str с удаленным конечным суффиксом.
"hello".delete_suffix("llo") #=> "he"
"hello".delete_suffix("hel") #=> "hello"String#delete_suffix!
правитьstr.delete_suffix!(suffix) #-> self или nilУдаляет завершающий суффикс из строки, возвращая nil, если не было сделано никаких изменений.
"hello".delete_suffix!("llo") #=> "he"
"hello".delete_suffix!("hel") #=> nil|
|
Полезно посмотреть на метод delete_suffix, который имеет схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод delete_suffix, который не имеет данного побочного эффекта |
String#downcase
правитьstr.downcase #-> new_strВозвращает копию строки str в которой все символы вернего регистра заменены на соответствующие символы нижнего.
"hEllO".downcase #-> "hello"|
|
Полезно посмотреть на методы capitalize, upcase и swapcase, которые имеют схожую функциональность |
| |
Внимание! У всех символов, кроме латиницы на эти изменения устойчивый иммунитет. Это не значит, что произойдет ошибка. Просто, они не будут преобразованы по вышеописанному правилу |
String#downcase!
правитьstr.downcase! #-> str или nilМодифицирует строку str по правилу: все символы верхнего регистра преобразовываются в соответствующие символы нижнего. Возвращает nil, если изменения не требуются.
str="hEllO"
str.downcase! #-> "hello"
str #-> "hello"
str.downcase! #-> nil|
|
Полезно посмотреть методы capitalize!, upcase! и swapcase!, которые также производят преобразования регистра |
| |
Внимание!
|
String#dump
правитьstr.dump #-> new_strСоздает версию строки str в которой все непечатные символы заменены на \nnn нотацию и все специальные символы экранированы.
"Hello world!\n".dump #-> "\"Hello world!\\n\""String#each
правитьstr.each(separator=$/) {|substr| block } #-> str
str.each_line(separator=$/) {|substr| block } #-> strРазбивает строку str используя значение параметра separator (по умолчанию separator=$/), передавая каждую из полученных подстрок в качестве параметра блока. Если в качестве параметра separator передается пустая строка, то строка будет делится по символу \n, исключая случай, когда несколько символов \n идут подряд (все символы \n будут засчитываться как один).
print "Example one\n"
"hello\nworld".each {|s| p s}
print "Example two\n"
"hello\nworld".each('l') {|s| p s}
print "Example three\n"
"hello\n\n\nworld".each('') {|s| p s}результат:
Example one "hello\n" "world" Example two "hel" "l" "o\nworl" "d" Example three "hello\n\n\n" "world"
|
|
String#each_byte
правитьstr.each_byte {|fixnum| block } #-> strПередает каждый байт строки str в блок.
"hello".each_byte {|c| print c, ' ' }результат:
104 101 108 108 111
|
|
В качестве результата итератор возвращает исходную строку str |
String#each_char
правитьstr.each_char {|char| block } #-> strПередает каждый символ строки str в блок.
"hello".each_char {|c| print c, ' ' }результат:
h e l l o
|
|
В качестве результата итератор возвращает исходную строку str |
String#each_line
правитьstr.each(separator=$/) {|substr| block } #-> str
str.each_line(separator=$/) {|substr| block } #-> strРазбивает строку str используя значение параметра separator (по умолчанию separator=$/), передавая каждую из полученных подстрок в качестве параметра блока. Если в качестве параметра separator передается пустая строка, то строка будет делится по символу \n, исключая случай, когда несколько символов \n идут подряд (все символы \n будут засчитываться как один).
print "Example one\n"
"hello\nworld".each_line{|s| p s}
print "Example two\n"
"hello\nworld".each_line('l'){|s| p s}
print "Example three\n"
"hello\n\n\nworld".each_line(''){|s| p s}результат:
Example one "hello\n" "world" Example two "hel" "l" "o\nworl" "d" Example three "hello\n\n\n" "world"
|
|
String#empty?
правитьstr.empty? #-> true или falseВозвращает true если строка str имеет нулевую длину (то есть, если строка str — пустая).
"hello".empty? #-> false
"".empty? #-> trueString#end_with?
правитьstr.end_with?([suffixes]+) #-> true или falseВозвращает true, если строка заканчивается одним из указанных суффиксов.
"hello".end_with?("ello") #-> trueВозвращает true, если один из суффиксов совпадает.
"hello".end_with?("heaven", "ello") #=> true
"hello".end_with?("heaven", "paradise") #=> falseString#eql?
правитьstr.eql?(other_str) #-> true или falseДве строки называются эквивалентными, если они имеют одинаковое содержимое и длину.
String#gsub
правитьstr.gsub(pattern, replacement) #-> new_str
str.gsub(pattern) {|match| block } #-> new_strВозвращает копию строки str, где все совпадения с шаблоном (или строкой) pattern заменены на строку replacement или результат выполнения блока (которому параметром передается результат совпадения).
В результате работы метода, найденное совпадение с шаблоном pattern записывается в специальную переменную $& (наследие языка Perl). В строке replacement возможно использование последовательностей вида \1, \2 и так далее до \9, которые являются ссылками на совпадения с группировками (номер группировки считается слева направо). Внутри блока на группировки можно ссылаться при помощи специальных переменных вида $1, $2 и так далее до $9. Также, выражению в блоке доступны специальные переменные $`, $& и $', которые позволяют получить доступ к подстроке до совпадения, совпадению и подстроке после совпадения, соответственно.
"hello".gsub(/[aeiou]/, '*') #-> "h*ll*"
"hello".gsub(/([aeiou])/, '<\1>') #-> "h<e>ll<o>"
"hello".gsub(/./) {|s| s[0].to_s + ' '} #-> "104 101 108 108 111 "|
|
Полезно посмотреть на метод sub, который имеет схожую функциональность |
String#gsub!
правитьstr.gsub!(pattern, replacement) #-> str или nil
str.gsub!(pattern) {|match| block } #-> str или nilВыполняет замены подобно gsub, но изменяет исходную строку str. Возвращает результат замен или nil, если замены невозможны.
|
|
Полезно посмотреть на метод sub!, который имеет схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод gsub, который не имеет данного побочного эффекта |
String#hash
правитьstr.hash #-> fixnumВычисляет хеш-код для строки str. Две строки с одним и тем же содержимым будут иметь одинаковый хеш-код (именно его использует метод eql?).
"rubynovich".hash #-> 958124529String#hex
правитьstr.hex #-> integerТрактует строку str как строку шестнадцатиричных цифр (с необязательным указанием знака или необятельным префиксом 0x) и возвращает cоотвествующее число. Если преобразование не удается, то возвращает ноль.
"0x0a".hex #-> 10
"-1234".hex #-> -4660
"0".hex #-> 0
"wombat".hex #-> 0|
|
String#include?
правитьstr.include? other_str #-> true или false
str.include? fixnum #-> true или falseВозвращает true, если строка str содержит передаваемые параметром строку other_str или символ fixnum.
"hello".include? "lo" #-> true
"hello".include? "ol" #-> false
"hello".include? ?h #-> trueString#index
правитьstr.index(substring [, offset]) #-> fixnum или nil
str.index(fixnum [, offset]) #-> fixnum или nil
str.index(regexp [, offset]) #-> fixnum или nilВозвращает индекс первого вхождения передаваемой параметром подстроки (substring), символа (fixnum) или совпадения с правилом (regexp) в строке str. Возвращает nil, если вхождения нет. В качестве второго параметра передается индекс (offset), с которого следует начинать поиск вхождений.
"hello".index('e') #-> 1
"hello".index('lo') #-> 3
"hello".index('a') #-> nil
"hello".index(10) #-> 1
"hello".index(/[aeiou]/, -3) #-> 4|
|
Полезно также взглянуть на метод rindex, который имеет подобный функционал |
String#insert
правитьstr.insert(index, other_str) #-> strВставляет строку other_str после указанного индекса index в строку str. Отрицательная индексация подразумевает нумерацию с конца строки.
"abcd".insert(0, 'X') #-> "Xabcd"
"abcd".insert(3, 'X') #-> "abcXd"
"abcd".insert(4, 'X') #-> "abcdX"
"abcd".insert(-3, 'X') #-> "abXcd"
"abcd".insert(-1, 'X') #-> "abcdX"String#inspect
правитьstr.inspect #-> stringВозвращает печатную версию строки str, в которой все специальные символы экранированы.
str = "hello"
str[3] = 8
str.inspect #-> "hel\010o"String#intern
правитьstr.intern #-> symbol
str.to_sym #-> symbolВозвращает объект класса Symbol, который соответствует строке str.
"Koala".intern #-> :Koala
s = 'cat'.intern #-> :cat
s == :cat #-> true
s = '@cat'.intern #-> :@cat
s == :@cat #-> trueЭтот метод может быть использован для создания символов, которые не могут быть созданы в :xxx нотации.
'cat and dog'.intern #-> :"cat and dog"|
|
|
String#length
правитьstr.length #-> integer
str.size #-> integerВозвращает размер строки str.
string = "54321"
string.length #-> 5|
|
Методы size и length — абсолютно идентичны, то есть являются именами одного и того же метода |
String#ljust
правитьstr.ljust(integer, padstr=' ') #-> new_strЕсли параметр integer больше, чем длина строки str, то возвращается новая строка длины integer со строкой str, которая выравнена по левому краю, а возникшее пустое место заполняется символами padstr; иначе, возвращается строка str.
"hello".ljust(4) #-> "hello"
"hello".ljust(20) #-> "hello "
"hello".ljust(20, '1234') #-> "hello123412341234123"|
|
Полезно посмотреть на методы rjust и center, которые имеют схожую функциональность |
String#lstrip
правитьstr.lstrip #-> new_strВозвращает копию строки str, в которой удалены все ведущие пробельные символы.
" hello ".lstrip #-> "hello "
"hello".lstrip #-> "hello"|
|
Полезно посмотреть на методы rstrip и strip, которые имеют схожую функциональность |
String#lstrip!
правитьstr.lstrip! #-> self или nilУдаляет ведущие пробелы из строки str. Возвращает nil, если в результате работы метода строка str осталась неизменной.
" hello ".lstrip #-> "hello "
"hello".lstrip! #-> nil|
|
Полезно посмотреть на методы rstrip! и strip!, которые имеют схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод lstrip, который не имеет данного побочного эффекта |
String#match
правитьstr.match(pattern) #-> matchdata или nilПреобразует параметр pattern в правило (если он таковым не был) и осуществляет сопоставление этого правила со строкой str.
'hello'.match('(.)\1') #-> #<MatchData:0x401b3d30>
'hello'.match('(.)\1')[0] #-> "ll"
'hello'.match(/(.)\1/)[0] #-> "ll"
'hello'.match('xx') #-> nil|
|
Данный метод практически не используется разработчиками. Вместо него рекомендуется использовать метод [] («батарейка»), который обладает схожим, но более развернутым функционалом |
String#next
правитьstr.succ #-> new_str
str.next #-> new_strРассматривает строку str как элемент символьной последовательности и возвращает следующий за строкой str элемент. Следующий элемент вычисляется увеличением кода крайнего правого элемента строки str на единицу. В результате увеличения символа, который является цифрой — получится цифра, а для символа, который является буквой — буква. Увеличение остальных символов происходит с использованием базовой символьной упорядоченной последовательности.
Если в результате увеличения возникает необходимость «переноса», символ левее увеличиваемого в данный момент — тоже увеличивается. Этот процесс повторяется для всех требуемых «переносов». Если необходимо, то к строке str будет добавлен дополнительный символ.
"abcd".next #-> "abce"
"THX1138".next #-> "THX1139"
"<<koala>>".next #-> "<<koalb>>"
"1999zzz".next #-> "2000aaa"
"ZZZ9999".next #-> "AAAA0000"
"***".next #-> "**+"
"zzz".next #-> "aaaa"|
|
Методы next и succ — абсолютно идентичны, то есть являются именами одного и того же метода |
String#next!
правитьstr.succ! #-> str
str.next! #-> strЭквивалентен методу next, но меняет строку str на результат своей работы.
|
|
Методы next! и succ! — абсолютно идентичны, то есть являются именами одного и того же метода |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод next, который не имеет данного побочного эффекта |
String#oct
правитьstr.oct #-> integerТрактует строку str как строку восьмеричных цифр (с необязательным указанием знака или необятельным префиксом 0) и возвращает cоотвествующее число. Если преобразование не удается, то возвращает ноль.
"123".oct #-> 83
"-377".oct #-> -255
"bad".oct #-> 0
"0377bad".oct #-> 255|
|
String#ord
правитьstr.ord #-> integerВозвращает целочисленный порядковый номер строки из одного символа.
"a".ord #-> 97
"A".ord #-> 65
"z".ord #-> 90
"Z".ord #-> 122|
|
Обратите внимание, что метод правильно работает при возврате порядкового номера при исползовании метода swapcase |
String#partition
правитьstr.partition(sep) #-> [head, sep, tail]
str.partition(regexp) #-> [head, match, tail]Ищет sep или шаблон (regexp) в строке и возвращает часть перед ним, совпадение и часть после него. Если он не найден, возвращает две пустые строки и строку.
"hello".partition("l") #=> ["he", "l", "lo"]
"hello".partition("x") #=> ["hello", "", ""]
"hello".partition(/.l/) #=> ["h", "el", "lo"]String#replace
правитьstr.replace #-> strЗаменяет содержимое str соответствующими значениями из other_str.
s = "krishna" #-> "krishna"
s.replace "rama" #-> "rama"String#reverse
правитьstr.reverse #-> new_strВозвращает новую строку, в которой символы строки str переставлены в обратном порядке.
"stressed".reverse #-> "desserts"String#reverse!
правитьstr.reverse! #-> strИзменяет порядок символов строки str на обратный.
str="stressed"
str.reverse! #-> "desserts"
str #-> "desserts"|
|
Обратите внимание, что ни при каких обстоятельствах метод reverse! не возвращает nil |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод reverse, который не имеет данного побочного эффекта |
String#rindex
правитьstr.rindex(substring [, fixnum]) #-> fixnum или nil
str.rindex(fixnum [, fixnum]) #-> fixnum или nil
str.rindex(regexp [, fixnum]) #-> fixnum или nilВозвращает индекс последнего вхождения передаваемой параметром подстроки (substring), символа (fixnum) или совпадения с правилом (regexp) в строке str. Возвращает nil, если вхождения нет. В качестве второго параметра передается индекс (fixnum), на котором следует закончить поиск.
"hello".rindex('e') #-> 1
"hello".rindex('l') #-> 3
"hello".rindex('a') #-> nil
"hello".rindex(101) #-> 1
"hello".rindex(/[aeiou]/, -2) #-> 1|
|
Полезно посмотреть на метод index, который имеет схожую функциональность |
String#rjust
правитьstr.rjust(integer, padstr=' ') #-> new_strЕсли параметр integer больше, чем длина строки str, то метод возвращает новую строку длины integer со строкой str выравненной по правому краю, а возникшее пустое место заполняется символами padstr; иначе, возвращается строка str.
"hello".rjust(4) #-> "hello"
"hello".rjust(20) #-> " hello"
"hello".rjust(20, '1234') #-> "123412341234123hello"|
|
Полезно посмотреть на методы ljust и center, которые имеют схожую функциональность |
String#rstrip
правитьstr.rstrip #-> new_strВозвращает копию строки str, в которой удалены все замыкающие пробельные символы.
" hello ".rstrip #-> " hello"
"hello".rstrip #-> "hello"|
|
Следует обратить внимание на методы lstrip и strip, которые имеют схожую функциональность |
String#rstrip!
правитьstr.rstrip! #-> self или nilУдаляет замыкающие пробельные символы из строки str. Возвращает nil, если в результате работы метода никаких изменений сделано не было.
" hello ".rstrip #-> " hello"
"hello".rstrip! #-> nil|
|
Полезно посмотреть описание методов lstrip! и strip!, которые имеют схожую функциональность |
String#scan
правитьstr.scan(pattern) #-> array
str.scan(pattern) {|match, ...| block } #-> strОбе формы вызова последовательно просматривают str на предмет совпадения с шаблоном (который может быть как строкой, так и правилом. Каждое совпадение записывается в массив (для первой формы вызова) или передается в блок (для второй формы вызова). Если шаблон (который является правилом) не содержит группировок, то каждое совпадение записывается в отдельный элемент (для первой формы вызова) или передается параметром блоку (для второй формы вызова). Также возможно использование специальной переменной $&, которая содержит результат последнего совпадения (актуально при использовании второй формы вызова). Если шаблон содержит группировки, то каждое совпадение разбивается на совпадения группировкам (получается двумерный массив).
a = "cruel world"
a.scan(/\w+/) #-> ["cruel", "world"]
a.scan(/.../) #-> ["cru", "el ", "wor"]
a.scan(/(...)/) #-> [["cru"], ["el "], ["wor"]]
a.scan(/(..)(..)/) #-> [["cr", "ue"], ["l ", "wo"]]…и для второй формы вызова:
a.scan(/\w+/) {|w| print "<<#{w}>> " }
print "\n"
a.scan(/(.)(.)/) {|a,b| print b, a }
print "\n"результат:
<<cruel>> <<world>> rceu lowlr
|
|
Полезно посмотреть на метод split, который имеет схожую функциональность |
String#setbyte
правитьstr.setbyte(index, integer) # => integerЗаменяет содержимое str соответствующими значениями из other_str.
s = "Sunday"
s.setbyte(0, 77)
s.setbyte(-5, 111)
s # => "Monday"String#size
правитьstr.length #-> integer
str.size #-> integerВозвращает размер строки str.
string = "54321"
string.size #-> 5|
|
Методы size и length — абсолютно идентичны, то есть являются именами одного и того же метода |
String#slice
правитьstr[index] #-> fixnum или nil
str[start, length] #-> new_str или nil
str[range] #-> new_str или nil
str[regexp] #-> new_str или nil
str[regexp, index] #-> new_str или nil
str[other_str] #-> new_str или nil
str.slice(index) #-> fixnum или nil
str.slice(start, length) #-> new_str или nil
str.slice(range) #-> new_str или nil
str.slice(regexp) #-> new_str или nil
str.slice(regexp, index) #-> new_str или nil
str.slice(other_str) #-> new_str или nilПолучение подстроки или символа — возвращает код символа с индексом index, или подстроку длины length, начиная с индекса start, или подстроку, которая располагается в диапазоне range. Во всех этих вариантах вызова отрицательная индексация подразумевает отсчет с конца строки str. Возвращается nil, если индекс index выходит за пределы допустимого диапазона, размер length запрашиваемой подстроки отрицательный или начало диапазона range попадает после конца строки str. Если передается правило regexp, то возвращается фрагмент строки str, который удовлетворяет правилу regexp (или nil, если такого совпадения найти не удалось). Если задан дополнительный параметр index, то возвращается содержимое группировки правила с номером index (если index равен 0, то возвращается фрагмент строки, который удовлетворяет правилу regexp). Если в качестве аргумента передается строка other_str, то возвращается строка other_str, если она является подстрокой строки str (или nil, иначе).
a = "hello there"
a.slice(1) #-> "e"
a.slice(1,3) #-> "ell"
a.slice(1..3) #-> "ell"
a.slice(-3,2) #-> "er"
a.slice(-4..-2) #-> "her"
a.slice(12..-1) #-> nil
a.slice(-2..-4) #-> ""
a.slice(/[aeiou](.)\1/) #-> "ell"
a.slice(/[aeiou](.)\1/, 0) #-> "ell"
a.slice(/[aeiou](.)\1/, 1) #-> "l"
a.slice(/[aeiou](.)\1/, 2) #-> nil
a.slice("lo") #-> "lo"
a.slice("bye") #-> nil|
|
String#slice!
правитьstr.slice!(fixnum) #-> fixnum или nil
str.slice!(fixnum, fixnum) #-> new_str или nil
str.slice!(range) #-> new_str или nil
str.slice!(regexp) #-> new_str или nil
str.slice!(other_str) #-> new_str или nilУдаляет определенный кусок текста из строки str и возвращает этот кусок в качестве результата. Если в качестве параметра передается число (Fixnum), то возможно возникновение ошибки типа IndexError, когда значение этого числа находится вне допустимого диапазона. Если в качестве параметра передается диапазон (Range), то возможно возникновение ошибки типа RangeError, когда диапазон выходит за рамки допустимых значений. В случае с параметрами типа Regexp и String метод молча реагирует на недопустимые значения.
string = "this is a string"
string.slice!(2) #-> "i"
string.slice!(3..6) #-> " is "
string.slice!(/s.*t/) #-> "sa st"
string.slice!("r") #-> "r"
string #-> "thing"| |
Внимание! Данный метод изменяет исходную строку. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод slice или [] («батарейка») |
|
|
Полезно посмотреть на методы slice и [] («батарейка»), которые имеют подобную функциональность |
String#split
правитьstr.split(pattern=$;, [limit]) #-> anArrayДелит строку str на подстроки по разделителю pattern (который может быть как правилом, так и строкой). Если разделитель pattern не указан, то деление происходит по пробельному символу (если иное не присвоено специальной переменной $;). В результате деления возвращается массив, который содержит фрагменты строки str (сам разделитель в результат не входит).
Если разделитель pattern является правилом, то деление производится по подстрокам, подходящим под данное правило. Если pattern — строка, то деление производится по подстрокам, которые совпадают с разделителем.
Если задан необязательный параметр limit, то результирующий массив будет иметь количество фрагментов строки str равное limit. Последний элемент будет содержать остаток, который, возможно, еще можно поделить (то есть в строке есть еще разделители).
" now's the time".split #-> ["now's", "the", "time"]
" now's the time".split(' ') #-> ["now's", "the", "time"]
" now's the time".split(/ /) #-> ["", "now's", "", "the", "time"]
"1, 2.34,56, 7".split(%r{,\s*}) #-> ["1", "2.34", "56", "7"]
"hello".split(//) #-> ["h", "e", "l", "l", "o"]
"hello".split(//, 3) #-> ["h", "e", "llo"]
"hi mom".split(%r{\s*}) #-> ["h", "i", "m", "o", "m"]
"mellow yellow".split("ello") #-> ["m", "w y", "w"]
"1,2,,3,4,,".split(',') #-> ["1", "2", "", "3", "4"]
"1,2,,3,4,,".split(',', 4) #-> ["1", "2", "", "3,4,,"]
"1,2,,3,4,,".split(',', -4) #-> ["1", "2", "", "3", "4", "", ""]
"1:2:3".split(/(:)()()/, 2) #=> ["1", ":", "", "", "2:3"]
"".split(',', -1) #=> []|
|
Полезно посмотреть на методы scan и chars, которые имеют схожую функциональность |
String#squeeze
правитьstr.squeeze(del=nil) #-> new_strСоздает множество символов из строки (или строк) del, переданных в качестве параметра. Возвращает новую строку, где идущие подряд одинаковые символы, которые принадлежат множеству (переданному в качестве параметра), заменяются на один такой символ. Если метод вызван без параметра, то все идущие подряд повторяющиеся символы будут заменены на соответствующий единичный.
"yellow moon".squeeze #-> "yelow mon"
" now is the".squeeze(" ") #-> " now is the"
"putters shoot balls".squeeze("m-z") #-> "puters shot balls"|
|
Использует те же самые правила создания множеств символов, что и в методе count |
String#squeeze!
правитьstr.squeeze!(del=nil) #-> new_strРаботает точно также, как и метод squeeze, но результат своей работы записывает в исходную строку.
str = "yellow moon"
str.squeeze! #-> "yelow mon"
str #-> "yelow mon| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод squeeze, который не имеет данного побочного эффекта |
String#start_with?
правитьstr.start_with?([prefixes]+) #-> true или falseВозвращает true, если str начинается с одного из заданных префиксов. Каждый из префиксов должен быть строкой или шаблоном (рegexp).
"hello".start_with?("hell") #=> true
"hello".start_with?(/H/i) #=> trueВозвращает истину, если один из префиксов совпадает.
"hello".start_with?("heaven", "hell") #=> true
"hello".start_with?("heaven", "paradise") #=> falseString#strip
правитьstr.strip #-> new_strВозвращает копию строки str в которой удалены ведущие и замыкающие пробельные символы.
" hello ".strip #-> "hello"
"\tgoodbye\r\n".strip #-> "goodbye"|
|
Полезно посмотреть на методы lstrip и rstrip, которые имеют схожую функциональность |
String#strip!
правитьstr.strip! #-> str или nilУдаляет ведущие и замыкающие пробельные символы из строки str. Возвращает nil, если строка str таковых не содержит.
str = " hello "
str.strip! #-> "hello"
str #-> "hello"
"goodbye".strip #-> nil|
|
Полезно посмотреть на методы lstrip! и rstrip!, которые имеют схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод strip, который не имеет данного побочного эффекта |
String#sub
правитьstr.sub(pattern, replacement) #-> new_str
str.sub(pattern) {|match| block } #-> new_strВозвращает копию строки str, где первое совпадение с шаблоном (или строкой) pattern заменено на строку replacement или результат выполнения блока (которому передается параметром результат совпадения).
В результате работы метода, найденное совпадение с шаблоном pattern записывается в специальную переменную $& (наследие языка Perl). В строке replacement возможно использование последовательностей вида \1, \2 и так далее до \9, которые являются ссылками на совпадения с группировками (номер группировки считается слева направо). Внутри блока на группировки можно ссылаться при помощи специальных переменных вида $1, $2 и так далее до $9. Также, выражению в блоке доступны специальные переменные $`, $& и $', которые позволяют получить доступ к подстроке до совпадения, совпадению и подстроке после совпадения, соответственно.
"hello".sub(/[aeiou]/, '*') #-> "h*llo"
"hello".sub(/([aeiou])/, '<\1>') #-> "h<e>llo"
"hello".sub(/./) {|s| s[0].to_s + ' ' } #-> "104 ello"|
|
Полезно посмотреть на метод gsub, который имеет схожую функциональность |
String#sub!
правитьstr.sub!(pattern, replacement) #-> str или nil
str.sub!(pattern) {|match| block } #-> str или nilВыполняет замену подобно sub, но изменяет исходную строку str. Возвращает результат замены или nil, если замена невозможна.
|
|
Полезно посмотреть на метод gsub!, который имеет схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод sub, который не имеет данного побочного эффекта |
String#succ
правитьstr.succ #-> new_str
str.next #-> new_strРассматривает строку str как элемент символьной последовательности и возвращает следующий за строкой str элемент. Следующий элемент вычисляется увеличением кода крайнего правого элемента строки str на единицу. В результате увеличения символа, который является цифрой — получится цифра, а для символа, который является буквой — буква. Увеличение остальных символов происходит с использованием базовой символьной упорядоченной последовательности. Если в результате увеличения возникает необходимость «переноса», символ левее увеличиваемого в данный момент — тоже увеличивается. Этот процесс повторяется для всех требуемых «переносов». Если необходимо, то к строке str будет добавлен дополнительный символ.
"abcd".succ #-> "abce"
"THX1138".succ #-> "THX1139"
"<<koala>>".succ #-> "<<koalb>>"
"1999zzz".succ #-> "2000aaa"
"ZZZ9999".succ #-> "AAAA0000"
"***".succ #-> "**+"
"zzz".succ #-> "aaaa"|
|
Методы succ и next — абсолютно идентичны, то есть являются именами одного и того же метода |
String#succ!
правитьstr.succ! #-> str
str.next! #-> strЭквивалентен методу succ, но меняет строку str на результат своей работы.
|
|
Методы succ! и next! — абсолютно идентичны, то есть являются именами одного и того же метода |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод succ, который не имеет данного побочного эффекта |
String#sum
правитьstr.sum(n=16) #-> integerВозвращает простую n-битную контрольную сумму символов строки str, где n опциональный целочисленный (Fixnum) параметр, по-умолчанию равный 16. Результатом -- это просто суммирование двоичных значений каждого символа строки str по модулю 2n - 1.
| |
Внимание! Использование данного метода для подсчета контрольной суммы -- не самая удачная идея. Рекомендуется использовать алгоритмы MD5 или SHA1, которые описаны в стандартных библиотеках md5 и sha1 |
String#swapcase
правитьstr.swapcase #-> new_strВозвращает копию строки str в которой все символы нижнего регистра заменены на соответствующие символы верхнего и все символы верхнего регистра заменены на соответствующие символы нижнего.
"Hello".swapcase #-> "hELLO"
"cYbEr_PuNk11".swapcase #-> "CyBeR_pUnK11"|
|
|
| |
Внимание! У всех символов, кроме латиницы на эти изменения устойчивый иммунитет. Это не значит, что будет возникать ошибка... просто они не будут преобразованы по вышеописанному правилу |
String#swapcase!
правитьstr.swapcase! #-> str или nilМодифицирует строку str по правилу: все символы нижнего регистра заменены на соответствующие символы верхнего и все символы верхнего регистра заменены на соответствующие символы нижнего. Возвращает nil, если изменения не требуются.
str="Hello"
str.swapcase! #-> "hELLO"
str #-> "hELLO"
str.swapcase! #-> "Hello"
"12345".swapcase! #-> nil|
|
|
| |
Внимание!
|
String#to_a
правитьstr.to_a() #-> arrayString#to_c
правитьstr.to_c #-> complexВозвращает комплексные числа complex, обозначающие строковую форму. Парсер игнорирует начальные пробелы и мусор в конце. Любые последовательности цифр можно разделить знаком подчеркивания. Возвращает nil для нулевой или мусорной строки.
'9'.to_c #=> (9+0i)
'2.5'.to_c #=> (2.5+0i)
'2.5/1'.to_c #=> ((5/2)+0i)
'-3/2'.to_c #=> ((-3/2)+0i)
'-i'.to_c #=> (0-1i)
'45i'.to_c #=> (0+45i)
'3-4i'.to_c #=> (3-4i)
'-4e2-4e-2i'.to_c #=> (-400.0-0.04i)
'-0.0-0.0i'.to_c #=> (-0.0-0.0i)
'1/2+3/4i'.to_c #=> ((1/2)+(3/4)*i)
'ruby'.to_c #=> (0+0i)|
|
Подробнее смотрите: Complex |
String#to_f
правитьstr.to_f #-> floatВозвращает результат интерпретации строки str, как дробного числа. Символы после последнего числового — игнорируются. Если строка str не является дробным числом, то возвращается 0.0.
"123.45e1".to_f #-> 1234.5
"45.67 degrees".to_f #-> 45.67
"thx1138".to_f #-> 0.0|
|
Полезно посмотреть на метод to_i, который имеет схожую функциональность |
|
|
Данный метод относится к отряду «тихих» методов, то есть не порождающих ошибок в результате своей работы |
String#to_i
правитьstr.to_i(base=10) #-> integerВозвращает в качестве результата интерпретацию символов строки str, как целого числа с основанием base (2, 8, 10, 16 или любого другого). Символы после последнего числового — игнорируются. Если строка str не является числом, то возвращается 0.
"12345".to_i #-> 12345
"99 red balloons".to_i #-> 99
"0a".to_i #-> 0
"0a".to_i(16) #-> 10
"hello".to_i #-> 0
"1100101".to_i(2) #-> 101
"1100101".to_i(8) #-> 294977
"1100101".to_i(10) #-> 1100101
"1100101".to_i(16) #-> 17826049|
|
Данный метод относится к отряду «тихих» методов, то есть не порождающих ошибок в результате своей работы |
String#to_s
правитьstr.to_s #-> str
str.to_str #-> strВозвращает строку str в качестве результата. Никаких преобразований не производится.
|
|
Методы to_s и to_str — абсолютно идентичны, но использование метода to_s предпочтительнее, так как его название короче |
String#to_str
правитьstr.to_s #-> str
str.to_str #-> strВозвращает строку str в качестве результата. Никаких преобразований не производится.
|
|
Методы to_s и to_str — абсолютно идентичны, но использование метода to_s предпочтительнее, так как его название короче |
String#to_sym
правитьstr.intern #-> symbol
str.to_sym #-> symbolВозвращает объект класса Symbol, который соответствует строке str.
"Koala".to_sym #-> :Koala
s = 'cat'.to_sym #-> :cat
s == :cat #-> true
s = '@cat'.to_sym #-> :@cat
s == :@cat #-> trueЭтот метод может быть использован для создания символов, которые не могут быть созданы в :xxx нотации.
'cat and dog'.to_sym #-> :"cat and dog"|
|
|
String#tr
правитьstr.tr(from, to) #-> new_strВозвращает копию строки str в которой символы из строки from заменены на соответствующие символы из строки to. Если строка to короче, чем from, то строка дополняется своим последним символом до длины строки from. Оба строковых параметра (from и to) могут использовать нотацию c1-c2, которая разворачивается в последовательность символов в диапазоне от с1 до с2. Если первым символом в строковом параметре указать символ ^, то это будет означать все множество символов, кроме указанных.
"hello".tr('aeiou', '*') #-> "h*ll*"
"hello".tr('^aeiou', '*') #-> "*e**o"
"hello".tr('el', 'ip') #-> "hippo"
"hello".tr('a-y', 'b-z') #-> "ifmmp"|
|
Полезно посмотреть на метод tr_s, который имеет схожую функциональность |
String#tr!
правитьstr.tr!(from, to) #-> new_str или nilПреобразует строку str, используя алгоритм, описанный для метода tr. Возвращает результат преобразования или nil, если в результате работы метода изменений сделано не было.
|
|
Полезно посмотреть на метод tr_s!, который имеет схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод tr, который не имеет данного побочного эффекта |
String#tr_s
правитьstr.tr_s(from, to) #-> new_strСоздает копию строки str, которая преобразована по алгоритму, описанному в методе tr, но с предварительным удалением дубликатов символов, которые описаны в строке from.
"hello".tr_s('l', 'r') #-> "hero"
"hello".tr_s('el', '*') #-> "h*o"
"hello".tr_s('el', 'hx') #-> "hhxo"|
|
Полезно посмотреть на метод tr, который имеет схожую функциональность |
String#tr_s!
правитьstr.tr_s!(from, to) #-> new_str или nilПреобразует строку str по алгоритму описанному в методе tr_s. Возвращает результат преобразования или nil, если в результате работы метода преобразований сделано не было.
|
|
Полезно посмотреть на метод tr!, который имеет схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод tr_s, который не имеет данного побочного эффекта |
String#unpack
правитьstr.unpack(format) #-> anArrayДекодирует строку str (которая может содержать двоичные данные) в соответствии с опциями, заданными в строке format и возвращает массив с декодированными данными. Строка format состоит из односимвольных директив (см. таблицу ниже). За каждой директивой может следовать число, которое описывает количество повторений этой опции. Символ «звездочка» (*) применяет опцию ко всем элементам строки (как бы бесконечное количество повторений опции). После директив s, S, i, I, l и L может следовать символ подчеркивания(_), который позволяет использовать размеры типов (количество бит), которые специфичны для данной платформы; иначе, будут использоваться платформо-независимые размеры типов. Пробельные символы в строке format игнорируются.
"abc \0\0abc \0\0".unpack('A6Z6') #-> ["abc", "abc "]
"abc \0\0".unpack('a3a3') #-> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*') #-> ["abc ", "abc "]
"aa".unpack('b8B8') #-> ["10000110", "01100001"]
"aaa".unpack('h2H2c') #-> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS') #-> [-2, 65534]
"now=20is".unpack('M*') #-> ["now is"]
"whole".unpack('xax2aX2aX1aX2a') #-> ["h", "e", "l", "l", "o"]| Опция | Тип | Описание |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Полезно посмотреть на метод pack, который имеет схожую функциональность |
String#upcase
правитьstr.upcase #-> new_strВозвращает копию строки str в которой все символы нижнего регистра заменены на соответствующие символы верхнего.
"hEllO".upcase #-> "HELLO"|
|
Полезно посмотреть на методы capitalize, downcase и swapcase, которые имеют схожую функциональность |
| |
Внимание! У всех символов, кроме латиницы на эти изменения устойчивый иммунитет. Это не значит, что возникнет ошибка. Просто, они не будут преобразованы по вышеописанному правилу |
String#upcase!
правитьstr.upcase! #-> str или nilМодифицирует строку str по правилу: все символы нижнего регистра преобразовываются в соответствующие символы верхнего. Возвращает nil, если изменения не требуются.
str="hEllO"
str.upcase! #-> "HELLO"
str #-> "HELLO"
str.upcase! #-> nil|
|
Полезно посмотреть на методы capitalize!, downcase! и swapcase!, которые имеют схожую функциональность |
| |
Внимание! Данный метод является «опасным», так как изменяет исходный объект. Вместо него рекомендуется использовать метод upcase, который не имеет данного побочного эффекта |
| |
Внимание! У всех символов, кроме латиницы на эти изменения устойчивый иммунитет. Это не значит, что возникнет ошибка. Просто, они не будут преобразованы по вышеописанному правилу |
String#upto
правитьstr.upto(other_str) {|s| block } #-> strДанный итератор проходит все значения между str и other_str включительно, передавая их в блок в качестве параметра.
"a8".upto("b6") {|s| print s, ' ' }
for s in "a8".."b6"
print s, ' '
endрезультат:
a8 a9 b0 b1 b2 b3 b4 b5 b6 a8 a9 b0 b1 b2 b3 b4 b5 b6
|
|
|
String#valid_encoding?
правитьstr.valid_encoding? #-> true или falseВозвращает true для строки str, которая закодирована правильно.
"\xc2\xa1".force_encoding("UTF-8").valid_encoding? #=> true
"\xc2".force_encoding("UTF-8").valid_encoding? #=> false
"\x80".force_encoding("UTF-8").valid_encoding? #=> falseКласс Struct
правитьКласс Struct реализует удобный способ объединения набора атрибутов, используя методы доступа, без явного создания класса. Класс Struct создает специфические классы, которые содержат только набор переменных и методы доступа к ним. В следующем примере мы создадим класс Customer и продемонстрируем пример использования объекта этого класса. В следующем описании, параметр symbol может быть строкой или экземпляром класса Symbol (например, :name).
Примеси
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)
Методы класса
Методы объекта
[]=, [], ==, each_pair, each, eql?, hash, inspect, length, members, select, size, to_a, to_s, values_at, values
Struct::new
правитьStruct.new( string, symbols* ) #-> StructClass
StructClass.new(arg, ...) #-> obj
StructClass[arg, ...] #-> objСоздание нового класса с именем string, содержащего методы доступа к атрибутам. Если имя string пропущено, то будет создан анонимная структура. Иначе, имя этой структуры будет выглядеть как константа класса Struct. Учтите, что имя структуры должно быть уникально и начинаться с большой буквы. Struct::new возвращает объект класса Class, который может быть использован для создания специфичных экземпляров новой структуры. Число действительных параметров должно быть меньше или равно числу атрибутов, объявленных для этой структуры.
# Создание структуры с именем внутри класса Struct
Struct.new("Customer", :name, :address) #-> Struct::Customer
Struct::Customer.new("Dave", "123 Main") #-> #<Struct::Customer name="Dave", address="123 Main">
# Имя структуры зависит от имени константы
Customer = Struct.new(:name, :address) #-> Customer
Customer.new("Dave", "123 Main") #-> #<Customer name="Dave", address="123 Main">Struct#==
правитьstruct == other_struct #-> true или falseЭквивалентность --- возвращает true если other_struct равен : они должны быть объектами одного и того же класса, созданного при помощи Struct::new, и значения внутренних переменных должны совпадать (в соответствии с методом Object#==).
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joejr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
jane = Customer.new("Jane Doe", "456 Elm, Anytown NC", 12345)
joe == joejr #-> true
joe == jane #-> falseStruct#[]
правитьstruct[symbol] #-> anObject
struct[fixnum] #-> anObjectЗначение атрибута можно получить, если передать в качестве параметра имя атрибута (в виде строки или символа) или числовой индекс в интервале (0..размер-1). Возникнет ошибка NameError, если имя атрибута отсутствует или IndexError, если числовой индекс будет лежать вне допустимого интервала.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe["name"] #-> "Joe Smith"
joe[:name] #-> "Joe Smith"
joe[0] #-> "Joe Smith"Struct#[]=
правитьstruct[symbol] = obj #-> obj
struct[fixnum] = obj #-> objИзменить значение атрибута можно передав в качестве параметра имя атрибута (в виде строки или символа) или целочисленный индекс в интервале (0..размер-1), а также объект obj, который надо присвоить атрибуту. Возникнет ошибка NameError, если имени атрибута не существует или IndexError, если целочисленный индекс будет лежать вне диапазона.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe["name"] = "Luke"
joe[:zip] = "90210"
joe.name #-> "Luke"
joe.zip #-> "90210"Struct#each
правитьstruct.each {|obj| block } #-> structВыполняет block по разу на каждый атрибут, передавая в блок его значение.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.each {|x| puts(x) }результат:
Joe Smith 123 Maple, Anytown NC 12345
Struct#each_pair
правитьstruct.each_pair {|sym, obj| block } #-> structВыполняет block по разу на каждый атрибут, передавая в блок имя (как символ) и значение параметра.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.each_pair {|name, value| puts("#{name} => #{value}") }результат:
name => Joe Smith address => 123 Maple, Anytown NC zip => 12345
Struct#eql?
правитьstruct.eql?(other) #-> true или falseДве структуры эквивалентны, если они являются одним и тем же объектом или если все их атрибуты эквиваленты (используется метод eql?).
Struct#hash
правитьstruct.hash #-> fixnumВозвращает контрольную сумму, основанную на контрольных суммах значений атрибутов.
Struct#inspect
правитьstruct.to_s #-> string
struct.inspect #-> stringДемонстрирует содержимое структуры в виде строки.
(еще известен как to_s)
Struct#length
правитьstruct.length #-> fixnum
struct.size #-> fixnumВозвращает количество атрибутов структуры.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.length #-> 3(еще известен как size)
Struct#members
правитьstruct.members #-> arrayВозвращает массив строк, состоящий из имен атрибутов структуры.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.members #-> ["name", "address", "zip"]Struct#select
правитьstruct.select {|i| block } #-> arrayВыполняет блок для каждого значения атрибута в структуре, возвращает массив содержащий элементы для которых блок вернул значение true (эквивалент метода Enumerable#select).
Lots = Struct.new(:a, :b, :c, :d, :e, :f)
l = Lots.new(11, 22, 33, 44, 55, 66)
l.select {|v| (v % 2).zero? } #-> [22, 44, 66]Struct#size
правитьstruct.length #-> fixnum
struct.size #-> fixnumВозвращает количество атрибутов структуры.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.length #-> 3(еще известен как length :))
Struct#to_a
правитьstruct.to_a #-> array
struct.values #-> arrayВозвращает массив значений атрибутов структуры.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.to_a[1] #-> "123 Maple, Anytown NC"(еще известен как values)
Struct#to_s
правитьstruct.to_s #-> string
struct.inspect #-> stringДемонстрирует содержимое структуры в виде строки.
(еще известен как inspect)
Struct#values
правитьstruct.to_a #-> array
struct.values #-> arrayВозвращает массив значений атрибутов структуры.
Customer = Struct.new(:name, :address, :zip)
joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
joe.to_a[1] #-> "123 Maple, Anytown NC"(еще известен как to_a)
Struct#values_at
правитьstruct.values_at(selector,... ) #-> an_arrayВозвращает массив, состоящий из значений элементов, индексы которых переданы в качестве параметров. Индексы могут быть целым числом или целочисленным интервалом. Смотри также select.
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)Класс Time
правитьImplements the extensions to the Time class that are described in the documentation for the time.rb library.
Extensions to time to allow comparisons with an early time class.
Примеси
Comparable (<, <=, ==, >, >=, between?)
Константы
CommonYearMonthDays, LeapYearMonthDays, MonthValue, RFC2822_DAY_NAME, RFC2822_MONTH_NAME, ZoneOffset
Методы класса
_load, apply_offset, at, gm, httpdate, local, make_time, mktime, month_days, new, now, parse, rfc2822, times, utc, w3cdtf, xmlschema, yaml_new, zone_offset, zone_utc?
Методы объекта
+, -, <=>, _dump, asctime, ctime, day, dst?, eql?, getgm, getlocal, getutc, gmt?, gmt_offset, gmtime, gmtoff, hash, hour, httpdate, inspect, isdst, iso8601, localtime, marshal_dump, marshal_load, mday, min, month, mon, rfc2822, rfc822, sec, strftime, succ, to_a, to_f, to_i, to_s, to_yaml, tv_sec, tv_usec, usec, utc?, utc_offset, utc, wday, xmlschema, yday, year, zone
Time::_load
правитьTime._load(string) #=> timeUnmarshal a dumped Time object.
Time::apply_offset
правитьTime::apply_offset(year, mon, day, hour, min, sec, off)(нет описания...)
Time::at
правитьTime.at( aTime ) #=> time
Time.at( seconds [, microseconds] ) #=> timeCreates a new time object with the value given by aTime, or the given number of seconds (and optional microseconds) from epoch. A non-portable feature allows the offset to be negative on some systems.
Time.at(0) #=> Wed Dec 31 18:00:00 CST 1969
Time.at(946702800) #=> Fri Dec 31 23:00:00 CST 1999
Time.at(-284061600) #=> Sat Dec 31 00:00:00 CST 1960Time::gm
правитьTime.utc( year [, month, day, hour, min, sec, usec] ) => time Time.utc( sec, min, hour, day, month, year, wday, yday, isdst, tz ) => time Time.gm( year [, month, day, hour, min, sec, usec] ) => time Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz ) => time
Creates a time based on given values, interpreted as UTC (GMT). The year must be specified. Other values default to the minimum value for that field (and may be nil or omitted). Months may be specified by numbers from 1 to 12, or by the three-letter English month names. Hours are specified on a 24-hour clock (0..23). Raises an ArgumentError if any values are out of range. Will also accept ten arguments in the order output by Time#to_a.
Time.utc(2000,"jan",1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
Time.gm(2000,"jan",1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
Time::httpdate
правитьTime::httpdate(date)
Parses date as HTTP-date defined by RFC 2616 and converts it to a Time object. ArgumentError is raised if date is not compliant with RFC 2616 or Time class cannot represent specified date. See #httpdate for more information on this format.
Time::local
правитьTime.local( year [, month, day, hour, min, sec, usec] ) => time Time.local( sec, min, hour, day, month, year, wday, yday, isdst, tz ) => time Time.mktime( year, month, day, hour, min, sec, usec ) => time
Same as Time::gm, but interprets the values in the local time zone.
Time.local(2000,"jan",1,20,15,1) #=> Sat Jan 01 20:15:01 CST 2000
Time::make_time
правитьTime::make_time(year, mon, day, hour, min, sec, sec_fraction, zone, now)
(нет описания...)
Time::mktime
правитьTime.local( year [, month, day, hour, min, sec, usec] ) => time Time.local( sec, min, hour, day, month, year, wday, yday, isdst, tz ) => time Time.mktime( year, month, day, hour, min, sec, usec ) => time
Same as Time::gm, but interprets the values in the local time zone.
Time.local(2000,"jan",1,20,15,1) #=> Sat Jan 01 20:15:01 CST 2000
Time::month_days
правитьTime::month_days(y, m)
(нет описания...)
Time::new
правитьTime.new -> time
Document-method: now Synonym for Time.new. Returns a Time object initialized to the current system time. Note: The object created will be created using the resolution available on your system clock, and so may include fractional seconds.
a = Time.new #=> Wed Apr 09 08:56:03 CDT 2003
b = Time.new #=> Wed Apr 09 08:56:03 CDT 2003
a == b #=> false
"%.6f" % a.to_f #=> "1049896563.230740"
"%.6f" % b.to_f #=> "1049896563.231466"
Time::now
правитьTime.now -> time
Synonym for Time.new. Returns a Time object initialized to the current system time. Note: The object created will be created using the resolution available on your system clock, and so may include fractional seconds.
a = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
b = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
a == b #=> True
"%.6f" % a.to_f #=> "1049896563.230740"
"%.6f" % b.to_f #=> "1049896563.231466"
Time::parse
править Time::parse(date, now=Time.now) {|year| ...}
Parses date using Date._parse and converts it to a Time object. If a block is given, the year described in date is converted by the block. For example:
Time.parse(...) {|y| y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}
If the upper components of the given time are broken or missing, they are supplied with those of now. For the lower components, the minimum values (1 or 0) are assumed if broken or missing. For example:
# Suppose it is "Thu Nov 29 14:33:20 GMT 2001" now and
# your timezone is GMT:
Time.parse("16:30") #=> Thu Nov 29 16:30:00 GMT 2001
Time.parse("7/23") #=> Mon Jul 23 00:00:00 GMT 2001
Time.parse("Aug 31") #=> Fri Aug 31 00:00:00 GMT 2001
Since there are numerous conflicts among locally defined timezone abbreviations all over the world, this method is not made to understand all of them. For example, the abbreviation "CST" is used variously as:
-06:00 in America/Chicago,
-05:00 in America/Havana,
+08:00 in Asia/Harbin,
+09:30 in Australia/Darwin,
+10:30 in Australia/Adelaide,
etc.
Based on the fact, this method only understands the timezone abbreviations described in RFC 822 and the system timezone, in the order named. (i.e. a definition in RFC 822 overrides the system timezone definition.) The system timezone is taken from Time.local(year, 1, 1).zone and Time.local(year, 7, 1).zone. If the extracted timezone abbreviation does not match any of them, it is ignored and the given time is regarded as a local time. ArgumentError is raised if Date._parse cannot extract information from date or Time class cannot represent specified date. This method can be used as fail-safe for other parsing methods as:
Time.rfc2822(date) rescue Time.parse(date)
Time.httpdate(date) rescue Time.parse(date)
Time.xmlschema(date) rescue Time.parse(date)
A failure for Time.parse should be checked, though.
Time::rfc2822
правитьTime::rfc2822(date)
Parses date as date-time defined by RFC 2822 and converts it to a Time object. The format is identical to the date format defined by RFC 822 and updated by RFC 1123. ArgumentError is raised if date is not compliant with RFC 2822 or Time class cannot represent specified date. See #rfc2822 for more information on this format.
Time::times
правитьTime.times => struct_tms
Deprecated in favor of Process::times
Time::utc
правитьTime.utc( year [, month, day, hour, min, sec, usec] ) => time Time.utc( sec, min, hour, day, month, year, wday, yday, isdst, tz ) => time Time.gm( year [, month, day, hour, min, sec, usec] ) => time Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz ) => time
Creates a time based on given values, interpreted as UTC (GMT). The year must be specified. Other values default to the minimum value for that field (and may be nil or omitted). Months may be specified by numbers from 1 to 12, or by the three-letter English month names. Hours are specified on a 24-hour clock (0..23). Raises an ArgumentError if any values are out of range. Will also accept ten arguments in the order output by Time#to_a.
Time.utc(2000,"jan",1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
Time.gm(2000,"jan",1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
Time::w3cdtf
правитьTime::w3cdtf(date)
(нет описания...)
Time::xmlschema
правитьTime::xmlschema(date)
Parses date as dateTime defined by XML Schema and converts it to a Time object. The format is restricted version of the format defined by ISO 8601. ArgumentError is raised if date is not compliant with the format or Time class cannot represent specified date. See #xmlschema for more information on this format.
Time::yaml_new
правитьTime::yaml_new( klass, tag, val )
(нет описания...)
Time::zone_offset
правитьTime::zone_offset(zone, year=Time.now.year)
(нет описания...)
Time::zone_utc?
правитьTime::zone_utc?(zone)
(нет описания...)
Time#+
правитьtime + numeric => time
Addition---Adds some number of seconds (possibly fractional) to time and returns that value as a new time.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t + (60 * 60 * 24) #=> Thu Apr 10 08:56:03 CDT 2003
Time#-
правитьtime - other_time => float time - numeric => time
Difference---Returns a new time that represents the difference between two times, or subtracts the given number of seconds in numeric from time.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t2 = t + 2592000 #=> Fri May 09 08:56:03 CDT 2003
t2 - t #=> 2592000.0
t2 - 2592000 #=> Wed Apr 09 08:56:03 CDT 2003
Более одного метода удовлетворяет вашему запросу. Вы можете уточнить ваш запрос, выбрав один из следующих методов:
Time#<=>, Time#<=>===Time#_dump===
time._dump => string
Dump time for marshaling.
Time#asctime
правитьtime.asctime => string time.ctime => string
Returns a canonical string representation of time.
Time.now.asctime #=> "Wed Apr 9 08:56:03 2003"
Time#ctime
правитьtime.asctime => string time.ctime => string
Returns a canonical string representation of time.
Time.now.asctime #=> "Wed Apr 9 08:56:03 2003"
Time#day
правитьtime.day => fixnum time.mday => fixnum
Returns the day of the month (1..n) for time.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.day #=> 9
t.mday #=> 9
Time#dst?
правитьtime.isdst => true or false time.dst? => true or false
Returns true if time occurs during Daylight Saving Time in its time zone.
Time.local(2000, 7, 1).isdst #=> true
Time.local(2000, 1, 1).isdst #=> false
Time.local(2000, 7, 1).dst? #=> true
Time.local(2000, 1, 1).dst? #=> false
Time#eql?
правитьtime.eql?(other_time)
Return true if time and other_time are both Time objects with the same seconds and fractional seconds.
Time#getgm
правитьtime.getgm => new_time time.getutc => new_time
Returns a new new_time object representing time in UTC.
t = Time.local(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 CST 2000
t.gmt? #=> false
y = t.getgm #=> Sun Jan 02 02:15:01 UTC 2000
y.gmt? #=> true
t == y #=> true
Time#getlocal
правитьtime.getlocal => new_time
Returns a new new_time object representing time in local time (using the local time zone in effect for this process).
t = Time.gm(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt? #=> true
l = t.getlocal #=> Sat Jan 01 14:15:01 CST 2000
l.gmt? #=> false
t == l #=> true
Time#getutc
правитьtime.getgm => new_time time.getutc => new_time
Returns a new new_time object representing time in UTC.
t = Time.local(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 CST 2000
t.gmt? #=> false
y = t.getgm #=> Sun Jan 02 02:15:01 UTC 2000
y.gmt? #=> true
t == y #=> true
Time#gmt?
правитьtime.utc? => true or false time.gmt? => true or false
Returns true if time represents a time in UTC (GMT).
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t.utc? #=> false
t = Time.gm(2000,"jan",1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
t.utc? #=> true
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.gmt? #=> false
t = Time.gm(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt? #=> true
Time#gmt_offset
правитьtime.gmt_offset => fixnum time.gmtoff => fixnum time.utc_offset => fixnum
Returns the offset in seconds between the timezone of time and UTC.
t = Time.gm(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt_offset #=> 0
l = t.getlocal #=> Sat Jan 01 14:15:01 CST 2000
l.gmt_offset #=> -21600
Time#gmtime
правитьtime.gmtime => time time.utc => time
Converts time to UTC (GMT), modifying the receiver.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.gmt? #=> false
t.gmtime #=> Wed Apr 09 13:56:03 UTC 2003
t.gmt? #=> true
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t.utc? #=> false
t.utc #=> Wed Apr 09 13:56:04 UTC 2003
t.utc? #=> true
Time#gmtoff
правитьtime.gmt_offset => fixnum time.gmtoff => fixnum time.utc_offset => fixnum
Returns the offset in seconds between the timezone of time and UTC.
t = Time.gm(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt_offset #=> 0
l = t.getlocal #=> Sat Jan 01 14:15:01 CST 2000
l.gmt_offset #=> -21600
Time#hash
правитьtime.hash => fixnum
Return a hash code for this time object.
Time#hour
правитьtime.hour => fixnum
Returns the hour of the day (0..23) for time.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.hour #=> 8
Time#httpdate
правитьhttpdate()
Returns a string which represents the time as rfc1123-date of HTTP-date defined by RFC 2616:
day-of-week, DD month-name CCYY hh:mm:ss GMT
Note that the result is always UTC (GMT).
Time#inspect
правитьtime.inspect => string time.to_s => string
Returns a string representing time. Equivalent to calling Time#strftime with a format string of ``%a %b %d %H:%M:%S %Z %Y.
Time.now.to_s #=> "Wed Apr 09 08:56:04 CDT 2003"
Time#isdst
правитьtime.isdst => true or false time.dst? => true or false
Returns true if time occurs during Daylight Saving Time in its time zone.
Time.local(2000, 7, 1).isdst #=> true
Time.local(2000, 1, 1).isdst #=> false
Time.local(2000, 7, 1).dst? #=> true
Time.local(2000, 1, 1).dst? #=> false
Time#iso8601
правитьiso8601(fraction_digits=0)
Alias for #xmlschema
Time#localtime
правитьtime.localtime => time
Converts time to local time (using the local time zone in effect for this process) modifying the receiver.
t = Time.gm(2000, "jan", 1, 20, 15, 1)
t.gmt? #=> true
t.localtime #=> Sat Jan 01 14:15:01 CST 2000
t.gmt? #=> false
Time#marshal_dump
правитьmarshal_dump()
undocumented
Time#marshal_load
правитьmarshal_load(p1)
undocumented
Time#mday
правитьtime.day => fixnum time.mday => fixnum
Returns the day of the month (1..n) for time.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.day #=> 9
t.mday #=> 9
Time#min
правитьtime.min => fixnum
Returns the minute of the hour (0..59) for time.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.min #=> 56
Time#mon
правитьtime.mon => fixnum time.month => fixnum
Returns the month of the year (1..12) for time.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.mon #=> 4
t.month #=> 4
Time#month
правитьtime.mon => fixnum time.month => fixnum
Returns the month of the year (1..12) for time.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.mon #=> 4
t.month #=> 4
Time#rfc2822
правитьrfc2822()
Returns a string which represents the time as date-time defined by RFC 2822:
day-of-week, DD month-name CCYY hh:mm:ss zone
where zone is [+-]hhmm. If self is a UTC time, -0000 is used as zone.
(еще известен как rfc822)
Time#rfc822
правитьrfc822()
Alias for #rfc2822
Time#sec
правитьtime.sec => fixnum
Returns the second of the minute (0..60)[Yes, seconds really can range from zero to 60. This allows the system to inject leap seconds every now and then to correct for the fact that years are not really a convenient number of hours long.] for time.
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t.sec #=> 4
Time#strftime
правитьTime.strftime( string ) => string
Formats time according to the directives in the given format string. Any text not listed as a directive will be passed through to the output string. Format meaning:
%a - The abbreviated weekday name (``Sun)
%A - The full weekday name (``Sunday)
%b - The abbreviated month name (``Jan)
%B - The full month name (``January)
%c - The preferred local date and time representation
%d - Day of the month (01..31)
%H - Hour of the day, 24-hour clock (00..23)
%I - Hour of the day, 12-hour clock (01..12)
%j - Day of the year (001..366)
%m - Month of the year (01..12)
%M - Minute of the hour (00..59)
%p - Meridian indicator (``AM or ``PM)
%S - Second of the minute (00..60)
%U - Week number of the current year,
starting with the first Sunday as the first
day of the first week (00..53)
%W - Week number of the current year,
starting with the first Monday as the first
day of the first week (00..53)
%w - Day of the week (Sunday is 0, 0..6)
%x - Preferred representation for the date alone, no time
%X - Preferred representation for the time alone, no date
%y - Year without a century (00..99)
%Y - Year with century
%Z - Time zone name
%% - Literal ``% character
t = Time.now
t.strftime("Printed on %m/%d/%Y") #=> "Printed on 04/09/2003"
t.strftime("at %I:%M%p") #=> "at 08:56AM"
Time#succ
правитьtime.succ => new_time
Return a new time object, one second later than time.
Time#to_a
правитьtime.to_a => array
Returns a ten-element array of values for time: {[ sec, min, hour, day, month, year, wday, yday, isdst, zone ]}. See the individual methods for an explanation of the valid ranges of each value. The ten elements can be passed directly to Time::utc or Time::local to create a new Time.
now = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t = now.to_a #=> [4, 56, 8, 9, 4, 2003, 3, 99, true, "CDT"]
Time#to_f
правитьtime.to_f => float
Returns the value of time as a floating point number of seconds since epoch.
t = Time.now
"%10.5f" % t.to_f #=> "1049896564.13654"
t.to_i #=> 1049896564
Time#to_i
правитьtime.to_i => int time.tv_sec => int
Returns the value of time as an integer number of seconds since epoch.
t = Time.now
"%10.5f" % t.to_f #=> "1049896564.17839"
t.to_i #=> 1049896564
Time#to_s
правитьtime.inspect => string time.to_s => string
Returns a string representing time. Equivalent to calling Time#strftime with a format string of ``%a %b %d %H:%M:%S %Z %Y.
Time.now.to_s #=> "Wed Apr 09 08:56:04 CDT 2003"
Time#to_yaml
править to_yaml( opts = {} )
(нет описания...)
Time#tv_sec
правитьtime.to_i => int time.tv_sec => int
Returns the value of time as an integer number of seconds since epoch.
t = Time.now
"%10.5f" % t.to_f #=> "1049896564.17839"
t.to_i #=> 1049896564
Time#tv_usec
правитьtime.usec => int time.tv_usec => int
Returns just the number of microseconds for time.
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
"%10.6f" % t.to_f #=> "1049896564.259970"
t.usec #=> 259970
Time#usec
правитьtime.usec => int time.tv_usec => int
Returns just the number of microseconds for time.
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
"%10.6f" % t.to_f #=> "1049896564.259970"
t.usec #=> 259970
Time#utc
правитьtime.gmtime => time time.utc => time
Converts time to UTC (GMT), modifying the receiver.
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.gmt? #=> false
t.gmtime #=> Wed Apr 09 13:56:03 UTC 2003
t.gmt? #=> true
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t.utc? #=> false
t.utc #=> Wed Apr 09 13:56:04 UTC 2003
t.utc? #=> true
Time#utc?
правитьtime.utc? => true or false time.gmt? => true or false
Returns true if time represents a time in UTC (GMT).
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t.utc? #=> false
t = Time.gm(2000,"jan",1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
t.utc? #=> true
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003
t.gmt? #=> false
t = Time.gm(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt? #=> true
Time#utc_offset
правитьtime.gmt_offset => fixnum time.gmtoff => fixnum time.utc_offset => fixnum
Returns the offset in seconds between the timezone of time and UTC.
t = Time.gm(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000
t.gmt_offset #=> 0
l = t.getlocal #=> Sat Jan 01 14:15:01 CST 2000
l.gmt_offset #=> -21600
Time#wday
правитьtime.wday => fixnum
Returns an integer representing the day of the week, 0..6, with Sunday == 0.
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t.wday #=> 3
Time#xmlschema
правитьxmlschema(fraction_digits=0)
Returns a string which represents the time as dateTime defined by XML Schema:
CCYY-MM-DDThh:mm:ssTZD
CCYY-MM-DDThh:mm:ss.sssTZD
where TZD is Z or [+-]hh:mm. If self is a UTC time, Z is used as TZD. [+-]hh:mm is used otherwise. fractional_seconds specifies a number of digits of fractional seconds. Its default value is 0.
(еще известен как iso8601)
Time#yday
правитьtime.yday => fixnum
Returns an integer representing the day of the year, 1..366.
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t.yday #=> 99
Time#year
правитьtime.year => fixnum
Returns the year for time (including the century).
t = Time.now #=> Wed Apr 09 08:56:04 CDT 2003
t.year #=> 2003
Time#zone
правитьtime.zone => string
Возвращает наименовние часового поиса. В Ruby 1.8 возвращает UTC , а не GMT для времени UTC.
t = Time.gm(2000, "jan", 1, 20, 15, 1)
t.zone #=> "UTC"
t = Time.local(2000, "jan", 1, 20, 15, 1)
t.zone #=> "CST"
Пример Ruby 2.0
t=Time.new
t.zone #=> OMST
Класс TrueClass
правитьГлобальное значение true является единственным экземпляром класса TrueClass и означает логическое «ДА» в алгебре логики. Класс содержит операторы, которые позволяют true корректно вести себя в логических выражениях.
Методы объекта
TrueClass#&
правитьtrue & obj #-> true или falseЛогическое «И» возвращает false, если obj — nil или false, true иначе.
TrueClass#^
правитьtrue ^ obj #-> !objИсключающее «ИЛИ» возвращает true, если obj — nil или false, false иначе.
TrueClass#to_s
правитьtrue.to_s #-> "true"Всегда возвращает строку "true".
TrueClass#|
правитьtrue | obj #-> trueЛогического «ИЛИ» всегда возвращает true. obj всегда вычисляется, так как является агрументом метода. В этом случае нет никакого сокращенного вычисления.
true | puts("или")
true || puts("логическое или")результат:
или