Литералы

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

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

• Числа

• Строки

• Символы

• Массивы

• Хэши

• Диапазоны

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

• Проци

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

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

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

Числа

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

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

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

Вы также можете использовать #@foo, #@@foo и #$foo в качестве сокращённой записи для соответственно #{ @foo }, #{ @@foo } и #{ $foo }.

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

'#{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
?あ      #=> "あ"

Документы здесь (heredocs)

Если вы пишете большой блок текста, вы можете использовать «документ здесь» или «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. См. 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
(..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"]

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