Строки

Core.AbstractCharТип

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

Core.CharТип

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

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

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

Base.codepointФункция

codepoint(c::AbstractChar) -> Integer

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

Base.lengthМетод

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

Base.sizeofМетод

sizeof(str::AbstractString)

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

Примеры

julia> sizeof("")
0

julia> sizeof("∀")
3

Base.:*Метод

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

Конкатенация строк и/или символов, создающая String. Эквивалентно вызову функции string с аргументами. Конкатенация встроенных типов строк всегда производит значение типа String, но другие типы строк могут выбрать возвращение строки другого типа, как удобно.

Примеры

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

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

Base.:^Метод

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

Повторение строки или символа n раз. Это также можно записать как repeat(s, n).

См. также: repeat

Примеры

julia> "Test "^3
"Test Test Test "

Base.stringФункция

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"

Base.repeatМетод

repeat(s::AbstractString, r::Integer)

Повторение строки r раз. Это можно записать как s^r.

См. также: ^

Примеры

julia> repeat("ha", 3)
"hahaha"

Base.repeatМетод

repeat(c::AbstractChar, r::Integer) -> String

Повторение символа r раз. Это можно эквивалентно выполнить, вызвав c^r.

Примеры

julia> repeat('A', 3)
"AAA"

Base.reprМетод

repr(x; context=nothing)

Создать строку из любого значения, используя функцию show. Не следует добавлять методы к repr; вместо этого определите метод show. Если string(x) для определенного типа требует высокой эффективности, тогда имеет смысл добавить метод к string и определить print(io::IO, x::MyType) = print(io, string(x)) для обеспечения согласованности функций.

Необязательный ключевой аргумент 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"

Core.StringМетод

String(s::AbstractString)

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

Base.SubStringТип

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"

Base.transcodeФункция

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.

Base.unsafe_stringФункция

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

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

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

Base.ncodeunitsМетод

ncodeunits(s::AbstractString) -> Int

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

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

Base.codeunitФункция

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

Base.codeunitsФункция

codeunits(s::AbstractString)

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

Base.asciiФункция

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"

Base.@r_strМакрос

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

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

Base.SubstitutionStringТип

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}

Base.@s_strМакрос

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

Base.@raw_strМакрос

@raw_str -> String

Создание сырой строки без интерполяции и экранирования. Исключением является то, что кавычки всё ещё должны быть экранированы. Обратные слэши экранируют как кавычки, так и другие обратные слэши, но только когда последовательность обратных слэшей предшествует символу кавычки. Таким образом, 2n обратных слэшей, за которыми следует кавычка, кодируют n обратных слэшей и конец литерала, а 2n+1 обратных слэшей, за которыми следует кавычка, кодируют n обратных слэшей и символ кавычки.

Примеры

julia> println(raw"\ $x")
\ $x

julia> println(raw"\"")
"

julia> println(raw"\\\"")
\"

julia> println(raw"\\x \\\"")
\\x \"

Base.@b_strМакрос

@b_str

Создание неизменяемого вектора байтов (UInt8) с использованием синтаксиса строки.

Примеры

julia> v = b"12\x01\x02"
4-element Base.CodeUnits{UInt8,String}:
 0x31
 0x32
 0x01
 0x02

julia> v[2]
0x32

Base.Docs.@html_strМакрос

@html_str -> Docs.HTML

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

Base.Docs.@text_strМакрос

@text_str -> Docs.Text

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

Base.isvalidМетод

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

Base.isvalidМетод

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

Base.isvalidМетод

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:
[...]

Base.matchФункция

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

Base.eachmatchФункция

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

Base.islessМетод

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

Проверка того, предшествует ли строка a строке b в алфавитном порядке (технически, в лексикографическом порядке по кодам Юникода).

Примеры

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

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

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

Base.:==Метод

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

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

Примеры

julia> "abc" == "abc"
true

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

Base.cmpМетод

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

Base.lpadФункция

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

Преобразование s в строку и дополнение полученной строки слева символом p до длины в n символов (кодов). Если s уже имеет длину n символов, возвращается исходная строка. По умолчанию дополняется пробелами.

Примеры

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

Base.rpadФункция

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

Преобразование s в строку и дополнение полученной строки справа символом p до длины в n символов (кодов). Если s уже имеет длину n символов, возвращается исходная строка. По умолчанию дополняется пробелами.

Примеры

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

Base.findfirstМетод

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

Base.findnextМетод

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

Base.findnextМетод

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

Base.findlastМетод

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

Base.findlastМетод

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

Поиск последнего вхождения символа ch в string.

Примеры

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

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

Base.findprevМетод

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

Base.occursinФункция

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

Base.reverseМетод

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"

Base.replaceМетод

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

Base.splitФункция

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"

Base.rsplitФункция

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"

Base.stripФункция

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

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

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

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

Примеры

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

Base.lstripФункция

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

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

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

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

Примеры

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

julia> lstrip(a)
"March"

Base.rstripФункция

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

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

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

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

Примеры

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

julia> rstrip(a)
"March"

Base.startswithФункция

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

Base.endswithФункция

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

Base.firstМетод

first(s::AbstractString, n::Integer)

Возвращает строку, состоящую из первых n символов s.

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

Base.lastМетод

last(s::AbstractString, n::Integer)

Получить строку, состоящую из последних n символов s.

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

Base.Unicode.uppercaseФункция

uppercase(s::AbstractString)

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

Примеры

julia> uppercase("Julia")
"JULIA"

Base.Unicode.lowercaseФункция

lowercase(s::AbstractString)

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

Примеры

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

Base.Unicode.titlecaseФункция

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"

Base.Unicode.uppercasefirstФункция

uppercasefirst(s::AbstractString) -> String

Возвращает s с первым символом, преобразованным в верхний регистр (технически «заглавная буква» для Unicode). См. также titlecase, чтобы преобразовать первый символ каждого слова в s.

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

Примеры

julia> uppercasefirst("python")
"Python"

Base.Unicode.lowercasefirstФункция

lowercasefirst(s::AbstractString)

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

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

Примеры

julia> lowercasefirst("Julia")
"julia"

Base.joinФункция

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"

Base.chopФункция

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

Base.chompФункция

chomp(s::AbstractString)

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

Примеры

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

Base.thisindФункция

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]
[...]

Base.nextindФункция

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

Base.previndФункция

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

Base.Unicode.textwidthФункция

textwidth(c)

Возвращает количество столбцов, необходимых для вывода символа.

Примеры

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

Возвращает количество столбцов, необходимых для вывода строки.

Примеры

julia> textwidth("March")
5

Base.isasciiФункция

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

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

Примеры

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

Base.Unicode.iscntrlФункция

iscntrl(c::AbstractChar) -> Bool

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

Примеры

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

Base.Unicode.isdigitФункция

isdigit(c::AbstractChar) -> Bool

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

Примеры

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

Base.Unicode.isletterФункция

isletter(c::AbstractChar) -> Bool

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

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

Base.Unicode.islowercaseФункция

islowercase(c::AbstractChar) -> Bool

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

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

Base.Unicode.isnumericФункция

isnumeric(c::AbstractChar) -> Bool

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

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

Примеры

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

Base.Unicode.isprintФункция

isprint(c::AbstractChar) -> Bool

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

Примеры

julia> isprint('\x01')
false

julia> isprint('A')
true

Base.Unicode.ispunctФункция

ispunct(c::AbstractChar) -> Bool

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

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

Base.Unicode.isspaceФункция

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

Base.Unicode.isuppercaseФункция

isuppercase(c::AbstractChar) -> Bool

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

Примеры

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

Base.Unicode.isxdigitФункция

isxdigit(c::AbstractChar) -> Bool

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

Примеры

julia> isxdigit('a')
true

julia> isxdigit('x')
false

Base.escape_stringФункция

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 для обратной операции.

Base.unescape_stringФункция

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

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

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

• Экранированный обратный слэш (\\)
• Экранированная двойная кавычка (\")
• Стандартные C-escape-последовательности (\a, \b, \t, \n, \v, \f, \r, \e)
• Коды Unicode (\u или \U префиксы с 1-4 шестнадцатеричными цифрами)
• Шестнадцатеричные байты (\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.