ruby перенос строки кода

Методы строк в Ruby

Строки Ruby предлагают множество встроенных методов для управления и изменения текста.

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

Определение длины строки

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

Рассмотрим такой пример:

open_source = «8host contributes to open source.»
print open_source.length
33

Метод учитывает все символы в строке, включая буквы, числа, пробелы и символы.

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

name = «»
name.empty? # true
name = «8host»
name.empty? # false
name = » »
name.empty? # false

Доступ к символу в строке

Чтобы отобразить или использовать в других операциях символы из строк, используйте метод slice.

Как и в массивах, в строках каждый элемент (символ) соответствует индексу. Индексация начинается с 0.

Строка 8host индексируется так:

0 1 2 3 4
8 h o s t

Метод slice позволяет извлекать символ или диапазон символов из строки. Передавая в качестве аргумента индекс, вы получите символ, который соответствует этому индексу. Передав два числа через запятую, вы получите все символы в заданном диапазоне включительно. Метод slice принимает диапазоны в виде 1..4.

«8host».slice(0) # «8»
«8host».slice(1,2) # «ho»
«8host».slice(1..4) # «host»

Синтаксис [] является псевдонимом slice:

«8host»[0] # «8»
«8host»[1,2] # «ho»
«8host»[1..4] # «host»

Также вы можете преобразовать строку в массив значений.

«8host».chars # [«8», «h», «o», «s», «t»]

Это позволяет управлять или изменять символы в строке.

Преобразование в верхний и нижний регистр

Методы upcase и downcase возвращают строку, преобразовывая символы в верхний и нижний регистр соответственно. Небуквенные символы не будут меняться.

Попробуйте преобразовать строку 8host Blog в верхний регистр:

name = «8host Blog»
print name.upcase
8HOST BLOG

Теперь переведите ее в нижний регистр:

print name.downcase
8host blog

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

Строки Ruby используют метод capitalize, чтобы переписать все слова в строке с большой буквы.

Также в Ruby есть метод swapcase, который обращает регистр строки. Например:

text = «Blog»
print text.swapcase
bLOG

Методы downcase, upcase, captalize и swapcase возвращают новую строку, не изменяя исходную строку. Об этом важно помнить.

Рассмотрим такой пример:

text = «world»
text.capitalize
print «Hello, #!»
Hello, world!

Хотя метод capitalize применен к переменной text, программа не использует значение, преобразованное методом capitalize. Чтобы изменить это, программу нужно переписать.

text = » world»
text = text.capitalize
print «Hello, #!»
Hello, World!

Методы downcase!, upcase!, capitalize! и swapcase! изменяют исходную строку.

text = «world»
text = text.capitalize!
print «Hello, #!»

Работа с отступами

Если вы пишете программу, которая должна форматировать текст, вам нужно добавить отступы перед, после или вокруг строки, чтобы она совпадала с другими данными. И наоборот – иногда необходимо удалить ненужные символы с начала или конца строк (например, лишние пробелы или специальные символы).

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

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

Методы ljust и rjust добавляют пробелы и символы слева и справа от строки соответственно и работают как метод center:

«8host».ljust(20) # «8host »
«8host».rjust(20) # » 8host»
«8host».rjust(20, «!») # «. 8host»

Чтобы удалить пробелы справа и слева соответственно, используйте методы rstrip и lstrip. Метод strip удаляет пробелы с обеих сторон.

» 8host».rstrip # «8host»
«8host «.lstrip # «8host»
» 8host «.strip # «8host»

Для изменения исходной строки используйте методы center!, ljust!, rjust!, lstrip!, rstrip! и strip!

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

Это особенно полезно, если вам нужно удалить символ новой строки (\n).

«This string has a newline\n».chop

Метод chop не изменяет исходную строку, а возвращает новую строку. Метод chop! Переписывает исходную строку.

Метод chomp может удалить несколько символов с конца строки.

Если вы не укажете строку, которую нужно удалить, chomp удалит символ новой строки.

«This string has a newline\n».chomp # «This string has a newline

Однако если в строке нет символа новой строки, метод chomp просто вернет исходную строку.

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

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

string = «Hello\n»
string.chomp! # «Hello»
string = «Hello»
string.chomp! # nil

Поиск символов и текста

Метод include? позволяет проверить, есть ли в строке искомая строка. Если она есть, он возвращает true, а если нет – false.

«8host».include?(«о») # true
«8host».include?(«b») # false

Метод index возвращает индекс искомого символа. Также он может определить индекс первого символа подстроки. При запросе несуществующего символа он возвращает nil.

«8host».index(«h») # 1
«8host».index(«os») # 2
«8host».index(«blog») # nil

Метод index находит только первое совпадение.

text = «8host has a blog»
text.index(«o») # 2

Строка содержит и другие символы «о», но метод выводит только первое совпадение.

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

Помимо поиска символов в строке, вы можете проверить, начинается ли строка с символа или подстроки, используя start_with? метод:

text = «8host has a blog»
text.start_with?(«8») # true
text.start_with?(«8host » # true

Метод start_with? принимает несколько строк и возвращает true, если совпадает хотя бы одна из них

text = «8host has a blog»
text.start_with?(«8host the Blog», «8host») # true

Вы можете использовать метод end_with? чтобы узнать, заканчивается ли строка указанной подстрокой. Он работает точно так же, как start_with?:

text = «8host has a blog»
text.end_with?(«blog») # true
text.end_with?(«site») # false
text.end_with?(«site», «blog») # true

Замена текста в строках

Функция поиска и замены текстовых процессоров позволяет искать строку и заменять ее другой строкой. В Ruby это делается с помощью методов sub и gsub.

Метод sub заменяет часть строки на другую.

Попробуйте изменить строку:

blog = «8host has a blog»
print blog.sub(«has»,»had»)
8host had a blog

Метод sub заменяет только первое совпадение. Рассмотрим такой пример с двумя вхождениями искомого слова:

blog = «8host has a blog. The blog has articles»
print blog.sub(«has»,»had»)
8host had a blog. The blog has articles

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

blog = «8host has a blog. The blog has articles»
print blog.gsub(«has»,»had»)
8host had a blog. The blog had articles

Методы sub и gsub всегда возвращают новые строки, оставляя исходные строки неизменными. Рассмотрим следующий пример:

text = «8host has a blog»
text.gsub(«blog», «site»)
print text
8host has a blog

Результат получается не тот, потому что программа не выполняет подстановку и не использует результат gsub в новой переменной. Чтобы получить ожидаемый результат, нужно переписать программу следующим образом:

text = «8host has a blog»
text = text.sub(«blog», «site»)
print text

Кроме того, вы можете использовать метод sub!, который изменяет исходную строку.

text = «8host has a good blog»
text.sub!(«good», «nice»)
text.sub!(«blog», «site»)
print text
8host has a nice site

Метод gsub! выполняет глобальную замену.

Методы sub и gsub принимают регулярные выражения в качестве шаблона поиска. Давайте заменим все гласные в строке символом @:

«8host has a good blog».gsub /[aeiou]/, «@»
«8h@st h@s @ g@@d bl@g»

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

«8host has a good blog».gsub /[aeiou]/, <"a" =>«@», «o» => «0»>
# «8h0st h@s @ g00d bl0g»

Вы можете использовать эти методы для выполнения более сложных замещений.

Заключение

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

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

Однако код, который не изменяет исходные данные, в дальнейшем может быть проще отлаживать.

Источник

Работа со строками в 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.

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’

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

Для примера создайте файл 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 ` ‘

Эта ошибка значит, что 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 ` ‘

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

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

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

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

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

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

«My name is » + my_name + «!»

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‘This isn’t what I wanted.’

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

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

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

В этом примере кавычка перед 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!»»

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

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!\»»

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

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

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

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

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

В некоторых программах вместо фигурных скобок синтаксис %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 = % longer string
with newlines>
puts output

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

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

This is a
longer string
with newlines

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

output = % longer string
with newlines
>

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

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

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

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

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

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

Источник