Литералы
Литералы создают объекты, которые можно использовать в программе. К литералам относятся:
Литералы логических значений и nil
nil и false — оба ложные значения. nil иногда используется для обозначения «отсутствия значения» или «неизвестного значения», но в условных выражениях вычисляется как false.
true — истинное значение. Все объекты, кроме nil и false, в условных выражениях вычисляются как истинное значение.
Числовые литералы
Целочисленные литералы
Целые числа любого размера можно записать следующим образом:
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 можно записать с помощью специального суффикса '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 можно записать следующим образом (с суффиксом i):
1i #=> (0+1i) 1i * 1i #=> (-1+0i)
Рациональные числа также могут быть мнимыми числами.
12.3ri #=> (0+(123/10)*i)
i должно располагаться после r; обратный порядок не допускается.
12.3ir #=> Syntax error
Строки
Управляющие последовательности
Некоторые символы можно записать в виде управляющих последовательностей в строках в двойных кавычках, символьных литералах, литералах here-документов (без кавычек, в двойных кавычках и с обратными кавычками), символах в двойных кавычках, ключах-символах в двойных кавычках в литералах Hash, литералах Regexp и нескольких процентных литералах (%, %Q, %W, %I, %r, %x).
Они позволяют использовать управляющие последовательности, такие как \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)
\<newline> continuation line (empty string) Последняя последовательность, <newline>, представляет собой пустую строку, а не символ. Она используется для переноса строки в строковом литерале.
Строковые литералы в двойных кавычках
Самый распространённый способ записать строку — использовать ":
"This is a string."
Строка может занимать несколько строк.
Любой символ " внутри строки необходимо экранировать:
"This string has a quote: \". As you can see, it is escaped"
В строках в двойных кавычках можно использовать управляющие последовательности, описанные в разделе Управляющие последовательности.
В строке в двойных кавычках любой другой символ, следующий за обратной косой чертой, интерпретируется как сам этот символ.
В строки в двойных кавычках можно подставлять другие значения с помощью #{...}:
"One plus one is two: #{1 + 1}"
Внутри интерполируемой части можно разместить любое выражение, но для удобства чтения лучше использовать короткие выражения.
Также можно использовать #@foo, #@@foo и #$foo как сокращённую запись соответственно для #{ @foo }, #{ @@foo } и #{ $foo }.
См. также:
Строковые литералы в одинарных кавычках
Интерполяцию можно отключить, экранировав символ «#» или используя строки в одинарных кавычках:
'#{1 + 1}' #=> "\#{1 + 1}"
Помимо отключения интерполяции, строки в одинарных кавычках отключают все управляющие последовательности, кроме одинарной кавычки (\') и обратной косой черты (\\).
В строке в одинарных кавычках любой другой символ, следующий за обратной косой чертой, интерпретируется буквально: как обратная косая черта, за которой следует сам символ.
См. также:
Конкатенация литералов 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} #=> 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
?あ #=> "あ" Литералы here-документов
Если нужно записать большой блок текста, можно использовать «here-документ» (heredoc):
expected_result = <<HEREDOC This would contain specially formatted text. That might span many lines HEREDOC
Here-документ начинается со строки после <<HEREDOC и заканчивается следующей строкой, начинающейся с HEREDOC. Результат включает завершающий символ новой строки.
Для here-документа можно использовать любой идентификатор, но обычно используют идентификаторы, состоящие только из заглавных букв.
Завершающий идентификатор можно сдвинуть вправо, если поставить «-» после <<:
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
В одной строке можно открыть несколько heredoc, но такой код может быть трудно читать:
puts(<<-ONE, <<-TWO) content for heredoc one ONE content for heredoc two TWO
Литералы символов
Symbol представляет имя внутри интерпретатора Ruby. Подробнее о символах и о том, когда Ruby создаёт их автоматически, см. в разделе Symbol.
На символ можно сослаться с помощью двоеточия: :my_symbol.
Символы также можно создавать с интерполяцией и управляющими последовательностями, описанными в разделе Управляющие последовательности, используя двойные кавычки:
:"my_symbol1"
:"my_symbol#{1 + 1}"
:"foo\sbar"
Как и для строк, одинарные кавычки можно использовать для отключения интерполяции и управляющих последовательностей:
:'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
Лямбда-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.
Это похоже на строку в двойных кавычках. Допускаются управляющие последовательности, описанные в разделе Управляющие последовательности. Другие экранированные символы (символ после обратной косой черты) интерпретируются как сам этот символ.
%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 можно использовать управляющие последовательности, описанные в разделе Управляющие последовательности. Однако продолжение строки <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 можно использовать управляющие последовательности, описанные в разделе Управляющие последовательности.
Ruby Core © 1993–2025 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.
