Литералы

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

• Булевы значения и 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 для табуляции и т. д. Полный список поддерживаемых 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)

Любой другой символ после обратной косой черты интерпретируется как сам символ.

Строки в двойных кавычках позволяют интерполировать другие значения с помощью #{...}:

"One plus one is two: #{1 + 1}"

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

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

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

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

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

%(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

Также существует обозначение символьного литерала для представления строк из одного символа, синтаксис которого — вопросительный знак (?) за которым следует один символ или 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 позволяет использовать интерполяцию и экранирование символов. Вы можете отключить интерполяцию и экранирование, поместив открывающий идентификатор в одинарные кавычки:

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

Для вызова метода над 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. См. Symbol для получения дополнительной информации о том, что представляют собой символы и когда ruby создает их внутри.

Вы можете обратиться к символу с помощью двоеточия: :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 для методов, которые вы можете использовать с хэшем.

Диапазоны

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

(1..2)  # includes its ending value
(1...2) # excludes its ending value
(1..)   # endless range, representing infinite sequence from 1 to Infinity

Вы можете создать диапазон для любого объекта. См. документацию 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"]

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