Строки

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, предназначенную скорее для восприятия человеком, эквивалентную отображению в интерактивной оболочке Julia для 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 и т. д. соответствуют свойствам Unicode символов. С этим параметром эти последовательности соответствуют только символам 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.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.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 с первым символом, преобразованным в верхний регистр (технически "заглавный регистр" для Юникода). См. также 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.

Примеры

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"

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

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

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access "α"
  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 == 0

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

Примеры

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

julia> nextind("α", 3)
ERROR: BoundsError: attempt to access "α"
  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 == 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 "α"
  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 в Юникоде.

Примеры

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

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

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

islowercase(c::AbstractChar) -> Bool

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

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

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

isnumeric(c::AbstractChar) -> Bool

Проверяет, является ли символ числовым. Символ считается числовым, если он принадлежит к категории Unicode Number, т.е. если код его категории начинается с '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 Punctuation, т.е. если код его категории начинается с 'P'.

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

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

isspace(c::AbstractChar) -> Bool

Проверяет, является ли символ символом пробела. Включает ASCII символы '\t', '\n', '\v', '\f', '\r', и ' ', латинский символ 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, Letter: Uppercase, или Lt, Letter: Titlecase.

Примеры

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

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

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

Примеры

julia> escape_string("aaa\nbbb")
"aaa\\nbbb"

julia> escape_string("\xfe\xff") # invalid utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # unambiguous
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 would be ambiguous
"ℵ\\x000"

См. также

unescape_string для обратной операции.

Base.unescape_stringФункция

unescape_string(str::AbstractString)::AbstractString
unescape_string(io, str::AbstractString)::Nothing

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

Распознаются следующие 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"

См. также

escape_string.