Строки

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

Примеры

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} единиц кода 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.

Примеры

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

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

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]) <: AbstractPattern

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

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

@r_str -> Regex

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

• i включает регистронезависимое соответствие
• m рассматривает токены ^ и $ как соответствие началу и концу отдельных строк, в отличие от всей строки.
• s разрешает модификатор . для соответствия символам новой строки.
• x включает "режим комментариев": пробелы разрешены, за исключением случаев, когда они экранированы с помощью \, а # рассматривается как начало комментария.
• a включает режим ASCII (отключает режимы UTF и UCP). По умолчанию \B, \b, \D, \d, \S, \s, \W, \w, и т. д. соответствуют свойствам символов Юникода. С этим параметром эти последовательности соответствуют только символам ASCII. Это включает \u также, который выводит указанное значение символа непосредственно как одиночный байт, а не пытается закодировать его в UTF-8. Важно, что этот параметр позволяет сопоставлять некорректные UTF-8 строки, рассматривая как сопоставляемую строку, так и целевую строку как простые байты (как если бы они были байтами ISO/IEC 8859-1/Latin-1), а не как кодировки символов. В этом случае этот параметр часто используется в сочетании с s. Этот параметр может быть дополнительно уточнён, начав шаблон с (UCP) или (UTF).

См. Regex, если нужна интерполяция.

Примеры

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

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

SubstitutionString(substr) <: AbstractString

Хранит заданную строку 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) имеет значение true, то s[i] вернёт символ, кодирование которого начинается в этом индексе; если false, то 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 <: AbstractMatch

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

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

Этот тип можно использовать как итератор по группам захвата совпадения, возвращая подстроки, захваченные в каждой группе. Из-за этого захваты совпадения можно деструктурировать. Если группа не была захвачена, 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> m.match
"11:30"

julia> m.captures
3-element Vector{Union{Nothing, SubString{String}}}:
 "11"
 "30"
 nothing


julia> m["minute"]
"30"

julia> hr, min, ampm = m; # destructure capture groups by iteration

julia> hr
"11"

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

Примеры

julia> search_f = occursin("JuliaLang is a programming language");

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

Инвертирует строку. Технически, эта функция инвертирует кодпоинты в строке, и её основное применение — для обработки строк в обратном порядке, особенно для обратных поисков регулярных выражений. См. также reverseind для преобразования индексов в s в индексы в reverse(s) и наоборот, и graphemes из модуля write для работы с видимыми пользователю «символами» (графемными кластерами) вместо кодпоинтов. См. также 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([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

Найти заданный шаблон pat в s, и заменить каждое вхождение на r. Если count предоставлен, заменить не более count вхождений. pat может быть одиночным символом, вектором или множеством символов, строкой или регулярным выражением. Если r является функцией, каждое вхождение заменяется на r(s) , где s — совпадающая подстрока (когда pat является AbstractPattern или AbstractString) или символ (когда pat — AbstractChar или набор AbstractChar). Если pat — регулярное выражение, и r — SubstitutionString, то ссылки на группы захвата в r заменяются соответствующим сопоставленным текстом. Чтобы удалить вхождения pat из string, установите r в пустую String ("").

Возвращаемое значение — новая строка после замены. Если аргумент io::IO указан, преобразованная строка записывается вместо этого в io (возвращая io). (Например, это может быть использовано в сочетании с IOBuffer для повторного использования предварительно выделенного буферного массива на месте.)

Можно указать несколько шаблонов, и они будут применяться слева направо одновременно, поэтому к любому символу будет применено только один шаблон, и шаблоны будут применяться только к входному тексту, а не к замещениям.

Примеры

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(io::IO, prefix::Union{AbstractString,Base.Chars})

Проверить, начинается ли объект IO с префикса. См. также peek.

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

isascii(cu::AbstractVector{CU}) where {CU <: Integer} -> Bool

Проверяет, принадлежат ли все значения в векторе набору символов ASCII (0x00 до 0x7f). Эта функция предназначена для использования другими реализациями строк, которым нужен быстрый тест на ASCII.

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

См. также 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).

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

Обратные слэши (\) экранируются двойным обратным слэшем ("\\"). Непечатаемые символы экранируются стандартными C-эскейпами, "\0" для NUL (если недвусмысленно), юникодом кодовой точки ("\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-эскейпов и юникодных последовательностей. Первый вариант возвращает экранированную строку, второй выводит результат в io. Аргумент keep задаёт набор символов, которые (наряду с обратными слэшами) должны оставаться неизменными.

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

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