Строки в Julia

Строка — это конечная последовательность из нуля или более символов. Это тип данных в языках программирования, используемый для представления текста.

В Julia обычно используются одинарные кавычки'для создания отдельных символов, а двойные кавычки"или тройные кавычки"""для создания строк. Например:

c = 'x'

str = "EXAMPLE"

example = """Example "EXAMPLE",包含了单个引号"""

Особенности строкового типа Julia:

  • Встроенный конкретный тип, используемый для строк (и строковых литералов) в Julia, — это String.
  • Все строковые типы Julia являются подтипами абстрактного типа AbstractString.
  • В Julia есть отличный тип для представления отдельных символов, а именно AbstractChar. Char — это встроенный подтип AbstractChar, 32-битный примитивный тип, который может представлять любой символ Unicode (на основе кодировки UTF-8).
  • Строки Julia неизменяемы — значение любого объекта AbstractString нельзя изменить.

Символы

Отдельные символы представлены значениями Char.

Char — это 32-битный примитивный тип, который можно преобразовать в соответствующее целочисленное значение, т. е. код Unicode:

Пример

julia> c = 'x'
'x': ASCII/Unicode U+0078 (категория Ll: Буква, строчная)

julia> typeof(c)
Char

julia> c = Int('x')
120

julia> typeof(c)
Int64

Мы также можем преобразовать целочисленное значение в Char:

Пример

julia> Char(97)
'a': ASCII/Unicode U+0061 (категория Ll: Буква, строчная)

julia> Char(120)
'x': ASCII/Unicode U+0078 (категория Ll: Буква, строчная)

Мы можем выполнять сравнения и ограниченные арифметические операции над значениями Char:

Пример

julia> 'A' < 'a'
истина

julia> 'A' <= 'a' <= 'Z'
false

julia> 'A' <= 'X' <= 'Z'
истина

julia> 'x' - 'a'
23

julia> 'A' + 1
'B': ASCII/Unicode U+0042 (категория Lu: Буква, заглавная)

Строки

Строки в Julia можно объявлять с помощью двойных кавычек"или трёх двойных кавычек"""Если нужно использовать кавычки в части строки, для этого можно использовать три двойные кавычки, как показано ниже:

Пример

julia> str = "EXAMPLE"
"EXAMPLE"

julia> example = """Пример учебника "EXAMPLE", содержит одинарную кавычку"""
“Rookie Tutorial\"EXAMPLE\", содержит одинарную кавычку"

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

Пример

julia> "Это длинная \
       строка"

"This is a long line"
Строки Julia, как и массивы, также могут использовать индексацию для чтения символа в указанной позиции или извлечения подстроки в указанной позиции. Начальный индекс — это1илиbegin, а конечная позиция —end :

Пример

julia> str = "EXAMPLE"
"EXAMPLE"

julia> str[begin]
'R': ASCII/Unicode U+0052 (category Lu: Letter, uppercase)

julia> str[1]
'R': ASCII/Unicode U+0052 (category Lu: Letter, uppercase)

julia> str[2]
'U': ASCII/Unicode U+0055 (category Lu: Letter, uppercase)

julia> str[end]
'B': ASCII/Unicode U+0042 (категория Lu: Буква, заглавная)

julia> str[end-1]
'O': ASCII/Unicode U+004F (категория Lu: буква, прописная)

Мы можем использовать индексирование по диапазону для извлечения подстрок:

Пример

julia> str = "EXAMPLE"
"EXAMPLE"

julia> str[begin:end]
"EXAMPLE"

julia> str[begin:end-1]
"RUNOO"

julia> str[2:5]
"UNOO"

Кроме того, выраженияstr[k]иstr[k:k]дают разные результаты: первое получает символ в указанной позиции с помощью индексирования, и его тип — Char; второе читает строку по заданному диапазону, за исключением того, что это просто строка, содержащая один символ:

Пример

julia> str[6]
'B': ASCII/Unicode U+0042 (категория Lu: Буква, заглавная)

julia> str[6:6]
"B"

Извлечение диапазона также можно реализовать с помощью методаSubString, например:

Пример

julia> str = "long string"
"long string"

julia> substr = SubString(str, 1, 4)
"long"

julia> typeof(substr)
SubString{String}

Конкатенация строк

Мы можем использовать метод string() для конкатенации нескольких строк:

Пример

julia> greet = "Hello"
"Hello"

julia> whom = "world"
"world"

julia> string(greet, ", ", whom, ".\n")
"Hello, world.\n"

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

Способ построения строк путём конкатенации иногда бывает немного громоздким. Чтобы уменьшить избыточные вызовы string или повторное умножение, Julia позволяет интерполировать строковые литералы с помощью $, как в Perl:

Пример

julia> "$greet, $whom."\n"
"Hello, world.\n"

Это более читабельно и удобно, и эквивалентно приведённой выше конкатенации строк — система переписывает этот внешне однострочный строковый литерал в конкатенацию строковых литералов с аргументами.string(greet, ", ", whom, ".\n")。

В$Самое короткое полное выражение после `$` принимается за выражение, значение которого вставляется в строку. Поэтому вы можете вставить любое выражение в строку, используя круглые скобки:

Пример

julia> "1 + 2 = $(1 + 2)"
"1 + 2 = 3"

И конкатенация, и интерполяция вызывают string для преобразования объектов в строковую форму. Однако string фактически просто возвращает вывод print, поэтому новым типам следует добавлять методы print или show, а не метод string.

Большинство объектов, не являющихся AbstractString, преобразуются в строки, которые близко соответствуют тому, как они вводятся в виде текстовых выражений:

Пример

julia> v = [1,2,3]
3-элементный Vector{Int64}:
 1
 2
 3

julia> "v: $v"
"v: [1, 2, 3]"

string является тождественной функцией для значений AbstractString и AbstractChar, поэтому они вставляются в строки как есть, без заключения в кавычки или экранирования:

Пример

julia> c = 'x'
'x': ASCII/Unicode U+0078 (категория Ll: Буква, строчная)

julia> "привет, $c"
"привет, x"

Если вы хотите включить литерал `$` в строковый литерал$, экранируйте его обратной косой чертой:

Пример

julia> print("У меня \$100 на моем счету.\n")
У меня $100 на моем счету.

Unicode и UTF-8

Julia полностью поддерживает символы и строки Unicode.

В символьных литералах кодовые точки Unicode можно представить с помощью escape-последовательностей Unicode \u и \U, а также всех стандартных escape-последовательностей C. Их также можно использовать для записи строковых литералов:

Пример

julia> s = "\u2200 x \u2203 y"
"∀ x ∃ y"

Отображаются ли эти символы Unicode как escape-последовательности или как специальные символы, зависит от настроек локали вашего терминала и его поддержки Unicode. Строковые литералы кодируются в UTF-8. UTF-8 — это кодировка переменной длины, означающая, что не все символы кодируются одинаковым числом байтов (кодовых единиц). В UTF-8 символы ASCII (те, что меньше 0x80 (128)) кодируются одним байтом, так же как и в ASCII; символы от 0x80 и выше кодируются с использованием до 4 байтов.


Строковые литералы в тройных кавычках

Тройные кавычки"""..."""обеспечивают удобство при создании более длинных и сложных строк. Внутри тройных кавычек можно удобно использовать переводы строк, кавычки и отступы без специальной обработки.

Пример

julia> str = """
           Hello,
           world.
         """

" Hello,\n  world.\n"

Сравнение строк

Мы можем использовать операторы сравнения для сравнения строк в лексикографическом порядке:

Пример

julia> "abracadabra" < "xylophone"
истина

julia> "abracadabra" == "xylophone"
false

julia> "Hello, world." != "Goodbye, world."
истина

julia> "1 + 2 = 3" == "1 + 2 = $(1 + 2)"
истина

Вы можете использовать функции findfirst и findlast, чтобы найти индекс конкретного символа:

Пример

julia> findfirst(isequal('o'), "xylophone")
4

julia> findlast(isequal('o'), "xylophone")
7

julia> findfirst(isequal('z'), "xylophone")

Вы можете передать третий аргумент и использовать функции findnext и findprev, чтобы найти символ по заданному смещению:

Пример

julia> findnext(isequal('o'), "xylophone", 1)
4

julia> findnext(isequal('o'), "xylophone", 5)
7

julia> findprev(isequal('o'), "xylophone", 5)
4

julia> findnext(isequal('o'), "xylophone", 8)

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

Пример

julia> occursin("world", "Hello, world.")
истина

julia> occursin("o", "Xylophon")
истина

julia> occursin("a", "Xylophon")
false

julia> occursin('o', "Xylophon")
истина

Последний пример показывает, что occursin также можно использовать для поиска символьных литералов.

Существуют также две удобные строковые функции: repeat и join:

Пример

julia> repeat(".:Z:.", 10)
".:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:."

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"

Другие полезные функции включают:

  • firstindex(str)- Возвращает минимальный (байтовый) индекс, который можно использовать для индексации в str (для строк это всегда 1, но не обязательно для других контейнеров).
  • lastindex(str)- Возвращает максимальный (байтовый) индекс, который можно использовать для индексации в str.
  • length(str)- Количество символов в str.
  • length(str, i, j)- Количество допустимых индексов символов от i до j в str.
  • ncodeunits(str)- Количество кодовых единиц в строке.
  • codeunit(str, i)- Возвращает значение кодовой единицы по индексу i в строке str.
  • thisind(str, i)- По произвольному индексу в строке находит первый индекс символа, содержащего этот индекс.
  • nextind(str, i, n=1)- Находит начало n-го символа после индекса i.
  • prevind(str, i, n=1)- находит начало n-го символа перед индексом i.

Сырые строковые литералы

Сырые строки без интерполяции и экранирования можно представить с помощьюraw"..."нестандартных строковых литералов. Сырые строковые литералы создают обычные объекты String, содержащие заключённое содержимое в точности как ввод, без интерполяции и экранирования. Это полезно для строк, содержащих код или разметку на других языках, которые используют"или\"\ как специальный символ.

Исключение состоит в том, что кавычки всё ещё нужно экранировать, напримерraw"\""эквивалентно"\"". Чтобы можно было выразить все строки, обратные слэши также нужно экранировать, но только когда они стоят непосредственно перед кавычкой.

julia> println(raw"\\ \\\"")
\\ \"

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

Другие расширения