Строки ruby
Строки — это произвольной длины наборы символов, которые заключены в одинарные или двойные кавычки.
Пример строк:
"this is a string"
‘this is a string in single quotes’
Вы можете объявлять строки используя специальный идентификатор строки %q, например:
%q!this is a string in single quotes!
%q{this is a string in single quotes}
Вы не можете использовать только цифры и буквы, все остальные символы доступны для заключения в них строкового литерала. Представленное в примере выше заключение строки в произвольные символы равносильно заключению в одинарные кавычки. Это важно знать потому, что между строкой в одинарных кавычках и в двойных имеется большая разница, но об этом чуточку ниже.
Ruby также позволяет создавать строковые литералы, которые занимают несколько физических строк:
str = "How are
you? !"
В результате такого объявления переменная str будет хранить следующую строку: "How are\nyou?", где \n является специальным символом новой строки. Чтобы вставить специальный символ используют экранирование, это символ обратного слеша \
Интерполяция строки
Запомните! Строки заключенные в двойные кавычки могут содержать выполняемые фрагменты кода, а также специальные символы, например тот же символ новой строки. Помещенный в строку код будет выполнен и на его место в строке будет вставлено возвращенное им значение. Код, который вы желаете поместить в строку следует заключить в фигурные скобки перед которыми должен следовать символ шарп — #{здесь ваш код}, примеры:
a = "String a has #{a.class} type" #=> "String a has String type"
a = 1
b = 2
c = "a + b = #{a + b}" #=> "a + b = 3"
Если вы не желаете, чтобы что-то помещенное в #{} выполнялось как код и чтобы специальные символы содержащиеся в строке игнорировались, вам следует либо использовать одинарные кавычки для заключения в них строки, либо экранировать те фрагменты строки, заключенной в двойные кавычки, которые могут выполняться. Экранирование происходит при помощи символа обратного слэша «\», примеры:
c = 'a + b = #{a + b}' #=> "a + b = \#{a + b}"
c = "a + b = \#{a + b}" #=> "a + b = \#{a + b}"
Обратите внимание, что не зависимо от того, в двойные или одинарные кавычки мы заключаем строку, переменной присваивается строка заключенная в двойные кавычки. Это означает, что в строке заключенное в одинарные кавычки автоматически происходит экранирование.
Не смотря на то, что в строках заключенных в одиночные кавычки экранирование происходит автоматически, все-таки существует один символ, который вам однозначно придется экранировать — это собственно одинарные кавычки, пример:
str = 'hello 'Chuck'!' # Произойдет ошибка!
str = 'hello \'Chuck\'!' #=> "hello 'Chuck'!"
Такое экранирование в одинарных строках необходимо для того, чтобы интерпретатор при чтении кода не путался в том, является ли одиночная кавычка частью строки, или она завершает ее. Именно для таких случаев и была добавлена возможность создания строк при помощи идентификатора строки %q и произвольных обрамляющих символов, так как строка созданная в такой способ абсолютно идентична строке заключенной в одинарные кавычки с той лишь разницей, что вам не нужно экранировать имеющиеся в строке кавычки, пример:
На этом с созданием строк мы покончили, перейдем к такому важному занятию, как работа со строками!
Конкатенация строк
Ruby очень изящный язык программирования, который имеет очень удобный и понятный синтаксис и предоставляет очень много встроенных методов для работы с основными типами.
Объединение строк (иными словами конкатенация) достаточно использовать оператор + (как не странно он же метод), пример:
str = "first string" + " " + "second string" #=> "first string second string"
Согласитесь, + здесь выглядит куда логичней, чем . в PHP, да и код более читабелен.
Еще один способ объединить строки — это оператор *, который занимается тем, что объединяет строку со своими копиями N-число раз, пример:
"string " * 3 #=> "string string string "
Индексация строк, элементы строк
В Ruby строки имеют несколько сходств с массивами по той причине, что каждый символ строки имеет свой индекс — порядок в строке по которому к нему можно обратится. Если говорить еще более точно, то таких индексов целых два: левосторонний и правосторонний, примеры:
str = "abcdefg"
str[0] #=> "a"
str[1] #=> "b"
str[2] #=> "c"
str[-1] #=> "g"
str[-2] #=> "f"
str[-3] #=> "e"
Левосторонние индексы указывают позицию символа с левой стороны (с начала) строки и начинаются с нуля. Правосторонние индексы указывают позицию символа с правой стороны (с конца строки) и начинаются с -1, при этом все правосторонние индексы имеют в себе знак "-", который и отличает их от левосторонних. Терминология «левая сторона строки» и «правая сторона строки» более корректна, поскольку, например, в арабском языке письмо идет справа на лево.
Ruby позволяет вам обращаться не только к отдельному символу в строке, но и к набору из промежутков таких символов, для этого в квадратных скобках необходимо указывать, либо индекс первого выбираемого символа и количество выбираемых символов, либо диапазон индексов выбираемых символов, примеры:
str = "abcdefg"
str[0,str.size] #=> "abcdefg"
str[0,3] #=> "abc"
str[-1,5] #=> "g"
str[0..str.size-1] #=> "abcdefg"
str[0..2] #=> "abc"
str[0..-1] #=> "abcdefg"
str[0..-3] #=> "abcde"
str[0...-3] #=> "abcd"
Вы не только можете получать фрагменты строки, но и устанавливать для них значения:
str #=> "abcdefg"
str[0] = "z"
str #=> "zbcdefg"
str[1..str.size] = "hello"
str #=> "zhello"
str[0..str.size] = ""
str #=> ""
str[0..1000] = "Hello Tom!"
str #=> "Hello Tom!"
Работа со строками
В Ruby практически все за редким исключением является объектом и строки не исключение. Строковый объект носит тип String, то есть является экземпляром класса String. Это означает, что строка, как и любой другой объект имеет собственные методы, некоторые из которых вы уже видели в примерах выше. Чтобы убедиться в том, является ли что-то объектом, достаточно попытаться вызвать у этого «чего-то» метод #class. Метод #class не возвращает сообщение «Эта штуковина — объект», он возвращает класс (тип), которому принадлежит объект. Если что-то не является объектом, то и не имеет методов вообще.
"abcdefg".class #=> String - убеждаемся в том, что строка - объект типа String
Методы строк
Далее мы поговорим о методах строк, на самом деле их огромное количество. Вашему вниманию представлю самые популярные, их не нужно запоминать. Вы просто должны знать, что есть такой метод и что он делает. Чтобы в случае необходимости не изобретать велосипед, а просто найти его. Либо на этом сайте, либо в rubydoc.
Строки имеют несколько методов позволяющих работать с регистром символов:
#upcase — данный метод переводит все символы строки в верхний регистр (делает все буквы заглавными), пример:
str = "abcdefg"
str.upcase #=> "ABCDEFG"
str #=> "abcdefg"
Обратите внимание на то, что строка не изменилась, метод #upcase просто возвратил новую строку. Для того, чтобы изменить саму строку для которой был вызван метод нужно использовать BANG-методы.
BANG-методы, это такие методы, которые изменяют сам объект, для которого они вызываются. В них нет ничего особого, кроме имени. Для BANG — методов желательно, но не обязательно давать имена, который заканчиваются на «!», в нашем случае это метод #upcase!:
str.upcase!
str #=> "ABCDEFG"
#downcase — этот метод противоположен методы #upcase, он переводит символы строки в нижний регистр, пример:
str.downcase #=> "abcdefg"
str #=> "ABCDEFG"
str.downcase! #=> "abcdefg"
str #=> "abcdefg"
#capitalize — данный метод используется для того, чтобы сделать первую букву строки заглавной:
str.capitalize #=> "Abcdefg"
str #=> "abcdefg"
str.capitalize! #=> "Abcdefg"
#swapcase — данный метод преобразует регистр символов в противоположный, то есть, заглавные буквы в строчные, а строчные в заглавные, пример:
rb = "RuByDeV.Ru"
rb.swapcase #=> "rUbYdEv.rU"
rb #=> "RuByDeV.Ru"
rb.swapcase! #=> "rUbYdEv.rU"
Удаление пробелов
#lstrip и #rstrip — данные методы используются для удаления пробелов соответственно с левой стороны строки и с правой стороны строки, пример:
str = " abcdefg "
str.lstrip #=> "abcdefg "
str.rstrip #=> " abcdefg"
str.lstrip!.rstrip! #=> "abcdefg"
#strip — данный метод объединяет в себе оба #lstrip и #rstrip:
str = " abcdefg "
str.strip #=> "abcdefg"
str.strip! #=> "abcdefg"
#reverse — данный метод меняет порядок символов в строке на обратный, пример:
str.reverse #=> «gfedcba»
str.reverse! #=> «gfedcba»
str.reverse! #=> «abcdefg»
#size и #length — оба эти метода выполняют одно и то же действие — они возвращают количество символов в строке:
"abcdefg".size #=> 7
"abc".length #=> 3
#delete — данный метод удаляет фрагмент строки, пример:
str #=> "abcdefg"
str.delete("abc") #=> "defg"
str.delete!("abc") #=> "defg"
#scan — метод принимает в качестве аргумента регулярное выражение и возвращает массив подстрок (фрагментов строки), которые соответствует регулярному выражению. Регулярным выражениям будет посвящена отдельная глава, а пока пример:
str #=> "defg"
str.scan(/d|e/) #=> ["d", "e"]
str.scan(/de/) #=> ["de"]
str.scan(/[^d,f]/) #=> ["e", "g"]
#chomp — данный метод удаляет окончание строки. Используйте этот символ всегда когда получаете информацию с консоли, потому что строки оканчиваются символом новой строки.
В качестве примера хочу привести маленький и глупый метод, который переводит множественную форму английского слова в одиночную форму просто путем удаления окончания:
#index и #rindex — данные методы принимают в качестве аргумента строку или шаблон регулярного выражения и возвращают соответственно индекс символа строки с которого начинается соответственно первое или последнее соответствие шаблону, примеры:
str = "mama mila ramu"
str.index("m") #=> 0
str.rindex("m") #=> 12
str.index(/ma/) #=> 0
str.rindex(/ma/) #=> 2
#insert — данный метод принимает в качестве аргументов строку и позицию вставки (индекс) для вставки данной строки в строку для которой он был вызван, при этом символы находящиеся в том месте, куда производится запись не перезаписываются а сдвигаются вперед, пример:
str = "hell" #=> "hell"
str.insert(str.size, "o") #=> "hello"
Метод #insert производит изменения непосредственно в самой строке.
#chars и #each_char — являются методами итераторами, которые проходят по каждому символу строки, передают его в блок кода, который выполняет над каждым символом определенное действие.
Примечание! В версии 2.0 метод chars теперь возвращает array
#empty? — данный метод возвращает значение true если строка пустая и false, если в строке имеется хотя бы один символ:
"".empty? #=> true
"hello".empty? #=> false
#include? — метод принимает фрагмент строки и проверяет строку для которой был вызван на то, существуют ли в ней подстроки соответствующие фрагменту, пример:
"hello".include?("ll") #=> true
"hello".include?("bye") #=> false
#b - метод возвращает копию строки в кодировке ASCII-8BIT
p "привет".b #=> "\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82"
