Строки

Тип 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.

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

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

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

codepoint(c::AbstractChar) -> Integer

Возвращает код Юникода (целое без знака) соответствующий символу c (или генерирует исключение, если c не представляет допустимый символ). Для Char, это значение UInt32, но типы AbstractChar, представляющие лишь подмножество Юникода, могут возвращать целые числа другой длины (например, 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. Эквивалентно вызову функции string с аргументами. Конкатенация встроенных типов строк всегда создаёт значение типа String, но другие типы строк могут выбрать возвращение строки другого типа, как это уместно.

Примеры

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

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

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

Повторяет строку или символ 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, предназначенную для восприятия человеком, эквивалентную отображению в REPL для x.

Примеры

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)

Преобразовать строку в непрерывный массив байтов, представленный кодировкой UTF-8. Такое представление часто подходит для передачи строк в C.

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

Подобно getindex, но возвращает представление фрагмента родительской строки s в заданном диапазоне i:j или r соответственно, а не создает копию.

Примеры

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

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

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

transcode(T, src)

Преобразовать данные строки между кодировками Юникода. 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, даже для неверных данных Юникода.

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

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 байта.

Примеры

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

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags])

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

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

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

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

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}

@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) равно 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:
[...]

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

Тип, представляющий одно совпадение с 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"

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

Примеры

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") # returns nothing, but not printed in the REPL

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

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

См. также contains.

occursin(haystack)

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

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

reverse(s::AbstractString) -> AbstractString

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

Примеры

julia> reverse("JuliaLang")
"gnaLailuJ"

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

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

julia> using Unicode

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

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

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.

Примеры

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::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> startswith_julia = startswith("Julia");

julia> startswith_julia("Julia")
true

julia> startswith_julia("NotJulia")
false

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

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

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

Примеры

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

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> endswith_julia = endswith("Julia");

julia> endswith_julia("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(s::AbstractString)

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

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

Примеры

julia> uppercase("Julia")
"JULIA"

lowercase(s::AbstractString)

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

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

Примеры

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

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

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

iscntrl(c::AbstractChar) -> Bool

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

Примеры

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

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

Примеры

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

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

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

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

См. также isuppercase.

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

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

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

Примеры

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

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

Примеры

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

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

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

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

Примеры

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

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

См. также islowercase.

Примеры

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

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

Примеры

julia> isxdigit('a')
true

julia> isxdigit('x')
false

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

См. также escape_string.

Примеры

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

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

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

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