Методы строк в 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: Ruby
1 комментарий
ля много инфы с спс