Методы строк в 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"

Получить доступ к символам в конце строки можно с помощью отрицательного индекса. -1 выведет последний символ строки, -2 – предпоследний и т.д.

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

"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, чтобы переписать все слова в строке с большой буквы.

" blog".capitalize    # " Blog"

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

text = "Blog"
print text.swapcase
bLOG

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

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

text = "world"
text.capitalize
print "Hello, #{text}!"
Hello, world!

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

text = " world"
text = text.capitalize
print "Hello, #{text}!"
Hello, World!

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

text = "world"
text = text.capitalize!
print "Hello, #{text}!"

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

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

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

"8host",center(21)    # "        8host        "

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

" [8host] ".center(21, "<>")   # "<><><> [8host] <><><>"

Методы 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.

"8host".chop     # "8hos"

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

"This string has a newline\n".chop

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

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

"8host".chomp("st")    # "8ho"

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

"This string has a newline\n".chomp   # "This string has a newline

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

"8host".chomp     # "8host"

Потому 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"

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

Заключение

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

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

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

Читайте также:

Tags: