Строки

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

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

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

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

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

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

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

codepoint(c::AbstractChar) -> Integer

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

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

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

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

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

Примеры

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

sizeof(str::AbstractString)

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

Примеры

julia> sizeof("")
0

julia> sizeof("∀")
3

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

Объединяет строки и/или символы, создавая String. Это эквивалентно вызову функции 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, необязательно задавая количество цифр для дополнения.

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)), чтобы гарантировать согласованность функций.

Примеры

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 может быть задан в виде объекта IO или IOContext, чьи атрибуты используются для потока ввода-вывода, передаваемого в show.

Обратите внимание, что repr(x) обычно похож на то, как значение x вводилось бы в Julia. Также см. repr(MIME("text/plain"), x), чтобы вместо этого вернуть "красиво отформатированную" версию x, предназначенную больше для восприятия человеком, эквивалентную отображению 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-стиля (завершающейся нулем), закодированной как UTF-8. (Указатель можно безопасно освободить после этого.) Если length указан (длина данных в байтах), строка не должна быть завершающейся нулём.

Эта функция помечена как "небезопасная", потому что она вызовет ошибку, если 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 из литеральной строки.

@text_str -> Docs.Text

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

isvalid(value) -> Bool

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

Примеры

julia> isvalid(Char(0xd800))
false

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

julia> isvalid(Char(0xd799))
true

isvalid(T, value) -> Bool

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

Примеры

julia> isvalid(Char, 0xd800)
false

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

julia> isvalid(Char, 0xd799)
true

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

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

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

Примеры

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

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

julia> isvalid(str, 2)
false

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

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

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

Примеры

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

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

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

julia> m.match
"aba"

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

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

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

Примеры

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

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator(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")

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 символов (кодов). Если s уже имеет длину в n символов, возвращается идентичная строка. По умолчанию дополняется пробелами.

Примеры

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

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

Преобразует s в строку и дополняет её справа символом p до длины в n символов (кодов). Если 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; [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."

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

Примеры

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

Примеры

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

Примеры

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

julia> rstrip(a)
"March"

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

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

См. также endswith.

Примеры

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.

Примеры

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

Примеры

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 равно true, каждый последующий символ преобразуется в нижний регистр, иначе они остаются неизменными. По умолчанию все символы, не являющиеся буквами, начинающие новое графема, считаются разделителями слов; предикатом, переданным в ключевом слове wordsep, можно определить, какие символы должны считаться разделителями слов. См. также uppercasefirst для преобразования только первого символа в s в верхний регистр.

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

Примеры

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

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

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

uppercasefirst(s::AbstractString) -> String

Возвращает s с первым символом, преобразованным в верхний регистр (технически «заглавными буквами» для Юникода). См. также 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,] strings [, delim [, last]])

Объединяет массив strings в одну строку, вставляя указанный разделитель (если есть) между смежными строками. Если last задано, оно будет использовано вместо delim между двумя последними строками. Если io задано, результат записывается в io вместо возврата как String.

strings может быть любым итерируемым объектом над элементами x, которые преобразуются в строки с помощью print(io::IOBuffer, x). strings будет выведено в io.

Примеры

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), возвращается пустая строка.

Примеры

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

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

Примеры

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 Юникода.

Примеры

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

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

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

Проверяет, является ли символ строчной буквой. Символ считается строчной буквой, если он принадлежит категории Unicode Ll, Буква: Строчная.

См. также: 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 Lu, Буква: Заглавная, или Lt, Буква: Прописная.

См. также: 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])::AbstractString
escape_string(io, str::AbstractString[, esc::])::Nothing

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

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

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

Примеры

julia> escape_string("aaa\nbbb")
"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 для обратной операции.

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

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

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

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

Примеры

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"

См. также

escape_string.