String

String представляет собой неизменяемую последовательность символов UTF-8.

Обычно String создаётся с помощью строкового литерала, заключающего символы UTF-8 в двойные кавычки ("):

"hello world"

Экранирование

Обратная косая черта обозначает специальный символ внутри строки; это может быть именованная escape-последовательность или числовое представление кодовой точки Unicode.

Доступные escape-последовательности:

"\""                  # double quote
"\\"                  # backslash
"\#"                  # hash character (to escape interpolation)
"\a"                  # alert
"\b"                  # backspace
"\e"                  # escape
"\f"                  # form feed
"\n"                  # newline
"\r"                  # carriage return
"\t"                  # tab
"\v"                  # vertical tab
"\377"                # octal ASCII character
"\xFF"                # hexadecimal ASCII character
"\uFFFF"              # hexadecimal unicode character
"\u{0}".."\u{10FFFF}" # hexadecimal unicode character

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

Обратная косая черта, за которой следует не более трёх цифр от 0 до 7, обозначает кодовую точку в восьмеричной записи:

"\101" # => "A"
"\123" # => "S"
"\12"  # => "\n"
"\1"   # string with one character with code point 1

Обратная косая черта, за которой следует u, обозначает кодовую точку Unicode. За ней могут следовать либо ровно четыре шестнадцатеричных символа, представляющих байты Unicode (от \u0000 до \uFFFF), либо от одного до шести шестнадцатеричных символов в фигурных скобках (от \u{0} до \u{10FFFF}.

"\u0041"    # => "A"
"\u{41}"    # => "A"
"\u{1F52E}" # => "🔮"

В фигурных скобках может быть несколько символов Unicode, разделённых пробелами.

"\u{48 45 4C 4C 4F}" # => "HELLO"

Интерполяция

Строковый литерал с интерполяцией позволяет встраивать в строку выражения, которые будут подставлены во время выполнения.

a = 1
b = 2
"sum: #{a} + #{b} = #{a + b}" # => "sum: 1 + 2 = 3"

Интерполяция строк также возможна с помощью String#%.

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

Интерполяцию можно отключить, экранировав символ решётки (#) обратной косой чертой или используя строковый литерал без интерполяции, например %q().

"\#{a + b}"  # => "#{a + b}"
%q(#{a + b}) # => "#{a + b}"

Интерполяция реализована с помощью String::Builder и вызова Object#to_s(IO) для каждого выражения, заключённого в #{...}. Выражение "sum: #{a} + #{b} = #{a + b}" эквивалентно следующему:

String.build do |io|
  io << "sum: "
  io << a
  io << " + "
  io << b
  io << " = "
  io << a + b
end

Строковые литералы с процентным знаком

Помимо строк в двойных кавычках, Crystal поддерживает строковые литералы, обозначаемые знаком процента (%) и парой разделителей. Допустимые разделители: круглые скобки (), квадратные скобки [], фигурные скобки {}, угловые скобки <> и вертикальные черты ||. За исключением вертикальных черт, все разделители могут быть вложенными: начальный разделитель внутри строки экранирует следующий конечный разделитель.

Это удобно для записи строк, содержащих двойные кавычки, которые пришлось бы экранировать в строках, заключённых в двойные кавычки.

%(hello ("world")) # => "hello (\"world\")"
%[hello ["world"]] # => "hello [\"world\"]"
%{hello {"world"}} # => "hello {\"world\"}"
%<hello <"world">> # => "hello <\"world\">"
%|hello "world"|   # => "hello \"world\""

Литерал, обозначенный %q, не поддерживает интерполяцию и экранирование, тогда как %Q имеет то же значение, что и %.

name = "world"
%q(hello \n #{name}) # => "hello \\n \#{name}"
%Q(hello \n #{name}) # => "hello \n world"

Литерал массива строк с процентным знаком

Помимо литерала отдельной строки, существует также процентный литерал для создания Array строк. Он обозначается %w и парой разделителей. Допустимые разделители те же, что и у строковых литералов с процентным знаком.

%w(foo bar baz)  # => ["foo", "bar", "baz"]
%w(foo\nbar baz) # => ["foo\\nbar", "baz"]
%w(foo(bar) baz) # => ["foo(bar)", "baz"]

Обратите внимание: литерал, обозначенный %w, не поддерживает интерполяцию и экранирование, за исключением пробелов. Строки разделяются одним пробелом (), который необходимо экранировать, чтобы использовать его как часть строки.

%w(foo\ bar baz) # => ["foo bar", "baz"]

Многострочные строки

Строковый литерал может занимать несколько строк:

"hello
      world" # => "hello\n      world"

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

"hello " \
"world, " \
"no newlines" # same as "hello world, no newlines"

Также обратную косую черту, за которой следует символ новой строки, можно вставить внутрь строкового литерала:

"hello \
     world, \
     no newlines" # same as "hello world, no newlines"

В этом случае начальные пробелы не включаются в результирующую строку.

Heredoc

Документ here, или heredoc, может быть полезен для записи строк, занимающих несколько строк. Heredoc обозначается <<-, за которым следует идентификатор heredoc — буквенно-цифровая последовательность, начинающаяся с буквы (и допускающая символы подчёркивания). Heredoc начинается со следующей строки и заканчивается на первой строке, содержащей только идентификатор heredoc, перед которым могут быть пробелы.

<<-XML
<parent>
  <child />
</parent>
XML

Начальные пробелы в содержимом heredoc удаляются в соответствии с количеством пробелов в последней строке перед идентификатором heredoc.

<<-STRING # => "Hello\n  world"
  Hello
    world
  STRING

<<-STRING # => "  Hello\n    world"
    Hello
      world
  STRING

После идентификатора heredoc, в той же строке, всё последующее продолжает исходное выражение, предшествующее heredoc. Это работает так, как если бы конец начального идентификатора heredoc был концом строки. Однако содержимое строки располагается в следующих строках вплоть до завершающего идентификатора heredoc, который должен находиться на отдельной строке.

<<-STRING.upcase # => "HELLO"
hello
STRING

def upcase(string)
  string.upcase
end

upcase(<<-STRING) # => "HELLO WORLD"
  Hello World
  STRING

Если в одной строке начинается несколько heredoc, их содержимое считывается последовательно:

print(<<-FIRST, <<-SECOND) # prints "HelloWorld"
  Hello
  FIRST
  World
  SECOND

Heredoc обычно поддерживает интерполяцию и экранирование.

Чтобы обозначить heredoc без интерполяции и экранирования, начальный идентификатор heredoc заключают в одинарные кавычки:

<<-'HERE' # => "hello \\n \#{world}"
  hello \n #{world}
  HERE