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, at, clear, collect!, collect, compact!, compact, concat, delete_at, delete_if, delete, each_index, each, empty?, eql?, fetch, fill, first, flatten!, flatten, frozen?, hash, include?, indexes, index, indices, insert, inspect, join, last, length, map!, map, nitems, pack, pop, push, rassoc, reject!, reject, replace, reverse!, reverse_each, reverse, rindex, select, shift, size, slice!, slice, sort!, sort, to_ary, to_a, to_s, transpose, uniq!, uniq, unshift, values_at, zip
[править] Array::[]
Array::[](...)
Возвращает новый массив, заполненный указанными объектами.
Array.[]( 1, 'a', /^A/ ) Array[ 1, 'a', /^A/ ] [ 1, 'a', /^A/ ]
[править] Array::new
Array.new(size=0, obj=nil) Array.new(array) Array.new(size){|index| block }
Возвращает новый массив. В первой форме вызова, создается пустой массив. Во второй, создается массив размера size, заполненный копиями obj (то есть, size ссылок на obj). В третьей, создается копия массив, переданного в качестве параметра (массив создается при помощи вызова метода to_ary от массива-параметра). В последнем случае, создается массив указанного размера. Каждый элемент в этом массиве вычисляется в указанном блоке, которому передается индекс обрабатываемого элемента. Результат блока записывается в качестве значения элемента в массив.
Array.new Array.new(2) Array.new(5, "A") # только одна копия объекта создается a = Array.new(2, Hash.new) a[0]['cat'] = 'feline' a a[1]['cat'] = 'Felix' a # здесь создается несколько копий объекта a = Array.new(2) { Hash.new } a[0]['cat'] = 'feline' a squares = Array.new(5) {|i| i*i} squares copy = Array.new(squares)
[править] Array#&
array & other_array
Пересечение множеств — возвращает новый массив, состоящий из элементов, которые есть в обоих массивах, но без дубликатов.
[ 1, 1, 3, 5 ] & [ 1, 2, 3 ] #=> [ 1, 3 ]
[править] Array#|
array | other_array -> an_array
Объединение множеств — возвращает новый массив, который объединяет элементы массивов array и other_array, но с удаленными дубликатами.
[ "a", "b", "c" ] | [ "c", "d", "a" ]
#=> [ "a", "b", "c", "d" ]
[править] Array#*
array * int -> an_array array * str -> a_string
Повторение — со строковым аргументом эквивалентен коду array.join(str). Иначе, возвращает новый массив, состоящий из int сцепленных копий array.
[ 1, 2, 3 ] * 3 #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]
[ 1, 2, 3 ] * "," #=> "1,2,3"
[править] Array#+
array + other_array -> an_array
Сцепление — возвращает новый массив, созданный из двух массивов путем добавления одного к другому.
[ 1, 2, 3 ] + [ 4, 5 ] #=> [ 1, 2, 3, 4, 5 ]
[править] Array#-
array - other_array -> an_array
Вычитание массивов — возвращает новый массив, который копирует оригинальный массив, но удаляет из него элементы, которые есть в другом массиве.
[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ] #=> [ 3, 3, 5 ]
 |
Если вам необходима разность множеств, а не вычитание массивов, то смотрите в сторону класса Set |
[править] Array#<<
array << obj -> array
Добавить элемент — добавляет передаваемый объект в конец массива. Возвращает массив с уже добавленным элементом.
[ 1, 2 ] << "c" << "d" << [ 3, 4 ]
#=> [ 1, 2, "c", "d", [ 3, 4 ] ]
|
Метод push имеет примерно такую же функциональность |
[править] Array#<=>
array <=> other_array -> -1, 0, +1
Сравнение — возвращает целое число (-1, 0, или +1) если текущий массив меньше, равен или больше другого массива. Соответствующие элементы обоих массивов сравниваются (используется метод <=>). Если какая либо из пар элементов не совпадает, то возвращается результат этого сравнения. Если все пары элементов совпадают, то возвращается результат сравнения по длине. Таким образом, два массива считаются «равными» (по мнению метода Array#<=>) тогда и только тогда, когда их длины и соответствующие пары элементов совпадают.
[ "a", "a", "c" ] <=> [ "a", "b", "c" ] #=> -1
[ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ] #=> +1
[править] Array#==
array == other_array -> bool
Равенство — два массива считаются равными, если количество элементов и соответствующие пары элементов равны (используется метод ==).
[ "a", "c" ] == [ "a", "c", 7 ] #=> false
[ "a", "c", 7 ] == [ "a", "c", 7 ] #=> true
[ "a", "c", 7 ] == [ "a", "d", "f" ] #=> false
[править] Array#[]
array[index] -> obj или nil array[start, length] -> an_array или nil array[range] -> an_array или nil array.slice(index) -> obj или nil array.slice(start, length) -> an_array или nil array.slice(range) -> an_array или nil
Получение значения элемента — возвращает элемент с индексом index, или подмассив длины length, начиная с индекса start, или подмассив, который располагается в диапазоне range. Отрицательная индексация предполагает отчет с конца массива (по индексу -1 располагается последний элемент). Возвращает nil, если индекс выходит за диапазон допустимых значений.
a = [ "a", "b", "c", "d", "e" ]
a[2] + a[0] + a[1] #=> "cab"
a[6] #=> nil
a[1, 2] #=> [ "b", "c" ]
a[1..3] #=> [ "b", "c", "d" ]
a[4..7] #=> [ "e" ]
a[6..10] #=> nil
a[-3, 3] #=> [ "c", "d", "e" ]
# специальные случаи
a[5] #=> nil
a[5, 1] #=> []
a[5..10] #=> []
|
[править] Array#[]=
maccuB[uHgekc] = obj -> obj maccuB[cTapT, pa3mep] = obj или an_array или nil -> obj или an_array или nil maccuB[guana3oH] = obj или an_array или nil -> obj или an_array или nil
Распределение элементов — помещает элемент в maccuB по uHgekcу, или заменяет подмассив некоторого pa3mepа, начиная с индекса cTapT, или заменяет подмассив в определенном guana3oHе. Если индексация превышает текущий размер массива, то массив увеличивается автоматически. Отрицательная индексация подразумевает отсчет с конца массива. Если для второго случая использовать pa3mep равный 0, то указанные элементы будут вставлены перед элементом с индексом cTapT. Если все параметры для второго и третьего случая задать равными nil, то из maccuBа будут удалены все элементы. Ошибка IndexError появляется тогда, когда отрицательный индекс указывает на элемент, расположенный перед началом массива.
a = Array.new
a[4] = "4"; #=> [nil, nil, nil, nil, "4"]
a[0, 3] = [ 'a', 'b', 'c' ] #=> ["a", "b", "c", nil, "4"]
a[1..2] = [ 1, 2 ] #=> ["a", 1, 2, nil, "4"]
a[0, 2] = "?" #=> ["?", 2, nil, "4"]
a[0..2] = "A" #=> ["A", "4"]
a[-1] = "Z" #=> ["A", "Z"]
a[1..-1] = nil #=> ["A"]
|
Полезно знать, что добавления элементов в массив существуют еще методы push и unshift |
[править] Array#abbrev
maccuB.abbrev(pattern = nil)
Вычисляет набор однозначных сокращений для строк в maccuBe. Если в качестве pattern передается правило или строка, то будут обрабатываться только строки, которые соответствуют правилу или начинаются с данной строки.
%w{ car cone }.abbrev #=> { "ca" => "car", "car" => "car",
"co" => "cone", "con" => cone",
"cone" => "cone" }
require 'abbrev'[править] Array#assoc
array.assoc(obj) -> an_array или nil
Ищет в двумерном массиве массив, первый элемент которого равен obj (для сравнения используется метод ==). Возвращает первый найденный массив (то есть, ассоциированный массив) или nil, если таковой найти не удалось
s1 = [ "colors", "red", "blue", "green" ]
s2 = [ "letters", "a", "b", "c" ]
s3 = "foo"
a = [ s1, s2, s3 ]
a.assoc("letters") #=> [ "letters", "a", "b", "c" ]
a.assoc("foo") #=> nil
|
Для понимания происходящего, полезно взглянуть на метод rassoc |
[править] Array#at
array.at(index) -> obj или nil
Возвращает элемент массива array с индексом index. Отрицательная индексация подразумевает отсчет с конца массива. возвращает nil, если индекс выходит за пределы допустимого дианазона.
a = [ "a", "b", "c", "d", "e" ]
a.at(0) #=> "a"
a.at(-1) #=> "e"
|
|
[править] Array#clear
array.clear -> array
Удаляет все элементы из массива array.
a = [ "a", "b", "c", "d", "e" ]
a.clear #=> [ ]
[править] Array#collect
array.collect {|item| block } -> an_array
array.map {|item| block } -> an_array
Выполняет выражение block для каждого элемента массива array. Создает новый массив, который состоит из значений, которые получены при вычислении выражения block.
a = [ "a", "b", "c", "d" ]
a.collect {|x| x + "!" } #=> ["a!", "b!", "c!", "d!"]
a #=> ["a", "b", "c", "d"]
|
|
[править] Array#collect!
array.collect! {|item| block } -> array
array.map! {|item| block } -> array
Выполняет выражение block для каждого элемента массива array, вычисленное выражение подставляется вместо текущего элемента.
a = [ "a", "b", "c", "d" ]
a.collect! {|x| x + "!" }
a #=> [ "a!", "b!", "c!", "d!" ]
|
|
.
[править] Array#compact
array.compact -> an_array
Возвращает копию массива array из которого удалены все элементы nil.
[ "a", nil, "b", nil, "c", nil ].compact
#=> [ "a", "b", "c" ]
[править] Array#compact!
array.compact! -> array или nil
Удаляет все элементы nil из массива array. Возвращает nil, если изменять ничего не потребовалось.
[ "a", nil, "b", nil, "c" ].compact! #=> [ "a", "b", "c" ]
[ "a", "b", "c" ].compact! #=> nil
[править] Array#concat
array.concat(other_array) -> array
Добавляет к массиву array элементы массива other_array.
[ "a", "b" ].concat( ["c", "d"] ) #=> [ "a", "b", "c", "d" ]
[править] Array#delete
array.delete(obj) -> obj или nil
array.delete(obj){ block } -> obj или nil
Удаляет все элементы массива array, которые равны obj. Если ничего не было удалено, то возвращает nil. Если задан блок, то, в случае отсутствия элементов для удаления, возвращает результат блока.
a = [ "a", "b", "b", "b", "c" ]
a.delete("b") #=> "b"
a #=> ["a", "c"]
a.delete("z") #=> nil
a.delete("z") { "not found" } #=> "not found"
[править] Array#delete_at
array.delete_at(index) -> obj или nil
Удаляет элемент из массива array, который имеет индекс index. Возвращает значение удаленного элемента или nil, если index находится вне допустимого диапазона.
a = %w( ant bat cat dog )
a.delete_at(2) #=> "cat"
a #=> ["ant", "bat", "dog"]
a.delete_at(99) #=> nil
|
Метод slice! имеет схожую функциональность |
[править] Array#delete_if
array.delete_if {|item| block } -> array
Удаляет все элементы массива array для которых значение внутри блока block равно true.
a = [ "a", "b", "c" ]
a.delete_if {|x| x >= "b" } #=> ["a"]
a #=> ["a"]
|
Полезно посмотреть на следующие итераторы reject и reject!, которые имеют схожую функциональность |
[править] Array#each
array.each {|item| block } -> array
Выполняет код в block для каждого элемента массива array, передавая в блок текущий элемент в качестве параметра.
a = [ "a", "b", "c" ]
a.each {|x| print x, " -- " }
результат:
a -- b -- c --
|
|
[править] Array#each_index
array.each_index {|index| block } -> array
Работает точно также, как и each, но передает в блок не текущий элемент, а индекс текущего элемента.
a = [ "a", "b", "c" ]
a.each_index {|x| print x, " -- " }
результат:
0 -- 1 -- 2 --
[править] Array#empty?
array.empty? -> true или false
Возвращает true, если array не содержит элементов.
[].empty? #=> true
[править] Array#eql?
array.eql?(other) -> true или false
Возвращает true, если array и other являются одним и тем же объектом или оба массива обладают одинаковым содержимым.
[править] Array#fetch
array.fetch(index) -> obj
array.fetch(index, default ) -> obj
array.fetch(index) {|index| block } -> obj
Попытка получить элемент массива array по индексу index. Если индекс выходит за пределы массива то, в первой форме вызова возникнет ошибка IndexError, во второй форме вызова будет возвращено значение default, и в третьей форме вызова будет возвращено значение блока block (в который передается запрашиваемый индекс в качестве параметра). Отрицательная индексация подразумевает отсчет с конца массива.
a = [ 11, 22, 33, 44 ]
a.fetch(1) #=> 22
a.fetch(-1) #=> 44
a.fetch(4, 'cat') #=> "cat"
a.fetch(4) { |i| i*i } #=> 16
[править] Array#fill
array.fill(obj) -> array
array.fill(obj, start [, length]) -> array
array.fill(obj, range ) -> array
array.fill {|index| block } -> array
array.fill(start [, length] ) {|index| block } -> array
array.fill(range) {|index| block } -> array
Первые три формы вызова заменяют указанные элементы массива array на значение obj. Если значение start равно nil, то это эквивалентно start=0. Если значение length равно nil, то это эквивалентно lenght=array.lenght. Последние три формы вызова заполняют массив значением выражения в блоке block (в который передается индекс текущего заменяемого элемента).
a = [ "a", "b", "c", "d" ]
a.fill("x") #=> ["x", "x", "x", "x"]
a.fill("z", 2, 2) #=> ["x", "x", "z", "z"]
a.fill("y", 0..1) #=> ["y", "y", "z", "z"]
a.fill {|i| i*i} #=> [0, 1, 4, 9]
a.fill(-2) {|i| i*i*i} #=> [0, 1, 8, 27]
[править] Array#first
array.first -> obj или nil array.first(n) -> an_array
Возвращает первый элемент или первые n элементов массива array. Если массив пуст, то для первой формы вызова (без n) возвращается nil, а для второй — пустой массив.
a = [ "q", "r", "s", "t" ]
a.first #=> "q"
a.first(1) #=> ["q"]
a.first(3) #=> ["q", "r", "s"]
[править] Array#flatten
array.flatten -> an_array
Преобразует многомерный массив array в одномерный.
s = [ 1, 2, 3 ] #=> [1, 2, 3]
t = [ 4, 5, 6, [7, 8] ] #=> [4, 5, 6, [7, 8]]
a = [ s, t, 9, 10 ] #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
a.flatten #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10
[править] Array#flatten!
array.flatten! -> array или nil
Преобразует многомерный массив array в одномерный. Возвращает nil, если массив array изначально был одномерным.
a = [ 1, 2, [3, [4, 5] ] ]
a.flatten! #=> [1, 2, 3, 4, 5]
a.flatten! #=> nil
a #=> [1, 2, 3, 4, 5]
[править] Array#frozen?
array.frozen? -> true или false
Возвращает true, если массив array заморожен (или временно заморожен, пока идет сортировка).
[править] Array#hash
array.hash -> fixnum
Вычисляет хеш-код для массива array. Два массива с одним и тем же содержимым будут иметь одинаковый хеш-код (именно его использует eql?).
[править] Array#include?
array.include?(obj) -> true или false
Возвращает true, если объект obj является элементом массива array (то есть какой-то из элементов массива == obj). Иначе — false.
a = [ "a", "b", "c" ]
a.include?("b") #=> true
a.include?("z") #=> false
[править] Array#index
array.index(obj) -> int или nil
Возвращает индекс первого вхождения элемента в массив array, который == obj. Возвращает nil, если такой элемент не был найден.
a = [ "a", "b", "c" ]
a.index("b") #=> 1
a.index("z") #=> nil
|
Советую взглянуть на метод rindex, который не только похож по названию, но, в некоторых случаях, работает точно также, как и index |
[править] Array#indexes
array.indexes( i1, i2, ... iN ) -> an_array array.indices( i1, i2, ... iN ) -> an_array
[править] Array#indices
array.indexes( i1, i2, ... iN ) -> an_array array.indices( i1, i2, ... iN ) -> an_array
[править] Array#insert
array.insert(index, obj...) -> array
Вставляет полученные значения перед элементом индексом index (может быть отрицательным).
a = %w{ a b c d }
a.insert(2, 99) #=> ["a", "b", 99, "c", "d"]
a.insert(-2, 1, 2, 3) #=> ["a", "b", 99, "c", 1, 2, 3, "d"]
[править] Array#inspect
array.inspect -> string
Создает «печатную» версию массива array.
[править] 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
Выполняет выражение block для каждого элемента массива array. Создает новый массив, который состоит из значений, которые получены при вычислении выражения block.
a = [ "a", "b", "c", "d" ]
a.map {|x| x + "!" } #=> ["a!", "b!", "c!", "d!"]
a #=> ["a", "b", "c", "d"]
|
|
[править] Array#map!
array.collect! {|item| block } -> array
array.map! {|item| block } -> array
Выполняет выражение block для каждого элемента массива array, вычисленное выражение подставляется вместо текущего элемента.
a = [ "a", "b", "c", "d" ]
a.map! {|x| x + "!" }
a #=> [ "a!", "b!", "c!", "d!" ]
|
|
[править] Array#nitems
array.nitems -> int
Возвращает количество элементов массива array, значение которых не равно nil. Может быть нулевым (для пустого массива или массива, который заполнен nil.
[ 1, nil, 3, nil, 5 ].nitems #=> 3
[править] Array#pack
array.pack ( aTemplateString ) -> aBinaryString
Упаковывает содержимое массива array в двоичную последовательность (в виде строки) в соответствии с опциями в строке aTemplateString (см. таблицу ниже). После опций A, a и Z может идти число, которое указывает на ширину результирующего поля. Для остальных, число после опций означает — количество элементов массива которые необходимо обработать в соответствии с указанной опцией. Если в вместо числа после директивы стоит символ * («звездочка»), то все оставшиеся элементы массива необходимо обработать в соответствии с этой опцией. Любую из опций s, S, i, I, l и L можно завершать _ (знаком подчеркивания) для того, чтобы использовать размер для базовой платформы; иначе, будет использован платформонезависимый размер. В строке aTemplateString пробелы игнорируются.
a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
a.pack("A3A3A3") #=> "a b c "
a.pack("a3a3a3") #=> "a\000\000b\000\000c\000\000"
n.pack("ccc") #=> "ABC"
Опции метода pack.
| Опция | Описание |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Данный метод обычно используется совместно с методом String#unpack, который выполняет обратные действия |
[править] Array#pop
array.pop -> obj или nil
Удаляет последний элемент из массива array и возвращает его. Если на момент вызова массив был пуст, то возвращает nil.
a = [ "a", "m", "z" ]
a.pop #=> "z"
a #=> ["a", "m"]
[править] Array#push
array.push(obj, ... ) -> array
Добавить элемент — добавляет передаваемый объект (или несколько объектов) в конец массива. Возвращает массив с выполненным преобразованием.
a = [ "a", "b", "c" ]
a.push("d", "e", "f") #=> ["a", "b", "c", "d", "e", "f"]
a #=> ["a", "b", "c", "d", "e", "f"]
[править] Array#rassoc
array.rassoc(key) -> an_array или nil
Ищет в двумерном массиве массив, последний элемент которого равен key (для сравнения используется метод ==). Возвращает первый найденный массив (то есть, ассоциированный массив) или nil, если таковой найти не удалось
a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
a.rassoc("two") #=> [2, "two"]
a.rassoc("four") #=> nil
|
Для понимания происходящего, полезно взглянуть на метод assoc |
[править] Array#reject
array.reject {|item| block } -> an_array
Возвращает новый массив, состоящий из элементов массива array, для которых значение внутри блока block равно false (или nil).
a = [1,2,3,4,5]
a.reject{ |item| item > 2 } #-> [1,2]
a #-> [1,2,3,4,5]
|
|
[править] Array#reject!
array.reject! {|item| block } -> array или nil
Подобно итератору delete_if удаляет из массива array элементы, для которых значение внутри блока block равно true, но возвращает nil, если изменений в массиве сделано не было.
a = [1,2,3,4,5]
a.reject!{ |item| item > 2 } #-> [1,2]
a #-> [1,2]
a.reject!{ |item| item > 2 } #-> nil
|
Полезно посмотреть описание итератора delete_if, который делает примерно тоже самое, но название которого лучше запоминается |
[править] Array#replace
array.replace(other_array) -> array
Заменяет содержимое массива array содержимым массива other_array.
a = [ "a", "b", "c", "d", "e" ]
a.replace([ "x", "y", "z" ]) #=> ["x", "y", "z"]
a #=> ["x", "y", "z"]
|
Данный метод работает как присваивание, но может быть использован при построении цепочки методов (которую присваивание обычно разрывает) |
.
[править] Array#reverse
array.reverse -> an_array
Возвращает новый массив, в котором элементы массива array стоят в обратном порядке.
[ "a", "b", "c" ].reverse #=> ["c", "b", "a"]
[ 1 ].reverse #=> [1]
[править] Array#reverse!
array.reverse! -> array
Изменяет порядок элементов в массиве array на обратный.
a = [ "a", "b", "c" ]
a.reverse! #=> ["c", "b", "a"]
a #=> ["c", "b", "a"]
.
[править] Array#reverse_each
array.reverse_each {|item| block }
Работает точно также, как и итератор each, но элементы массива array обрабатываются в обратном порядке.
a = [ "a", "b", "c" ]
a.reverse_each {|x| print x, " " }
результат:
c b a
|
Достичь точно такого же результата можно вот так: array.reverse.each {|item| block } |
[править] Array#rindex
array.rindex(obj) -> int или nil
Возвращает индекс последнего вхождения элемента в массив array, который == obj. Возвращает nil, если такой элемент не был найден Простым языком - находит obj с конца.
a = [ "a", "b", "b", "b", "c" ]
a.rindex("b") #=> 3
a.rindex("z") #=> nil
|
Советую взглянуть на метод index, который не только похож по названию, но, в некоторых случаях, работает точно также, как и rindex |
[править] Array#select
array.select {|item| block } -> an_array
Выполняет выражение в block для каждого элемента массива array и возвращает массив, который состоит из элементов, для которых выражение в block принимает значение true.
a = %w{ a b c d e f }
a.select {|v| v =~ /[aeiou]/} #=> ["a", "e"]
|
Есть итераторы Enumerable#select и #Enumerable#find_all, которые имеют схожую функциональность |
[править] Array#shift
array.shift -> obj or nil
Удаляет первый элемент из массива array и возвращает его (как бы «сдвигает» массив влево на один элемент). Если на момент вызова массив был пуст, то возвращает nil.
args = [ "-m", "-q", "filename" ]
args.shift #=> "-m"
args #=> ["-q", "filename"]
|
Данный метод обычно используют совместно с методами push, pop и unshift |
[править] Array#size
array.length -> int array.size -> int
Возвращает количество элементов в array. Может быть нулевым (для пустого массива).
[ 1, 2, 3, 4, 5 ].size #=> 5
|
[править] 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 по индексу (иногда с продолжительностью lenght) или диапазону. Возвращает удаляемые объект, подмассив или nil (если указанный индекс выходит за предел допустимых значений).
def slice!(*args)
result = self[*args]
self[*args] = nil
result
end
a = [ "a", "b", "c" ]
a.slice!(1) #=> "b"
a #=> ["a", "c"]
a.slice!(-1) #=> "c"
a #=> ["a"]
a.slice!(100) #=> nil
a #=> ["a"]
|
Частными реализациями данного метода являются методы pop ( array.slice!(-1) ) и shift ( array.slice!(0) ) |
[править] Array#sort
array.sort -> an_array
array.sort {| a,b | block } -> an_array
Возвращает новый массив, который получен путем сортировки массива array (по возрастанию). Элементы массива должны допускать сравнение при помощи метода <=>, если это не обеспечивается, то можно использовать необязательный блок. Блок предназначенный для сравнения параметров a и b, должен возвращать значения -1, 0, или +1.
a = [ "d", "a", "e", "c", "b" ]
a.sort #=> ["a", "b", "c", "d", "e"]
a.sort {|x,y| y <=> x } #=> ["e", "d", "c", "b", "a"]
|
Более интересная и чаще используемая форма сортировки производится при помощи итератора Enumerable#sort_by |
[править] Array#sort!
array.sort! -> array
array.sort! {| a,b | block } -> array
Сортирует массив array (по возрастанию). Элементы массива должны допускать сравнение при помощи метода <=>, если это не обеспечивается, то можно использовать необязательный блок. Блок предназначенный для сравнения параметров a и b, должен возвращать значения -1, 0, или +1.
a = [ "d", "a", "e", "c", "b" ]
a.sort #=> ["a", "b", "c", "d", "e"]
a.sort {|x,y| y <=> x } #=> ["e", "d", "c", "b", "a"]
|
Более интересная и чаще используемая форма сортировки производится при помощи метода Enumerable#sort_by |
.
[править] Array#to_a
array.to_a -> array
Возвращает указатель на self. Если вызывается от потомка класса Array, то конвертирует указанный объект в массив (объект класса Array).
[править] Array#to_ary
array.to_ary -> array
Возвращает указатель на self. По сути, ничего не делает.
[править] Array#to_s
array.to_s -> string
Возвращает результат self.join.
[ "a", "e", "i", "o" ].to_s #=> "aeio"
[править] Array#transpose
array.transpose -> an_array
Подразумевает, что array является массивом массивов (то есть с размерностью больше, чем один) и меняет местами столбцы со строками (транспонирует).
a = [[1,2], [3,4], [5,6]]
a.transpose #=> [[1, 3, 5], [2, 4, 6]]
[править] Array#uniq
array.uniq -> an_array
Возвращает новый массив, который получен из массива array путем удаления всех повторяющихся элементов (то есть остаются только «uniq'альные элементы»).
a = [ "a", "a", "b", "b", "c" ]
a.uniq #=> ["a", "b", "c"]
[править] Array#uniq!
array.uniq! -> array или nil
Удаляет из массива array все повторяющиеся элементы (то есть остаются только «uniq'альные элементы»). Возвращает nil, если повторяющиеся элементы в массиве array отсутствовали.
a = [ "a", "a", "b", "b", "c" ]
a.uniq! #=> ["a", "b", "c"]
b = [ "a", "b", "c" ]
b.uniq! #=> nil
[править] Array#unshift
array.unshift(obj, ...) -> array
Добавляет элементы в начало массива array (со сдвигом вправо уже существующих).
a = [ "b", "c", "d" ]
a.unshift("a") #=> ["a", "b", "c", "d"]
a.unshift(1, 2) #=> [ 1, 2, "a", "b", "c", "d"]
a #=> [ 1, 2, "a", "b", "c", "d"]
[править] Array#values_at
array.values_at(selector,... ) -> an_array
Возвращает массив, который состоит из элементов массива array, которые соответствуют передаваемым селекторам. Селекторы могут быть целыми числами (индексами) или целочисленными диапазонами.
a = %w{ a b c d e f }
a.values_at(1, 3, 5)
a.values_at(1, 3, 5, 7)
a.values_at(-1, -3, -5, -7)
a.values_at(1..3, 2...5)
|
Для подобных целей также используются методы select и [] («батарейка»). Вот только в «батарейке» нельзя указывать несколько непоследовательных индексов или диапазонов, а select отбирает элементы по условию (а не по индексу) |
[править] Array#zip
array.zip(arg, ...) -> an_array
array.zip(arg, ...) {| arr | block } -> nil
Преобразует аргументы в массивы (при помощи метода to_a). Объединяет каждый элемент массива array с соответствующим массивом, переданным в качестве аргумента. В результате этого создается двумерный массив с array.size строками и с n столбцами, где n — максимальная из длин аргументов-массивов. Если длина какого либо из аргументов-массивов меньше n, то он расширяется до длины n (дополняется nil). Если задан блок, то получаемые массивы передаются в блок в качестве параметра, иначе — возвращается двумерный массив.
a = [ 4, 5, 6 ]
b = [ 7, 8, 9 ]
[1,2,3].zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1,2].zip(a,b) #=> [[1, 4, 7], [2, 5, 8]]
a.zip([1,2],[8]) #=> [[4,1,8], [5,2,nil], [6,nil,nil]]
|
Обычно используется совместно с методом assoc, то есть zip подготавливает для него массив, по которому будет осуществляться ассоциация |
[править] Класс 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
Так как ftl уже является вещественным числом, то данный метод всегда возвращает 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, floor, gcdlcm, gcd, integer?, lcm, next, numerator, prime_division, round, succ, times, to_int, to_i, to_r, 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, который имеет схожую функциональность |
[править] 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#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 #-> integer int.succ #-> integer
Возвращает целое число, которое равно int + 1.
1.next #-> 2 (-1).next #-> 0
|
Методы succ и next — абсолютно идентичны, то есть являются именами одного и того же метода |
[править] Integer#numerator
num.numerator #-> num
Для целого числа числитель всегда равен его значению. Поэтому данный метод возвращает значение num.
|
Полезно посмотреть на метод denominator, который имеет схожую функциональность |
[править] Integer#prime_division
num.prime_division #-> array
Возвращает двумерный массив, состоящий из простых делителей числа и их степеней.
require 'mathn' 35.prime_division #-> [[5, 1], [7, 1]] 256.prime_division #-> [[2, 8]]
|
Полезно посмотреть на метод from_prime_division, который имеет схожую функциональность |
[править] 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 #-> integer int.succ #-> integer
Возвращает целое число, которое равно 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_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#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#<=>
num <=> other #-> 0 или nil
Возвращает ноль, если num равно other, в противном случае — nil.
[править] 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.
1.floor #-> 1 (-1).floor #-> -1
|
Полезно посмотреть на методы 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 не является нулем и 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
Методы класса
Методы объекта
[]=, [], %, *, +, <<, <=>, ==, =~, capitalize!, capitalize, casecmp, center, chomp!, chomp, chop!, chop, concat, count, crypt, delete!, delete, 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, 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_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] #-> 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[1] #-> 101 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#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!, которые имеют схожую функциональность |
[править] 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#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!, который имеет схожую функциональность |
[править] 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!, который удаляет только символы перевода строки, а не просто последний символ. Это позволит избежать многих трудновыявляемых ошибок в будущем |
[править] 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 |
[править] 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!, которые также производят преобразования регистра |
- Данный метод изменяет исходную строку. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод downcase
- У всех символов, кроме латиницы на эти изменения устойчивый иммунитет. Это не значит, что будет возникать ошибка... просто они не будут преобразованы по вышеописанному правилу
[править] 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#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!, который имеет схожую функциональность |
[править] 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(101) #-> 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!, которые имеют схожую функциональность |
[править] 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! — абсолютно идентичны, то есть являются именами одного и того же метода |
[править] String#oct
str.oct #-> integer
Трактует строку str как строку восьмеричных цифр (с необязательным указанием знака или необятельным префиксом 0) и возвращает cоотвествующее число. Если преобразование не удается, то возвращает ноль.
"123".oct #-> 83 "-377".oct #-> -255 "bad".oct #-> 0 "0377bad".oct #-> 255
|
[править] String#replace
str.replace(other_str) #-> str
Заменяет содержимое строки str на значение параметра other_str.
s = "hello" #-> "hello" s.replace "world" #-> "world"
[править] 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 |
[править] 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#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) #-> 101 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) #-> 105 string.slice!(3..6) #-> " is " string.slice!(/s.*t/) #-> "sa st" string.slice!("r") #-> "r" string #-> "thing"
|
Полезно посмотреть на методы 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", "", ""]
|
Полезно посмотреть на метод scan, который имеет схожую функциональность |
[править] 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
[править] String#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!, которые имеют схожую функциональность |
[править] 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!, который имеет схожую функциональность |
[править] 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! — абсолютно идентичны, то есть являются именами одного и того же метода |
[править] String#sum
str.sum(n=16) #-> integer
Возвращает простую n-битную контрольную сумму символов строки str, где n опциональный целочисленный (Fixnum) параметр, по-умолчанию равный 16. Результатом -- это просто суммирование двоичных значений каждого символа строки str по модулю 2n - 1.
[править] 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
|
|
- Данный метод изменяет исходную строку. Будьте внимательны! Чтобы исключить подобного рода изменения используйте метод swapcase
- У всех символов, кроме латиницы на эти изменения устойчивый иммунитет. Это не значит, что будет возникать ошибка... просто они не будут преобразованы по вышеописанному правилу
[править] 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!, который имеет схожую функциональность |
[править] 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!, который имеет схожую функциональность |
[править] 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!, которые имеют схожую функциональность |
[править] 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
|
|
[править] Класс 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("логическое или")
результат:
или
