Strings

Тип 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 (для безошибечного кодирования недопустимых потоков байтов), в этом случае преобразование не-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 и т. д. соответствуют на основе свойств символов Unicode. С этой опцией эти последовательности соответствуют только символам ASCII. Это также включает \u, который будет выводить указанное значение символа напрямую как один байт и не будет пытаться закодировать его в UTF-8. Важно, что эта опция позволяет соответствовать недопустимым строкам UTF-8, рассматривая как сопоставитель, так и цель как простые байты (как если бы они были байтами ISO/IEC 8859-1 / Latin-1), а не как кодировки символов. В этом случае эта опция часто комбинируется с s. Эту опцию можно дополнительно уточнить, начав шаблон с (UCP) или (UTF).

Смотрите 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 (категория Ll: буква, строчная)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: недопустимый индекс [2], допустимые ближайшие индексы [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 обозначает группу, которая не была захвачена.

Этот тип можно использовать как итератор по группам захвата Regex, возвращая подстроки, захваченные в каждой группе. Из-за этого захваты совпадения могут быть деструктурированы. Если группа не была захвачена, вместо подстроки будет возвращено 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; # деструктурировать группы захвата по итерации

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 в алфавитном порядке (технически, в лексикографическом порядке по кодам Unicode).

Примеры

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

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

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

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

Проверьте, равны ли две строки символ за символом (технически, кодовая точка Unicode за кодовой точкой). Если одна из строк является 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 в алфавитном порядке (технически, лексикографическом порядке по кодовым точкам Unicode).

Примеры

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") # ничего не возвращает, но не выводится в 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") # шляпа находится над x во входных данных, над e в выходных
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # переворачивает графемы; шляпа находится над x в обоих входных и выходных данных
"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 (категория Lu: Буква, верхний регистр)

julia> uppercase('ê')
'Ê': Unicode U+00CA (категория Lu: Буква, верхний регистр)

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 (категория Ll: Буква, строчная)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (категория Ll: Буква, строчная)

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 (категория Lu: Буква, верхний регистр)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (категория Lt: Буква, заглавный регистр)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (категория Lu: Буква, верхний регистр)

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

Капитализирует первый символ каждого слова в s; если strict истинно, каждый другой символ преобразуется в строчную букву, в противном случае они остаются без изменений. По умолчанию все не-буквы, начинающие новый графем, считаются разделителями слов; предикат может быть передан в качестве ключевого слова 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") # удалить не-ASCII символы
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # заменить не-ASCII символы на пробелы
"abcde fgh"

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

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

iscntrl(c::AbstractChar) -> Bool

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

Примеры

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

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

Смотрите также 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

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

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

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

Примеры

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

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

См. также 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 escape последовательностей. Первая форма возвращает экранированную строку, вторая выводит результат в io.

Обратные слэши (\) экранируются двойным обратным слэшем ("\\"). Непечатаемые символы экранируются либо с помощью их стандартных C escape кодов, "\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") # недопустимый utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # однозначно
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 было бы неоднозначным
"ℵ\\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 escape последовательностей. Первая форма возвращает декодированную строку, вторая выводит результат в io. Аргумент keep указывает коллекцию символов, которые (вместе с обратными слешами) должны быть сохранены в исходном виде.

Следующие escape последовательности распознаются:

• Экранированный обратный слеш (\\)
• Экранированная двойная кавычка (\")
• Стандартные C escape последовательности (\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 последовательность
"aaa\nbbb"

julia> unescape_string("\\u03c0") # юникод
"π"

julia> unescape_string("\\101") # восьмеричный
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # использование аргумента `keep`
"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 (категория Ll: Буква, строчная)

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`](@ref), порядок возвращаемых аннотаций соответствует порядку, в котором они были применены.

Смотрите также: [`annotate!`](@ref).

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.