Работа со строками в Ruby

Строка – это последовательность из одного или нескольких символов, которая может состоять из букв, цифр и других символов.

В Ruby строки являются объектами и, в отличие от других языков, строки изменяемы – их можно редактировать, и для этого не нужно создавать новую строку.

Строки присутствуют почти в каждой программе. Строки позволяют отображать текст и помогают пользователям взаимодействовать с программой. Даже эта статья, которую вы сейчас читаете – по сути, набор строк, отображенный на экране вашего устройства с помощью браузера.

Строки – самый базовый и очень важный тип данных.

В этой статье вы узнаете, как работать со строками в Ruby. Вы научитесь создавать строки, отображать их на экране, хранить их в переменных, объединять несколько строк в одну и обрабатывать специальные символы: символы новой строки, апострофы и двойные кавычки.

Создание и вывод строк

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

'This is a string in single quotes.'
"This is a string in double quotes."

В большинстве случаев неважно, в каких кавычках пишутся строки, если они используются последовательно во всем коде программы. Однако двойные кавычки позволяют также выполнять интерполяцию строк, о которой вы узнаете чуть позже.

Чтобы отобразить строку на экране, используйте метод print:

print "Let's print out this string."

Метод print отображает строку так, как она записана.

Для примера попробуйте написать простую программу print.rb, которая будет запускать метод print.

Читайте также: Написание простой программы Ruby

Вставьте в файл:

print 'This is the first string.'
print 'This is the second string.'
print 'This is the third string.'

Сохраните файл и запустите программу:

ruby print.rb
This is the first string.This is the second string.This is the third string.

Вместо трех отдельных строк программа вывела все три строки подряд. Метод print выводит строку на экран, не переходя на новую строку. Если вы хотите, чтобы каждая строка текста была в отдельной строке, нужно добавить символ разрыва строки самостоятельно.

Для этого можно использовать метод puts. Отредактируйте код программы:

puts 'This is the first string.'
puts 'This is the second string.'
puts 'This is the third string.'

Сохраните изменения и запустите программу:

This is the first string.
This is the second string.
This is the third string.

Метод puts добавляет символ новой строки автоматически.

Хранение строк в переменных

Переменная – это именованная ссылка на место в памяти компьютера. Переменные используются для хранения и извлечения данных.

Чтобы сохранить строку в переменной, определите имя переменной и присвойте ей значение строки:

my_string = 'This is my string'

Чтобы извлечь значение, используйте имя переменной:

print my_string

Для примера создайте файл string_variables.rb и добавьте следующий код:

my_name = "8host Blog"
my_age = "5 years"
puts my_name
puts my_age

В этой программе используются переменные my_name и my_age. Каждой переменной присвоена строка. Метод puts выводит каждую из них с новой строки.

Сохраните и закройте файл.

Запустите программу:

ruby string_variables.rb
8host Blog
5 years

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

Конкатенация строк

Конкатенация – это объединение двух или более строк в одну новую строку. Чтобы объединить строки, используйте оператор конкатенации +. Символ + также является оператором сложения в арифметических операциях.

Попробуйте объединить строки 8host и blog:

"8host" + "blog"
8hostblog

Конкатенация объединяет конец первой строки с началом второй. Чтобы между строками был пробел, его нужно добавить либо в конец первой, либо в начало второй строки:

"8host " + "blog"
8host blog

Строки и переменные довольно часто используются вместе, и именно здесь часто необходима конкатенация. Например:

color = "Blue"
print "My favorite color is " + color

Это выдаст строку:

My favorite color is blue

Обратите внимание: после слова is поставлен пробел.

Таким образом можно объединять несколько строк. Создайте файл concatenation.rb и добавьте в него код:

my_name = "8host Blog"
my_age = "none of your business"
puts "My name is " + my_name + " and my age is " + my_age + "."

Эта программа содержит переменные my_name и my_age. Но теперь она не будет просто выводить значения, а поместит их в другую строку. Сохраните файл и запустите программу:

My name is 8host Blog and my age is none of your business.

Объединяя две или более строк с помощью конкатенации, вы создаете новую строку, которую вы можете использовать в программе. К примеру, новую строку можно присвоить переменной:

my_name = "8host Blog"
my_age = "none of your business"
# assign concatenated string to variable
output = "My name is " + my_name + " and my age is " + my_age + "."
# Print the output.
puts output

В такой маленькой программе вводить дополнительную переменную output не нужно. Но в более крупных программах строки, созданные путем конкатенации, иногда используются в нескольких блоках кода. Также лучше сразу разделить логику и вывод программы по разным файлам или компонентам, чтобы упростить управление и поддержку программы.

Не используйте оператор + между двумя разными типами данных. Выполнить конкатенацию строки и числа невозможно.

Чтобы посмотреть, как это бывает, создайте файл strings_and_integers.rb и добавьте в него такой код:

my_name = "8host Blog"
my_number = 55
print my_name + my_number

Переменная my_name содержит строку, а переменная my_number – целое число. Интерпретатор понимает, что 55 – не строка, поскольку оно не взято в кавычки.

Запустите программу:

ruby strings_and_ints.rb
strings_and_ints.rb:4:in `+': no implicit conversion of Integer into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

Эта ошибка значит, что Ruby может объединять только строки.

Примечание: В Ruby 2.3 и старше вы получите такую ошибку:

strings_and_ints.rb:4:in `+': no implicit conversion of Fixnum into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

Ключевое слово Fixnum – тип данных, который относился к целым числам в предыдущих версиях Ruby. Это сокращение от Fixed Number. В Ruby 2.4 типы Fixnum и Bignum исключены и заменены на Integer.

Чтобы исправить ошибку, число 55 можно взять в кавычки, чтобы интерпретатор воспринимал его как строку. Также можно преобразовать число в строку во время конкатенации.

my_name = "8host Blog"
my_number = 55
print my_name + my_number.to_s

Метод .to_s преобразует число в строку. Это лучший подход, поскольку он позволяет сохранить целое число и не менять его тип явно. С числами бывают проблемы, так как в строках они должны использоваться как строки, а в остальной логике программы – как числа.

Запустите программу:

8host Blog55

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

Конкатенация – очень полезная функция, но может вызвать ошибки. Если вы случайно пропустите один из операторов +, вы можете получить синтаксическую ошибку. Чтобы объединить строки с переменными, содержащими числа, нужно преобразовать переменные в строки. Ruby предоставляет другой способ добавления значений переменных в строки, который устраняет обе эти проблемы, он называется интерполяцией строк.

Интерполяция строк

При конкатенации строк и переменных вывод бывает сложно читать, иногда в нем даже сложно найти ошибку. Интерполяция строк позволяет вставлять выражения в строку, заключенную в двойные кавычки.

Вместо:

"My name is " + my_name + "!"

Можно написать:

"My name is #{my_name}!"

Вместо оператора + строка помещается в синткасис #{}, который помогает Ruby вставить выражение в строку.

Попробуйте создать новую простую программу, interpolation.rb. Добавьте в нее такой код:

my_name = "8host Blog"
my_age = "none of your business"
output = "My name is #{my_name} and my age is #{my_age}."
puts output

Эта программа выполняет те же действия, что и предыдущая, но ее код отличается.

Интерполяция строк имеет еще одно преимущество: она может автоматически преобразовывать числовые значения в строки. Откройте программу strings_and_integers.rb в редакторе, но измените последнюю строку, чтобы она выглядела следующим образом:

my_name = "8host Blog"
my_number = 55
# use interpolation instead of concatenation
print "My name is #{my_name} and my favorite number is #{my_number}."

Ruby автоматически преобразует число в строку, и программа выведет следующий результат при запуске:

My name is 8host Blog and my favorite number is 55.

Интерполяция – удобная и производительная функция.

Строковые литералы и строковые значения

Обратите внимание: все строки, которые вы создали, заключены в кавычки в коде, но при выводе кавычки не отображаются.

Строковый литерал – это строка, которая написана в исходном коде, включая кавычки. Строковое значение – это то, что вы видите на выходе, без кавычек.

Это строковый литерал:

"8host Blog"

А это – строковое значение:

8host Blog

В большинстве случаев вам не придется думать об этой разнице, но это следует знать, чтобы использовать в строках специальные символы: кавычки или апострофы.

Обход кавычек и апострофов в строках

В связи с тем, что кавычки используются для обозначения строк, иногда возникают ошибки и проблемы, если в самих строках нужно использовать апострофы и кавычки.

Если вы попытаетесь использовать апостроф в середине строки, взятой в одинарные кавычки:

'This isn't what I wanted.'

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

Оставшуюся строку он попробует распознать как код и выдаст ошибку.

Аналогичная ситуация возникает в этой строке с двойными кавычками:

"8host says, "Hello!""

В этом примере кавычка перед Hello воспринимается как закрывающая, а двойная кавычка после Hello! создает новую строку, которая не имеет соответствующей закрывающей кавычки. В результате Ruby отобразит ошибку.

Есть несколько вариантов исправить эту ошибку. Во-первых, можно использовать альтернативный синтаксис для создания строк: если нужно использовать двойные кавычки в строке, используйте для определения строки одинарные кавычки и наоборот. Также можно обойти кавычки или использовать другой синтаксис Ruby для определения строк.

Вариант 1: Альтернативный синтаксис

Проще всего заключать строки с апострофом в двойные кавычки, а строки с кавычками – в одинарные.

Вместо этой ошибки:

'This isn't what I wanted.'

Строка будет интерпретирована полностью:

"This isn't what I wanted."

Аналогичным образом все исправляется здесь:

"8host says, "Hello!""
'8host says, "Hello!"'

Этот подход позволяет быстро исправить простые ошибки, но он не всегда работает. К примеру, он не сработает в этой строке:

"8host says, "I'm a big blog!""

Двойная кавычка перед I’m воспринимается как закрывающая. Апостроф в I’m будет интерпретирован как начало новой строки (‘m a big blog!»»). Но в конце такой строки интерпретатор не видит соответствующей закрывающей кавычки.

Если взять строку в одинарные кавычки, ошибка не будет исправлена:

'8host says, "I'm a big blog!"'

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

Кроме того, этот подход сделает код программы сложным и непоследовательным.

Вариант 2: Escape-символы

Символ обратного слеша \ — это escape-символ, благодаря которому Ruby не будет интерпретировать символ в строке буквально.

Вернемся к предыдущему примеру:

"8host says, "I'm a big blog!""

Создайте программу quoting.rb и вставьте в нее:

print "8host says, "I'm a big blog!""

Запустите программу:

ruby quoting.rb

Вы получите такой вывод:

quoting.rb:1: syntax error, unexpected tCONSTANT, expecting end-of-input
print "8host says, "I'm a big blog!""
^

Чтобы исправить ошибку, нужно добавить обратный слеш перед внутренними кавычками:

print "8host says, \"I'm a big blog!\""

Снова запустите программу:

8host says, "I'm a big blog!"

Обратите внимание: обходить апостроф не нужно, он не вызывает никаких конфликтов.

Вариант 3: Другой разделитель строк

До сих пор для определения границ строк использовались кавычки. Но в Ruby можно создавать строки, используя другие символы. Вы можете выбрать разделитель (символ, в который будет заключаться строка) после знака процента, например, так:

%$8host says, "I'm a big blog!"$

Этот синтаксис автоматически удалит встроенные строки. Фактически строка выглядит так:

"8host says, \"I'm a big blog!\""

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

Чтобы избежать этого, можно использовать пару фигурных скобок, квадратных или круглых скобок в качестве разделителей строк. Обычно используют фигурные.

%{8host says, "I'm a big blog!"}

Все эти варианты поддерживают интерполяцию строк.

articles = 5
print %{8host says, "I just created #{articles} articles!"}

Также для определения строк в Ruby используются %Q{} и %q{}. Синтаксис %Q{} работает как строка с двойными кавычками и поддерживает интерполяцию строк:

articles = 5
print %Q{8host says, "I just created #{articles} articles!"}

Синтаксис %q{} работает как строка с одинарными кавычками:

%q{8host says, "I just created #{articles} articles!"}

В некоторых программах вместо фигурных скобок синтаксис %q и %Q использует круглые или квадратные скобки.

Многострочные строки и новые строки

Иногда возникает необходимость добавить символ новой строки. Для этого используются escape-символы \n и \r.

output = "This is\na string\nwith newlines"
puts output
This is
a string
with newlines

Технически это делит вывод на несколько строк. Однако очень длинную строку сложно читать и поддерживать в одной строке. Есть несколько решений.

Во-первых, можно применить конкатенацию:

output = "This is a\n" +
"longer string\n" +
"with newlines."
puts output

Также можно добавить разрывы строки:

output = "This is a
longer string
with newlines"
puts output

Можно использовать альтернативный синтаксис:

output = %{This is a
longer string
with newlines}
puts output

Последние два метода не требуют символа новой строки \n.

В результате вывод будет содержать разрывы строк, а также все отступы:

This is a
longer string
with newlines

Чтобы удалить лишние пробельные символы из кода, используйте:

output = %{This is a
longer string
with newlines
}

Вы также можете создавать многострочные строки, используя heredoc – многострочные строковые литералы в программах. Вот как пишется этот код:

output = <<-END
This is a
longer string
with newlines
END

Маркеры <<-END и END определяют начало и конец heredoc.

В Ruby heredoc позволяет сократить количество пробелов. Отступы строк в heredoc сохраняются. К примеру:

output = <<-END
This is a
longer string
with newlines
END

Эти строки будут содержать два пробела отступа.

Ruby 2.3 и выше предлагают синтаксис «squiggly heredoc», который автоматически удаляет пробелы в начале строки. Замените дефис в определении heredoc тильдой (вместо << — будет << ~):

output = <<~END
This is a
longer string
with newlines
and the code is indented
but the output is not.
END

Вывод будет таким:

This is a
longer string
with newlines
and the code is indented
but the output is not.

Heredoc в Ruby также поддерживает интерполяцию строк.

Как видите, существует много способов обработки новых строк и многострочных строк в Ruby. Выберите наиболее удобный для вас метод и используйте его последовательно.

Репликация строк

В некоторых ситуациях строку нужно повторить несколько раз. Для этого используется оператор *. Как и оператор +, оператор * имеет и другие функции, при работе с числами он является оператором умножения. Если оператору * задать одну строку и одно целое число, * он повторит эту строку заданное количество раз.

К примеру, чтобы вывести 8host 5 раз, нужно ввести:

print "8host" * 5
8host8host8host8host8host

С помощью этой функции можно создавать изображения ASCII.

Создайте файл banner.rb и добавьте в него код:

puts "=" * 15
puts "| Hello World |"
puts "=" * 15

Вывод этой программы выглядит так:

===============
| Hello World |
===============

Это простейший пример того, как компьютер может выполнять повторяющиеся задачи.

Tags: