Ruby Language
Струны
Поиск…
Синтаксис
- 'Строка' // создает строку через однокасканный литерал
- «Строка» // создает строку через двухцилиндровый литерал
- String.new ("Строка")
- % q (строка) // альтернативный синтаксис для создания одиночных кавычек
- % Q (строка A) // альтернативный синтаксис для создания строк с двойными кавычками
Разница между строковыми литералами с одной кавычкой и двумя кавычками
Основное отличие состоит в том, что String литералы с двойными кавычками поддерживают строковые интерполяции и полный набор управляющих последовательностей.
Например, они могут включать произвольные выражения Ruby с помощью интерполяции:
# Single-quoted strings don't support interpolation
puts 'Now is #{Time.now}'
# Now is #{Time.now}
# Double-quoted strings support interpolation
puts "Now is #{Time.now}"
# Now is 2016-07-21 12:43:04 +0200
Строки с двойными кавычками также поддерживают весь набор управляющих последовательностей, включая "\n" , "\t" ...
puts 'Hello\nWorld'
# Hello\nWorld
puts "Hello\nWorld"
# Hello
# World
... в то время как строки с одиночными кавычками не поддерживают escape-последовательности, ограничивая минимальный набор, необходимый для использования однокаскадных строк: буквенные одинарные кавычки и обратные косые черты, '\'' и '\\' соответственно.
Создание строки
Ruby предоставляет несколько способов создания объекта String . Наиболее распространенный способ - использовать одиночные или двойные кавычки для создания « строкового литерала »:
s1 = 'Hello'
s2 = "Hello"
Основное отличие состоит в том, что строковые литералы с двойными кавычками немного более гибкие, поскольку они поддерживают интерполяцию и некоторые escape-последовательности обратной косой черты.
Существует также несколько других возможных способов создания строкового литерала с использованием произвольных разделителей строк. Произвольный разделитель строк - это % за которым следует соответствующая пара разделителей:
%(A string)
%{A string}
%<A string>
%|A string|
%!A string!
Наконец, вы можете использовать %q и %Q последовательности, которые эквивалентны ' и " «:
puts %q(A string)
# A string
puts %q(Now is #{Time.now})
# Now is #{Time.now}
puts %Q(A string)
# A string
puts %Q(Now is #{Time.now})
# Now is 2016-07-21 12:47:45 +0200
%q и %Q последовательности полезны, когда строка содержит либо одинарные кавычки, либо двойные кавычки, либо их сочетание. Таким образом, вам не нужно избегать содержимого:
%Q(<a href="/profile">User's profile<a>)
Вы можете использовать несколько разных разделителей, если имеется соответствующая пара:
%q(A string)
%q{A string}
%q<A string>
%q|A string|
%q!A string!
Конкатенация строк
Конкатенация строк с помощью оператора + :
s1 = "Hello"
s2 = " "
s3 = "World"
puts s1 + s2 + s3
# => Hello World
s = s1 + s2 + s3
puts s
# => Hello World
Или с помощью оператора << :
s = 'Hello'
s << ' '
s << 'World'
puts s
# => Hello World
Обратите внимание, что оператор << изменяет объект с левой стороны.
Вы также можете умножать строки, например
"wow" * 3
# => "wowwowwow"
Строчная интерполяция
#{ruby_expression} разделитель " и %Q последовательность поддерживает строчную интерполяцию с использованием #{ruby_expression} :
puts "Now is #{Time.now}"
# Now is Now is 2016-07-21 12:47:45 +0200
puts %Q(Now is #{Time.now})
# Now is Now is 2016-07-21 12:47:45 +0200
Мануальная обработка
"string".upcase # => "STRING"
"STRING".downcase # => "string"
"String".swapcase # => "sTRING"
"string".capitalize # => "String"
Эти четыре метода не изменяют исходный приемник. Например,
str = "Hello"
str.upcase # => "HELLO"
puts str # => "Hello"
Существует четыре аналогичных метода, которые выполняют одни и те же действия, но изменяют исходный приемник.
"string".upcase! # => "STRING"
"STRING".downcase! # => "string"
"String".swapcase! # => "sTRING"
"string".capitalize! # => "String"
Например,
str = "Hello"
str.upcase! # => "HELLO"
puts str # => "HELLO"
Заметки:
- до Ruby 2.4 эти методы не обрабатывают unicode.
Разделение строки
String#split разбивает String на Array , основываясь на разделителе.
"alpha,beta".split(",")
# => ["alpha", "beta"]
Пустая String выводит в пустой Array :
"".split(",")
# => []
Неподходящий разделитель приводит к Array содержащему один элемент:
"alpha,beta".split(".")
# => ["alpha,beta"]
Вы также можете разбить строку, используя регулярные выражения:
"alpha, beta,gamma".split(/, ?/)
# => ["alpha", "beta", "gamma"]
Разделитель является необязательным, по умолчанию строка разделяется на пробелы:
"alpha beta".split
# => ["alpha", "beta"]
Присоединение к строкам
Array#join объединяет Array в String на основе разделителя:
["alpha", "beta"].join(",")
# => "alpha,beta"
Разделитель является необязательным, и по умолчанию используется пустая String .
["alpha", "beta"].join
# => "alphabeta"
Пустой Array приводит к пустой String , независимо от того, какой разделитель используется.
[].join(",")
# => ""
Многострочные строки
Самый простой способ создать многострочную строку - просто использовать несколько строк между кавычками:
address = "Four score and seven years ago our fathers brought forth on this
continent, a new nation, conceived in Liberty, and dedicated to the
proposition that all men are created equal."
Основная проблема с этим методом заключается в том, что если строка содержит цитату, она разбивает синтаксис строки. Чтобы обойти проблему, вы можете использовать вместо heredoc :
puts <<-RAVEN
Once upon a midnight dreary, while I pondered, weak and weary,
Over many a quaint and curious volume of forgotten lore—
While I nodded, nearly napping, suddenly there came a tapping,
As of some one gently rapping, rapping at my chamber door.
"'Tis some visitor," I muttered, "tapping at my chamber door—
Only this and nothing more."
RAVEN
Ruby поддерживает shell-style здесь документы с <<EOT , но завершающий текст должен начинаться с строки. Это закручивает отступ кода, поэтому нет смысла использовать этот стиль. К сожалению, строка будет иметь отступы в зависимости от того, как сам код имеет отступ.
Ruby 2.3 решает проблему, введя <<~ которая удаляет лишние ведущие пространства:
def build_email(address)
return (<<~EMAIL)
TO: #{address}
To Whom It May Concern:
Please stop playing the bagpipes at sunrise!
Regards,
Your neighbor
EMAIL
end
Percent Strings также работают для создания многострочных строк:
%q(
HAMLET Do you see yonder cloud that's almost in shape of a camel?
POLONIUS By the mass, and 'tis like a camel, indeed.
HAMLET Methinks it is like a weasel.
POLONIUS It is backed like a weasel.
HAMLET Or like a whale?
POLONIUS Very like a whale
)
Существует несколько способов избежать интерполяции и escape-последовательностей:
Одинарная кавычка вместо двойной кавычки:
'\n is a carriage return.'Нижний регистр
qв процентной строке:%q[#{not-a-variable}]Одинарная кавычка терминальной строки в heredoc:
<<-'CODE' puts 'Hello world!' CODE
Форматированные строки
Ruby может вставлять массив значений в строку, заменяя любые заполнители значениями из поставляемого массива.
"Hello %s, my name is %s!" % ['World', 'br3nt']
# => Hello World, my name is br3nt!
Держатели мест представлены двумя %s а значения задаются массивом ['Hello', 'br3nt'] . Оператор % указывает строке для ввода значений массива.
Сменные замены символов
Метод tr возвращает копию строки, где символы первого аргумента заменяются символами второго аргумента.
"string".tr('r', 'l') # => "stling"
Чтобы заменить только первое вхождение шаблона другим выражением, используйте метод sub
"string ring".sub('r', 'l') # => "stling ring"
Если вы хотите заменить все вхождения шаблона этим выражением, используйте gsub
"string ring".gsub('r','l') # => "stling ling"
Чтобы удалить символы, перейдите в пустую строку для второго параметра
Вы также можете использовать регулярные выражения во всех этих методах.
Важно отметить, что эти методы возвращают только новую копию строки и не будут изменять строку на месте. Для этого вам нужно использовать tr! , sub! и gsub! методов соответственно.
Понимание данных в строке
В Ruby строка представляет собой последовательность байтов вместе с именем кодировки (например, UTF-8 , US-ASCII , ASCII-8BIT ), которая указывает, как вы можете интерпретировать эти байты как символы.
Строки Ruby могут использоваться для хранения текста (в основном последовательность символов), и в этом случае обычно используется кодировка UTF-8.
"abc".bytes # => [97, 98, 99]
"abc".encoding.name # => "UTF-8"
Строки Ruby также могут использоваться для хранения двоичных данных (последовательность байтов), и в этом случае обычно используется кодировка ASCII-8BIT.
[42].pack("i").encoding # => "ASCII-8BIT"
Возможно, что последовательность байтов в строке не соответствует кодировке, что приводит к ошибкам, если вы попытаетесь использовать эту строку.
"\xFF \xFF".valid_encoding? # => false
"\xFF \xFF".split(' ') # ArgumentError: invalid byte sequence in UTF-8
Замена строк
p "This is %s" % "foo"
# => "This is foo"
p "%s %s %s" % ["foo", "bar", "baz"]
# => "foo bar baz"
p "%{foo} == %{foo}" % {:foo => "foo" }
# => "foo == foo"
Дополнительную информацию см. В разделе String % docs и Kernel :: sprintf .
Строка начинается с
Чтобы узнать, начинается ли строка с шаблона, start_with? метод пригодится
str = "zebras are cool"
str.start_with?("zebras") => true
Вы также можете проверить положение шаблона с index
str = "zebras are cool"
str.index("zebras").zero? => true
Строка заканчивается
Чтобы найти, заканчивается ли строка шаблоном, end_with? метод пригодится
str = "I like pineapples"
str.end_with?("pineaaples") => false
Позиционирующие строки
В Ruby строки могут быть выровнены по левому краю, выравниваться по правому краю или по центру
Для выравнивания по ljust метод ljust . Это принимает два параметра: целое число, представляющее количество символов новой строки и строки, представляющее шаблон, который нужно заполнить.
Если целое число больше длины исходной строки, новая строка будет выравниваться по левому краю с необязательным параметром строки, занимающим оставшееся пространство. Если параметр строки не указан, строка будет дополняться пробелами.
str ="abcd"
str.ljust(4) => "abcd"
str.ljust(10) => "abcd "
Чтобы правильно обосновать строку, используйте метод rjust . Это принимает два параметра: целое число, представляющее количество символов новой строки и строки, представляющее шаблон, который нужно заполнить.
Если целое число больше длины исходной строки, новая строка будет правильно обоснована с необязательным параметром строки с оставшимся пространством. Если параметр строки не указан, строка будет дополняться пробелами.
str = "abcd"
str.rjust(4) => "abcd"
str.rjust(10) => " abcd"
Чтобы центрировать строку, используйте метод center . Это принимает два параметра, целое число, представляющее ширину новой строки и строку, в которую будет добавлена исходная строка. Строка будет выровнена по центру.
str = "abcd"
str.center(4) => "abcd"
str.center(10) => " abcd "