Строки

Тип AbstractString является супертипом всех реализаций строк в Julia. Строки представляют собой кодировки последовательностей Unicode кодовых точек, как представлено типом AbstractChar. Julia делает несколько предположений о строках:

• Строки закодированы в терминах кодовых единиц фиксированного размера
  • Кодовые единицы могут быть извлечены с помощью codeunit(s, i)
  • Первая кодовая единица имеет индекс 1
  • Последняя кодовая единица имеет индекс ncodeunits(s)
  • Любой индекс i такой, что 1 ≤ i ≤ ncodeunits(s) находится в границах
• Индексирование строк выполняется в терминах этих кодовых единиц:
  • Символы извлекаются с помощью s[i] с действительным индексом строки i
  • Каждая AbstractChar в строке закодирована одной или несколькими кодовыми единицами
  • Только индекс первой кодовой единицы AbstractChar является допустимым индексом
  • Кодирование AbstractChar не зависит от того, что ему предшествует или следует за ним
  • Кодировки строк являются [самосинхронизирующимися] — т. е. isvalid(s, i) имеет сложность O(1)

[самосинхронизирующиеся]: https://en.wikipedia.org/wiki/Self-synchronizing_code

Некоторые функции строк, которые извлекают кодовые единицы, символы или подстроки из строк, возвращают ошибку, если вы передаёте индексы за пределами границ или недопустимые индексы строк. Это включает codeunit(s, i) и s[i]. Функции, выполняющие арифметику с индексами строк, используют более гибкий подход к индексированию и возвращают ближайший допустимый индекс строки при наличии в границах, а при выходе за границы ведут себя так, как будто существует бесконечное количество символов заполнения по обе стороны от строки. Обычно эти воображаемые символы заполнения имеют длину кодовой единицы 1, но типы строк могут выбрать разные размеры «воображаемых» символов, что имеет смысл для их реализации (например, подстроки могут передавать арифметику с индексами базовой строке, которую они представляют). К функциям с гибким индексированием относятся те, которые предназначены для арифметики с индексами: thisind, nextind и prevind. Эта модель позволяет арифметике с индексами работать с индексами вне границ в качестве промежуточных значений, пока вы их не используете для извлечения символа, что часто помогает избежать необходимости кодирования ситуаций граничных случаев.

См. также codeunit, ncodeunits, thisind, nextind, prevind.

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

Данный подтип AbstractChar может быть способен представлять только подмножество Unicode, в этом случае преобразование из недопустимого UInt32 значения может вызвать ошибку. Напротив, встроенный тип Char представляет собой супермножество Unicode (для без потерь кодирования недопустимых байтовых потоков), в этом случае преобразование не-Unicode значения в 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.

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

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

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

codepoint(c::AbstractChar) -> Integer

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

length(s::AbstractString) -> Int
length(s::AbstractString, i::Integer, j::Integer) -> Int

Возвращает количество символов в строке s с индексами от i до j.

Это вычисляется как количество индексов кодовых единиц с i до j, которые являются допустимыми индексами символов. При единственном аргументе строки, это вычисляет количество символов во всей строке. С аргументами i и j это вычисляет количество индексов между i и j включительно, которые являются допустимыми индексами в строке s. В дополнение к значениям в пределах границ, i может принимать значение вне границ ncodeunits(s) + 1, а j может принимать значение вне границ 0.

См. также isvalid, ncodeunits, lastindex, thisind, nextind, prevind.

Примеры

julia> length("jμΛIα")
5

sizeof(str::AbstractString)

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

Примеры

julia> sizeof("")
0

julia> sizeof("∀")
3

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

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

Примеры

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

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

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

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

См. также repeat.

Примеры

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

string(n::Integer; base::Integer = 10, pad::Integer = 1)

Преобразовать целое число n в строку в заданной base, необязательно указав количество цифр для дополнения.

См. также digits, bitstring, count_zeros.

Примеры

julia> string(5, base = 13, pad = 4)
"0005"

julia> string(-13, base = 5, pad = 4)
"-0023"

string(xs...)

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

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

См. также: String, repr, sprint, show.

Примеры

julia> string("a", 1, true)
"a1true"

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

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

См. также ^.

Примеры

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

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

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

Примеры

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

repr(x; context=nothing)

Создать строку из любого значения, используя функцию show. Не следует добавлять методы к repr; вместо этого определите метод show.

Необязательный ключевой аргумент context может быть установлен в пару :key=>value, кортеж пар :key=>value, или объект IO или IOContext, атрибуты которого используются для потока ввода/вывода, переданного в show.

Обратите внимание, что repr(x) обычно похож на то, как значение x было бы введено в Julia. См. также repr(MIME("text/plain"), x), чтобы вместо этого вернуть "форматированную" версию x, предназначенную больше для человеческого восприятия, эквивалентную отображению x в интерактивной оболочке.

Примеры

julia> repr(1)
"1"

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

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

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

String(s::AbstractString)

Создать новую String из существующей AbstractString.

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

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

Макрос @views преобразует все срезы строк s[i:j] в подстроки SubString(s, i, j) в блоке кода.

Примеры

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

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

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

LazyString <: AbstractString

Ленивое представление интерполяции строк. Это полезно, когда строка должна быть построена в контексте, где фактическая интерполяция и построение строки не нужны или нежелательны (например, в путях ошибок функций).

Этот тип разработан для того, чтобы быть дешёвым для построения во время выполнения, пытаясь переложить как можно больше работы на макросы или последующие операции печати.

Примеры

julia> n = 5; str = LazyString("n is ", n)
"n is 5"

См. также @lazy_str.

Расширенная помощь

Свойства безопасности для конкуретных программ

Сама ленивая строка не создает проблем с многопоточностью, даже если она печатается в нескольких задачах Julia. Однако, если методы print на захваченном значении могут иметь проблему с многопоточностью при вызове без синхронизации, печать ленивой строки может вызвать проблему. Кроме того, методы print на захваченных значениях могут быть вызваны несколько раз, хотя будет возвращен только ровно один результат.

lazy"str"

Создать LazyString с помощью обычной синтаксической конструкции интерполяции строк. Обратите внимание, что интерполяции вычисляются во время построения LazyString, но печать откладывается до первого доступа к строке.

См. документацию LazyString для свойств безопасности многопоточных программ.

Примеры

julia> n = 5; str = lazy"n is $n"
"n is 5"

julia> typeof(str)
LazyString

transcode(T, src)

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

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

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

Примеры

julia> str = "αβγ"
"αβγ"

julia> transcode(UInt16, str)
3-element Vector{UInt16}:
 0x03b1
 0x03b2
 0x03b3

julia> transcode(String, transcode(UInt16, str))
"αβγ"

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

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

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

ncodeunits(s::AbstractString) -> Int

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

Примеры

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

julia> ncodeunits('∫'), ncodeunits('e'), ncodeunits('ˣ')
(3, 1, 2)

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

codeunit(s::AbstractString) -> Type{<:Union{UInt8, UInt16, UInt32}}

Возвращает тип кодовой единицы заданного строкового объекта. Для строк с кодировкой ASCII, Latin-1 или UTF-8 это будет UInt8; для UCS-2 и UTF-16 — UInt16; для UTF-32 — UInt32. Тип кодовой единицы необязательно ограничивается этими тремя типами, но трудно представить широко используемые кодировки строк, не использующие одну из этих единиц. codeunit(s) равно typeof(codeunit(s,1)) при s — непустой строке.

См. также ncodeunits.

codeunit(s::AbstractString, i::Integer) -> Union{UInt8, UInt16, UInt32}

Возвращает значение кодовой единицы в строке s по индексу i. Обратите внимание, что

codeunit(s, i) :: codeunit(s)

То есть, значение, возвращаемое codeunit(s, i), имеет тип, возвращаемый codeunit(s).

Примеры

julia> a = codeunit("Hello", 2)
0x65

julia> typeof(a)
UInt8

См. также ncodeunits, checkbounds.

codeunits(s::AbstractString)

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

Примеры

julia> codeunits("Juλia")
6-element Base.CodeUnits{UInt8, String}:
 0x4a
 0x75
 0xce
 0xbb
 0x69
 0x61

ascii(s::AbstractString)

Преобразует строку в тип String и проверяет, что она содержит только данные ASCII, в противном случае выбрасывает ArgumentError, указывающий положение первого не-ASCII байта.

См. также предикат isascii для фильтрации или замены не-ASCII символов.

Примеры

julia> ascii("abcdeγfgh")
ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
Stacktrace:
[...]

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags])

Тип, представляющий регулярное выражение. Объекты Regex могут использоваться для сопоставления строк с помощью match.

Объекты Regex могут быть созданы с помощью строкового макроса @r_str. Конструктор Regex(pattern[, flags]) обычно используется, если строка pattern нуждается во вставке.

@r_str -> Regex

Конструирование регулярного выражения, например r"^[a-z]*$", без интерполяции и экранирования (кроме кавычки ", которую всё ещё нужно экранировать). Регулярное выражение также принимает один или несколько флагов, перечисленных после закрывающей кавычки, для изменения его поведения:

• i включает нечувствительность к регистру
• m обрабатывает токены ^ и $ как сопоставления начала и конца отдельных строк, а не всей строки.
• s позволяет модификатору . сопоставлять переводы строк.
• x включает «режим комментариев»: пробелы разрешены, за исключением случаев экранирования с помощью \, а # рассматривается как начало комментария.
• a отключает режим UCP (включает режим ASCII). По умолчанию \B, \b, \D, \d, \S, \s, \W, \w, и т.д. сопоставляются на основе свойств символов Юникода. С этим параметром эти последовательности сопоставляются только с символами ASCII.

См. Regex, если необходима интерполяция.

Примеры

julia> match(r"a+.*b+.*?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
RegexMatch("angry,\nBad world")

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

SubstitutionString(substr)

Сохраняет заданную строку substr как SubstitutionString, для использования в заменах регулярных выражений. Чаще всего создаётся с помощью макроса @s_str.

Примеры

julia> SubstitutionString("Hello \\g<name>, it's \\1")
s"Hello \g<name>, it's \1"

julia> subst = s"Hello \g<name>, it's \1"
s"Hello \g<name>, it's \1"

julia> typeof(subst)
SubstitutionString{String}

@s_str -> SubstitutionString

Конструирование строки подстановки, используемой для замен регулярных выражений. Внутри строки последовательности вида \N относятся к N-ой группе захвата в регулярном выражении, а \g<groupname> относится к группе захвата с именем groupname.

Примеры

julia> msg = "#Hello# from Julia";

julia> replace(msg, r"#(.+)# from (?<from>\w+)" => s"FROM: \g<from>; MESSAGE: \1")
"FROM: Julia; MESSAGE: Hello"

@raw_str -> String

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

Примеры

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

julia> println(raw"\"")
"

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

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

@b_str

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

Примеры

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

julia> v[2]
0x32

@html_str -> Docs.HTML

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

Примеры

julia> html"Julia"
HTML{String}("Julia")

@text_str -> Docs.Text

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

Примеры

julia> text"Julia"
Julia

isvalid(value) -> Bool

Возвращает true, если заданное значение является допустимым для его типа, который в настоящее время может быть либо AbstractChar, либо String, либо SubString{String}.

Примеры

julia> isvalid(Char(0xd800))
false

julia> isvalid(SubString(String(UInt8[0xfe,0x80,0x80,0x80,0x80,0x80]),1,2))
false

julia> isvalid(Char(0xd799))
true

isvalid(T, value) -> Bool

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

Примеры

julia> isvalid(Char, 0xd800)
false

julia> isvalid(String, SubString("thisisvalid",1,5))
true

julia> isvalid(Char, 0xd799)
true

isvalid(s::AbstractString, i::Integer) -> Bool

Предикат, указывающий, является ли данный индекс началом кодирования символа в s или нет. Если isvalid(s, i) истинно, то s[i] вернёт символ, кодирование которого начинается в этом индексе; если ложно, то s[i] вызовет ошибку некорректного индекса или ошибку выхода за пределы границ в зависимости от того, находится ли i в пределах границ. Для того, чтобы isvalid(s, i) была функцией со сложностью O(1), кодирование s должно быть самосинхронизирующимся. Это основное предположение поддержки строковых типов в Julia.

См. также getindex, iterate, thisind, nextind, prevind, length.

Примеры

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (category Ll: Letter, lowercase)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: invalid index [2], valid nearby indices [1]=>'α', [3]=>'β'
Stacktrace:
[...]

match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

Поиск первого совпадения регулярного выражения r в s и возвращение объекта RegexMatch с результатом совпадения, или ничего, если совпадение не найдено. Совпадающую подстроку можно получить, обратившись к m.match, а захваченные последовательности — обратившись к m.captures. Необязательный аргумент idx задаёт индекс, с которого нужно начать поиск.

Примеры

julia> rx = r"a(.)a"
r"a(.)a"

julia> m = match(rx, "cabac")
RegexMatch("aba", 1="b")

julia> m.captures
1-element Vector{Union{Nothing, SubString{String}}}:
 "b"

julia> m.match
"aba"

julia> match(rx, "cabac", 3) === nothing
true

eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

Поиск всех совпадений регулярного выражения r в s и возвращение итератора по совпадениям. Если overlap равно 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 Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")

RegexMatch

Тип, представляющий единственное совпадение Regex в строке. Обычно создаётся функцией match.

Поле match хранит подстроку всей совпавшей строки. Поле captures хранит подстроки для каждой группы захвата, индексированные по номеру. Для индексации по имени группы захвата следует индексировать весь объект совпадения, как показано в примерах. Положение начала совпадения хранится в поле offset. Поле offsets хранит позиции начала каждой группы захвата, при этом 0 обозначает группу, которая не была захвачена.

Этот тип может использоваться как итератор по группам захвата Regex, возвращая подстроки, захваченные в каждой группе. Благодаря этому захваченные группы совпадения можно распаковать. Если группа не была захвачена, то вместо подстроки будет возвращаться nothing.

Методы, принимающие объект RegexMatch, определены для iterate, length, eltype, keys, haskey и getindex, где ключами являются имена или номера группы захвата. Более подробную информацию см. в keys.

Примеры

julia> m = match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30 in the morning")
RegexMatch("11:30", hour="11", minute="30", 3=nothing)

julia> hr, min, ampm = m;

julia> hr
"11"

julia> m["minute"]
"30"

julia> m.match
"11:30"

keys(m::RegexMatch) -> Vector

Возвращает вектор ключей для всех групп захвата базового регулярного выражения. Ключ включается даже если группа захвата не найдена. То есть idx будет в возвращаемом значении, даже если m[idx] == nothing.

У неименованных групп захвата будут целочисленные ключи, соответствующие их индексу. У именованных групп захвата будут строковые ключи.

Примеры

julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
  "hour"
  "minute"
 3

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

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

Примеры

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

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

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

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

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

Примеры

julia> "abc" == "abc"
true

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

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

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

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

Примеры

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

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

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

Примеры

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

findfirst(pattern::AbstractString, string::AbstractString)
findfirst(pattern::AbstractPattern, string::String)

Находит первое вхождение pattern в string. Эквивалентно findnext(pattern, string, firstindex(s)).

Примеры

julia> findfirst("z", "Hello to the world") # returns nothing, but not printed in the REPL

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

findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::AbstractPattern, string::String, start::Integer)

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

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

findnext("substring", string, i) == start:stop так, что string[start:stop] == "substring" и i <= start, или nothing если не найдено совпадение.

Примеры

julia> findnext("z", "Hello to the world", 1) === nothing
true

julia> findnext("o", "Hello to the world", 6)
8:8

julia> findnext("Lang", "JuliaLang", 2)
6:9

findnext(ch::AbstractChar, string::AbstractString, start::Integer)

Найдите следующее вхождение символа ch в string, начиная с позиции start.

Примеры

julia> findnext('z', "Hello to the world", 1) === nothing
true

julia> findnext('o', "Hello to the world", 6)
8

findlast(pattern::AbstractString, string::AbstractString)

Найдите последнее вхождение pattern в string. Эквивалентно findprev(pattern, string, lastindex(string)).

Примеры

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

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

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

Найдите последнее вхождение символа ch в string.

Примеры

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

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

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

Найдите предыдущее вхождение pattern в string, начиная с позиции start.

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

findprev("substring", string, i) == start:stop таким образом, что string[start:stop] == "substring" и stop <= i, или nothing в случае отсутствия совпадения.

Примеры

julia> findprev("z", "Hello to the world", 18) === nothing
true

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

julia> findprev("Julia", "JuliaLang", 6)
1:5

occursin(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)

Определяет, является ли первый аргумент подстрокой второго. Если needle является регулярным выражением, проверяет, содержит ли haystack соответствие.

Примеры

julia> occursin("Julia", "JuliaLang is pretty cool!")
true

julia> occursin('a', "JuliaLang is pretty cool!")
true

julia> occursin(r"a.a", "aba")
true

julia> occursin(r"a.a", "abba")
false

См. также contains.

occursin(haystack)

Создайте функцию, которая проверяет, содержится ли её аргумент в haystack, т.е. функция, эквивалентная needle -> occursin(needle, haystack).

Возвращаемая функция имеет тип Base.Fix2{typeof(occursin)}.

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") # hat is above x in the input, above e in the output
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # reverses graphemes; hat is above x in both in- and output
"ex̂a"

replace(s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

Поиск заданного шаблона pat в s, и замена каждого вхождения на r. Если count задано, заменяется не более count вхождений. pat может быть одиночным символом, вектором или множеством символов, строкой или регулярным выражением. Если r является функцией, каждое вхождение заменяется на r(s) где s — совпавшая подстрока (когда pat является AbstractPattern или AbstractString или символом (когда pat является AbstractChar или набором AbstractChar). Если r является регулярным выражением, а 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."

julia> replace("abcabc", "a" => "b", "b" => "c", r".+" => "a")
"bca"

eachsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

Разделяет str по вхождениям разделителя(ей) dlm и возвращает итератор по подстрокам. dlm может быть в любом из форматов, разрешенных первым аргументом findnext (т.е. строкой, регулярным выражением или функцией), или одиночным символом или набором символов.

Если dlm опущено, оно по умолчанию равно isspace.

Дополнительные ключевые аргументы:

• limit: максимальный размер результата. limit=0 означает отсутствие максимального размера (по умолчанию)
• keepempty: должны ли пустые поля храниться в результате. По умолчанию false без аргумента dlm, true с аргументом dlm.

См. также split.

Примеры

julia> a = "Ma.rch"
"Ma.rch"

julia> b = eachsplit(a, ".")
Base.SplitIterator{String, String}("Ma.rch", ".", 0, true)

julia> collect(b)
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

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

Примеры

julia> a = "Ma.rch"
"Ma.rch"

julia> split(a, ".")
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

rsplit(s::AbstractString; limit::Integer=0, keepempty::Bool=false)
rsplit(s::AbstractString, chars; limit::Integer=0, keepempty::Bool=true)

Аналогично split, но начиная с конца строки.

Примеры

julia> a = "M.a.r.c.h"
"M.a.r.c.h"

julia> rsplit(a, ".")
5-element Vector{SubString{String}}:
 "M"
 "a"
 "r"
 "c"
 "h"

julia> rsplit(a, "."; limit=1)
1-element Vector{SubString{String}}:
 "M.a.r.c.h"

julia> rsplit(a, "."; limit=2)
2-element Vector{SubString{String}}:
 "M.a.r.c"
 "h"

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

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

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

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

См. также lstrip и rstrip.

Примеры

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

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

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

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

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

См. также strip и rstrip.

Примеры

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

julia> lstrip(a)
"March"

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

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

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

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

См. также strip и lstrip.

Примеры

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

julia> rstrip(a)
"March"

startswith(s::AbstractString, prefix::AbstractString)

Возвратить true если s начинается с prefix. Если prefix является вектором или множеством символов, проверить, принадлежит ли первый символ s этому множеству.

См. также endswith, contains.

Примеры

julia> startswith("JuliaLang", "Julia")
true

startswith(prefix)

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

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

Примеры

julia> startswith("Julia")("JuliaLang")
true

julia> startswith("Julia")("Ends with Julia")
false

startswith(s::AbstractString, prefix::Regex)

Возвратить true если s начинается с шаблона регулярного выражения prefix.

См. также occursin и endswith.

Примеры

julia> startswith("JuliaLang", r"Julia|Romeo")
true

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

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

См. также startswith, contains.

Примеры

julia> endswith("Sunday", "day")
true

endswith(suffix)

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

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

Примеры

julia> endswith("Julia")("Ends with Julia")
true

julia> endswith("Julia")("JuliaLang")
false

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

Возвратить true если s заканчивается на шаблоне регулярного выражения suffix.

См. также occursin и startswith.

Примеры

julia> endswith("JuliaLang", r"Lang|Roberts")
true

contains(haystack::AbstractString, needle)

Возвратить true если haystack содержит needle. Это то же самое, что и occursin(needle, haystack), но предоставляется для согласованности с startswith(haystack, needle) и endswith(haystack, needle).

См. также occursin, in, issubset.

Примеры

julia> contains("JuliaLang is pretty cool!", "Julia")
true

julia> contains("JuliaLang is pretty cool!", 'a')
true

julia> contains("aba", r"a.a")
true

julia> contains("abba", r"a.a")
false

contains(needle)

Создать функцию, которая проверяет, содержит ли ее аргумент needle, т.е. функцию, эквивалентную haystack -> contains(haystack, needle).

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

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

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

Примеры

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

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

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

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

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

Примеры

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

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

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

uppercase(c::AbstractChar)

Преобразовать c в верхний регистр.

См. также lowercase, titlecase.

Примеры

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> uppercase('ê')
'Ê': Unicode U+00CA (category Lu: Letter, uppercase)

uppercase(s::AbstractString)

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

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

Примеры

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

Преобразовать c в нижний регистр.

См. также uppercase, titlecase.

Примеры

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)

lowercase(s::AbstractString)

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

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

Примеры

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

titlecase(c::AbstractChar)

Преобразовать c в заглавный регистр. Это может отличаться от верхнего регистра для диграфов, сравните пример ниже.

См. также uppercase, lowercase.

Примеры

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (category Lt: Letter, titlecase)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (category Lu: Letter, uppercase)

titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

Преобразовать первую букву каждого слова в s; если strict имеет значение true, каждый второй символ преобразуется в нижний регистр, в противном случае они остаются без изменений. По умолчанию все символы, не являющиеся буквами, начинающие новое графемное объединение, считаются разделителями слов; предикат может быть передан в качестве ключевого слова wordsep, чтобы определить, какие символы должны считаться разделителями слов. Смотрите также uppercasefirst, чтобы преобразовать только первую букву в s.

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

Примеры

julia> titlecase("the JULIA programming language")
"The Julia Programming Language"

julia> titlecase("ISS - international space station", strict=false)
"ISS - International Space Station"

julia> titlecase("a-a b-b", wordsep = c->c==' ')
"A-a B-b"

uppercasefirst(s::AbstractString) -> String

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

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

Примеры

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

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

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

Примеры

julia> lowercasefirst("Julia")
"julia"

join([io::IO,] iterator [, delim [, last]])

Объединяет любые iterator в одну строку, вставляя заданный разделитель (если он есть) между соседними элементами. Если last задано, оно будет использоваться вместо delim между последними двумя элементами. Каждый элемент iterator преобразуется в строку с помощью print(io::IOBuffer, x). Если io задано, результат записывается в io, а не возвращается как String.

Примеры

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

julia> join([1,2,3,4,5])
"12345"

chop(s::AbstractString; head::Integer = 0, tail::Integer = 1)

Удаляет первый head и последний tail символы из s. Вызов chop(s) удаляет последний символ из s. Если запрашивается удаление больше символов, чем length(s), возвращается пустая строка.

См. также chomp, startswith, first.

Примеры

julia> a = "March"
"March"

julia> chop(a)
"Marc"

julia> chop(a, head = 1, tail = 2)
"ar"

julia> chop(a, head = 5, tail = 5)
""

chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex}) -> SubString

Удаляет префикс prefix из s. Если s не начинается с prefix, возвращается строка, равная s.

См. также chopsuffix.

Примеры

julia> chopprefix("Hamburger", "Ham")
"burger"

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"

chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex}) -> SubString

Удаляет суффикс suffix из s. Если s не заканчивается на suffix, возвращается строка, равная s.

См. также chopprefix.

Примеры

julia> chopsuffix("Hamburger", "er")
"Hamburg"

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"

chomp(s::AbstractString) -> SubString

Удаляет единственный заключительный символ новой строки из строки.

См. также chop.

Примеры

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

thisind(s::AbstractString, i::Integer) -> Int

Если i находится в пределах s, вернуть индекс начала символа, кодовая единица которого i является частью. Другими словами, если i — начало символа, вернуть i; если i — не начало символа, откатиться до начала символа и вернуть этот индекс. Если i равно 0 или ncodeunits(s)+1, вернуть i. Во всех других случаях выбросить BoundsError.

Примеры

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

julia> thisind("α", 4)
ERROR: BoundsError: attempt to access 2-codeunit String at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access 2-codeunit String at index [-1]
[...]

nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• Случай n == 1

  Если i находится в пределах s вернуть индекс начала символа, кодировка которого начинается после индекса i. Другими словами, если i — начало символа, вернуть начало следующего символа; если i — не начало символа, перейти вперёд до начала символа и вернуть этот индекс. Если i равно 0 вернуть 1. Если i находится в пределах, но больше или равно lastindex(str), вернуть ncodeunits(str)+1. В противном случае выбросить BoundsError.

• Случай n > 1

  Поведение аналогично применению n раз nextind для n==1. Единственное отличие заключается в том, что если n настолько велико, что применение nextind достигнет ncodeunits(str)+1, то каждая оставшаяся итерация увеличивает возвращаемое значение на 1. Это означает, что в этом случае nextind может вернуть значение, большее, чем ncodeunits(str)+1.

• Случай n == 0

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

Примеры

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

julia> nextind("α", 3)
ERROR: BoundsError: attempt to access 2-codeunit String at index [3]
[...]

julia> nextind("α", 0, 2)
3

julia> nextind("α", 1, 2)
4

prevind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• Случай n == 1

  Если i находится в пределах s, вернуть индекс начала символа, кодировка которого начинается до индекса i. Другими словами, если i является началом символа, вернуть начало предыдущего символа; если i не является началом символа, откатиться до начала символа и вернуть этот индекс. Если i равно 1, вернуть 0. Если i равно ncodeunits(str)+1, вернуть lastindex(str). В противном случае выбросить BoundsError.

• Случай n > 1

  Ведет себя как применение n раз prevind для n==1. Единственное отличие в том, что если n настолько велико, что применение prevind достигнет 0, то каждое оставшееся повторение уменьшает возвращаемое значение на 1. Это означает, что в этом случае prevind может вернуть отрицательное значение.

• Случай n == 0

  Вернуть i только если i является допустимым индексом в str или равен ncodeunits(str)+1. В противном случае выбросить StringIndexError или BoundsError.

Примеры

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

julia> prevind("α", 0)
ERROR: BoundsError: attempt to access 2-codeunit String at index [0]
[...]

julia> prevind("α", 2, 2)
0

julia> prevind("α", 2, 3)
-1

textwidth(c)

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

Примеры

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

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

Примеры

julia> textwidth("March")
5

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

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

Примеры

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

Например, isascii может использоваться в качестве предикатной функции для filter или replace для удаления или замены, соответственно, не-ASCII символов:

julia> filter(isascii, "abcdeγfgh") # discard non-ASCII chars
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # replace non-ASCII chars with spaces
"abcde fgh"

iscntrl(c::AbstractChar) -> Bool

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

Примеры

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

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

См. также: isletter.

Примеры

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

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

См. также: isdigit.

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

Проверяет, является ли символ строчной буквой (в соответствии с производным свойством Unicode Lowercase).

См. также isuppercase.

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

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

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

Примеры

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

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

Примеры

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

Проверяет, принадлежит ли символ универсальной категории Unicode Punctuation, т.е. символ, код категории которого начинается с 'P'.

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

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

Примеры

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

Проверяет, является ли символ заглавной буквой (в соответствии с производным свойством Unicode Uppercase).

См. также islowercase.

Примеры

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

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

Примеры

julia> isxdigit('a')
true

julia> isxdigit('x')
false

escape_string(str::AbstractString[, esc]; keep = ())::AbstractString
escape_string(io, str::AbstractString[, esc]; keep = ())::Nothing

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

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

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

Аргумент keep указывает набор символов, которые следует сохранить как есть. Обратите внимание, что esc имеет здесь приоритет.

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

Примеры

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

julia> escape_string("aaa\nbbb"; keep = '\n')
"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(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing

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

Распознаются следующие экранированные последовательности:

• Экранированный обратный слэш (\\)
• Экранированная двойная кавычка (\")
• Стандартные C-экранированные последовательности (\a, \b, \t, \n, \v, \f, \r, \e)
• Код точки кодирования Unicode BMP (\u с 1–4 шестнадцатеричными символами в качестве постфикса)
• Все точки кодирования Unicode (\U с 1–8 шестнадцатеричными символами в качестве постфикса; максимальное значение = 0010ffff)
• Шестнадцатеричные байты (\x с 1–2 шестнадцатеричными символами в качестве постфикса)
• Восьмеричные байты (\ с 1–3 восьмеричными символами в качестве постфикса)

См. также escape_string.

Примеры

julia> unescape_string("aaa\\nbbb") # C escape sequence
"aaa\nbbb"

julia> unescape_string("\\u03c0") # unicode
"π"

julia> unescape_string("\\101") # octal
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # using `keep` argument
"aaa \\g \n"