Литералы
Литералы создают объекты, которые можно использовать в вашей программе. Литералы включают:
Булевы и 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'.
Примеры:
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
Строки
Строковые литералы
Наиболее распространенный способ записи строк — использование ":
"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. Подробнее о символах и о том, когда Ruby их создаёт, см. Symbol.
Вы можете сослаться на символ с использованием двоеточия: :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 }
Этот же синтаксис используется для ключевых аргументов метода.
Как и символьные литералы, вы можете поместить ключи-символы в кавычки.
{ "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 Литералы
Лямбда-процедуру можно создать с помощью ->:
-> { 1 + 1 }
Вызов вышеуказанной процедуры вернет результат 2.
Вы можете потребовать аргументов для процедуры следующим образом:
->(v) { 1 + v }
Эта процедура добавит к своему аргументу единицу.
Процентные литералы
Каждый из литералов в данном разделе может использовать эти парные разделители:
-
[и]. -
(и). -
{и}. -
<и>. -
Любой другой символ, как начальный, так и конечный разделитель.
Эти примеры показаны в следующем разделе.
%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:
%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"
Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.
