Строки

Тип 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, необязательно указав количество цифр для заполнения.

julia> string(5, base = 13, pad = 4)
"0005"

julia> string(13, base = 5, pad = 4)
"0023"

string(xs...)

Создать строку из любых значений, кроме nothing, используя функцию 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 в REPL.

Примеры

julia> repr(1)
"1"

julia> repr(zeros(3))
"[0.0, 0.0, 0.0]"

julia> repr(big(1/3))
"0.333333333333333314829616256247390992939472198486328125"

julia> repr(big(1/3), context=:compact => true)
"0.333333"

String(s::AbstractString)

Преобразуйте строку в представлении непрерывного массива байтов, закодированного как байты 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 (завершённой символом NULL), закодированной как UTF-8. (Указатель можно безопасно освободить после этого.) Если length указано (длина данных в байтах), строка не должна быть завершена символом NULL.

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

ncodeunits(s::AbstractString) -> Int

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

См. также: 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).

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

codeunits(s::AbstractString)

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

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"

@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 могут быть этого типа, или Vector{UInt8} или SubString{String}.

Примеры

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("αβγdef", 2)
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 Array{Union{Nothing, SubString{String}},1}:
 "b"

julia> m.match
"aba"

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

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

Поиск всех совпадений регулярного выражения r в s и возвращение итератора по совпадениям. Если перекрытие 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 Array{RegexMatch,1}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Array{RegexMatch,1}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")

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

Проверка, равны ли две строки символ за символом (точнее, по кодам Юникода).

Примеры

julia> "abc" == "abc"
true

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

cmp(a::AbstractString, b::AbstractString) -> Int

Сравнение двух строк. Возвращает 0 если обе строки имеют одинаковую длину и символ в каждом индексе одинаков в обеих строках. Возвращает -1 если a является префиксом b, или если a предшествует b в алфавитном порядке. Возвращает 1 если b является префиксом a, или если b предшествует a в алфавитном порядке (точнее, в лексикографическом порядке по кодам Юникода).

Примеры

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

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::Regex, 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::Regex, 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,Regex,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

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") # combining characters can lead to surprising results
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # reverses graphemes
"ex̂a"

replace(s::AbstractString, pat=>r; [count::Integer])

Ищет заданный шаблон pat в s и заменяет каждое вхождение на r. Если count указано, заменяется не более count вхождений. pat может быть одиночным символом, вектором или множеством символов, строкой или регулярным выражением. Если r — функция, каждое вхождение заменяется на r(s), где s — совпавшая подстрока (если pat — Regex или 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 Array{SubString{String},1}:
 "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 Array{SubString{String},1}:
 "M"
 "a"
 "r"
 "c"
 "h"

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

julia> rsplit(a,".";limit=2)
2-element Array{SubString{String},1}:
 "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(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(s::AbstractString, suffix::Regex)

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

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

Примеры

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

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 со всеми символами, преобразованными в верхний регистр.

Примеры

julia> uppercase("Julia")
"JULIA"

lowercase(s::AbstractString)

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

Примеры

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

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

Преобразует первый символ каждого слова в s; если strict истинно, каждый последующий символ преобразуется в нижний регистр, в противном случае они остаются без изменений. По умолчанию все символы, не являющиеся буквами, считаются разделителями слов; предикат может быть передан в качестве ключевого слова wordsep для определения символов, которые следует рассматривать как разделители слов. См. также uppercasefirst для преобразования только первого символа в s в верхний регистр.

Примеры

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 String
  at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access 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 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 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 Letter, то есть символ, код категории которого начинается с 'L'.

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

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

Примеры

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, Letter: Uppercase, или Lt, Letter: Titlecase.

Примеры

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

Обратные слэши (\) экранируются двойным обратным слэшем ("\\"). Непечатаемые символы экранируются либо стандартными C-эскейп-кодами, "\0" для NUL (если недвусмысленно), кодом Юникода ("\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-эскейп-последовательностей. Первый вариант возвращает эскейп-строку, второй выводит результат в 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 восьмеричными цифрами)

Примеры

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.