Литералы
Литералы создают объекты, которые можно использовать в программе. К литералам относятся:
Логические литералы и литерал nil
nil и false — это значения false. nil иногда используется для обозначения «отсутствия значения» или «неизвестного значения», но в условных выражениях оно вычисляется как false.
true — это значение true. Все объекты, кроме nil и false, в условных выражениях вычисляются как true.
Числовые литералы
Целочисленные литералы
Целые числа любого размера можно записывать следующим образом:
1234 1_234
Все эти числа имеют одно и то же значение — 1 234. Подчёркивание можно использовать для повышения удобочитаемости. Его можно поставить в любом месте числа.
Для записи чисел в десятичной, шестнадцатеричной, восьмеричной или двоичной системе счисления можно использовать специальный префикс. Для десятичных чисел используйте префикс 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
Литерал Rational можно записать с помощью специального суффикса 'r'.
Примеры:
1r # => (1/1) 2/3r # => (2/3) # With denominator. -1r # => (-1/1) # With signs. -2/3r # => (-2/3) 2/-3r # => (-2/3) -2/-3r # => (2/3) +1/+3r # => (1/3) 1.2r # => (6/5) # With fractional part. 1_1/2_1r # => (11/21) # With embedded underscores. 2/4r # => (1/2) # Automatically reduced.
Синтаксис:
<rational-literal> = <numerator> [ '/' <denominator> ] 'r'
<numerator> = [ <sign> ] <digits> [ <fractional-part> ]
<fractional-part> = '.' <digits>
<denominator> = [ sign ] <digits>
<sign> = '-' | '+'
<digits> = <digit> { <digit> | '_' <digit> }
<digit> = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' Обратите внимание на следующий пример: он разбирается как числитель Float 1.2, делённый на знаменатель Rational 3r, в результате чего получается Float:
1.2/3r # => 0.39999999999999997
Литералы Complex
Число 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"
В строках в двойных кавычках доступны escape-последовательности, описанные в разделе Escape-последовательности.
В строке в двойных кавычках любой другой символ после обратной косой черты интерпретируется как сам этот символ.
В строках в двойных кавычках можно подставлять другие значения с помощью #{...}:
"One plus one is two: #{1 + 1}"
Внутри интерполируемого фрагмента можно разместить любое выражение, однако для удобочитаемости лучше использовать небольшие выражения.
В качестве сокращённой записи для #{ @foo }, #{ @@foo } и #{ $foo } соответственно также можно использовать #@foo, #@@foo и #$foo.
См. также:
Строковые литералы в одинарных кавычках
Интерполяцию можно отключить, экранировав символ «#» или используя строки в одинарных кавычках:
'#{1 + 1}' #=> "\#{1 + 1}"
Помимо интерполяции, строки в одинарных кавычках отключают все escape-последовательности, кроме одинарной кавычки (\') и обратной косой черты (\\).
В строке в одинарных кавычках любой другой символ после обратной косой черты интерпретируется как есть: обратная косая черта и сам символ.
См. также:
Конкатенация литералов String
Соседние строковые литералы автоматически объединяются интерпретатором:
"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} #=> NoMethodError: undefined method 'q' for main
Литерал символа
Также существует запись символьного литерала для представления строки из одного символа. Она состоит из вопросительного знака (?), за которым следует один символ или escape-последовательность (кроме переноса строки), соответствующая одной кодовой точке в кодировке скрипта:
?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
?あ #=> "あ" Escape-последовательности
Некоторые символы можно записывать с помощью escape-последовательностей в строках в двойных кавычках, символьных литералах, литералах here-документов (без кавычек, в двойных кавычках и с обратными кавычками), символах в двойных кавычках, ключах-символах в литералах Hash, литералах Regexp и нескольких литералах с процентной нотацией (%, %Q, %W, %I, %r, %x).
Они поддерживают такие escape-последовательности, как \n для перевода строки, \t для табуляции и т. д. Полный список поддерживаемых escape-последовательностей:
\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)
\<newline> continuation line (empty string) Последняя последовательность, <newline>, обозначает пустую строку, а не символ. Она используется для переноса строки в строковом литерале.
Литералы here-документов
Для записи большого блока текста можно использовать «here-документ», или «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 поддерживает интерполяцию и escape-последовательности, описанные в разделе Escape-последовательности. Интерполяцию и экранирование можно отключить, заключив открывающий идентификатор в одинарные кавычки:
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
В одной строке можно открыть несколько heredoc, однако такой код может быть трудно читать:
puts(<<-ONE, <<-TWO) content for heredoc one ONE content for heredoc two TWO
Литералы Symbol
Symbol представляет имя внутри интерпретатора Ruby. Подробнее о том, что такое символы и когда Ruby создаёт их самостоятельно, см. в документации Symbol.
На символ можно сослаться с помощью двоеточия: :my_symbol.
Символы также можно создавать с помощью интерполяции и escape-последовательностей, описанных в разделе Escape-последовательности, заключив их в двойные кавычки:
:"my_symbol1"
:"my_symbol#{1 + 1}"
:"foo\sbar"
Как и для строк, одинарные кавычки можно использовать для отключения интерполяции и escape-последовательностей:
:'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.
Литералы регулярных выражений
Регулярное выражение можно создать, заключив его между начальным и конечным символами косой черты ('/'):
re = /foo/ # => /foo/ re.class # => Regexp
После завершающей косой черты можно указать один или несколько символов-модификаторов, задающих режимы регулярного выражения. Подробнее см. в разделе Режимы регулярных выражений.
В регулярных выражениях наряду с экранированными символами можно использовать интерполяцию. Обратите внимание: регулярному выражению может потребоваться больше экранированных символов, чем строке.
См. также:
Описание синтаксиса регулярных выражений см. в документации Regexp.
Литералы Lambda Proc
Lambda proc можно создать с помощью ->:
-> { 1 + 1 }
Вызов указанного выше proc вернёт результат 2.
Аргументы для proc можно сделать обязательными следующим образом:
->(v) { 1 + v }
Этот proc прибавляет единицу к своему аргументу.
Литералы с процентной нотацией
В каждом из литералов, описанных в этом разделе, можно использовать следующие парные разделители:
-
[и]. -
(и). -
{и}. -
<и>. -
Непробельный символ ASCII, не являющийся буквой или цифрой, кроме перечисленных выше, — в качестве открывающего и закрывающего разделителя.
Разделители можно экранировать обратной косой чертой. Однако первые четыре пары (квадратные скобки, круглые скобки, фигурные скобки и угловые скобки) можно использовать без обратной косой черты, если они правильно образуют пары.
Примеры приведены в следующем разделе.
%q: строковые литералы без интерполяции String
Строку без интерполяции можно записать с помощью %q. Созданная строка будет такой же, как если бы она была записана в одинарных кавычках:
%q[foo bar baz] # => "foo bar baz" # Using [].
%q(foo bar baz) # => "foo bar baz" # Using ().
%q{foo bar baz} # => "foo bar baz" # Using {}.
%q<foo bar baz> # => "foo bar baz" # Using <>.
%q|foo bar baz| # => "foo bar baz" # Using two |.
%q:foo bar baz: # => "foo bar baz" # Using two :.
%q(1 + 1 is #{1 + 1}) # => "1 + 1 is \#{1 + 1}" # No interpolation.
%q[foo[bar]baz] # => "foo[bar]baz" # brackets can be nested.
%q(foo(bar)baz) # => "foo(bar)baz" # parenthesis can be nested.
%q{foo{bar}baz} # => "foo{bar}baz" # braces can be nested.
%q<foo<bar>baz> # => "foo<bar>baz" # angle brackets can be nested.
Это похоже на строку в одинарных кавычках, но с помощью обратной косой черты можно экранировать только обратные косые черты и указанные разделители.
% and %Q: строковые литералы с интерполяцией String
Строку с интерполяцией можно записать с помощью %Q или его псевдонима %:
%[foo bar baz] # => "foo bar baz"
%(1 + 1 is #{1 + 1}) # => "1 + 1 is 2" # Interpolation.
Это похоже на строку в двойных кавычках. Поддерживаются escape-последовательности, описанные в разделе Escape-последовательности. Другие экранированные символы (обратная косая черта, за которой следует символ) интерпретируются как сам этот символ.
%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[foo\ bar baz\ bat] # => ["foo bar", "baz bat"]
%w(#{1 + 1}) # => ["\#{1", "+", "1}"]
%W(#{1 + 1}) # => ["2"]
# The nested delimiters evaluated to a flat array of strings
# (not nested array).
%w[foo[bar baz]qux] # => ["foo[bar", "baz]qux"]
Для разделения слов считаются пробельными следующие символы:
-
пробел, ASCII 20h (SPC)
-
перевод страницы, ASCII 0Ch (FF)
-
символ новой строки (перевод строки), ASCII 0Ah (LF)
-
возврат каретки, ASCII 0Dh (CR)
-
горизонтальная табуляция, ASCII 09h (TAB)
-
вертикальная табуляция, ASCII 0Bh (VT)
Пробельные символы можно экранировать обратной косой чертой, чтобы включить их в слово.
%W поддерживают escape-последовательности, описанные в разделе Escape-последовательности. Однако перенос строки <newline> использовать нельзя, поскольку он интерпретируется как экранированный символ новой строки, описанный выше.
%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[foo\ bar baz\ bat] # => [:"foo bar", :"baz bat"]
%i(#{1 + 1}) # => [:"\#{1", :+, :"1}"]
%I(#{1 + 1}) # => [:"2"]
Пробельные символы и их экранирование обрабатываются так же, как в литералах массивов строк, описанных в разделе %w и %W: литералы массивов строк.
%s: литералы Symbol
Символ можно записать с помощью %s:
%s[foo] # => :foo %s[foo bar] # => :"foo bar"
Интерполяция не поддерживается. Только обратные косые черты и указанные разделители можно экранировать обратной косой чертой.
%r: литералы Regexp
Регулярное выражение можно записать с помощью %r; в качестве начального и конечного разделителя можно использовать практически любой символ:
%r/foo/ # => /foo/ %r:name/value pair: # => /name\/value pair/
В качестве разделителей можно использовать несколько пар «симметричных» символов:
%r[foo] # => /foo/
%r{foo} # => /foo/
%r(foo) # => /foo/
%r<foo> # => /foo/
После завершающего разделителя можно указать один или несколько символов-модификаторов, задающих режимы регулярного выражения. Подробнее см. в разделе Режимы регулярных выражений.
%x: литералы с обратными кавычками
Команду оболочки можно записать и выполнить с помощью %x:
%x(echo 1) # => "1\n"
%x[echo #{1 + 2}] # => "3\n"
%x[echo \u0030] # => "0\n"
Поддерживается интерполяция. %x поддерживают escape-последовательности, описанные в разделе Escape-последовательности.
Ruby Core © 1993–2025 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.
