Документация Engee

Текстовые строки

# Core.AbstractString — Type

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

  • Строки кодируются в виде «единиц кода» фиксированного размера.

    • Единицы кода можно извлечь с помощью codeunit(s, i).

    • Первая единица кода имеет индекс 1.

    • Последняя единица кода имеет индекс ncodeunits(s).

    • Любой индекс i такой, что 1 ≤ i ≤ ncodeunits(s) находится в передах границ.

  • Индексирование строк осуществляется с точки зрения этих единиц кода.

    • Символы извлекаются по s[i] с допустимым индексом строки i.

    • Каждый символ AbstractChar в строке кодируется с помощью одной или нескольких единиц кода.

    • Допустимым является только индекс первой единицы кода AbstractChar.

    • Кодировка AbstractChar не зависит от того, что ей предшествует или следует за ней.

    • Кодировки строк являются самосинхронизирующимися ([самосинхронизирующийся]), т. е.  — i.e.  — это O(1).

[самосинхронизирующийся]: https://en.wikipedia.org/wiki/Self-synchronizing_code ""

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

См. также описание функций codeunit, ncodeunits, thisind и nextind, prevind.

# Core.AbstractChar — Type

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

Подтип AbstractChar может представлять лишь подмножество символов Юникода. В этом случае попытка преобразования неподдерживаемого значения UInt32 приведет к ошибке. И наоборот, встроенный тип Char представляет собой надмножество символов Юникода (что необходимо для кодирования потоков с недопустимыми байтами без потерь). В этом случае преобразование значения, которому нет соответствия в Юникоде, в UInt32 приведет к ошибке. С помощью функции isvalid можно проверить, какие кодовые позиции представимы данным типом AbstractChar.

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

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

# Core.Char — Type

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

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

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

# Base.codepoint — Function

codepoint(c::AbstractChar) -> Integer

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

# Base.length — Method

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

# Base.sizeof — Method

sizeof(str::AbstractString)

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

Примеры

julia> sizeof("")
0

julia> sizeof("∀")
3

# Base.:* — Method

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

Выполняет конкатенацию строк и (или) символов, возвращая объект String. Это равноценно вызову функции string с теми же аргументами. При конкатенации строк встроенных типов всегда возвращается значение типа String, но для других типов строк результат может иметь другой тип.

Примеры

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

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

# Base.:^ — Method

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

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

См. также описание repeat.

Примеры

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

# Base.string — Function

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"

# Base.repeat — Method

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

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

См. также описание метода ^.

Примеры

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

# Base.repeat — Method

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

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

Примеры

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

# Base.repr — Method

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 1.7

Для передачи кортежа в именованном аргументе context требуется версия Julia не ниже 1.7.

Примеры

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"

# Core.String — Method

String(s::AbstractString)

Создает новую строку (String) из существующей AbstractString.

# Base.SubString — Type

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"

# Base.LazyString — Type

LazyString <: AbstractString

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

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

Примеры

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

См. также описание @lazy_str.

Совместимость: Julia 1.8

Для LazyString требуется версия Julia не ниже 1.8.

Расширенная справка

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

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

Совместимость: Julia 1.9

В версиях Julia не ниже 1.9 использование LazyString является безопасным в указанном выше смысле.

# Base.@lazy_str — Macro

lazy"str"

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

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

Примеры

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

julia> typeof(str)
LazyString
Совместимость: Julia 1.8

Для lazy"str" требуется версия Julia не ниже 1.8.

# Base.transcode — Function

transcode(T, src)

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

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

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

Примеры

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

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

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

# Base.unsafe_string — Function

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

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

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

# Base.ncodeunits — Method

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.

# Base.codeunit — Function

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.

# Base.codeunits — Function

codeunits(s::AbstractString)

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

Примеры

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

# Base.ascii — Function

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"

# Base.Regex — Type

Regex(pattern[, flags])

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

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

Для экранирования интерполируемых переменных используйте \Q и \E (например, Regex("\\Q$x\\E")).

# Base.@r_str — Macro

@r_str -> Regex

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

  • i включает сопоставление без учета регистра.

  • m — символы ^ и $ рассматриваются как соответствующие началу и концу отдельных строк, а не всего текста.

  • s позволяет сопоставлять модификатор . с символами новой строки.

  • x включает «режим комментария»: пробелы включаются, кроме случаев, когда они экранированы символом , а символ#`` расценивается как начало комментария.

  • a отключает режим UCP (включает режим ASCII). По умолчанию сопоставление последовательностей \B, \b, \D, \d, \S, \s, \W и \w выполняется на основании свойств символов Юникода. Если установлен данный флаг, эти последовательности сопоставляются только с символами ASCII.

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

Примеры

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

У этого регулярного выражения активированы первые три флага.

# Base.SubstitutionString — Type

SubstitutionString(substr)

Сохраняет указанную строку 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}

# Base.@s_str — Macro

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

# Base.@raw_str — Macro

@raw_str -> String

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

Примеры

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

julia> println(raw"\"")
"

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

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

# Base.@b_str — Macro

@b_str

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

Примеры

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

julia> v[2]
0x32

# Base.Docs.@html_str — Macro

@html_str -> Docs.HTML

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

Примеры

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

# Base.Docs.@text_str — Macro

@text_str -> Docs.Text

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

Примеры

julia> text"Julia"
Julia

# Base.isvalid — Method

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

# Base.isvalid — Method

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
Совместимость: Julia 1.6

Поддержка значений в виде подмассива появилась в Julia 1.6.

# Base.isvalid — Method

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

Предикат, указывающий, является ли указанный индекс началом кодировки символа в s. Если isvalid(s, i) имеет значение true, s[i] вернет символ, кодировка которого начинается по этому индексу. В случае значения false 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:
[...]

# Base.match — Function

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

Ищет первое соответствие регулярному выражению r в s и возвращает объект RegexMatch, содержащий найденное совпадение, или nothing, если совпадений не найдено. Совпадающую подстроку можно получить путем обращения к 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

# Base.eachmatch — Function

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(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")

# Base.RegexMatch — Type

RegexMatch

Тип, представляющий одно совпадение с 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> hr, min, ampm = m;

julia> hr
"11"

julia> m["minute"]
"30"

julia> m.match
"11:30"

# Base.keys — Method

keys(m::RegexMatch) -> Vector

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

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

Совместимость: Julia 1.7

Этот метод был добавлен в Julia 1.7.

Примеры

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

# Base.isless — Method

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

Проверяет, предшествует ли строка a строке b в алфавитном порядке (говоря более строго, в лексикографическом порядке по кодовым позициям Юникода).

Примеры

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

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

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

# Base.:== — Method

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

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

Примеры

julia> "abc" == "abc"
true

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

# Base.cmp — Method

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

# Base.lpad — Function

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

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

Примеры

julia> lpad("March", 10)
"     March"
Совместимость: Julia 1.7

В Julia 1.7 в этой функции начало использоваться значение textwidth вместо простого подсчета символов (кодовых позиций).

# Base.rpad — Function

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

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

Примеры

julia> rpad("March", 20)
"March               "
Совместимость: Julia 1.7

В Julia 1.7 в этой функции начало использоваться значение textwidth вместо простого подсчета символов (кодовых позиций).

# Base.findfirst — Method

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

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

Примеры

julia> findfirst("z", "Hello to the world") # возвращает nothing, но не выводится в REPL

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

# Base.findnext — Method

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

# Base.findnext — Method

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

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

Совместимость: Julia 1.3

Для этого метода требуется версия Julia не ниже 1.3.

Примеры

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

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

# Base.findlast — Method

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

# Base.findlast — Method

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

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

Совместимость: Julia 1.3

Для этого метода требуется версия Julia не ниже 1.3.

Примеры

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

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

# Base.findprev — Method

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

# Base.occursin — Function

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 1.6

Для этого метода требуется версия Julia не ниже 1.6.

# Base.reverse — Method

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"

# Base.replace — Method

replace(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 ("").

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

Совместимость: Julia 1.7

Для использования нескольких шаблонов требуется версия 1.7.

Примеры

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"

# Base.eachsplit — Function

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 1.8

Для функции eachsplit требуется версия Julia не ниже 1.8.

Примеры

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"

# Base.split — Function

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"

# Base.rsplit — Function

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"

# Base.strip — Function

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

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

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

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

См. также описание lstrip и rstrip.

Совместимость: Julia 1.2

Для метода, принимающего предикативную функцию, требуется версия Julia не ниже 1.2.

Примеры

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

# Base.lstrip — Function

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"

# Base.rstrip — Function

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"

# Base.startswith — Function

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

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

См. также описание endswith и contains.

Примеры

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

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

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

Совместимость: Julia 1.5

Для использования функции startswith(prefix) с одним аргументом требуется версия Julia не ниже 1.5.

Примеры

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

julia> startswith("Julia")("Ends with Julia")
false
startswith(s::AbstractString, prefix::Regex)

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

startswith не компилирует привязку в регулярное выражение, а передает ее как match_option в PCRE. Если время компиляции амортизируется, occursin(r"^...", s) выполняется быстрее, чем startswith(s, r"...").

См. также описание occursin и endswith.

Совместимость: Julia 1.2

Для этого метода требуется версия Julia не ниже 1.2.

Примеры

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

# Base.endswith — Function

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

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

См. также описание startswith и contains.

Примеры

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

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

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

Совместимость: Julia 1.5

Для использования функции endswith(suffix) с одним аргументом требуется версия Julia не ниже 1.5.

Примеры

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

julia> endswith("Julia")("JuliaLang")
false
endswith(s::AbstractString, suffix::Regex)

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

endswith не компилирует привязку в регулярное выражение, а передает ее как match_option в PCRE. Если время компиляции амортизируется, occursin(r"...$", s) выполняется быстрее, чем endswith(s, r"...").

См. также описание occursin и startswith.

Совместимость: Julia 1.2

Для этого метода требуется версия Julia не ниже 1.2.

Примеры

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

# Base.contains — Function

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
Совместимость: Julia 1.5

Для функции contains требуется версия Julia не ниже 1.5.

 
contains(needle)

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

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

# Base.first — Method

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

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

Примеры

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

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

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

# Base.last — Method

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

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

Примеры

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

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

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

# Base.Unicode.uppercase — Function

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"

# Base.Unicode.lowercase — Function

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"

# Base.Unicode.titlecase — Function

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"

# Base.Unicode.uppercasefirst — Function

uppercasefirst(s::AbstractString) -> String

Возвращает строку s с преобразованием первого символа в верхний регистр (говоря более строго, в заглавную букву Юникода). См. также описание функции titlecase, которая позволяет преобразовать в прописные первые буквы каждого слова в строке s.

См. также описание функций lowercasefirst, uppercase, lowercase и titlecase.

Примеры

julia> uppercasefirst("python")
"Python"

# Base.Unicode.lowercasefirst — Function

lowercasefirst(s::AbstractString)

Возвращает строку s с преобразованием первого символа в нижний регистр.

См. также описание функций uppercasefirst, uppercase, lowercase и titlecase.

Примеры

julia> lowercasefirst("Julia")
"julia"

# Base.join — Function

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"

# Base.chop — Function

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

# Base.chopprefix — Function

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

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

См. также описание chopsuffix.

Совместимость: Julia 1.8

Эта функция впервые реализована в Julia 1.8.

Примеры

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

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

# Base.chopsuffix — Function

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

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

См. также описание chopprefix.

Совместимость: Julia 1.8

Эта функция впервые реализована в Julia 1.8.

Примеры

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

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

# Base.chomp — Function

chomp(s::AbstractString) -> SubString

Удаляет из строки один конечный символ начала строки.

См. также описание chop.

Примеры

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

# Base.thisind — Function

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]
[...]

# Base.nextind — Function

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

    Равносильно применению nextind n раз для 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

# Base.prevind — Function

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

    Равносильно применению prevind n раз для 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

# Base.Unicode.textwidth — Function

textwidth(c)

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

Примеры

julia> textwidth('α')
1

julia> textwidth('⛵')
2
textwidth(s::AbstractString)

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

Примеры

julia> textwidth("March")
5

# Base.isascii — Function

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"

# Base.Unicode.iscntrl — Function

iscntrl(c::AbstractChar) -> Bool

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

Примеры

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

# Base.Unicode.isdigit — Function

isdigit(c::AbstractChar) -> Bool

Проверяет, является ли символ цифрой (0—​9).

См. также описание isletter.

Примеры

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

# Base.Unicode.isletter — Function

isletter(c::AbstractChar) -> Bool

Проверяет, является ли символ буквой. Символ считается буквой, если он относится к общей категории Юникода «Буква», то есть его код категории начинается с «L».

См. также описание isdigit.

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

# Base.Unicode.islowercase — Function

islowercase(c::AbstractChar) -> Bool

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

См. также описание isuppercase.

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

# Base.Unicode.isnumeric — Function

isnumeric(c::AbstractChar) -> Bool

Проверяет, является ли символ цифрой. Символ считается цифрой, если он относится к общей категории Юникода «Число», то есть его код категории начинается с «N».

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

Примеры

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

# Base.Unicode.isprint — Function

isprint(c::AbstractChar) -> Bool

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

Примеры

julia> isprint('\x01')
false

julia> isprint('A')
true

# Base.Unicode.ispunct — Function

ispunct(c::AbstractChar) -> Bool

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

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

# Base.Unicode.isspace — Function

isspace(c::AbstractChar) -> Bool

Проверяет, является ли символ пробелом. Сюда относятся символы ASCII «\t», «\n», «\v», «\f», «\r» и « », символ Latin-1 U+0085 и символы категории Юникода Zs.

Примеры

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

# Base.Unicode.isuppercase — Function

isuppercase(c::AbstractChar) -> Bool

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

См. также описание islowercase.

Примеры

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

# Base.Unicode.isxdigit — Function

isxdigit(c::AbstractChar) -> Bool

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

Примеры

julia> isxdigit('a')
true

julia> isxdigit('x')
false

# Base.escape_string — Function

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

Общее экранирование стандартных escape-последовательностей C и Юникода. Первая форма возвращает экранированную строку; вторая выводит результат в io.

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

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

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

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

Совместимость: Julia 1.7

Аргумент keep впервые реализован в Julia 1.7.

Примеры

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"

# Base.unescape_string — Function

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

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

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

  • экранированный обратный слэш (\\);

  • экранированные двойные кавычки (\");

  • стандартные escape-последовательности C (\a, \b, \t, \n, \v, \f, \r, \e);

  • кодовые позиции BMP Юникода (\u с 1—​4 шестнадцатеричными цифрами в конце);

  • все кодовые позиции Юникода (\U с 1—​8 шестнадцатеричными цифрами в конце, максимальное значение = 0010ffff);

  • шестнадцатеричные байты (\x с 1—​2 шестнадцатеричными цифрами в конце);

  • восьмеричные байты (\ с 1—​3 восьмеричными цифрами в конце).

См. также описание escape_string.

Примеры

julia> unescape_string("aaa\\nbbb") # escape-последовательность C
"aaa\nbbb"

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

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

julia> unescape_string("aaa \\g \\n", ['g']) # используется аргумент `keep`
"aaa \\g \n"