Строки

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

Примеры

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

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

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

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

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

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

ncodeunits(s::AbstractString) -> Int

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

Примеры

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

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

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

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

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

См. также ncodeunits.

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

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

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

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

Примеры

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

julia> typeof(a)
UInt8

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

codeunits(s::AbstractString)

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

Примеры

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

ascii(s::AbstractString)

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

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

Примеры

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

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags])

Тип, представляющий регулярное выражение. Объекты 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] вернёт символ, кодирование которого начинается в этом индексе. В противном случае, 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 в алфавитном порядке (технически, в лексикографическом порядке по кодам символов Юникода).

Примеры

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"

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

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

Если dlm опущено, оно по умолчанию равно isspace.

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

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

См. также split.

Примеры

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

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

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

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

Если dlm опущено, оно по умолчанию равно isspace.

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

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

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

Примеры

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

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

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

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

Примеры

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

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

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

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

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

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

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

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

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

Примеры

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

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

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

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

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

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

Примеры

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

julia> lstrip(a)
"March"

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

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

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

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

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

Примеры

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

julia> rstrip(a)
"March"

startswith(s::AbstractString, prefix::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)
""

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

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

См. также chopsuffix.

Примеры

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

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

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

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

См. также chopprefix.

Примеры

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

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

chomp(s::AbstractString) -> SubString

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

См. также chop.

Примеры

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

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

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

Примеры

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

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

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

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

• Случай n == 1

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

• Случай n > 1

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

• Случай n == 0

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

Примеры

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

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

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

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

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

• Случай n == 1

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

• Случай n > 1

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

• Случай n == 0

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

Примеры

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

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

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

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

textwidth(c)

Получить количество столбцов, необходимых для вывода символа.

Примеры

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

Получить количество столбцов, необходимых для вывода строки.

Примеры

julia> textwidth("March")
5

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

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

Примеры

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

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

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

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

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 Letter, т. е. символ, код категории которого начинается с 'L'.

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

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

См. также isuppercase.

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

Проверяет, является ли символ числовым. Символ классифицируется как числовой, если он принадлежит универсальной категории Unicode Number, т. е. символ, код категории которого начинается с '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 Punctuation, т. е. символ, код категории которого начинается с '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)
• Кодовые точки BMP Unicode (\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"