Строки

Тип AbstractString является супертипом всех реализаций строк в Julia. Строки представляют собой кодировки последовательностей Unicode кодовых точек, как представлены типом AbstractChar. Julia делает несколько предположений о строках:

• Строки закодированы в терминах кодовых единиц фиксированного размера:
  • Кодовые единицы могут быть извлечены с помощью codeunit(s, i)
  • Первая кодовая единица имеет индекс 1
  • Последняя кодовая единица имеет индекс ncodeunits(s)
  • Любой индекс i такой, что 1 ≤ i ≤ ncodeunits(s) находится в границах
• Индексирование строк выполняется в терминах этих кодовых единиц:
  • Символы извлекаются с помощью s[i] с допустимым индексом строки i
  • Каждая AbstractChar в строке кодируется одной или несколькими кодовыми единицами
  • Только индекс первой кодовой единицы AbstractChar является допустимым индексом
  • Кодировка AbstractChar не зависит от того, что ей предшествует или следует за ней
  • Кодировки строк являются самосинхронизирующимися — т. е. isvalid(s, i) имеет сложность O(1)

Некоторые функции строк, которые извлекают кодовые единицы, символы или подстроки из строк, возвращают ошибку, если вы передаете индексы вне границ или недопустимые индексы строк. Это включает codeunit(s, i) и s[i]. Функции, которые выполняют арифметику с индексами строк, используют более гибкий подход к индексированию и дают вам ближайший допустимый индекс строки при нахождении в пределах границ, или при выходе за пределы границ, ведут себя так, как будто существует бесконечное число символов, заполняющих каждый край строки. Обычно эти воображаемые символы заполнения имеют длину кодовой единицы 1, но типы строк могут выбирать разные размеры «воображаемых» символов, что имеет смысл для их реализаций (например, подстроки могут передавать арифметику индексов в базовую строку, на которую они предоставляют представление). К функциям с гибким индексированием относятся функции, предназначенные для арифметики индексов: thisind, nextind и prevind. Эта модель позволяет арифметике индексов работать с индексами, выходящими за пределы границ, как со промежуточными значениями, до тех пор, пока они не используются для извлечения символа, что часто помогает избежать необходимости обхода краевых случаев.

См. также codeunit, ncodeunits, thisind, nextind, prevind.

Тип AbstractChar является супертипом всех реализаций символов в Julia. Символ представляет собой Unicode кодовую точку и может быть преобразован в целое число с помощью функции codepoint для получения числового значения кодовой точки или создан из этого же целого числа. Эти числовые значения определяют, как символы сравниваются с < и ==, например. Новые типы T <: AbstractChar должны, как минимум, определять метод codepoint(::T) и конструктор T(::UInt32).

Данный подтип AbstractChar может быть способен представлять только подмножество Unicode, в этом случае преобразование из недопустимого значения UInt32 может вызвать ошибку. И наоборот, встроенный тип Char представляет собой супермножество Unicode (для беспричинной кодировки недопустимых байтовых потоков), в этом случае преобразование недопустимого значения *в* UInt32 вызывает ошибку. Функция isvalid может использоваться для проверки того, какие кодовые точки могут быть представлены в данном типе AbstractChar.

Внутри тип AbstractChar может использовать различные кодировки. Преобразование через codepoint(char) не покажет эту кодировку, так как всегда возвращает Unicode значение символа. print(io, c) любого c::AbstractChar генерирует кодировку, определяемую io (UTF-8 для всех встроенных типов IO ), если необходимо, через преобразование в Char.

write(io, c), в отличие от этого, может генерировать кодировку, в зависимости от typeof(c), и read(io, typeof(c)) должно читать такую же кодировку как write. Новые типы AbstractChar должны предоставить свои реализации write и read.

Char(c::Union{Number,AbstractChar})

Char — 32-битный тип AbstractChar, который является стандартным представлением символов в Julia. Char — тип, используемый для литералов символов, например, 'x', и он также является типом элементов String.

Для беспричинного представления произвольных байтовых потоков, хранящихся в String, значение Char может хранить информацию, которая не может быть преобразована в Unicode кодовую точку — преобразование такого Char в UInt32 вызовет ошибку. Функция isvalid(c::Char) может использоваться для запроса, представляет ли c допустимый Unicode символ.

codepoint(c::AbstractChar) -> Integer

Возвращает Unicode кодовую точку (целое без знака) соответствующую символу c (или выводит исключение, если c не представляет допустимый символ). Для Char, это значение UInt32, но типы AbstractChar, которые представляют только подмножество Unicode, могут вернуть целое число другого размера (например, UInt8).

length(s::AbstractString) -> Int
length(s::AbstractString, i::Integer, j::Integer) -> Int

Возвращает количество символов в строке s от индексов i до j.

Это вычисляется как количество индексов кодовых единиц от i до j, которые являются допустимыми индексами символов. При использовании только одного аргумента строки, это вычисляет количество символов в всей строке. С аргументами i и j вычисляет количество индексов между i и j включительно, которые являются допустимыми индексами в строке s. В дополнение к значениям в пределах границ, i может принимать значение вне границ ncodeunits(s) + 1, а j может принимать значение вне границ 0.

См. также isvalid, ncodeunits, lastindex, thisind, nextind, prevind.

Примеры

julia> length("jμΛIα")
5

sizeof(str::AbstractString)

Размер строки str в байтах. Равен количеству кодовых единиц в str, умноженному на размер одной кодовой единицы в str.

Примеры

julia> sizeof("")
0

julia> sizeof("∀")
3

*(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString

Объединяет строки и/или символы, создавая String или AnnotatedString (в зависимости от ситуации). Это эквивалентно вызову функции string или annotatedstring для аргументов. Конкатенация встроенных типов строк всегда создает значение типа String, но другие типы строк могут выбирать возврат строки другого типа, если это уместно.

Примеры

julia> "Hello " * "world"
"Hello world"

julia> 'j' * "ulia"
"julia"

^(s::Union{AbstractString,AbstractChar}, n::Integer) -> AbstractString

Повторяет строку или символ n раз. Это также может быть записано как repeat(s, n).

См. также repeat.

Примеры

julia> "Test "^3
"Test Test Test "

string(n::Integer; base::Integer = 10, pad::Integer = 1)

Преобразовать целое число n в строку в заданном base, необязательно задавая количество цифр для дополнения.

См. также digits, bitstring, count_zeros.

Примеры

julia> string(5, base = 13, pad = 4)
"0005"

julia> string(-13, base = 5, pad = 4)
"-0023"

string(xs...)

Создать строку из любых значений с использованием функции print.

string обычно не следует определять непосредственно. Вместо этого определите метод print(io::IO, x::MyType). Если string(x) для определенного типа необходимо сделать высокоэффективным, тогда имеет смысл добавить метод к string и определить print(io::IO, x::MyType) = print(io, string(x)) для обеспечения согласованности функций.

См. также: String, repr, sprint, show.

Примеры

julia> string("a", 1, true)
"a1true"

repeat(s::AbstractString, r::Integer)

Повторить строку r раз. Это можно записать как s^r.

См. также ^.

Примеры

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

Повторить символ r раз. Это можно эквивалентно выполнить, вызвав c^r.

Примеры

julia> repeat('A', 3)
"AAA"

repr(x; context=nothing)

Создать строку из любого значения с использованием функции show. Не следует добавлять методы к repr; вместо этого определите метод show.

Необязательный ключевой аргумент context может быть установлен на пару :key=>value, кортеж пар :key=>value, или объект IO или IOContext, атрибуты которого используются для потока ввода/вывода, переданного в show.

Обратите внимание, что repr(x) обычно аналогичен тому, как значение x вводилось бы в Julia. См. также repr(MIME("text/plain"), x), чтобы вместо этого вернуть «красиво отформатированную» версию x, предназначенную для восприятия человеком, эквивалентную отображению x в REPL.

Примеры

julia> repr(1)
"1"

julia> repr(zeros(3))
"[0.0, 0.0, 0.0]"

julia> repr(big(1/3))
"0.333333333333333314829616256247390992939472198486328125"

julia> repr(big(1/3), context=:compact => true)
"0.333333"

String(s::AbstractString)

Создать новую String из существующей AbstractString.

SubString(s::AbstractString, i::Integer, j::Integer=lastindex(s))
SubString(s::AbstractString, r::UnitRange{<:Integer})

Как getindex, но возвращает представление родительской строки s в диапазоне i:j или r соответственно, вместо создания копии.

Макрос @views преобразует все срезы строк s[i:j] в подстроки SubString(s, i, j) в блоке кода.

Примеры

julia> SubString("abc", 1, 2)
"ab"

julia> SubString("abc", 1:2)
"ab"

julia> SubString("abc", 2)
"bc"

LazyString <: AbstractString

Ленивое представление интерполяции строк. Это полезно, когда строка должна быть построена в контексте, где выполнение фактической интерполяции и построения строки не требуется или нежелательно (например, в путях ошибок функций).

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

Примеры

julia> n = 5; str = LazyString("n is ", n)
"n is 5"

См. также @lazy_str.

Расширенная помощь

Свойства безопасности для параллельных программ

Сама ленивая строка не создает проблем с параллельностью, даже если она печатается в нескольких задачах Julia. Однако, если методы print на захваченном значении могут иметь проблему с параллельностью при вызове без синхронизации, вывод ленивой строки может вызвать проблему. Кроме того, методы print на захваченных значениях могут вызываться несколько раз, хотя будет возвращен только ровно один результат.

lazy"str"

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

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

Примеры

julia> n = 5; str = lazy"n is $n"
"n is 5"

julia> typeof(str)
LazyString

transcode(T, src)

Преобразование строковых данных между кодировками Unicode. src является либо String, либо Vector{UIntXX} единиц кода UTF-XX, где XX равно 8, 16 или 32. T указывает кодировку возвращаемого значения: String для возврата (кодированной в UTF-8) String, или UIntXX для возврата Vector{UIntXX} данных UTF-XX. (Псевдоним Cwchar_t также может быть использован как целочисленный тип для преобразования wchar_t* строк, используемых внешними C-библиотеками.)

Функция transcode выполняется успешно, пока входные данные могут быть разумно представлены в целевой кодировке; она всегда выполняется успешно для преобразований между кодировками UTF-XX, даже для некорректных данных Unicode.

В настоящее время поддерживается только преобразование в/из UTF-8.

Примеры

julia> str = "αβγ"
"αβγ"

julia> transcode(UInt16, str)
3-element Vector{UInt16}:
 0x03b1
 0x03b2
 0x03b3

julia> transcode(String, transcode(UInt16, str))
"αβγ"

unsafe_string(p::Ptr{UInt8}, [length::Integer])

Копирование строки из адреса строки в стиле C (завершающейся символом NUL), закодированной как UTF-8. (Указатель можно безопасно освободить после этого.) Если length указан (длина данных в байтах), строка не должна быть завершена символом NUL.

Эта функция помечена как «небезопасная», потому что она вызовет сбой, если p не является допустимым адресом памяти для данных заданной длины.

ncodeunits(s::AbstractString) -> Int

Возвращает количество единиц кода в строке. Индексы, которые находятся в пределах для доступа к этой строке, должны удовлетворять 1 ≤ i ≤ ncodeunits(s). Не все такие индексы являются допустимыми — они могут не быть началом символа, но они вернут значение единицы кода при вызове codeunit(s,i).

Примеры

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

julia> ncodeunits('∫'), ncodeunits('e'), ncodeunits('ˣ')
(3, 1, 2)

См. также codeunit, checkbounds, sizeof, length, lastindex.

codeunit(s::AbstractString) -> Type{<:Union{UInt8, UInt16, UInt32}}

Возвращает тип кодового блока заданного строкового объекта. Для строк с кодировкой ASCII, Latin-1 или UTF-8 это будет UInt8; для UCS-2 и UTF-16 это будет UInt16; для UTF-32 это будет UInt32. Тип кодового блока необязательно ограничивать этими тремя типами, но трудно придумать широко используемые кодировки строк, которые не используют один из этих блоков. codeunit(s) совпадает с typeof(codeunit(s,1)) когда s — непустая строка.

См. также ncodeunits.

codeunit(s::AbstractString, i::Integer) -> Union{UInt8, UInt16, UInt32}

Возвращает значение кодового блока в строке s по индексу i. Обратите внимание, что

codeunit(s, i) :: codeunit(s)

То есть значение, возвращаемое codeunit(s, i), имеет тип, возвращаемый codeunit(s).

Примеры

julia> a = codeunit("Hello", 2)
0x65

julia> typeof(a)
UInt8

См. также ncodeunits, checkbounds.

codeunits(s::AbstractString)

Получить векторный объект, содержащий кодовые блоки строки. По умолчанию возвращает обёртку CodeUnits, но codeunits может быть необязательно определена для новых типов строк при необходимости.

Примеры

julia> codeunits("Juλia")
6-element Base.CodeUnits{UInt8, String}:
 0x4a
 0x75
 0xce
 0xbb
 0x69
 0x61

ascii(s::AbstractString)

Преобразует строку в тип String и проверяет, что она содержит только данные ASCII, в противном случае выбрасывает ArgumentError, указывающий позицию первого не-ASCII байта.

См. также предикат isascii для фильтрации или замены не-ASCII символов.

Примеры

julia> ascii("abcdeγfgh")
ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
Stacktrace:
[...]

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags]) <: AbstractPattern

Тип, представляющий регулярное выражение. Объекты Regex могут использоваться для сопоставления строк с match.

Объекты Regex могут быть созданы с использованием строковой макрокоманды @r_str. Конструктор Regex(pattern[, flags]) обычно используется, если строка pattern требует интерполяции. Подробную информацию о флагах см. в документации строковой макрокоманды.

@r_str -> Regex

Создаёт регулярное выражение, например, r"^[a-z]*$", без интерполяции и экранирования (кроме кавычек ", которые всё ещё нужно экранировать). Регулярное выражение также принимает один или несколько флагов, перечисленных после закрывающей кавычки, для изменения его поведения:

• i включает нечувствительное к регистру сопоставление
• m рассматривает токены ^ и $ как сопоставление начала и конца отдельных строк, в отличие от всей строки.
• s позволяет модификатору . сопоставлять новые строки.
• x включает "режим свободного пробела": пробелы между токенами регулярного выражения игнорируются, за исключением случаев, когда они экранированы с помощью \, и # в регулярном выражении рассматривается как начало комментария (который игнорируется до конца строки).
• a включает ASCII-режим (отключает режимы UTF и UCP). По умолчанию \B, \b, \D, \d, \S, \s, \W, \w, и т. д. сопоставляются на основе свойств символов Юникода. С этим параметром эти последовательности сопоставляются только с ASCII-символами. Это включает \u, который также выводит заданное значение символа непосредственно как один байт и не пытается закодировать его в UTF-8. Важно, что этот параметр позволяет сопоставлять некорректные строки UTF-8, обрабатывая как сопоставляющий объект, так и целевую строку как простые байты (как если бы они были байтами ISO/IEC 8859-1/Latin-1), а не как кодировки символов. В этом случае этот параметр часто используется в сочетании с s.

См. Regex, если требуется интерполяция.

Примеры

julia> match(r"a+.*b+.*?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
RegexMatch("angry,\nBad world")

Это регулярное выражение включает первые три флага.

SubstitutionString(substr) <: AbstractString

Сохраняет заданную строку substr как SubstitutionString, для использования в заменах регулярных выражений. Чаще всего создаётся с помощью макрокоманды @s_str.

Примеры

julia> SubstitutionString("Hello \\g<name>, it's \\1")
s"Hello \g<name>, it's \1"

julia> subst = s"Hello \g<name>, it's \1"
s"Hello \g<name>, it's \1"

julia> typeof(subst)
SubstitutionString{String}

@s_str -> SubstitutionString

Строит строку подстановки, используемую для подстановок в регулярных выражениях. Внутри строки последовательности вида \N ссылаются на N-ую группу захвата в регулярном выражении, а \g<groupname> ссылается на группу захвата с именем groupname.

Примеры

julia> msg = "#Hello# from Julia";

julia> replace(msg, r"#(.+)# from (?<from>\w+)" => s"FROM: \g<from>; MESSAGE: \1")
"FROM: Julia; MESSAGE: Hello"

@raw_str -> String

Создаёт необрабатываемую строку без интерполяции и экранирования. Исключение составляют кавычки, которые всё ещё необходимо экранировать. Обратные слэши экранируют как кавычки, так и другие обратные слэши, но только тогда, когда перед символом кавычки стоит последовательность обратных слэшей. Таким образом, 2n обратных слэшей, за которыми следует символ кавычки, кодируют n обратных слэшей и конец литерала, в то время как 2n+1 обратных слэшей, за которыми следует символ кавычки, кодируют n обратных слэшей, за которым следует символ кавычки.

Примеры

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

julia> println(raw"\"")
"

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

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

@b_str

Создаёт неизменяемый вектор байтов (UInt8) с помощью синтаксиса строк.

Примеры

julia> v = b"12\x01\x02"
4-element Base.CodeUnits{UInt8, String}:
 0x31
 0x32
 0x01
 0x02

julia> v[2]
0x32

@html_str -> Docs.HTML

Создаёт объект HTML из литеральной строки.

Примеры

julia> html"Julia"
HTML{String}("Julia")

@text_str -> Docs.Text

Создаёт объект Text из литеральной строки.

Примеры

julia> text"Julia"
Julia

isvalid(value) -> Bool

Возвращает true, если заданное значение является допустимым для своего типа, который в настоящее время может быть либо AbstractChar, либо String, либо SubString{String}.

Примеры

julia> isvalid(Char(0xd800))
false

julia> isvalid(SubString(String(UInt8[0xfe,0x80,0x80,0x80,0x80,0x80]),1,2))
false

julia> isvalid(Char(0xd799))
true

isvalid(T, value) -> Bool

Возвращает true, если заданное значение является допустимым для данного типа. Типы в настоящее время могут быть либо AbstractChar, либо String. Значения для AbstractChar могут быть типа AbstractChar или UInt32. Значения для String могут быть того же типа, SubString{String}, Vector{UInt8}, или непрерывным подмассивом.

Примеры

julia> isvalid(Char, 0xd800)
false

julia> isvalid(String, SubString("thisisvalid",1,5))
true

julia> isvalid(Char, 0xd799)
true

isvalid(s::AbstractString, i::Integer) -> Bool

Предикат, указывающий, является ли данный индекс началом кодирования символа в s или нет. Если isvalid(s, i) истинно, то s[i] вернёт символ, кодирование которого начинается в этом индексе; если ложно, то s[i] поднимет ошибку некорректного индекса или ошибку выхода за пределы границ, в зависимости от того, находится ли i в пределах границ. Для того, чтобы isvalid(s, i) имела сложность O(1), кодирование s должно быть самосинхронизирующимся. Это основное предположение для поддержки строк в Julia.

См. также getindex, iterate, thisind, nextind, prevind, length.

Примеры

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (category Ll: Letter, lowercase)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: invalid index [2], valid nearby indices [1]=>'α', [3]=>'β'
Stacktrace:
[...]

match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

Поиск первого совпадения регулярного выражения r в s и возвращение объекта RegexMatch, содержащего совпадение, или ничего, если совпадение не найдено. Совпадающую подстроку можно получить, обратившись к m.match, а захваченные последовательности — обратившись к m.captures. Необязательный аргумент idx указывает индекс, с которого следует начать поиск.

Примеры

julia> rx = r"a(.)a"
r"a(.)a"

julia> m = match(rx, "cabac")
RegexMatch("aba", 1="b")

julia> m.captures
1-element Vector{Union{Nothing, SubString{String}}}:
 "b"

julia> m.match
"aba"

julia> match(rx, "cabac", 3) === nothing
true

eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

Поиск всех совпадений регулярного выражения r в s и возвращение итератора по совпадениям. Если overlap равно true, то совпадающие последовательности могут перекрывать индексы в исходной строке, в противном случае они должны относиться к различным диапазонам символов.

Примеры

julia> rx = r"a.a"
r"a.a"

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator{String}(r"a.a", "a1a2a3a", false)

julia> collect(m)
2-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")

RegexMatch <: AbstractMatch

Тип, представляющий одно совпадение с Regex, найденное в строке. Обычно создаётся функцией match.

Поле match хранит подстроку всей совпавшей строки. Поле captures хранит подстроки для каждой группы захвата, пронумерованные по порядку. Чтобы индексировать по имени группы захвата, следует индексировать весь объект совпадения, как показано в примерах. Положение начала совпадения хранится в поле offset. Поле offsets хранит позиции начала каждой группы захвата, при этом 0 обозначает группу, которая не была захвачена.

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

Методы, принимающие объект RegexMatch, определены для iterate, length, eltype, keys, haskey и getindex, где ключи являются именами или номерами группы захвата. Более подробная информация содержится в keys.

Примеры

julia> m = match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30 in the morning")
RegexMatch("11:30", hour="11", minute="30", 3=nothing)

julia> m.match
"11:30"

julia> m.captures
3-element Vector{Union{Nothing, SubString{String}}}:
 "11"
 "30"
 nothing


julia> m["minute"]
"30"

julia> hr, min, ampm = m; # destructure capture groups by iteration

julia> hr
"11"

keys(m::RegexMatch) -> Vector

Возвращает вектор ключей для всех групп захвата основного регулярного выражения. Ключ включается даже если группа захвата не совпадает. То есть, idx будет в возвращаемом значении, даже если m[idx] == nothing.

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

Примеры

julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
  "hour"
  "minute"
 3

isless(a::AbstractString, b::AbstractString) -> Bool

Проверка, находится ли строка a перед строкой b в алфавитном порядке (технически, в лексикографическом порядке по кодам символов Юникода).

Примеры

julia> isless("a", "b")
true

julia> isless("β", "α")
false

julia> isless("a", "a")
false

==(a::AbstractString, b::AbstractString) -> Bool

Проверка на равенство двух строк посимвольно (технически, по кодам символов Юникода). Если хотя бы одна из строк является AnnotatedString, то должны совпадать и свойства строки.

Примеры

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

cmp(a::AbstractString, b::AbstractString) -> Int

Сравнение двух строк. Возвращает 0, если обе строки имеют одинаковую длину и символы в каждом индексе совпадают в обеих строках. Возвращает -1, если a является префиксом b, или если a стоит перед b в алфавитном порядке. Возвращает 1, если b является префиксом a, или если b стоит перед a в алфавитном порядке (технически, в лексикографическом порядке по кодам символов Юникода).

Примеры

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

lpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

Преобразует s в строку и дополняет её слева символом p до длины n символов (в textwidth). Если s уже имеет длину n символов, возвращается такая же строка. По умолчанию дополняется пробелами.

Примеры

julia> lpad("March", 10)
"     March"

rpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

Преобразует s в строку и дополняет её справа символом p до длины n символов (в textwidth). Если s уже имеет длину n символов, возвращается такая же строка. По умолчанию дополняется пробелами.

Примеры

julia> rpad("March", 20)
"March               "

findfirst(pattern::AbstractString, string::AbstractString)
findfirst(pattern::AbstractPattern, string::String)

Находит первое вхождение pattern в string. Эквивалентно findnext(pattern, string, firstindex(s)).

Примеры

julia> findfirst("z", "Hello to the world") # returns nothing, but not printed in the REPL

julia> findfirst("Julia", "JuliaLang")
1:5

findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::AbstractPattern, string::String, start::Integer)

Находит следующее вхождение pattern в string, начиная с позиции start. pattern может быть строкой или регулярным выражением, в таком случае string должен быть типа String.

Возвращаемое значение — диапазон индексов, где найдена совпадающая последовательность, такой, что s[findnext(x, s, i)] == x:

findnext("substring", string, i) == start:stop при string[start:stop] == "substring" и i <= start, или nothing в случае отсутствия совпадения.

Примеры

julia> findnext("z", "Hello to the world", 1) === nothing
true

julia> findnext("o", "Hello to the world", 6)
8:8

julia> findnext("Lang", "JuliaLang", 2)
6:9

findnext(ch::AbstractChar, string::AbstractString, start::Integer)

Найдите следующее вхождение символа ch в string, начиная с позиции start.

Примеры

julia> findnext('z', "Hello to the world", 1) === nothing
true

julia> findnext('o', "Hello to the world", 6)
8

findlast(pattern::AbstractString, string::AbstractString)

Найдите последнее вхождение pattern в string. Эквивалентно findprev(pattern, string, lastindex(string)).

Примеры

julia> findlast("o", "Hello to the world")
15:15

julia> findfirst("Julia", "JuliaLang")
1:5

findlast(ch::AbstractChar, string::AbstractString)

Найдите последнее вхождение символа ch в string.

Примеры

julia> findlast('p', "happy")
4

julia> findlast('z', "happy") === nothing
true

findprev(pattern::AbstractString, string::AbstractString, start::Integer)

Найдите предыдущее вхождение pattern в string, начиная с позиции start.

Возвращаемое значение — диапазон индексов, где найдена соответствующая последовательность, такой что s[findprev(x, s, i)] == x:

findprev("substring", string, i) == start:stop так, что string[start:stop] == "substring" и stop <= i, или nothing в случае отсутствия совпадения.

Примеры

julia> findprev("z", "Hello to the world", 18) === nothing
true

julia> findprev("o", "Hello to the world", 18)
15:15

julia> findprev("Julia", "JuliaLang", 6)
1:5

occursin(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)

Определяет, является ли первый аргумент подстрокой второго. Если needle является регулярным выражением, проверяет, содержит ли haystack соответствие.

Примеры

julia> occursin("Julia", "JuliaLang is pretty cool!")
true

julia> occursin('a', "JuliaLang is pretty cool!")
true

julia> occursin(r"a.a", "aba")
true

julia> occursin(r"a.a", "abba")
false

См. также contains.

occursin(haystack)

Создайте функцию, которая проверяет, содержится ли её аргумент в haystack, т.е. функция, эквивалентная needle -> occursin(needle, haystack).

Возвращаемая функция имеет тип Base.Fix2{typeof(occursin)}.

Примеры

julia> search_f = occursin("JuliaLang is a programming language");

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

Инвертирует строку. Технически, эта функция инвертирует кодовые точки в строке, и её основное применение — для обработки строк в обратном порядке, особенно для обратных поисков по регулярным выражениям. См. также reverseind для преобразования индексов в s в индексы в reverse(s) и наоборот, и graphemes из модуля Unicode для работы с видимыми пользователю «символами» (графическими кластерами) вместо кодовых точек. См. также Iterators.reverse для итерации в обратном порядке без создания копии. Пользовательские типы строк должны реализовывать функцию reverse самостоятельно и обычно должны возвращать строку с тем же типом и кодировкой. Если они возвращают строку с другой кодировкой, они также должны переопределить reverseind для этого типа строк, чтобы удовлетворить s[reverseind(s,i)] == reverse(s)[i].

Примеры

julia> reverse("JuliaLang")
"gnaLailuJ"

Объединение символов может привести к неожиданным результатам:

julia> reverse("ax̂e") # hat is above x in the input, above e in the output
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # reverses graphemes; hat is above x in both in- and output
"ex̂a"

replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

Ищет указанный шаблон pat в s, и заменяет каждое вхождение на r. Если count предоставлен, заменяет не более count вхождений. pat может быть одиночным символом, вектором или набором символов, строкой или регулярным выражением. Если r является функцией, каждое вхождение заменяется на r(s) где s — сопоставленная подстрока (когда pat является AbstractPattern или AbstractString ) или символ (когда pat является AbstractChar или коллекцией AbstractChar). Если pat является регулярным выражением и r — SubstitutionString, то ссылки на группы захвата в r заменяются соответствующим сопоставленным текстом. Чтобы удалить вхождения pat из string, установите r в пустую String ("").

Возвращаемое значение — новая строка после замен. Если аргумент io::IO предоставлен, преобразованная строка записывается вместо этого в io (возвращая io). (Например, это можно использовать совместно с IOBuffer для повторного использования предварительно выделенного буфера массива на месте.)

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

Примеры

julia> replace("Python is a programming language.", "Python" => "Julia")
"Julia is a programming language."

julia> replace("The quick foxes run quickly.", "quick" => "slow", count=1)
"The slow foxes run quickly."

julia> replace("The quick foxes run quickly.", "quick" => "", count=1)
"The  foxes run quickly."

julia> replace("The quick foxes run quickly.", r"fox(es)?" => s"bus\1")
"The quick buses run quickly."

julia> replace("abcabc", "a" => "b", "b" => "c", r".+" => "a")
"bca"

eachsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

Разделяет str по вхождениям разделителя(ей) dlm и возвращает итератор по подстрокам. dlm может быть любым из форматов, разрешённых для первого аргумента findnext (т.е. как строка, регулярное выражение или функция), или как одиночный символ или коллекция символов.

Если dlm опущено, по умолчанию используется isspace.

Необязательные ключевые аргументы:

• limit: максимальный размер результата. limit=0 означает отсутствие максимума (по умолчанию)
• keepempty: должны ли пустые поля сохраняться в результате. По умолчанию false без аргумента dlm, true с аргументом dlm.

См. также split.

Примеры

julia> a = "Ma.rch"
"Ma.rch"

julia> b = eachsplit(a, ".")
Base.SplitIterator{String, String}("Ma.rch", ".", 0, true)

julia> collect(b)
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

eachrsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachrsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

Возвращает итератор по SubString строк str, созданных при разделении по разделителю(ям) dlm, и возвращаемых в обратном порядке (справа налево). dlm может быть любым из форматов, разрешённых для первого аргумента findprev (т.е. строка, одиночный символ или функция), или коллекция символов.

Если dlm опущено, по умолчанию используется isspace, а keepempty по умолчанию false.

Необязательные ключевые аргументы:

• Если limit > 0, итератор разделит не более limit - 1 раз перед возвращением остальной части строки без разделения. limit < 1 подразумевает отсутствие ограничения на разделения (по умолчанию).
• keepempty: должны ли пустые поля возвращаться при итерации. По умолчанию false без аргумента dlm, true с аргументом dlm.

Обратите внимание, что в отличие от split, rsplit и eachsplit, эта функция итерирует подстроки справа налево, как они встречаются во входных данных.

См. также eachsplit, rsplit.

Примеры

julia> a = "Ma.r.ch";

julia> collect(eachrsplit(a, ".")) == ["ch", "r", "Ma"]
true

julia> collect(eachrsplit(a, "."; limit=2)) == ["ch", "Ma.r"]
true

split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

Разделить str на массив подстрок по вхождениям разделителя(ей) dlm. dlm может быть в любом формате, разрешённом первым аргументом findnext (т.е. строкой, регулярным выражением или функцией), или как один символ или набор символов.

Если dlm опущено, по умолчанию используется isspace.

Необязательные ключевые аргументы:

• limit: максимальный размер результата. limit=0 означает отсутствие максимального значения (по умолчанию)
• keepempty: сохранять ли пустые поля в результате. По умолчанию false без аргумента dlm, true с аргументом dlm.

См. также rsplit, eachsplit.

Примеры

julia> a = "Ma.rch"
"Ma.rch"

julia> split(a, ".")
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

rsplit(s::AbstractString; limit::Integer=0, keepempty::Bool=false)
rsplit(s::AbstractString, chars; limit::Integer=0, keepempty::Bool=true)

Аналогично split, но начиная с конца строки.

Примеры

julia> a = "M.a.r.c.h"
"M.a.r.c.h"

julia> rsplit(a, ".")
5-element Vector{SubString{String}}:
 "M"
 "a"
 "r"
 "c"
 "h"

julia> rsplit(a, "."; limit=1)
1-element Vector{SubString{String}}:
 "M.a.r.c.h"

julia> rsplit(a, "."; limit=2)
2-element Vector{SubString{String}}:
 "M.a.r.c"
 "h"

strip([pred=isspace,] str::AbstractString) -> SubString
strip(str::AbstractString, chars) -> SubString

Удалить начальные и конечные символы из str, либо те, которые указаны в chars, либо те, для которых функция pred возвращает true.

По умолчанию удаляются начальные и конечные пробелы и разделители: см. isspace для подробностей.

Необязательный аргумент chars указывает, какие символы удалить: это может быть один символ, вектор или множество символов.

См. также lstrip и rstrip.

Примеры

julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"

lstrip([pred=isspace,] str::AbstractString) -> SubString
lstrip(str::AbstractString, chars) -> SubString

Удалить начальные символы из str, либо те, которые указаны в chars, либо те, для которых функция pred возвращает true.

По умолчанию удаляются начальные пробелы и разделители: см. isspace для подробностей.

Необязательный аргумент chars указывает, какие символы удалить: это может быть один символ или вектор или множество символов.

См. также strip и rstrip.

Примеры

julia> a = lpad("March", 20)
"               March"

julia> lstrip(a)
"March"

rstrip([pred=isspace,] str::AbstractString) -> SubString
rstrip(str::AbstractString, chars) -> SubString

Удалить конечные символы из str, либо те, которые указаны в chars, либо те, для которых функция pred возвращает true.

По умолчанию удаляются конечные пробелы и разделители: см. isspace для подробностей.

Необязательный аргумент chars указывает, какие символы удалить: это может быть один символ или вектор или множество символов.

См. также strip и lstrip.

Примеры

julia> a = rpad("March", 20)
"March               "

julia> rstrip(a)
"March"

startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})

Возвращает true, если s начинается с prefix, что может быть строкой, символом или кортежем/вектором/множеством символов. Если prefix является кортежем/вектором/множеством символов, проверяется, принадлежит ли первый символ s этому набору.

См. также endswith, contains.

Примеры

julia> startswith("JuliaLang", "Julia")
true

startswith(io::IO, prefix::Union{AbstractString,Base.Chars})

Проверяет, начинается ли объект IO с префикса, который может быть строкой, символом или кортежем/вектором/множеством символов. См. также peek.

startswith(prefix)

Создает функцию, проверяющую, начинается ли её аргумент с prefix, т.е. функцию, эквивалентную y -> startswith(y, prefix).

Возвращаемая функция имеет тип Base.Fix2{typeof(startswith)}, который может использоваться для реализации специализированных методов.

Примеры

julia> startswith("Julia")("JuliaLang")
true

julia> startswith("Julia")("Ends with Julia")
false

startswith(s::AbstractString, prefix::Regex)

Возвращает true, если s начинается с шаблона регулярного выражения prefix.

См. также occursin и endswith.

Примеры

julia> startswith("JuliaLang", r"Julia|Romeo")
true

endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

Возвращает true, если s оканчивается на suffix, что может быть строкой, символом или кортежем/вектором/множеством символов. Если suffix является кортежем/вектором/множеством символов, проверяется, принадлежит ли последний символ s этому набору.

См. также startswith, contains.

Примеры

julia> endswith("Sunday", "day")
true

endswith(suffix)

Создаёт функцию, проверяющую, заканчивается ли её аргумент на suffix, т.е. функцию, эквивалентную y -> endswith(y, suffix).

Возвращаемая функция имеет тип Base.Fix2{typeof(endswith)}, который может использоваться для реализации специализированных методов.

Примеры

julia> endswith("Julia")("Ends with Julia")
true

julia> endswith("Julia")("JuliaLang")
false

endswith(s::AbstractString, suffix::Regex)

Возвращает true, если s заканчивается на шаблоне регулярного выражения suffix.

См. также occursin и startswith.

Примеры

julia> endswith("JuliaLang", r"Lang|Roberts")
true

contains(haystack::AbstractString, needle)

Возвращает true, если haystack содержит needle . Это то же самое, что и occursin(needle, haystack), но предоставляется для согласованности с startswith(haystack, needle) и endswith(haystack, needle).

См. также occursin, in, issubset.

Примеры

julia> contains("JuliaLang is pretty cool!", "Julia")
true

julia> contains("JuliaLang is pretty cool!", 'a')
true

julia> contains("aba", r"a.a")
true

julia> contains("abba", r"a.a")
false

contains(needle)

Создайте функцию, которая проверяет, содержит ли её аргумент needle, то есть функцию, эквивалентную haystack -> contains(haystack, needle).

Возвращаемая функция имеет тип Base.Fix2{typeof(contains)}, который может использоваться для реализации специализированных методов.

first(s::AbstractString, n::Integer)

Получить строку, состоящую из первых n символов s.

Примеры

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

last(s::AbstractString, n::Integer)

Получить строку, состоящую из последних n символов s.

Примеры

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

uppercase(c::AbstractChar)

Преобразовать c в верхний регистр.

См. также lowercase, titlecase.

Примеры

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> uppercase('ê')
'Ê': Unicode U+00CA (category Lu: Letter, uppercase)

uppercase(s::AbstractString)

Возвращает s со всеми символами в верхнем регистре.

См. также lowercase, titlecase, uppercasefirst.

Примеры

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

Преобразовать c в нижний регистр.

См. также uppercase, titlecase.

Примеры

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)

lowercase(s::AbstractString)

Возвращает s со всеми символами в нижнем регистре.

См. также uppercase, titlecase, lowercasefirst.

Примеры

julia> lowercase("STRINGS AND THINGS")
"strings and things"

titlecase(c::AbstractChar)

Преобразовать c в заглавную форму. Это может отличаться от верхнего регистра для диграфов, сравните пример ниже.

См. также uppercase, lowercase.

Примеры

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (category Lt: Letter, titlecase)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (category Lu: Letter, uppercase)

titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

Приводит к заглавному регистру первый символ каждого слова в s; если strict равно true, каждый другой символ преобразуется в нижний регистр, в противном случае они остаются без изменений. По умолчанию все небуквенные символы, начинающие новое графемное написание, рассматриваются как разделители слов; в качестве аргумента wordsep можно передать предикат, определяющий, какие символы следует считать разделителями слов. См. также uppercasefirst для приведения только первого символа в s к заглавной форме.

См. также uppercase, lowercase, uppercasefirst.

Примеры

julia> titlecase("the JULIA programming language")
"The Julia Programming Language"

julia> titlecase("ISS - international space station", strict=false)
"ISS - International Space Station"

julia> titlecase("a-a b-b", wordsep = c->c==' ')
"A-a B-b"

uppercasefirst(s::AbstractString) -> String

Возвращает s с первым символом в верхнем регистре (технически «заглавном» для Unicode). См. также titlecase для приведения к заглавной форме первого символа каждого слова в s.

См. также lowercasefirst, uppercase, lowercase, titlecase.

Примеры

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

Возвращает s с первым символом в нижнем регистре.

См. также uppercasefirst, uppercase, lowercase, titlecase.

Примеры

julia> lowercasefirst("Julia")
"julia"

join([io::IO,] iterator [, delim [, last]])

Объединить любые iterator в одну строку, вставляя заданный разделитель (если есть) между смежными элементами. Если last задан, он будет использоваться вместо delim между последними двумя элементами. Каждый элемент iterator преобразуется в строку с помощью print(io::IOBuffer, x). Если io задан, результат записывается в io вместо возвращения как String.

Примеры

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

julia> join([1,2,3,4,5])
"12345"

chop(s::AbstractString; head::Integer = 0, tail::Integer = 1)

Удалить первый head и последний tail символ из s . Вызов chop(s) удаляет последний символ из s. Если требуется удалить больше символов, чем length(s), возвращается пустая строка.

См. также chomp, startswith, first.

Примеры

julia> a = "March"
"March"

julia> chop(a)
"Marc"

julia> chop(a, head = 1, tail = 2)
"ar"

julia> chop(a, head = 5, tail = 5)
""

chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex}) -> SubString

Удалить префикс prefix из s. Если s не начинается с prefix, возвращается строка, равная s.

См. также chopsuffix.

Примеры

julia> chopprefix("Hamburger", "Ham")
"burger"

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"

chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex}) -> SubString

Удалить суффикс suffix из s. Если s не заканчивается на suffix, возвращается строка, равная s.

См. также chopprefix.

Примеры

julia> chopsuffix("Hamburger", "er")
"Hamburg"

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"

chomp(s::AbstractString) -> SubString

Удалить одиночную конечную новую строку из строки.

См. также chop.

Примеры

julia> chomp("Hello\n")
"Hello"

thisind(s::AbstractString, i::Integer) -> Int

Если i находится в границах s, возвращает индекс начала символа, кодовый блок которого i является частью. Другими словами, если i является началом символа, возвращает i; если i не является началом символа, возвращает индекс начала символа, возвращаясь назад до начала символа. Если i равно 0 или ncodeunits(s)+1, возвращает i. В противном случае генерирует BoundsError.

Примеры

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

julia> thisind("α", 4)
ERROR: BoundsError: attempt to access 2-codeunit String at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access 2-codeunit String at index [-1]
[...]

nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• Случай n == 1

  Если i находится в границах s, возвращает индекс начала символа, кодирование которого начинается после индекса i. Другими словами, если i является началом символа, возвращает начало следующего символа; если i не является началом символа, перемещается вперёд до начала символа и возвращает этот индекс. Если i равно 0, возвращает 1. Если i находится в границах и больше или равно lastindex(str), возвращает ncodeunits(str)+1. В противном случае генерирует BoundsError.

• Случай n > 1

  Действует подобно применению n раз nextind для n==1. Единственное отличие состоит в том, что если n настолько велико, что применение nextind достигнет ncodeunits(str)+1, то каждая оставшаяся итерация увеличивает возвращаемое значение на 1. Это означает, что в этом случае nextind может вернуть значение большее, чем ncodeunits(str)+1.

• Случай n == 0

  Возвращает i только если i является допустимым индексом в s или равно 0. В противном случае генерируется StringIndexError или BoundsError.

Примеры

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

julia> nextind("α", 3)
ERROR: BoundsError: attempt to access 2-codeunit String at index [3]
[...]

julia> nextind("α", 0, 2)
3

julia> nextind("α", 1, 2)
4

prevind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• Случай n == 1

  Если i находится в границах s, возвращает индекс начала символа, кодирование которого начинается перед индексом i. Другими словами, если i является началом символа, возвращает начало предыдущего символа; если i не является началом символа, возвращает индекс начала символа, возвращаясь назад до начала символа. Если i равно 1, возвращает 0. Если i равно ncodeunits(str)+1, возвращает lastindex(str). В противном случае генерируется BoundsError.

• Случай n > 1

  Действует подобно применению n раз prevind для n==1. Единственное отличие состоит в том, что если n настолько велико, что применение prevind достигнет 0, то каждая оставшаяся итерация уменьшает возвращаемое значение на 1. Это означает, что в этом случае prevind может вернуть отрицательное значение.

• Случай n == 0

  Возвращает i только если i является допустимым индексом в str или равно ncodeunits(str)+1. В противном случае генерируется StringIndexError или BoundsError.

Примеры

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

julia> prevind("α", 0)
ERROR: BoundsError: attempt to access 2-codeunit String at index [0]
[...]

julia> prevind("α", 2, 2)
0

julia> prevind("α", 2, 3)
-1

textwidth(c)

Возвращает количество столбцов, необходимых для вывода символа.

Примеры

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

Возвращает количество столбцов, необходимых для вывода строки.

Примеры

julia> textwidth("March")
5

isascii(c::Union{AbstractChar,AbstractString}) -> Bool

Проверяет, принадлежит ли символ набору символов ASCII, или это верно для всех элементов строки.

Примеры

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

Например, isascii может использоваться как функция-предикат для filter или replace для удаления или замены соответственно не-ASCII символов:

julia> filter(isascii, "abcdeγfgh") # discard non-ASCII chars
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # replace non-ASCII chars with spaces
"abcde fgh"

isascii(cu::AbstractVector{CU}) where {CU <: Integer} -> Bool

Проверяет, принадлежат ли все значения в векторе набору символов ASCII (0x00 до 0x7f). Эта функция предназначена для использования другими реализациями строк, которым требуется быстрая проверка ASCII.

iscntrl(c::AbstractChar) -> Bool

Проверяет, является ли символ управляющим символом. Управляющие символы — это непечатаемые символы подмножества Latin-1 Unicode.

Примеры

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

Проверяет, является ли символ десятичной цифрой (0-9).

См. также: isletter.

Примеры

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

Проверяет, является ли символ буквой. Символ классифицируется как буква, если он принадлежит к общей категории Unicode «Буква», т.е. символ, код категории которого начинается с 'L'.

См. также: isdigit.

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

Проверяет, является ли символ строчной буквой (согласно свойству Unicode Lowercase).

См. также isuppercase.

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

Проверяет, является ли символ числовым. Символ классифицируется как числовой, если он принадлежит к общей категории Unicode «Число», т.е. символ, код категории которого начинается с 'N'.

Обратите внимание, что эта широкая категория включает символы, такие как ¾ и ௰. Используйте isdigit для проверки, является ли символ десятичной цифрой от 0 до 9.

Примеры

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

Проверяет, является ли символ печатным символом, включая пробелы, но не управляющим символом.

Примеры

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

Проверяет, принадлежит ли символ общей категории Unicode «Пунктуация», т.е. символ, код категории которого начинается с 'P'.

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

Проверяет, является ли символ символом пробела. Включает ASCII символы '\t', '\n', '\v', '\f', '\r', и ' ', символ Latin-1 U+0085, и символы в категории Unicode Zs.

Примеры

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

Проверяет, является ли символ заглавной буквой (согласно свойству, производному от стандарта Юникод Uppercase).

См. также islowercase.

Примеры

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

Проверяет, является ли символ допустимой шестнадцатеричной цифрой. Обратите внимание, что это не включает x (как в стандартном префиксе 0x).

Примеры

julia> isxdigit('a')
true

julia> isxdigit('x')
false

escape_string(str::AbstractString[, esc]; keep = ())::AbstractString
escape_string(io, str::AbstractString[, esc]; keep = ())::Nothing

Общая эскапирование традиционных C- и Unicode-эскейп-последовательностей. Первый вариант возвращает эскейп-строку, второй печатает результат в io.

Обратные слэши (\) экранируются двойным обратным слэшем ("\\"). Непечатаемые символы экранируются либо стандартными C-эскейп-кодами, "\0" для NUL (если однозначно), кодом Юникод (префикс "\u") или шестнадцатеричным кодом (префикс "\x").

Необязательный аргумент esc задаёт любые дополнительные символы, которые также должны быть экранированы путём добавления обратного слэша (" также экранируется по умолчанию в первом варианте).

Аргумент keep задаёт набор символов, которые должны остаться без изменений. Обратите внимание, что esc имеет здесь приоритет.

См. также unescape_string для обратной операции.

Примеры

julia> escape_string("aaa\nbbb")
"aaa\\nbbb"

julia> escape_string("aaa\nbbb"; keep = '\n')
"aaa\nbbb"

julia> escape_string("\xfe\xff") # invalid utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # unambiguous
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 would be ambiguous
"ℵ\\x000"

escape_raw_string(s::AbstractString, delim='"') -> AbstractString
escape_raw_string(io, s::AbstractString, delim='"')

Экранировать строку способом, используемым для парсинга литералов сырых строк. Для каждого символа двойной кавычки (") в строке-входе s (или delim, если указано), эта функция подсчитывает количество n предшествующих обратных слэшей (\ символов), а затем увеличивает количество обратных слэшей с n до 2n+1 (даже для n = 0). Она также удваивает последовательность обратных слэшей в конце строки.

Эта конвенция экранирования используется в сырых строках и других нестандартных строковых литералах. (Она также является конвенцией экранирования, ожидаемой системой выполнения Microsoft C/C++ компилятора, когда она парсит строку командной строки в массив argv[].)

См. также escape_string.

unescape_string(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing

Общая уборка традиционных C и Unicode эскейп-последовательностей. Первый вариант возвращает строку, второй печатает результат в io. Аргумент keep задает коллекцию символов, которые (вместе с обратными слэшами) должны оставаться без изменений.

Распознаются следующие эскейп-последовательности:

• Экранированный обратный слэш (\\)
• Экранированная двойная кавычка (\")
• Стандартные C эскейп-последовательности (\a, \b, \t, \n, \v, \f, \r, \e)
• Коды Unicode BMP (\u с 1-4 последующими шестнадцатеричными цифрами)
• Все коды Unicode (\U с 1-8 последующими шестнадцатеричными цифрами; максимальное значение = 0010ffff)
• Шестнадцатеричные байты (\x с 1-2 последующими шестнадцатеричными цифрами)
• Восьмеричные байты (\ с 1-3 последующими восьмеричными цифрами)

См. также escape_string.

Примеры

julia> unescape_string("aaa\\nbbb") # C escape sequence
"aaa\nbbb"

julia> unescape_string("\\u03c0") # unicode
"π"

julia> unescape_string("\\101") # octal
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # using `keep` argument
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

Строка с метаданными в виде аннотированных областей.

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

                           C
                    ┌──────┸─────────┐
  "this is an example annotated string"
  └──┰────────┼─────┘         │
     A        └─────┰─────────┘
                    B

Приведённая выше диаграмма представляет AnnotatedString, где три диапазона были аннотированы (метками A, B и C). Каждая аннотация содержит метку (Symbol) и значение (Any). Эти три части информации хранятся как @NamedTuple{region::UnitRange{Int64}, label::Symbol, value}.

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

Код, написанный для AnnotatedString в целом, должен сохранять следующие свойства:

• Какие символы аннотация применяется к
• Порядок, в котором аннотации применяются к каждому символу

Дополнительная семантика может быть введена конкретными применениями AnnotatedString.

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

См. также AnnotatedChar, annotatedstring, annotations и annotate!.

Конструкторы

AnnotatedString(s::S<:AbstractString) -> AnnotatedString{S}
AnnotatedString(s::S<:AbstractString, annotations::Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}})

AnnotatedString также можно создать с помощью annotatedstring, который действует аналогично string, но сохраняет все присутствующие аннотации в аргументах.

Примеры

julia> AnnotatedString("this is an example annotated string",
                    [(1:18, :A => 1), (12:28, :B => 2), (18:35, :C => 3)])
"this is an example annotated string"

AnnotatedChar{S <: AbstractChar} <: AbstractChar

Символ с аннотациями.

Более конкретно, это простая оболочка вокруг любого другого AbstractChar, которая хранит список произвольных аннотированных меток (@NamedTuple{label::Symbol, value} ) с обернутым символом.

См. также: AnnotatedString, annotatedstring, annotations, и annotate!.

Конструкторы

AnnotatedChar(s::S) -> AnnotatedChar{S}
AnnotatedChar(s::S, annotations::Vector{@NamedTuple{label::Symbol, value}})

Примеры

julia> AnnotatedChar('j', :label => 1)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)

annotatedstring(values...)

Создать AnnotatedString из любого числа values с использованием их представлений print.

Это действует как string, но заботится о сохранении любых аннотаций (в форме AnnotatedString или AnnotatedChar значений).

См. также AnnotatedString и AnnotatedChar.

Примеры

julia> annotatedstring("now a AnnotatedString")
"now a AnnotatedString"

julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label => 1)]), ", and unannotated")
"annotated, and unannotated"

annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
            [position::Union{Integer, UnitRange}]) ->
    Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}}

Получить все аннотации, которые применяются к str. Если position задан, будут возвращены только аннотации, которые перекрываются с position.

Аннотации предоставляются вместе с областями, к которым они применяются, в виде вектора кортежей область–аннотация.

В соответствии с семантикой, документированной в AnnotatedString, порядок возвращаемых аннотаций соответствует порядку их применения.

См. также: annotate!.

annotations(chr::AnnotatedChar) -> Vector{@NamedTuple{label::Symbol, value}}

Получить все аннотации chr, в виде вектора пар аннотаций.

annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol, value)
annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol, value)

Добавьте аннотацию к range строки str (или всей строке) с помощью помеченного значения (label => value). Чтобы удалить существующие аннотации label, используйте значение nothing.

Порядок применения аннотаций к str имеет семантическое значение, как описано в AnnotatedString.

annotate!(char::AnnotatedChar, label::Symbol, value::Any)

Добавьте аннотацию к char с помощью пары label => value.