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, то есть |
Класс 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
Класс 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 иначе.
Класс 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
Начинает сборку мусора, пока не отключена вручную.
Класс 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
Примесь 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 (заданного в радианах).
Класс 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.56
Numeric#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) #-> true
Numeric#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 равен нулю.
Класс 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 #-> -2
Proc#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) #-> 99
Proc#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, вместе с указателем на место, где блок был объявлен.
Класс 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) #-> false
Range#===[править]
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) #-> false
Range#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 в печатную форму.
Класс 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? #=> false
String#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") #-> 0
String#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" #-> 4
String#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? #-> true
String#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") #=> false
String#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 #-> 958124529
String#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 #-> true
String#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Класс 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("логическое или")результат:
или