Как работать со строками в 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 отображает строку точно так, как она написана.
Попробуйте. Создайте новую программу Ruby с именем print.rb с помощью текстового редактора и используйте метод print для вывода трех строк:
print 'This is the first string.'
print 'This is the second string.'
print 'This is the third string.'
Сохраните файл и запустите программу:
- ruby print.rb
Вы увидите следующий вывод:
OutputThis is the first string.This is the second string.This is the third string.
Вместо трех строк, напечатанных на отдельных строках, все три строки были напечатаны вместе в одной строке. Метод print выводит строку на экран, но если вы хотите, чтобы каждая строка располагалась на отдельной строке, вам придется самостоятельно добавить символ разрыва строки.
Если вы хотите, чтобы все три строки были в отдельных строках, используйте вместо этого метод puts. Измените свою программу, чтобы использовать puts вместо print:
puts 'This is the first string.'
puts 'This is the second string.'
puts 'This is the third string.'
Теперь снова запустите программу, и вы увидите такой вывод:
OutputThis 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 в своем редакторе с помощью следующей команды:
- nano string_variables.rb
Затем добавьте следующий код:
my_name = "Sammy the Shark"
my_age = "none of your business"
puts my_name
puts my_age
Эта программа определяет две переменные: my_name и my_age. Каждой переменной присваивается строка. Затем мы используем метод puts для вывода каждой строки на отдельной строке.
Сохраните файл с помощью CTRL + X и y, затем запустите программу:
- ruby string_variables.rb
Вы увидите следующий вывод:
OutputSammy the Shark
none of your business
Назначая строки переменным, вы можете избежать повторного ввода одной и той же строки каждый раз, когда вы хотите ее использовать, что упрощает работу со строками и манипулирование ими в ваших программах.
Давайте посмотрим, как соединить строки вместе, чтобы создать новые строки.
Конкатенация строк
Конкатенация означает объединение двух или более строк вместе для создания новой строки. Для конкатенации мы используем оператор конкатенации, представленный символом +. Символ + также является оператором сложения при использовании с арифметическими операциями.
Вот как можно соединить строки sammy и shark вместе:
"sammy" + "shark"
Это приведет к следующему результату:
Outputsammyshark
Конкатенация соединяет строки от начала до конца, объединяя их и выводя новое строковое значение. Если вы хотите, чтобы между словами sammy и shark был пробел, вы должны включить этот пробел в одну из строк, например:
"sammy " + "shark"
На самом деле вы не будете писать подобный код в программе, но вам придется довольно часто смешивать строки и переменные вместе, и именно здесь вступает в действие конкатенация.
Вот пример:
color = "Blue"
print "My favorite color is " + color
Это приведет к выводу Мой любимый цвет — синий. Обратите внимание, что мы оставили пробел после слова is в строке, чтобы в выводе был пробел между строкой и значением переменной в выводе.
Таким образом вы можете объединить несколько строк вместе. Создайте файл concatenation.rb и добавьте этот код:
my_name = "Sammy the Shark"
my_age = "none of your business"
puts "My name is " + my_name + " and my age is " + my_age + "."
Эта программа определяет две переменные: my_name и my_age, каждая со своей собственной строкой, как вы делали раньше. Но на этот раз вместо того, чтобы печатать значения, мы печатаем строку, которая использует конкатенацию для вывода этих значений с некоторым дополнительным контекстом.
Когда вы запустите эту программу, вы увидите следующий вывод:
OutputMy name is Sammy the Shark and my age is none of your business.
В этой небольшой программе вы использовали конкатенацию для вставки переменных в эту строку.
Когда вы объединяете две или более строк посредством конкатенации, вы создаете новую строку, которую вы можете использовать во всей своей программе, поэтому вы можете назначить созданную вами строку новой переменной, которую вы сможете использовать позже:
my_name = "Sammy the Shark"
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 = "Sammy the Shark"
my_number = 27
print my_name + my_number
На этот раз у нас есть my_name, который содержит строку Sammy the Shark, и my_number, который содержит целое число 27. Мы знаем, что 27 — это не строка, потому что она не заключена в кавычки. У него также нет десятичной точки, поэтому мы знаем, что это целое число.
Если вы запустите программу:
- ruby strings_and_ints.rb
Вы увидите это сообщение об ошибке:
Outputstrings_and_ints.rb:4:in `+': no implicit conversion of Integer into String (TypeError)
from strings_and_ints.rb:4:in `<main>'
Ошибка нет неявного преобразования Integer в String означает, что 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. Это сокращение от фиксированного номера. В Ruby 2.4 Fixnum и его аналог Bignum больше не существуют и заменены на Integer.
Мы могли бы изменить нашу программу и поместить число 27 в кавычки (27), чтобы оно было объявлено как строка, а не целое число. Или мы можем преобразовать число в строку при создании строки, например:
my_name = "Sammy the Shark"
my_number = 27
print my_name + my_number.to_s
Метод .to_s преобразует целое число в строку. Это лучший подход, так как он позволяет нам сохранить наше число как целое число в нашей программе. Нам нужно, чтобы это была строка только при выводе, но мы можем захотеть, чтобы это было целое число, если нам нужно использовать его в других частях логики нашей программы.
Запустите программу еще раз, и вы увидите на экране Sammy the Shark27.
Преобразование чисел в строки для конкатенации — это то, с чем вы часто сталкиваетесь при работе с почтовыми индексами, валютой, телефонными номерами и другими числовыми данными, которые вы хотите отображать на экране вместе с текстом.
Конкатенация мощная, но может быть сложной. Если вы случайно пропустите один из операторов +, вы можете получить синтаксическую ошибку. И если вам нужно соединить строки с переменными, содержащими числа, вы должны преобразовать переменные в строки. Ruby предоставляет другой способ вставки значений переменных в строку, называемый интерполяцией строк, который решает обе эти проблемы.
Использование интерполяции строк
При объединении строк и переменных вывод может быть трудным для чтения и отладки. Интерполяция строк решает эту проблему, позволяя вставлять выражения в строку, заключенную в двойные кавычки.
Вместо того, чтобы писать это:
"My name is " + my_name + "!"
Вы можете сделать это:
"My name is #{my_name}!"
Вместо завершения строки и использования оператора + вы заключаете переменную с синтаксисом #{}. Этот синтаксис говорит Ruby оценить выражение и внедрить его в строку.
Попробуйте. Создайте новую программу с именем interpolation.rb и добавьте следующий код:
my_name = "Sammy the Shark"
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 = "Sammy the Shark"
my_number = 27
# use interpolation instead of concatenation
print "My name is #{my_name} and my favorite number is #{my_number}."
Ruby автоматически преобразует my_number в строку, и ваша программа выведет следующий вывод при ее запуске:
OutputMy name is Sammy the Shark and my favorite number is 27.
Интерполяция строк мощна и удобна. Это также предпочтительный метод для объединения строк с переменными.
Строковые литералы и строковые значения
Обратите внимание, что все созданные вами строки в коде заключены в кавычки, но фактический вывод не включает кавычки.
Существует различие при обращении к каждому из них. Строковый литерал – это строка, записанная в исходном коде, включая кавычки. строковое значение — это то, что вы видите в выходных данных, и оно не включает кавычки.
Это строковый литерал:
"Sammy the Shark"
Строковое значение будет Sammy the Shark.
В большинстве случаев вам не придется беспокоиться об этой разнице, если вы не хотите использовать в своих строках специальные символы, такие как кавычки или апострофы.
Экранирование кавычек и апострофов в строках
Из-за того, что кавычки используются для обозначения строк, вам придется проделать небольшую дополнительную работу, если вы хотите использовать апострофы и кавычки в строках.
Если вы попытаетесь использовать апостроф в середине строки в одинарных кавычках, например:
'This isn't what I wanted.'
Апостроф в isnt завершает строку, как видно из странного выделения в этом примере. В результате интерпретатор Ruby попытается проанализировать остальную часть предполагаемой строки как код, и вы получите сообщение об ошибке.
Вы бы столкнулись с той же ситуацией, если бы использовали двойные кавычки в строке, заключенной в двойные кавычки:
"Sammy says, "Hello!""
В этом примере закрывающая двойная кавычка перед Hello завершает строку, а двойная кавычка после Hello! создает новую строку, в которой нет соответствующей двойной кавычки. чтобы завершить его, поэтому Ruby отобразит ошибку.
Чтобы избежать этой проблемы, у вас есть несколько вариантов. Во-первых, вы можете использовать альтернативный синтаксис для создания строк; если вам нужно использовать двойные кавычки в строке, используйте одинарные кавычки для определения строки, и наоборот. Вы также можете экранировать кавычки или использовать другой синтаксис Ruby для определения строк. Рассмотрим каждый подход.
Вариант 1. Используйте синтаксис альтернативной строки
Самый простой способ обойти эти проблемы — заключить строку в одинарные кавычки, если она должна содержать двойные кавычки, и заключить строку в двойные кавычки, если в строке необходимо использовать одинарные кавычки.
Вместо определения этой строки в одинарных кавычках:
'This isn't what I wanted.'
Определите его с помощью двойных кавычек:
"This isn't what I wanted."
И вместо использования двойных кавычек для определения этой строки:
"Sammy says, "Hello!""
Используйте одинарные кавычки:
'Sammy says, "Hello!"'
Использование альтернативного синтаксиса может избавить вас от некоторых быстрых заторов, но это не всегда сработает. Например, ни один из подходов не будет работать для этой строки:
"Sammy says, "I'm a happy shark!""
В этом примере закрывающая двойная кавычка перед Im действительно сбивает с толку. Это завершает первую строку, а затем Ruby встречает апостроф в Im, который начинает новую строку со значением m a happy shark!. Но эта новая строка не имеет подходящей одинарной кавычки для ее завершения. И использование одинарных кавычек для заключения строки приводит к аналогичной проблеме:
'Sammy says, "I'm a happy shark!"'
На этот раз апостроф в Im завершает строку.
Использование альтернативного синтаксиса также может сделать ваш код несогласованным. Постоянное переключение между строковым синтаксисом может привести к путанице. Мы можем экранировать символы, чтобы обойти эту проблему.
Вариант 2: Экранирование символов в строках
Символ обратной косой черты (\), часто называемый экранирующим символом в строках, не позволит Ruby буквально интерпретировать следующий символ в строке.
Вот наша проблемная строка, закодированная в двойные кавычки, с двойными кавычками внутри:
"Sammy says, "I'm a happy shark!""
Создайте новую программу Ruby с именем quoting.rb и добавьте в файл следующий код:
print "Sammy says, "I'm a happy shark!""
Запустите программу:
- ruby quoting.rb
И вы увидите этот вывод:
Outputquoting.rb:1: syntax error, unexpected tCONSTANT, expecting end-of-input
print "Sammy says, "I'm a happy shark!""
^
Чтобы исправить ошибку, используйте обратную косую черту перед внутренними двойными кавычками:
print "Sammy says, \"I'm a happy shark!\""
Затем снова запустите программу, и вы увидите ожидаемый результат:
Sammy says, "I'm a happy shark!"
Обратите внимание, что в этом примере вам не нужно экранировать апостроф, поскольку конфликта нет. Вам нужно только избегать кавычек, которые могут запутать Ruby.
Вы можете полностью избежать экранирования кавычек, используя другой синтаксис для определения строк.
Вариант 3. Использование альтернативного синтаксиса для строк
До сих пор вы использовали кавычки для определения границ ваших строк. Вы можете создавать строки в Ruby, используя и другие символы. Вы можете определить разделитель или символ, который хотите использовать для заключения строки, указав его после знака процента, например:
%$Sammy says, "I'm a happy shark!"$
Этот синтаксис автоматически экранирует встроенные строки. Фактическая строка выглядит так:
"Sammy says, \"I'm a happy shark!\""
Однако изменение разделителя означает, что вы должны избегать разделителя, если вам нужно его использовать. В этом случае. если бы вам пришлось использовать знак доллара в вашей строке, вам нужно было бы избежать буквального знака доллара в строке.
Чтобы избежать этого, вы также можете использовать пары фигурных скобок, квадратных скобок или круглых скобок в качестве разделителей. Наиболее распространены фигурные скобки:
%{Sammy says, "I'm a happy shark!"}
Все эти формы поддерживают интерполяцию строк, если вам это нужно.
droplets = 5
print %{Sammy says, "I just created #{droplets} droplets!"}
Вы также увидите %Q{} и %q{}, используемые для определения строк в программах Ruby. Синтаксис %Q{} работает точно так же, как строки в двойных кавычках, что означает, что вам не нужно избегать двойных кавычек, и вы сможете использовать интерполяцию строк:
droplets = 5
print %Q{Sammy says, "I just created #{droplets} droplets!"}
Синтаксис %q{} работает точно так же, как строки в одинарных кавычках:
%q{Sammy says, "I'm a happy shark!"}
Вы можете увидеть синтаксис %q и %Q, используемый в некоторых программах со скобками или квадратными скобками вместо фигурных скобок.
Как видите, в Ruby существует множество способов создания строк. Какой бы метод вы ни выбрали, будьте последовательны в своем коде. Вы обнаружите, что методы %Q{} и %{} являются наиболее распространенными.
Теперь, когда вы знаете, как обрабатывать специальные символы, давайте посмотрим, как обрабатывать длинные строки и символы новой строки.
Длинные строки и новые строки
Иногда вам может понадобиться вставить в строку символ новой строки или возврат каретки. Вы можете использовать escape-символы \n или \r, чтобы вставить новую строку в код:
output = "This is\na string\nwith newlines"
puts output
Эта программа выдаст такой результат:
OutputThis 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). Этот подход сохраняет пробелы, включая отступы и новые строки.
В результате вывод будет содержать разрывы строк, а также все начальные отступы, например:
OutputThis is a
longer string
with newlines
Чтобы этого не произошло, удалите лишние пробелы из кода:
output = %{This is a
longer string
with newlines
}
Вы также можете создавать многострочные строки, используя heredoc или \here document — термин, используемый для литералов многострочных строк в программах. Вот как вы напишете этот код:
output = <<-END
This is a
longer string
with newlines
END
Маркеры <<-END и END обозначают начало и конец документа.
Heredocs в Ruby также сохраняют пробельные символы, что означает, что если вы делаете отступ в коде в 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
Это дает следующий результат:
OutputThis is a
longer string
with newlines
and the code is indented
but the output is not.
Это позволяет вам использовать heredocs и сохранять ваш код с красивым отступом.
Heredocs в Ruby также поддерживает интерполяцию строк.
Как видите, в Ruby существует множество способов обработки символов новой строки и многострочных строк. Вы столкнетесь со всеми этими методами при работе с существующим кодом Ruby, поскольку каждый проект имеет свой собственный стиль. В своем собственном коде выберите стиль, который подходит именно вам, и будьте последовательны.
Репликация строк
Могут быть случаи, когда вам нужно использовать Ruby для повторения строки символов несколько раз. Вы можете сделать это с помощью оператора *. Как и оператор +, оператор * имеет другое применение при использовании с числами, где он является оператором умножения. При использовании с одной строкой и одним целым числом * является оператором репликации строки, повторяющим одну строку столько раз, сколько вы хотели бы использовать предоставленное вами целое число.
Чтобы распечатать Sammy девять раз, вы должны использовать следующий код:
print "Sammy" * 9
Этот код производит следующий вывод:
OutputSammySammySammySammySammySammySammySammySammy
Вы можете использовать это для создания красивого ASCII-арта. Создайте файл с именем banner.rb и добавьте следующий код:
puts "=" * 15
puts "| Hello World |"
puts "=" * 15
Можете ли вы представить, что выдаст программа перед ее запуском?
Он производит этот вывод:
Output===============
| Hello World |
===============
Это всего лишь небольшой пример того, как вы можете заставить компьютер выполнять за вас повторяющиеся задачи.
Заключение
В этом руководстве вы узнали, как работать со строковым типом данных в языке программирования Ruby. Вы создали новые строки, объединили их с другими строками и обработали новые строки, кавычки и апострофы. Затем вы использовали интерполяцию строк, чтобы упростить смешивание строк и значений переменных, и научились повторять строки.