Перейти к содержанию

Ruby/Справочник/String

Материал из Викиучебника — открытых книг для открытого мира

Класс 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

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

new

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

[]=, [], %, *, +, <<, <=>, ==, =~, ascii_only?, capitalize!, capitalize, casecmp, center, chars, chomp!, chomp, chop!, chop, clear, concat, count, crypt, delete!, delete, delete_prefix, delete_prefix!, downcase!, downcase, dump, each_byte, each_char, each_line, each, empty?, eql?, gsub!, gsub, hash, hex, include?, index, insert, inspect, intern, length, ljust, lstrip!, lstrip, match, next!, next, nstrip, oct, ord, replace, reverse!, reverse, rindex, rjust, rstrip!, rstrip, scanf, scan, size, slice!, slice, split, squeeze!, squeeze, strip!, strip, sub!, sub, succ!, succ, sum, swapcase!, swapcase, to_blob, to_a, to_c, to_f, to_i, to_str, to_sym, to_s, tr!, tr_s!, tr_s, tr, unpack, upcase!, upcase, upto

String::new

[править]

String.new(str="")   #-> new_str

Возвращает новую строку, которая содержит копию строки str, передаваемой в качестве параметра.

String#%

[править]

str % arg   #-> new_str

Форматирование строки. В управляющую строку str вместо спецификаторов преобразования подставляются данные из arg. Если в строке str указано несколько спецификаторов преобразования, то arg должен быть массивом.

"%05d" % 123                       #-> "00123"
"%-5s: %08x" % [ "ID", self.id ]   #-> "ID   : 200e14d6"
Информация

Описание формата управляющей строки и спецификаторов можно посмотреть в описании метода Kernel::sprintf

String#*

[править]

str * integer  #-> new_str

Повторение — возвращает новую строку, которая состоит из integer-копий строки str.

"Ho! " * 3   #-> "Ho! Ho! Ho! "

String#+

[править]

str + other_str   #-> new_str

Сцепление — возвращает новую строку, состоящую из строк str и other_str.

"Hello from " + self.to_s   #-> "Hello from main"
Информация

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

String#<<

[править]

str << fixnum        #-> str
str.concat(fixnum)   #-> str
str << obj           #-> str
str.concat(obj)      #-> str

Добавление — присоединяет аргумент к str. Если аргумент типа Fixnum в диапазоне от 0 до 255, то он перед присоединением конвертируется в символ.

a = "hello ";
a << "world"   #-> "hello world"
a << 33        #-> "hello world!"
Информация

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

String#<=>

[править]

str <=> other_str   #-> -1, 0, +1

Сравнение — возвращает -1, если other_str меньше str; возвращает 0, если other_str и str равны; возвращает +1, если other_str больше str. Если строки различаются по длине, но эквивалентны на длине самой короткой из двух, то большей считается та, которая длиннее. Если переменная $= равна false, то сравнение базируется на сравнении двоичных значений каждого символа в строке. В старых версиях Руби, изменением $= можно было добиться регистронезависимого сравнения, но теперь эту функцию выполняет метод casecmp, который и рекомендуется использовать для этих целей.

"abcdef" <=> "abcde"     #-> 1
"abcdef" <=> "abcdef"    #-> 0
"abcdef" <=> "abcdefg"   #-> -1
"abcdef" <=> "ABCDEF"    #-> 1
Информация

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

Информация

Метод <=> служит основой для таких методов, как: <, <=, >, >= и between?, которые подключаются вместе с модулем Comparable

String#==

[править]

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

Эквивалентность — если строки str и obj не совпадают, то возвращается false. Возвращается true только в случае, когда код str <=> obj возвращает 0.

String#=~

[править]

str =~ obj   #-> fixnum или nil

Сопоставление с шаблоном — если obj является правилом, то он используется как шаблон для сопоставления с str и возвращает позицию с которой найдено соспоставление или nil, если такого сопоставления найти не удалось. Иначе, происходит вызов метода obj.=~, которому передается str как аргумент. По умолчанию, метод =~ в классе Object возвращает false.

"cat o' 9 tails" =~ /\d/   #-> 7
"cat o' 9 tails" =~ 9      #-> false
Информация

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

String#[]

[править]

str[index]                  #-> символ или nil
str[start, length]          #-> new_str или nil
str[range]                  #-> new_str или nil
str[regexp]                 #-> new_str или nil
str[regexp, index]          #-> new_str или nil
str[other_str]              #-> new_str или nil
str.slice(index)            #-> fixnum или nil
str.slice(start, length)    #-> new_str или nil
str.slice(range)            #-> new_str или nil
str.slice(regexp)           #-> new_str или nil
str.slice(regexp, index)    #-> new_str или nil
str.slice(other_str)        #-> new_str или nil

Получение подстроки или символа — возвращает код символа с индексом index, или подстроку длины length, начиная с индекса start, или подстроку, которая располагается в диапазоне range. Во всех этих вариантах вызова отрицательная индексация подразумевает отсчет с конца строки str. Возвращается nil, если индекс index выходит за пределы допустимого диапазона, размер length запрашиваемой подстроки отрицательный или начало диапазона range попадает после конца строки str. Если передается правило regexp, то возвращается фрагмент строки str, который удовлетворяет правилу regexp (или nil, если такого совпадения найти не удалось). Если задан дополнительный параметр index, то возвращается содержимое группировки правила с номером index (если index равен 0, то возвращается фрагмент строки, который удовлетворяет правилу regexp). Если в качестве аргумента передается строка other_str, то возвращается строка other_str, если она является подстрокой строки str (или nil, иначе).

a = "hello there"
a[1]                   #-> "e"
a[1,3]                 #-> "ell"
a[1..3]                #-> "ell"
a[-3,2]                #-> "er"
a[-4..-2]              #-> "her"
a[12..-1]              #-> nil
a[-2..-4]              #-> ""
a[/[aeiou](.)\1/]      #-> "ell"
a[/[aeiou](.)\1/, 0]   #-> "ell"
a[/[aeiou](.)\1/, 1]   #-> "l"
a[/[aeiou](.)\1/, 2]   #-> nil
a["lo"]                #-> "lo"
a["bye"]               #-> nil
Информация

Методы slice и [] («батарейка») — абсолютно идентичны!

String#[]=

[править]

str[index] = fixnum
str[index] = new_str
str[start, length] = new_str
str[range] = new_str
str[regexp] = new_str
str[regexp, index] = new_str
str[other_str] = new_str

Присваивание значения элементу — заменяет часть или все содержимое строки str. Внутри квадратных скобок используются те же самые параметры, что и в [] («батарейка»). Если заменяемая строка не совпадает по размеру с заменяющей, то происходит соответствующая адаптация. Если правило или строка или индекс не позволяют определить позицию для замены, то возникает ошибка IndexError. Если используется форма вызова с regexp и index, то происходит замена подстроки, которая совпадает группировкой в regexp с номером index. Формы вызова, которым передается index или start могут вызвать ошибку IndexError, если их значение выходит за пределы индексации строки; форма вызова с range может вызвать ошибку RangeError, а форма вызова с regexp или other_str тихо реагируют на возможные ошибки (отсутствие совпадение с правилом или строкой).

String#ascii_only?

[править]

str.ascii_only?   #-> true или false

Возвращает true для строки, которая содержит только ASCII символы. В противном случае возвращает false.

"abc".force_encoding("UTF-8").ascii_only?          #=> true
"abc\u{6666}".force_encoding("UTF-8").ascii_only?          #=> false

String#bytesize

[править]

bytesize   #-> integer

Возвращает количество байтов в себе:

"\x80\u3042".bytesize     #=> 4
"hello".bytesize          #=> 5
Информация

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

String#byteslice

[править]

byteslice(integer)   #-> new_str или nil
byteslice(integer, integer) #-> new_str или nil
byteslice(range) #-> new_str или nil

Байтовая ссылка - если передано одно целое число, возвращает подстроку из одного байта в этой позиции. Если переданы два объекта Integer, возвращает подстроку, начиная со смещения, заданного первым, и длину, заданную вторым. Если задан диапазон, возвращается подстрока, содержащая байты со смещениями, заданными диапазоном. Во всех трех случаях, если смещение отрицательное, оно отсчитывается от конца str. Возвращает nil, если начальное смещение выходит за пределы строки, длина отрицательна или начало диапазона больше конца. Кодировка полученной строки сохраняет исходную кодировку.

"hello".byteslice(1)     #=> "e"
"hello".byteslice(-1)    #=> "o"
"hello".byteslice(1, 2)  #=> "el"
"\x80\u3042".byteslice(1, 3) #=> "\u3042"
"\x03\u3042\xff".byteslice(1..3) #=> "\u3042"

String#capitalize

[править]

str.capitalize   #-> new_str

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

"hello".capitalize    #-> "Hello"
"HELLO".capitalize    #-> "Hello"
"123ABC".capitalize   #-> "123abc"
Информация

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

String#capitalize!

[править]

str.capitalize!   #-> str или nil

Модифицирует строку str по правилу: первый символ преобразуется в верхний регистр, а остальные — в нижний. Возвращает nil, если изменения не требуются.

a = "hello"
a.capitalize!   #-> "Hello"
a               #-> "Hello"
a.capitalize!   #-> nil
Информация

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

String#casecmp

[править]

str.casecmp(other_str)   #-> -1, 0, +1

Регистронезависимая версия метода <=>.

"abcdef".casecmp("abcde")     #-> 1
"aBcDeF".casecmp("abcdef")    #-> 0
"abcdef".casecmp("abcdefg")   #-> -1
"abcdef".casecmp("ABCDEF")    #-> 0

String#center

[править]

str.center(integer, padstr)   #-> new_str

Если integer больше, чем str.length, то возвращает новую строку, длина которой равна integer, строка str располагается посередине, обитая символами строки padstr; иначе, возвращает str.

"hello".center(4)         #-> "hello"
"hello".center(20)        #-> "       hello        "
"hello".center(20, '123') #-> "1231231hello12312312"
Информация

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

String#chars

[править]

str.chars   #-> array

Возвращает массив, содержащий символы строки, из которой вызывается метод.

"hello".chars            #-> ["h", "e", "l", "l", "o"]

String#chomp

[править]

str.chomp(separator=$/)   #-> new_str

Возвращает новую строку, которая является копией строки str в которой удален последний символ separator. Если системная переменная $/ не была изменена и не передается параметр separator, то метод chomp удалит завершающие символы строки (такие как \n, \r и \r\n).

"hello".chomp            #-> "hello"
"hello\n".chomp          #-> "hello"
"hello\r\n".chomp        #-> "hello"
"hello\n\r".chomp        #-> "hello\n"
"hello\r".chomp          #-> "hello"
"hello \n there".chomp   #-> "hello \n there"
"hello".chomp("llo")     #-> "he"
Информация

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

String#chomp!

[править]

str.chomp!(separator=$/)   #-> str или nil

Модифицирует строку str по алгоритму, описанному в методе chomp. Возвращает обработанную строку str или nil, если изменения не требуются.

"hello".chomp!            #-> nil
"hello\n".chomp!          #-> "hello"
"hello".chomp!("llo")     #-> "he"
Информация

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

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#chr

[править]

str.chr   #-> string

Возвращает односимвольную строку с начала строки.

str = "abcde"
str.chr           #-> "a"
str = "bcde"
str.chr           #-> "b"

String#clear

[править]

str.clear   #-> empty string

Делает строку, из которой вызывается, пустой.

str = "abcde"
str.clear           #-> ""

String#concat

[править]

str << fixnum        #-> str
str.concat(fixnum)   #-> str
str << obj           #-> str
str.concat(obj)      #-> str

Добавление — присоединяет аргумент к str. Если аргумент типа Fixnum в диапазоне от 0 до 255, то он перед присоединением конвертируется в символ.

a = "hello ";
a.concat("world")   #-> "hello world"
a.concat(33)        #-> "hello world!"
Информация

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

String#count

[править]

str.count(other_str*)   #-> fixnum

Каждый параметр other_str преобразуется в множество символов. Метод подсчитывает количество символов str, которые принадлежат этому множеству. При помощи символа "галочка" (^) задаются исключения из множества. Выражения типа c1-c2 задают множество символов, которые располагаются между символами c1 и c2.

a = "hello world"
a.count "lo"            #-> 5
a.count "lo", "o"       #-> 2
a.count "hello", "^l"   #-> 4
a.count "ej-m"          #-> 4

String#crypt

[править]

str.crypt(salt_str)   #-> new_str

Применяет однопроходное криптографическое хеширование к строке str посредством функции crypt из стандартной библиотеки языка Си. Аргументом метода является строка salt_str, которая содержит "шумовые" символы. Она должна быть длиннее двух символов, каждый из которых должен принадлежать множеству [a-zA-Z0-9./].

String#delete

[править]

str.delete(other_str*)   #-> new_str

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

"hello".delete "l","lo"        #-> "heo"
"hello".delete "lo"            #-> "he"
"hello".delete "aeiou", "^e"   #-> "hell"
"hello".delete "ej-m"          #-> "ho"
Информация

Использует те же самые правила создания множеств символов, что и в методе count

String#delete!

[править]

str.delete!(other_str*)   #-> str или nil

Удаляет из строки str все символы, передаваемые параметром. Возвращает модифицированную строку str или nil, если строка str не была модифицирована.

str="hello"
str.delete! "l","lo"        #-> "heo"
str                         #-> "heo"
str.delete! "l","lo"        #-> nil
Информация

Использует те же самые правила создания множеств символов, что и в методе count

String#delete_prefix

[править]

str.delete_prefix(prefix)   #-> new_str

Возвращает копию str с удаленным начальным префиксом.

str="hello"
str.delete_prefix("hel")        #-> "lo"
str                         #-> "hello"
str.delete_prefix("llo")        #-> "hello"
str                         #-> "hello"

String#delete_prefix!

[править]

str.delete_prefix!(prefix)   #-> self или nil

Удаляет начальный префикс из строки, возвращая nil, если не было сделано никаких изменений.

str="hello"
str.delete_prefix!("hel")        #-> "lo"
str                         #-> "lo"
str.delete_prefix!("llo")        #-> nil
str                         #-> "hello"
Информация

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

String#delete_suffix

[править]

str.delete_suffix(suffix)   #-> new_str

Возвращает копию str с удаленным конечным суффиксом.

"hello".delete_suffix("llo") #=> "he"
"hello".delete_suffix("hel") #=> "hello"

String#delete_suffix!

[править]

str.delete_suffix!(suffix)   #-> self или nil

Удаляет завершающий суффикс из строки, возвращая nil, если не было сделано никаких изменений.

"hello".delete_suffix!("llo") #=> "he"
"hello".delete_suffix!("hel") #=> nil
Информация

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

String#downcase

[править]

str.downcase   #-> new_str

Возвращает копию строки str в которой все символы вернего регистра заменены на соответствующие символы нижнего.

"hEllO".downcase   #-> "hello"
Информация

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

String#downcase!

[править]

str.downcase!   #-> str или nil

Модифицирует строку str по правилу: все символы верхнего регистра преобразовываются в соответствующие символы нижнего. Возвращает nil, если изменения не требуются.

str="hEllO"
str.downcase! #-> "hello"
str           #-> "hello"
str.downcase! #-> nil
Информация

Полезно посмотреть методы capitalize!, upcase! и swapcase!, которые также производят преобразования регистра

String#dump

[править]

str.dump   #-> new_str

Создает версию строки str в которой все непечатные символы заменены на \nnn нотацию и все специальные символы экранированы.

"Hello world!\n".dump   #-> "\"Hello world!\\n\""

String#each

[править]

str.each(separator=$/) {|substr| block }        #-> str
str.each_line(separator=$/) {|substr| block }   #-> str

Разбивает строку str используя значение параметра separator (по умолчанию separator=$/), передавая каждую из полученных подстрок в качестве параметра блока. Если в качестве параметра separator передается пустая строка, то строка будет делится по символу \n, исключая случай, когда несколько символов \n идут подряд (все символы \n будут засчитываться как один).

print "Example one\n"
"hello\nworld".each {|s| p s}
print "Example two\n"
"hello\nworld".each('l') {|s| p s}
print "Example three\n"
"hello\n\n\nworld".each('') {|s| p s}

результат:

 Example one
 "hello\n"
 "world"
 Example two
 "hel"
 "l"
 "o\nworl"
 "d"
 Example three
 "hello\n\n\n"
 "world"
Информация
  • Обратите внимание, что разделитель separator не удаляется (в отличие от результата работы метода split), а присутствует в результате
  • В качестве результата итератор возвращает исходную строку str
  • Итераторы each и each_line — абсолютно идентичны!

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"
Информация
  • Обратите внимание, что разделитель separator не удаляется (в отличие от результата работы метода split), а присутствует в результате
  • В качестве результата итератор возвращает исходную строку str
  • Итераторы each и each_line — абсолютно идентичны!

String#empty?

[править]

str.empty?   #-> true или false

Возвращает true если строка str имеет нулевую длину (то есть, если строка str — пустая).

"hello".empty?   #-> false
"".empty?        #-> true

String#end_with?

[править]

str.end_with?([suffixes]+) #-> true или false

Возвращает true, если строка заканчивается одним из указанных суффиксов.

"hello".end_with?("ello")  #-> true

Возвращает true, если один из суффиксов совпадает.

"hello".end_with?("heaven", "ello")     #=> true
"hello".end_with?("heaven", "paradise") #=> false

String#eql?

[править]

str.eql?(other_str)   #-> true или false

Две строки называются эквивалентными, если они имеют одинаковое содержимое и длину.

String#gsub

[править]

str.gsub(pattern, replacement)       #-> new_str
str.gsub(pattern) {|match| block }   #-> new_str

Возвращает копию строки str, где все совпадения с шаблоном (или строкой) pattern заменены на строку replacement или результат выполнения блока (которому параметром передается результат совпадения).

В результате работы метода, найденное совпадение с шаблоном pattern записывается в специальную переменную $& (наследие языка Perl). В строке replacement возможно использование последовательностей вида \1, \2 и так далее до \9, которые являются ссылками на совпадения с группировками (номер группировки считается слева направо). Внутри блока на группировки можно ссылаться при помощи специальных переменных вида $1, $2 и так далее до $9. Также, выражению в блоке доступны специальные переменные $`, $& и $', которые позволяют получить доступ к подстроке до совпадения, совпадению и подстроке после совпадения, соответственно.

"hello".gsub(/[aeiou]/, '*')              #-> "h*ll*"
"hello".gsub(/([aeiou])/, '<\1>')         #-> "h<e>ll<o>"
"hello".gsub(/./) {|s| s[0].to_s + ' '}   #-> "104 101 108 108 111 "
Информация

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

String#gsub!

[править]

str.gsub!(pattern, replacement)        #-> str или nil
str.gsub!(pattern) {|match| block }    #-> str или nil

Выполняет замены подобно gsub, но изменяет исходную строку str. Возвращает результат замен или nil, если замены невозможны.

Информация

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

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
Информация
  • Вместо данного метода рекомендуется использовать метод to_i, который является универсальной заменой методов hex и oct
  • Полезно взглянуть на метод oct, который имеет схожий функционал

String#include?

[править]

str.include? other_str   #-> true или false
str.include? fixnum      #-> true или false

Возвращает true, если строка str содержит передаваемые параметром строку other_str или символ fixnum.

"hello".include? "lo"   #-> true
"hello".include? "ol"   #-> false
"hello".include? ?h     #-> true

String#index

[править]

str.index(substring [, offset])   #-> fixnum или nil
str.index(fixnum [, offset])      #-> fixnum или nil
str.index(regexp [, offset])      #-> fixnum или nil

Возвращает индекс первого вхождения передаваемой параметром подстроки (substring), символа (fixnum) или совпадения с правилом (regexp) в строке str. Возвращает nil, если вхождения нет. В качестве второго параметра передается индекс (offset), с которого следует начинать поиск вхождений.

"hello".index('e')             #-> 1
"hello".index('lo')            #-> 3
"hello".index('a')             #-> nil
"hello".index(10)             #-> 1
"hello".index(/[aeiou]/, -3)   #-> 4
Информация

Полезно также взглянуть на метод rindex, который имеет подобный функционал

String#insert

[править]

str.insert(index, other_str)   #-> str

Вставляет строку other_str после указанного индекса index в строку str. Отрицательная индексация подразумевает нумерацию с конца строки.

"abcd".insert(0, 'X')    #-> "Xabcd"
"abcd".insert(3, 'X')    #-> "abcXd"
"abcd".insert(4, 'X')    #-> "abcdX"
"abcd".insert(-3, 'X')   #-> "abXcd"
"abcd".insert(-1, 'X')   #-> "abcdX"

String#inspect

[править]

str.inspect   #-> string

Возвращает печатную версию строки str, в которой все специальные символы экранированы.

str = "hello"
str[3] = 8
str.inspect       #-> "hel\010o"

String#intern

[править]

str.intern   #-> symbol
str.to_sym   #-> symbol

Возвращает объект класса Symbol, который соответствует строке str.

"Koala".intern         #-> :Koala
s = 'cat'.intern       #-> :cat
s == :cat              #-> true
s = '@cat'.intern      #-> :@cat
s == :@cat             #-> true

Этот метод может быть использован для создания символов, которые не могут быть созданы в :xxx нотации.

'cat and dog'.intern   #-> :"cat and dog"
Информация
  • Полезно также взглянуть на метод Symbol#id2name, который осуществляет обратное преобразование
  • Методы intern и to_sym — абсолютно идентичны, но использование метода to_sym предпочтительнее

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
Информация
  • Вместо данного метода рекомендуется использовать метод to_i, который является универсальной заменой методов hex и oct
  • Полезно взглянуть на метод hex, который имеет схожий функционал

String#ord

[править]

str.ord   #-> integer

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


"a".ord       #-> 97
"A".ord      #-> 65
"z".ord      #-> 90
"Z".ord      #-> 122
Информация

Обратите внимание, что метод правильно работает при возврате порядкового номера при исползовании метода swapcase

String#partition

[править]

str.partition(sep)  #-> [head, sep, tail]
str.partition(regexp) #-> [head, match, tail]

Ищет sep или шаблон (regexp) в строке и возвращает часть перед ним, совпадение и часть после него. Если он не найден, возвращает две пустые строки и строку.


"hello".partition("l")         #=> ["he", "l", "lo"]
"hello".partition("x")         #=> ["hello", "", ""]
"hello".partition(/.l/)        #=> ["h", "el", "lo"]

String#replace

[править]

str.replace   #-> str

Заменяет содержимое str соответствующими значениями из other_str.


s = "krishna"       #-> "krishna"
s.replace "rama"      #-> "rama"

String#reverse

[править]

str.reverse   #-> new_str

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

"stressed".reverse   #-> "desserts"

String#reverse!

[править]

str.reverse!   #-> str

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

str="stressed"
str.reverse!   #-> "desserts"
str            #-> "desserts"
Информация

Обратите внимание, что ни при каких обстоятельствах метод reverse! не возвращает nil

String#rindex

[править]

str.rindex(substring [, fixnum])   #-> fixnum или nil
str.rindex(fixnum [, fixnum])      #-> fixnum или nil
str.rindex(regexp [, fixnum])      #-> fixnum или nil

Возвращает индекс последнего вхождения передаваемой параметром подстроки (substring), символа (fixnum) или совпадения с правилом (regexp) в строке str. Возвращает nil, если вхождения нет. В качестве второго параметра передается индекс (fixnum), на котором следует закончить поиск.

"hello".rindex('e')             #-> 1
"hello".rindex('l')             #-> 3
"hello".rindex('a')             #-> nil
"hello".rindex(101)             #-> 1
"hello".rindex(/[aeiou]/, -2)   #-> 1
Информация

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

String#rjust

[править]

str.rjust(integer, padstr=' ')   #-> new_str

Если параметр integer больше, чем длина строки str, то метод возвращает новую строку длины integer со строкой str выравненной по правому краю, а возникшее пустое место заполняется символами padstr; иначе, возвращается строка str.

"hello".rjust(4)            #-> "hello"
"hello".rjust(20)           #-> "               hello"
"hello".rjust(20, '1234')   #-> "123412341234123hello"
Информация

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

String#rstrip

[править]

str.rstrip   #-> new_str

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

"  hello  ".rstrip   #-> "  hello"
"hello".rstrip       #-> "hello"
Информация

Следует обратить внимание на методы lstrip и strip, которые имеют схожую функциональность

String#rstrip!

[править]

str.rstrip!   #-> self или nil

Удаляет замыкающие пробельные символы из строки str. Возвращает nil, если в результате работы метода никаких изменений сделано не было.

"  hello  ".rstrip   #-> "  hello"
"hello".rstrip!      #-> nil
Информация

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

String#scan

[править]

str.scan(pattern)                         #-> array
str.scan(pattern) {|match, ...| block }   #-> str

Обе формы вызова последовательно просматривают str на предмет совпадения с шаблоном (который может быть как строкой, так и правилом. Каждое совпадение записывается в массив (для первой формы вызова) или передается в блок (для второй формы вызова). Если шаблон (который является правилом) не содержит группировок, то каждое совпадение записывается в отдельный элемент (для первой формы вызова) или передается параметром блоку (для второй формы вызова). Также возможно использование специальной переменной $&, которая содержит результат последнего совпадения (актуально при использовании второй формы вызова). Если шаблон содержит группировки, то каждое совпадение разбивается на совпадения группировкам (получается двумерный массив).

a = "cruel world"
a.scan(/\w+/)        #-> ["cruel", "world"]
a.scan(/.../)        #-> ["cru", "el ", "wor"]
a.scan(/(...)/)      #-> [["cru"], ["el "], ["wor"]]
a.scan(/(..)(..)/)   #-> [["cr", "ue"], ["l ", "wo"]]

…и для второй формы вызова:

a.scan(/\w+/) {|w| print "<<#{w}>> " }
print "\n"
a.scan(/(.)(.)/) {|a,b| print b, a }
print "\n"

результат:

 <<cruel>> <<world>>
 rceu lowlr
Информация

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

String#setbyte

[править]

str.setbyte(index, integer)  # => integer

Заменяет содержимое str соответствующими значениями из other_str.

s = "Sunday"
s.setbyte(0, 77)
s.setbyte(-5, 111)
s # => "Monday"

String#size

[править]

str.length   #-> integer
str.size     #-> integer

Возвращает размер строки str.

string = "54321"
string.size   #-> 5
Информация

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

String#slice

[править]

str[index]                 #-> fixnum или nil
str[start, length]         #-> new_str или nil
str[range]                 #-> new_str или nil
str[regexp]                #-> new_str или nil
str[regexp, index]         #-> new_str или nil
str[other_str]             #-> new_str или nil
str.slice(index)           #-> fixnum или nil
str.slice(start, length)   #-> new_str или nil
str.slice(range)           #-> new_str или nil
str.slice(regexp)          #-> new_str или nil
str.slice(regexp, index)   #-> new_str или nil
str.slice(other_str)       #-> new_str или nil

Получение подстроки или символа — возвращает код символа с индексом index, или подстроку длины length, начиная с индекса start, или подстроку, которая располагается в диапазоне range. Во всех этих вариантах вызова отрицательная индексация подразумевает отсчет с конца строки str. Возвращается nil, если индекс index выходит за пределы допустимого диапазона, размер length запрашиваемой подстроки отрицательный или начало диапазона range попадает после конца строки str. Если передается правило regexp, то возвращается фрагмент строки str, который удовлетворяет правилу regexp (или nil, если такого совпадения найти не удалось). Если задан дополнительный параметр index, то возвращается содержимое группировки правила с номером index (если index равен 0, то возвращается фрагмент строки, который удовлетворяет правилу regexp). Если в качестве аргумента передается строка other_str, то возвращается строка other_str, если она является подстрокой строки str (или nil, иначе).

a = "hello there"
a.slice(1)                   #-> "e"
a.slice(1,3)                 #-> "ell"
a.slice(1..3)                #-> "ell"
a.slice(-3,2)                #-> "er"
a.slice(-4..-2)              #-> "her"
a.slice(12..-1)              #-> nil
a.slice(-2..-4)              #-> ""
a.slice(/[aeiou](.)\1/)      #-> "ell"
a.slice(/[aeiou](.)\1/, 0)   #-> "ell"
a.slice(/[aeiou](.)\1/, 1)   #-> "l"
a.slice(/[aeiou](.)\1/, 2)   #-> nil
a.slice("lo")                #-> "lo"
a.slice("bye")               #-> nil
Информация

Методы slice и [] («батарейка») — абсолютно идентичны!

String#slice!

[править]

str.slice!(fixnum)           #-> fixnum или nil
str.slice!(fixnum, fixnum)   #-> new_str или nil
str.slice!(range)            #-> new_str или nil
str.slice!(regexp)           #-> new_str или nil
str.slice!(other_str)        #-> new_str или nil

Удаляет определенный кусок текста из строки str и возвращает этот кусок в качестве результата. Если в качестве параметра передается число (Fixnum), то возможно возникновение ошибки типа IndexError, когда значение этого числа находится вне допустимого диапазона. Если в качестве параметра передается диапазон (Range), то возможно возникновение ошибки типа RangeError, когда диапазон выходит за рамки допустимых значений. В случае с параметрами типа Regexp и String метод молча реагирует на недопустимые значения.

string = "this is a string"
string.slice!(2)        #-> "i"
string.slice!(3..6)     #-> " is "
string.slice!(/s.*t/)   #-> "sa st"
string.slice!("r")      #-> "r"
string                  #-> "thing"
Информация

Полезно посмотреть на методы slice и [] («батарейка»), которые имеют подобную функциональность

String#split

[править]

str.split(pattern=$;, [limit])   #-> anArray

Делит строку str на подстроки по разделителю pattern (который может быть как правилом, так и строкой). Если разделитель pattern не указан, то деление происходит по пробельному символу (если иное не присвоено специальной переменной $;). В результате деления возвращается массив, который содержит фрагменты строки str (сам разделитель в результат не входит).

Если разделитель pattern является правилом, то деление производится по подстрокам, подходящим под данное правило. Если pattern — строка, то деление производится по подстрокам, которые совпадают с разделителем.

Если задан необязательный параметр limit, то результирующий массив будет иметь количество фрагментов строки str равное limit. Последний элемент будет содержать остаток, который, возможно, еще можно поделить (то есть в строке есть еще разделители).

" now's  the time".split        #-> ["now's", "the", "time"]
" now's  the time".split(' ')   #-> ["now's", "the", "time"]
" now's  the time".split(/ /)   #-> ["", "now's", "", "the", "time"]
"1, 2.34,56, 7".split(%r{,\s*}) #-> ["1", "2.34", "56", "7"]
"hello".split(//)               #-> ["h", "e", "l", "l", "o"]
"hello".split(//, 3)            #-> ["h", "e", "llo"]
"hi mom".split(%r{\s*})         #-> ["h", "i", "m", "o", "m"]

"mellow yellow".split("ello")   #-> ["m", "w y", "w"]
"1,2,,3,4,,".split(',')         #-> ["1", "2", "", "3", "4"]
"1,2,,3,4,,".split(',', 4)      #-> ["1", "2", "", "3,4,,"]
"1,2,,3,4,,".split(',', -4)     #-> ["1", "2", "", "3", "4", "", ""]
"1:2:3".split(/(:)()()/, 2)     #=> ["1", ":", "", "", "2:3"]
"".split(',', -1)               #=> []
Информация

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

String#squeeze

[править]

str.squeeze(del=nil)    #-> new_str

Создает множество символов из строки (или строк) del, переданных в качестве параметра. Возвращает новую строку, где идущие подряд одинаковые символы, которые принадлежат множеству (переданному в качестве параметра), заменяются на один такой символ. Если метод вызван без параметра, то все идущие подряд повторяющиеся символы будут заменены на соответствующий единичный.

"yellow moon".squeeze                  #-> "yelow mon"
"  now   is  the".squeeze(" ")         #-> " now is the"
"putters shoot balls".squeeze("m-z")   #-> "puters shot balls"
Информация

Использует те же самые правила создания множеств символов, что и в методе count

String#squeeze!

[править]

str.squeeze!(del=nil)    #-> new_str

Работает точно также, как и метод squeeze, но результат своей работы записывает в исходную строку.

str = "yellow moon"
str.squeeze! #-> "yelow mon"
str          #-> "yelow mon

String#start_with?

[править]

str.start_with?([prefixes]+) #-> true или false

Возвращает true, если str начинается с одного из заданных префиксов. Каждый из префиксов должен быть строкой или шаблоном (рegexp).

"hello".start_with?("hell")               #=> true
"hello".start_with?(/H/i)                 #=> true

Возвращает истину, если один из префиксов совпадает.

"hello".start_with?("heaven", "hell")     #=> true
"hello".start_with?("heaven", "paradise") #=> false

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"
Информация
  • В переводе с английского, «swap» — переставлять местами
  • Полезно посмотреть методы capitalize, downcase и upcase, которые также производят преобразования регистра

String#swapcase!

[править]

str.swapcase!   #-> str или nil

Модифицирует строку str по правилу: все символы нижнего регистра заменены на соответствующие символы верхнего и все символы верхнего регистра заменены на соответствующие символы нижнего. Возвращает nil, если изменения не требуются.

str="Hello"
str.swapcase!          #-> "hELLO"
str                    #-> "hELLO"
str.swapcase!          #-> "Hello"
"12345".swapcase!      #-> nil
Информация
  • В переводе с английского, «swap» — переставлять местами
  • Полезно посмотреть методы capitalize!, downcase! и upcase!, которые также производят преобразования регистра


String#to_a

[править]

str.to_a()   #-> array

String#to_c

[править]

str.to_c   #-> complex

Возвращает комплексные числа complex, обозначающие строковую форму. Парсер игнорирует начальные пробелы и мусор в конце. Любые последовательности цифр можно разделить знаком подчеркивания. Возвращает nil для нулевой или мусорной строки.

'9'.to_c           #=> (9+0i)
'2.5'.to_c         #=> (2.5+0i)
'2.5/1'.to_c       #=> ((5/2)+0i)
'-3/2'.to_c        #=> ((-3/2)+0i)
'-i'.to_c          #=> (0-1i)
'45i'.to_c         #=> (0+45i)
'3-4i'.to_c        #=> (3-4i)
'-4e2-4e-2i'.to_c  #=> (-400.0-0.04i)
'-0.0-0.0i'.to_c   #=> (-0.0-0.0i)
'1/2+3/4i'.to_c    #=> ((1/2)+(3/4)*i)
'ruby'.to_c        #=> (0+0i)
Информация

Подробнее смотрите: Complex

String#to_f

[править]

str.to_f   #-> float

Возвращает результат интерпретации строки str, как дробного числа. Символы после последнего числового — игнорируются. Если строка str не является дробным числом, то возвращается 0.0.

"123.45e1".to_f        #-> 1234.5
"45.67 degrees".to_f   #-> 45.67
"thx1138".to_f         #-> 0.0
Информация

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

Информация

Данный метод относится к отряду «тихих» методов, то есть не порождающих ошибок в результате своей работы

String#to_i

[править]

str.to_i(base=10)   #-> integer

Возвращает в качестве результата интерпретацию символов строки str, как целого числа с основанием base (2, 8, 10, 16 или любого другого). Символы после последнего числового — игнорируются. Если строка str не является числом, то возвращается 0.

"12345".to_i             #-> 12345
"99 red balloons".to_i   #-> 99
"0a".to_i                #-> 0
"0a".to_i(16)            #-> 10
"hello".to_i             #-> 0
"1100101".to_i(2)        #-> 101
"1100101".to_i(8)        #-> 294977
"1100101".to_i(10)       #-> 1100101
"1100101".to_i(16)       #-> 17826049
Информация

Данный метод относится к отряду «тихих» методов, то есть не порождающих ошибок в результате своей работы

String#to_s

[править]

str.to_s     #-> str
str.to_str   #-> str

Возвращает строку str в качестве результата. Никаких преобразований не производится.

Информация

Методы to_s и to_str — абсолютно идентичны, но использование метода to_s предпочтительнее, так как его название короче

String#to_str

[править]

str.to_s     #-> str
str.to_str   #-> str

Возвращает строку str в качестве результата. Никаких преобразований не производится.

Информация

Методы to_s и to_str — абсолютно идентичны, но использование метода to_s предпочтительнее, так как его название короче

String#to_sym

[править]

str.intern   #-> symbol
str.to_sym   #-> symbol

Возвращает объект класса Symbol, который соответствует строке str.

"Koala".to_sym         #-> :Koala
s = 'cat'.to_sym       #-> :cat
s == :cat              #-> true
s = '@cat'.to_sym      #-> :@cat
s == :@cat             #-> true

Этот метод может быть использован для создания символов, которые не могут быть созданы в :xxx нотации.

'cat and dog'.to_sym   #-> :"cat and dog"
Информация
  • Полезно также взглянуть на метод Symbol#id2name, который осуществляет обратное преобразование
  • Методы intern и to_sym — абсолютно идентичны, но использование метода to_sym предпочтительнее

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"]
Опция Тип Описание
A
String
строка с удаленными замыкающими пробельными символами
a
String
строка
B
String
извлечь биты из каждого символа (старший двоичный разряд идет первым)
b
String
извлечь биты из каждого символа (младший двоичный разряд идет первым)
C
Fixnum
извлечь символ, как беззнаковое целое (unsigned int)
c
Fixnum
извлечь символ, как целое (int)
d, D
Float
интерпретировать sizeof(double) символов как дробное двойной точности (double), собственный формат («нативный»)
E
Float
интерпретировать sizeof(double) символов как дробное двойной точности (double), прямой порядок байт
e
Float
интерпретировать sizeof(float) символов как дробное (float), прямой порядок байт
f, F
Float
интерпретировать sizeof(float) символов как дробное (float), собственный формат («нативный»)
G
Float
интерпретировать sizeof(double) символов как дробное с двойной точностью (double), «сетевой» порядок байт
g
Float
интерпретировать sizeof(float) символов как дробное (float), «сетевой» порядок байт
H
String
извлечь шестнадцатиричные полубайты из каждого символа (старший полубайт идет первым)
h
String
извлечь шестнадцатиричные полубайты из каждого символа (младший полубайт идет первым)
I
Integer
интерпретировать sizeof(int) (может отличаться, если используется _) следующих символов как беззнаковое целое (unsigned int), собственный формат («нативный»)
i
Integer
интерпретировать sizeof(int) (может отличаться, если используется _) следующих символов как целое (int), собственный формат («нативный»)
L
Integer
интерпретировать четыре (может отличаться, если используется _) следующих символа как беззнаковое длинное целое (unsigned long int), собственный формат («нативный»)
l
Integer
интерпретировать четыре (может отличаться, если используется _) следующих символа как длинное целое (long int), собственный формат («нативный»)
M
String
строка готовая к печати, закодированная MIME (см. RFC2045)
m
String
строка закодированная Base64 (см. RFC4648)
N
Integer
интерпретировать четыре символа как беззнаковое длинное целое (unsigned long int), «сетевой» порядок байт
n
Fixnum
интерпретировать два символа как беззнаковое короткое целое (unsigned short int), «сетевой» порядок байт
P
String
интерпретировать sizeof(char *) символов как указатель и вернуть \emph{len} символов из указанной области
p
String
интерпретировать sizeof(char *) символов как указатель на строку с завершающим нулем
Q
Integer
интерпретировать 8 символов как беззнаковое 64-битное целое
q
Integer
интерпретировать 8 символов как 64-битное целое
S
Fixnum
интерпретировать два (количество может отличаться, если используется _) следующих символа как беззнаковое короткое целое (unsigned short int), собственный формат («нативный»)
s
Fixnum
интерпретировать два (количество может отличаться, если используется _) следующих символа как короткое целое (short int), собственный формат («нативный»)
U
Integer
UTF-8 символы как беззнаковое целое
u
String
строка UU-кодированная
V
Fixnum
интерпретировать четыре символа как беззнаковое длинное целое (unsigned long int), прямой порядок байт
v
Fixnum
интерпретировать два символа как беззнаковое короткое целое (unsigned short int), прямой порядок байт
w
Integer
BER-упакованное целое (см. Array.pack)
X
переместить указатель на один символ назад
x
переместить указатель на один символ вперед
Z
String
строка с удаленными замыкающими нулевыми символами (null) до первого null с *
@
переместить указатель на абсолютную позицию
Информация

Полезно посмотреть на метод 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
Информация
  • Для поиска следующего значения последовательности используется метод succ
  • В качестве результата возвращает строку str (от которой был вызван)

String#valid_encoding?

[править]

str.valid_encoding?   #-> true или false

Возвращает true для строки str, которая закодирована правильно.

"\xc2\xa1".force_encoding("UTF-8").valid_encoding?  #=> true
"\xc2".force_encoding("UTF-8").valid_encoding?      #=> false
"\x80".force_encoding("UTF-8").valid_encoding?      #=> false