Литералы

Литералы создают объекты, которые можно использовать в вашей программе. Литералы включают:

• Булевы значения и nil

• Числа

• Строки

• Символы

• Массивы

• Хэши

• Диапазоны

• Регулярные выражения

• Процедуры

Булевы значения и nil

nil и false — оба ложные значения. nil иногда используется для обозначения «отсутствия значения» или «неизвестного значения», но в условных выражениях оценивается как false.

true — истинное значение. Все объекты, кроме nil и false, оцениваются как истинные значения в условных выражениях.

(Также существуют константы TRUE, FALSE и NIL, но предпочтительнее использовать строчные формы литералов.)

Числа

Вы можете записать целые числа любого размера следующим образом:

1234
1_234

Эти числа имеют одинаковое значение, 1234. Подчеркивание может использоваться для повышения удобочитаемости для человека. Вы можете поместить подчеркивание в любом месте числа.

Числа с плавающей точкой могут быть записаны следующим образом:

12.34
1234e-2
1.234E1

Эти числа имеют одинаковое значение, 12.34. Вы также можете использовать подчеркивания в числах с плавающей точкой.

Вы можете использовать специальный префикс для записи чисел в десятичном, шестнадцатеричном, восьмеричном или двоичном форматах. Для десятичных чисел используйте префикс 0d, для шестнадцатеричных чисел — префикс 0x, для восьмеричных чисел — префикс 0 или 0o, для двоичных чисел — префикс 0b. Буквенная часть числа нечувствительна к регистру.

Примеры:

0d170
0D170

0xaa
0xAa
0xAA
0Xaa
0XAa
0XaA

0252
0o252
0O252

0b10101010
0B10101010

Все эти числа имеют одинаковое десятичное значение, 170. Как целые числа и числа с плавающей точкой, вы можете использовать подчеркивание для удобочитаемости.

Rational числа

Числа с суффиксом r являются Rational числами.

12r         #=> (12/1)
12.3r       #=> (123/10)

Rational числа являются точными, в то время как Float числа являются приближенными.

0.1r + 0.2r #=> (3/10)
0.1 + 0.2   #=> 0.30000000000000004

Complex числа

Числа с суффиксом i являются Complex (или мнимыми) числами.

1i          #=> (0+1i)
1i * 1i     #=> (-1+0i)

Также Rational числа могут быть мнимыми числами.

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}"

Любое выражение может быть помещено внутри интерполированной части, но для удобочитаемости лучше держать выражение коротким.

Интерполяция может быть отключена путём экранирования символа «#» или использования строк в одинарных кавычках:

'#{1 + 1}' #=> "\#{1 + 1}"

Помимо отключения интерполяции, строки в одинарных кавычках также отключают все последовательности экранирования, кроме одинарной кавычки (\') и обратной косой черты (\\).

Вы также можете создавать строки, используя %:

%(1 + 1 is #{1 + 1}) #=> "1 + 1 is 2"

Существует два разных типа % строк %q(...) ведёт себя как строка в одинарных кавычках (нет интерполяции или экранирования символов), в то время как %Q ведёт себя как строка в двойных кавычках. Подробнее о синтаксисе строк в процентах см. ниже.

Смежные строковые литералы автоматически конкатенируются интерпретатором:

"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 Documents (heredocs)

Если вы пишете большой блок текста, вы можете использовать «here document» или «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 для методов, которые можно использовать с хэшем.

Диапазоны

Диапазон представляет интервал значений. Диапазон может включать или исключать своё конечное значение.

(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 для получения подробностей о методах, которые необходимо реализовать.

Регулярные выражения

Регулярное выражение создаётся с помощью «/»:

/my regular expression/

Регулярное выражение может быть дополнено флагами, которые изменяют поведение сопоставления регулярного выражения. Флаг «i» делает регулярное выражение нечувствительным к регистру:

/my regular expression/i

Интерполяция может использоваться внутри регулярных выражений, наряду с экранированными символами. Обратите внимание, что регулярное выражение может потребовать дополнительных экранированных символов, чем строка.

См. Regexp для описания синтаксиса регулярных выражений.

Процедуры

Процедуру можно создать с помощью ->:

-> { 1 + 1 }

Вызов вышеуказанной процедуры даст результат 2.

Вы можете потребовать аргументов для процедуры следующим образом:

->(v) { 1 + v }

Эта процедура добавит один к её аргументу.

Строки в процентах

Помимо %(...) , которая создаёт String, % может создавать другие типы объектов. Как и со строками, большая буква позволяет использовать интерполяцию и экранированные символы, а маленькая буква отключает их.

Это типы строк в процентах в Ruby:

%i

Array символов

%q

String

%r

Регулярное выражение

%s

Symbol

%w

Array строк

%x

Обратные кавычки (захват результата подоболочки)

Для двух форм массивов строк в процентах, если вы хотите включить пробел в одном из элементов массива, вы должны экранировать его символом «\»:

%w[one one-hundred\ one]
#=> ["one", "one-hundred one"]

Если вы используете «(», «[», «{», «<», вы должны закрыть их соответственно «)», «]», «}», «>». Вы можете использовать большинство других символов, не являющихся буквенно-цифровыми, для разделителей строк в процентах, таких как «%», «|», «^» и т. д.