Литералы
Литералы создают объекты, которые можно использовать в вашей программе. Литералы включают:
Логические и 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' Обратите внимание на это, которое анализируется как числитель с плавающей точкой 1.2 поделенный на знаменатель с рациональными 3r, что приводит к значению с плавающей точкой:
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
?あ #=> "あ" См. также:
Литералы документов 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 позволяет интерполировать и экранировать символы. Вы можете отключить интерполяцию и экранирование, поместив открывающий идентификатор в одинарные кавычки:
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
Символьные литералы
A 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 }
Этот же синтаксис используется для ключевых аргументов для метода.
Как и литералы 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 options.
Интерполяция может использоваться внутри регулярных выражений вместе с экранированными символами. Обратите внимание, что регулярное выражение может потребовать дополнительных экранированных символов, чем строка.
См. также:
См. 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:
:foo # => :foo :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.
