Литералы
Литералы создают объекты, которые можно использовать в вашей программе. Литералы включают:
Булевы и 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. Вы также можете использовать подчеркивания в числах с плавающей точкой.
Рациональные литералы
Вы можете записать рациональный литерал, используя специальный суффикс, '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
Комплексные литералы
Вы можете записать комплексное число, используя суффикс i:
1i #=> (0+1i) 1i * 1i #=> (-1+0i)
Также рациональные числа могут быть мнимыми.
12.3ri #=> (0+(123/10)*i)
i должно быть помещено после r; обратное не допускается.
12.3ir #=> Syntax error
Строки
Последовательности escape
Некоторые символы могут быть представлены как последовательности escape в строках в двойных кавычках, литералах символов, литералах документов здесь (незаключенных, в двойных кавычках и с обратными кавычками), символах в двойных кавычках, ключах символов в двойных кавычках в литералах 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>, представляет пустую строку вместо символа. Используется для сгиба строки в строке.
Литералы строк в двойных кавычках
Наиболее распространенный способ записи строк — использование ":
"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} #=> NameError: uninitialized constant q
Литерал символа
Есть также обозначение литерала символа для представления строк из одного символа, синтаксис которого — знак вопроса (?) за которым следует один символ или последовательность 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
?あ #=> "あ" Литералы документов здесь
Если вы пишете большой блок текста, вы можете использовать «документ здесь» или «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
Вы можете открыть несколько heredocs в одной строке, но это может быть трудно читать:
puts(<<-ONE, <<-TWO) content for heredoc one ONE content for heredoc two TWO
Символьные литералы
Symbol представляет имя внутри интерпретатора Ruby. См. Symbol для получения дополнительной информации о том, что представляют собой символы и когда Ruby создает их внутри.
Вы можете ссылаться на символ, используя двоеточие: :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.
Это похоже на строку в двойных кавычках. Она поддерживает последовательности экранирования, описанные в Последовательностях экранирования. Другие экранированные символы (обратная косая черта, за которой следует символ) интерпретируются как этот символ.
%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–2024 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.
