Строки

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)

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

Примеры

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

Примеры

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

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

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