Литералы
Литералы создают объекты, которые вы можете использовать в своей программе. Литералы включают:
Булевы и Nil литералы
nil и false оба являются ложными значениями. nil иногда используется для обозначения «нет значения» или «неизвестно», но в условных выражениях оценивается как false.
true является истинным значением. Все объекты, кроме nil и false, оцениваются как истинные значения в условных выражениях.
Числовые литералы
Целочисленные литералы
Целые числа любого размера можно записать следующим образом:
1234 1_234
Эти числа имеют одинаковое значение, 1234. Подчеркивание может использоваться для повышения читабельности для человека. Вы можете разместить подчеркивание где угодно в числе.
Вы можете использовать специальный префикс для записи чисел в десятичном, шестнадцатеричном, восьмеричном или двоичном форматах. Для десятичных чисел используйте префикс 0d, для шестнадцатеричных — префикс 0x, для восьмеричных — префикс 0 или 0o, для двоичных — префикс 0b. Буквенная часть числа нечувствительна к регистру.
Примеры:
0d170 0D170 0xaa 0xAa 0xAA 0Xaa 0XAa 0XaA 0252 0o252 0O252 0b10101010 0B10101010
Все эти числа имеют одинаковое десятичное значение, 170. Как целые и вещественные числа, вы можете использовать подчеркивание для повышения читабельности.
Вещественные литералы
Вещественные числа могут быть записаны следующим образом:
12.34 1234e-2 1.234E1
Эти числа имеют одинаковое значение, 12,34. Вы также можете использовать подчеркивания в вещественных числах.
Рациональные литералы
Вы можете записать Rational число следующим образом (с постфиксом r):
12r #=> (12/1) 12.3r #=> (123/10)
Рациональное число является точным, в то время как вещественное число может быть приближенным.
0.1r + 0.2r #=> (3/10) 0.1 + 0.2 #=> 0.30000000000000004
Комплексные литералы
Вы можете записать Complex число следующим образом (с постфиксом i):
1i #=> (0+1i) 1i * 1i #=> (-1+0i)
Также рациональные числа могут быть мнимыми числами.
12.3ri #=> (0+(123/10)*i)
i должен быть помещен после r; обратное не допускается.
12.3ir #=> Syntax error
Строки
Строковые литералы
Наиболее распространённый способ записи строк — использование ":
"This is a string."
Строка может занимать много строк.
Любой внутренний " должен быть экранирован:
"This string has a quote: \". As you can see, it is escaped"
Строки в двойных кавычках позволяют использовать экранированные символы, такие как \n для новой строки, \t для табуляции и т. д. Полный список поддерживаемых последовательностей экранирования приведен ниже:
\a bell, ASCII 07h (BEL)
\b backspace, ASCII 08h (BS)
\t horizontal tab, ASCII 09h (TAB)
\n newline (line feed), ASCII 0Ah (LF)
\v vertical tab, ASCII 0Bh (VT)
\f form feed, ASCII 0Ch (FF)
\r carriage return, ASCII 0Dh (CR)
\e escape, ASCII 1Bh (ESC)
\s space, ASCII 20h (SPC)
\\ backslash, \
\nnn octal bit pattern, where nnn is 1-3 octal digits ([0-7])
\xnn hexadecimal bit pattern, where nn is 1-2 hexadecimal digits ([0-9a-fA-F])
\unnnn Unicode character, where nnnn is exactly 4 hexadecimal digits ([0-9a-fA-F])
\u{nnnn ...} Unicode character(s), where each nnnn is 1-6 hexadecimal digits ([0-9a-fA-F])
\cx or \C-x control character, where x is an ASCII printable character
\M-x meta character, where x is an ASCII printable character
\M-\C-x meta control character, where x is an ASCII printable character
\M-\cx same as above
\c\M-x same as above
\c? or \C-? delete, ASCII 7Fh (DEL) Любой другой символ после обратной косой черты интерпретируется как сам символ.
Строки в двойных кавычках позволяют интерполировать другие значения с помощью #{...}:
"One plus one is two: #{1 + 1}"
Любое выражение может быть помещено в интерполируемую часть, но лучше всего сохранять выражение компактным для повышения читабельности.
Вы также можете использовать #@foo, #@@foo и #$foo в качестве сокращений соответственно #{ @foo }, #{ @@foo } и #{ $foo }.
Интерполяция может быть отключена путём экранирования символа «#» или использованием одиночных кавычек:
'#{1 + 1}' #=> "\#{1 + 1}"
Помимо отключения интерполяции, строки в одинарных кавычках также отключают все последовательности экранирования, кроме одинарной кавычки (\') и обратной косой черты (\\).
Смежные строковые литералы автоматически конкатенируются интерпретатором:
"con" "cat" "en" "at" "ion" #=> "concatenation" "This string contains "\ "no newlines." #=> "This string contains no newlines."
Любая комбинация смежных строк в одинарных, двойных кавычках или с процентом будет конкатенирована, если строка с процентом не является последней.
%q{a} 'b' "c" #=> "abc"
"a" 'b' %q{c} #=> NameError: uninitialized constant q
Также существует обозначение литерала символа для представления строковых литералов из одного символа, синтаксис которого представляет собой знак вопроса (?) за которым следует один символ или последовательность экранирования, соответствующая одному кодовому пункту в кодировке сценария:
?a #=> "a"
?abc #=> SyntaxError
?\n #=> "\n"
?\s #=> " "
?\\ #=> "\\"
?\u{41} #=> "A"
?\C-a #=> "\x01"
?\M-a #=> "\xE1"
?\M-\C-a #=> "\x81"
?\C-\M-a #=> "\x81", same as above
?あ #=> "あ" См. также:
Литералы документов здесь
Если вы пишете большой блок текста, вы можете использовать «документ здесь» или «heredoc»:
expected_result = <<HEREDOC This would contain specially formatted text. That might span many lines HEREDOC
Heredoc начинается в строке, следующей за <<HEREDOC и заканчивается следующей строкой, начинающейся с HEREDOC. Результат включает завершающую новую строку.
Вы можете использовать любой идентификатор с heredoc, но обычно используются идентификаторы с заглавными буквами.
Вы можете отступать завершающий идентификатор, если вы поместите «-» после <<:
expected_result = <<-INDENTED_HEREDOC This would contain specially formatted text. That might span many lines INDENTED_HEREDOC
Обратите внимание, что, хотя завершающий идентификатор может быть отформатирован с отступом, содержимое всегда обрабатывается как выровненное по левому краю. Если вы отступите содержимое, эти пробелы появятся в выводе.
Чтобы иметь отформатированное с отступом содержимое, а также отступающий завершающий идентификатор, вы можете использовать «волнистый» heredoc, который использует «~» вместо «-» после <<:
expected_result = <<~SQUIGGLY_HEREDOC This would contain specially formatted text. That might span many lines SQUIGGLY_HEREDOC
Отступ самой левой строки будет удалён из каждой строки содержимого. Обратите внимание, что пустые строки и строки, состоящие только из табуляции и пробелов, будут проигнорированы при определении отступа, но экранированные табуляции и пробелы считаются неотступными символами.
Heredoc позволяет интерполяцию и экранирование символов. Вы можете отключить интерполяцию и экранирование, заключив открывающий идентификатор в одинарные кавычки:
expected_result = <<-'EXPECTED'
One plus one is #{1 + 1}
EXPECTED
p expected_result # prints: "One plus one is \#{1 + 1}\n"
Идентификатор также может быть заключён в двойные кавычки (что эквивалентно отсутствию кавычек) или в обратные кавычки. Когда он заключён в обратные кавычки, HEREDOC ведёт себя как Kernel#‘:
puts <<-`HEREDOC`
cat #{__FILE__}
HEREDOC
При использовании кавычек в качестве ограничителей, любой символ кроме этой кавычки и новой строки (CR и/или LF) может быть использован в качестве идентификатора.
Для вызова метода на heredoc поместите его после открывающего идентификатора:
expected_result = <<-EXPECTED.chomp
One plus one is #{1 + 1}
EXPECTED
Вы можете открыть несколько heredocs в одной строке, но это может быть трудно читать:
puts(<<-ONE, <<-TWO) content for heredoc one ONE content for heredoc two TWO
Символьные литералы
Symbol представляет имя внутри интерпретатора Ruby. См. Symbol для более подробной информации о том, что представляют собой символы и когда Ruby создаёт их внутри.
Вы можете ссылаться на символ, используя двоеточие: :my_symbol.
Вы также можете создавать символы с помощью интерполяции:
:"my_symbol1"
:"my_symbol#{1 + 1}"
Как и в строках, одинарная кавычка может использоваться для отключения интерполяции:
:'my_symbol#{1 + 1}' #=> :"my_symbol\#{1 + 1}"
При создании Hash, существует специальный синтаксис для ссылки на Symbol также.
См. также:
Массивы литералов
Массив создаётся с использованием объектов между [ и ]:
[1, 2, 3]
Вы можете помещать выражения внутри массива:
[1, 1 + 1, 1 + 2] [1, [1 + 1, [1 + 2]]]
См. также:
См. Array для методов, которые вы можете использовать с массивом.
Хеш литералы
Хеш создаётся с использованием пар ключ-значение между { и }:
{ "a" => 1, "b" => 2 }
И ключ, и значение могут быть любыми объектами.
Вы можете создать хеш с ключами-символами с помощью следующего синтаксиса:
{ a: 1, b: 2 }
Этот же синтаксис используется для ключевых аргументов для метода.
Как и литералы Symbol, вы можете использовать кавычки для символьных ключей.
{ "a 1": 1, "b #{1 + 1}": 2 }
равно
{ :"a 1" => 1, :"b 2" => 2 }
Hash значения могут быть опушены, что означает, что значение будет взято из контекста по имени ключа:
x = 100
y = 200
h = { x:, y: }
#=> {:x=>100, :y=>200}
См. Hash для методов, которые вы можете использовать с хешем.
Диапазоны литералов
Диапазон представляет собой интервал значений. Диапазон может включать или исключать конечное значение.
(1..2) # includes its ending value (1...2) # excludes its ending value (1..) # endless range, representing infinite sequence from 1 to Infinity (..1) # beginless range, representing infinite sequence from -Infinity to 1
Вы можете создать диапазон любых объектов. См. документацию Range для подробностей о методах, которые нужно реализовать.
Литералы регулярных выражений
Регулярное выражение создаётся с использованием «/»:
/my regular expression/
За регулярным выражением могут следовать флаги, которые изменяют поведение сопоставления регулярного выражения. Флаг «i» делает регулярное выражение нечувствительным к регистру:
/my regular expression/i
Интерполяция может использоваться внутри регулярных выражений вместе с экранированными символами. Обратите внимание, что регулярное выражение может потребовать дополнительных экранированных символов по сравнению со строкой.
См. также:
См. Regexp для описания синтаксиса регулярных выражений.
Lambda Proc Литералы
Лямбда-процедуру можно создать с помощью ->:
-> { 1 + 1 }
Вызов вышеуказанной процедуры даст результат 2.
Вы можете потребовать аргументы для процедуры следующим образом:
->(v) { 1 + v }
Эта процедура добавит единицу к своему аргументу.
Процентные литералы
Каждый из литералов в этом разделе может использовать эти парные разделители:
-
[и </tt>]</tt>. -
(и </tt>)</tt>. -
{и </tt>}</tt>. -
<и </tt>></tt>. -
Любой другой символ, как начальный, так и конечный разделитель.
Эти примеры показаны в следующем разделе.
%q: Неинтерполируемые String литералы
Вы можете записать неинтерполируемую строку с помощью %q. Созданная строка эквивалентна строке, созданной с одинарными кавычками:
%[foo bar baz] # => "foo bar baz" # Using [].
%(foo bar baz) # => "foo bar baz" # Using ().
%{foo bar baz} # => "foo bar baz" # Using {}.
%<foo bar baz> # => "foo bar baz" # Using <>.
%|foo bar baz| # => "foo bar baz" # Using two |.
%:foo bar baz: # => "foo bar baz" # Using two :.
%q(1 + 1 is #{1 + 1}) # => "1 + 1 is \#{1 + 1}" # No interpolation.
% and %Q: Интерполируемые String литералы
Вы можете записать интерполируемую строку с помощью %Q или ее псевдонима %:
%[foo bar baz] # => "foo bar baz"
%(1 + 1 is #{1 + 1}) # => "1 + 1 is 2" # Interpolation.
%w and %W: Литералы массивов строк
Вы можете записать массив строк с помощью %w (неинтерполируемый) или %W (интерполируемый):
%w[foo bar baz] # => ["foo", "bar", "baz"]
%w[1 % *] # => ["1", "%", "*"]
# Use backslash to embed spaces in the strings.
%w[foo\ bar baz\ bat] # => ["foo bar", "baz bat"]
%w(#{1 + 1}) # => ["\#{1", "+", "1}"]
%W(#{1 + 1}) # => ["2"]
%i and %I: Литералы массивов символов
Вы можете записать массив символов с помощью %i (неинтерполируемый) или %I (интерполируемый):
%i[foo bar baz] # => [:foo, :bar, :baz]
%i[1 % *] # => [:"1", :%, :*]
# Use backslash to embed spaces in the symbols.
%i[foo\ bar baz\ bat] # => [:"foo bar", :"baz bat"]
%i(#{1 + 1}) # => [:"\#{1", :+, :"1}"]
%I(#{1 + 1}) # => [:"2"]
%s: Symbol Литералы
Вы можете записать символ с помощью %s:
:foo # => :foo :foo bar # => :"foo bar"
%r: Regexp Литералы
Вы можете записать регулярное выражение с помощью %r:
r = %r[foo\sbar] # => /foo\sbar/ 'foo bar'.match(r) # => #<MatchData "foo bar"> r = %r[foo\sbar]i # => /foo\sbar/i 'FOO BAR'.match(r) # => #<MatchData "FOO BAR">
%x: Литералы обратных кавычек
Вы можете записать и выполнить командную оболочку с помощью %x:
%x(echo 1) # => "1\n"
Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.
