Строки

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

Примеры

julia> repr(1)
"1"

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

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

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

String(s::AbstractString)

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

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

Аналогично getindex, но возвращает представление исходной строки s в заданном диапазоне i:j или r соответственно, вместо создания копии.

Примеры

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

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

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

transcode(T, src)

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

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

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

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

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

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

@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) истинно, то 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("αβγ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 в алфавитном порядке (технически, в лексикографическом порядке по кодам Unicode).

Примеры

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

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

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

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

Проверить, равны ли две строки, символ за символом (технически, код Unicode за кодом 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::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

См. также: contains.

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

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

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

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)}, что позволяет реализовать специализированные методы.

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

Примеры

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 равно true, остальные символы преобразуются в нижний регистр, иначе остаются без изменений. По умолчанию все символы, не являющиеся буквами, считаются разделителями слов; предикат, переданный в качестве ключевого слова 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 с преобразованием первого символа в верхний регистр (технически "заглавный регистр" для 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,] strings [, delim [, last]])

Объединяет массив strings в одну строку, вставляя заданный разделитель (если он есть) между смежными строками. Если io задано, оно будет использоваться вместо 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

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

Примеры

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-категории «Буква», то есть символ, код категории которого начинается с «L».

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

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

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

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

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

Примеры

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

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

Примеры

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

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

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

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

Примеры

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

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

Примеры

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 (если однозначно), кодом 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.