Строки

Core.AbstractCharТип

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

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

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

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

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)

Возвращает код Юникода (бесзнаковое целое число), соответствующий символу 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)

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

Примеры

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

Создать строку из любых значений, используя функцию print.

Примеры

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.

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

julia> repr(big(1/3), context=:compact => true)
"3.33333e-01"

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.

Примеры

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

Примеры

julia> isvalid(Char(0xd800))
false

julia> isvalid(Char(0xd799))
true

Base.isvalidМетод

isvalid(T, value) -> Bool

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

Примеры

julia> isvalid(Char, 0xd800)
false

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

Примеры

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

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

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

Base.:==Метод

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

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

Примеры

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 в алфавитном порядке (технически, в лексикографическом порядке по кодам 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

Base.lpadФункция

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

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

Примеры

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

Base.rpadФункция

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

Преобразование s в строку и добавление пробелов справа к полученной строке до достижения длины 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:end, где string[start:end] == "substring", или 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)
findlast(pattern::Regex, string::String)

Поиск последнего вхождения pattern в string. Эквивалентно findlast(pattern, string, lastindex(s)).

Примеры

julia> findlast("o", "Hello to the world")
15:15

julia> findfirst("Julia", "JuliaLang")
1:5

Base.findprevМетод

findprev(pattern::AbstractString, string::AbstractString, start::Integer)
findprev(pattern::Regex, string::String, start::Integer)

Поиск предыдущего вхождения pattern в string, начиная с позиции start. pattern может быть строкой или регулярным выражением, в этом случае string должен быть типа String.

Возвращаемое значение — диапазон индексов, где найдена совпадающая последовательность, такой, что s[findprev(x, s, i)] == x:

findprev("substring", string, i) = start:end, где string[start:end] == "substring", или 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(str::AbstractString, [chars])

Удалить начальные и конечные символы из str. По умолчанию удаляются начальные пробелы и разделители: см. 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

Base.endswithФункция

endswith(s::AbstractString, suffix::AbstractString)

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

См. также startswith.

Примеры

julia> endswith("Sunday", "day")
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. Например,

Примеры

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 настолько велико, что применение 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 "α"
  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 "α"
  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 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' и ' ', символ 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

Core.SymbolТип

Symbol(x...) -> Symbol

Создаёт Symbol, конкатенируя строковые представления аргументов.

Примеры

julia> Symbol("my", "name")
:myname

julia> Symbol("day", 4)
:day4

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.