Строки

Base.lengthМетод

length(s::AbstractString)

Количество символов в строке s.

Пример

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

Base.sizeofМетод

sizeof(s::AbstractString)

Количество байтов в строке s.

Пример

julia> sizeof("❤")
3

Base.:*Метод

*(x, y...)

Оператор умножения. x*y*z*... вызывает эту функцию со всеми аргументами, т.е. *(x, y, z, ...).

Base.:^Метод

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

Повторить строку s n раз. Функция repeat является псевдонимом этого оператора.

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

Base.stringФункция

string(xs...)

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

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

Base.reprФункция

repr(x)

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

Core.StringМетод

String(s::AbstractString)

Преобразовать строку в непрерывный массив байтов, представленный кодировкой UTF-8. Такое представление часто подходит для передачи строк в C.

Base.transcodeФункция

transcode(T, src)

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

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

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

Base.unsafe_stringФункция

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

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

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

Base.codeunitМетод

codeunit(s::AbstractString, i::Integer)

Получить i-ю кодовую единицу закодированной строки. Например, возвращает i-й байт представления строки UTF-8.

Base.asciiФункция

ascii(s::AbstractString)

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

julia> ascii("abcdeγfgh")
ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
Stacktrace:
 [1] ascii(::String) at ./strings/util.jl:479

julia> ascii("abcdefgh")
"abcdefgh"

Base.@r_strМакрос

@r_str -> Regex

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

• i включает сопоставление без учёта регистра

• m обрабатывает токены ^ и $ как сопоставление начала и конца отдельных строк, а не всей строки.

• s позволяет модификатору . сопоставлять символы новой строки.

• x включает «режим комментариев»: пробелы разрешены, за исключением случаев, когда они экранированы с помощью \, а # обрабатывается как начало комментария.

Например, это регулярное выражение имеет все три флага, включенные:

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

Base.Docs.@html_strМакрос

@html_str -> Docs.HTML

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

Base.Docs.@text_strМакрос

@text_str -> Docs.Text

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

Base.UTF8proc.normalize_stringФункция

normalize_string(s::AbstractString, normalform::Symbol)

Нормализовать строку s в соответствии с одной из четырёх «нормальных форм» стандарта Юникода: normalform может быть :NFC, :NFD, :NFKC, или :NFKD. Нормальные формы C (каноническое объединение) и D (каноническое разложение) преобразуют различные визуально идентичные представления одной и той же абстрактной строки в единую каноническую форму, форма C более компактна. Нормальные формы KC и KD дополнительно канонизируют «совместимые эквиваленты»: они преобразуют символы, которые абстрактно похожи, но визуально отличаются, в один канонический выбор (например, они расширяют лигатуры до отдельных символов), форма KC более компактна.

Альтернативно, более тонкий контроль и дополнительные преобразования могут быть получены путём вызова normalize_string(s; keywords...), где указано любое количество следующих логических ключевых слов (по умолчанию все false, за исключением compose) :

• compose=false: не выполнять каноническое объединение

• decompose=true: выполнить каноническое разложение вместо канонического объединения (compose=true игнорируется, если присутствует)

• compat=true: совместимые эквиваленты канонизируются

• casefold=true: выполнить Unicode-преобразование в нижний регистр, например, для сопоставления строк без учёта регистра

• newline2lf=true, newline2ls=true, или newline2ps=true: преобразуют различные последовательности новых строк (LF, CRLF, CR, NEL) в символ новой строки (LF), символ разрыва строки (LS) или символ разрыва абзаца (PS), соответственно

• stripmark=true: удалить диакритические знаки (например, ударения)

• stripignore=true: удалить «стандартно игнорируемые» символы Юникода (например, мягкий дефис или маркер слева направо)

• stripcc=true: удалить управляющие символы; горизонтальные табуляции и переводы страниц преобразуются в пробелы; новые строки также преобразуются в пробелы, за исключением случаев, когда был указан флаг преобразования новой строки

• rejectna=true: выбросить ошибку, если найдены неназначенные кодовые точки

• stable=true: обеспечить стабильность версии Юникода

Например, NFKC соответствует опциям compose=true, compat=true, stable=true.

Base.UTF8proc.graphemesФункция

graphemes(s::AbstractString) -> GraphemeIterator

Возвращает итератор по подстрокам s, которые соответствуют расширенным графемам в строке, как определено в Unicode UAX #29. (Грубо говоря, это то, что пользователи воспринимают как отдельные символы, хотя они могут содержать более одной кодовой точки; например, буква, сочетающаяся с диакритическим знаком, является одной графемой.)

Base.isvalidМетод

isvalid(value) -> Bool

Возвращает true, если заданное значение является допустимым для своего типа, в настоящее время это может быть Char или String.

Base.isvalidМетод

isvalid(T, value) -> Bool

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

Base.isvalidМетод

isvalid(str::AbstractString, i::Integer)

Определяет, является ли индекс i допустимым для данной строки.

Примеры

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: UnicodeError: invalid character index
[...]

Base.UTF8proc.is_assigned_charФункция

is_assigned_char(c) -> Bool

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

Base.ismatchФункция

ismatch(r::Regex, s::AbstractString) -> Bool

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

Base.matchФункция

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

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

Base.eachmatchФункция

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

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

Base.matchallФункция

matchall(r::Regex, s::AbstractString[, overlap::Bool=false]) -> Vector{AbstractString}

Возвращает вектор совпадающих подстрок из eachmatch.

Base.lpadФункция

lpad(s, n::Integer, p::AbstractString=" ")

Создает строку, по крайней мере, n символов в ширину при выводе, заполняя s слева копиями p.

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

Base.rpadФункция

rpad(s, n::Integer, p::AbstractString=" ")

Создает строку, по крайней мере, n символов в ширину при выводе, заполняя s справа копиями p.

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

Base.searchФункция

search(string::AbstractString, chars::Chars, [start::Integer])

Поиск первого вхождения заданных символов в заданной строке. Второй аргумент может быть одиночным символом, вектором или набором символов, строкой или регулярным выражением (хотя регулярные выражения разрешены только для непрерывных строк, таких как ASCII или UTF-8). Третий аргумент необязательно задаёт начальный индекс. Возвращаемое значение — диапазон индексов, где найдена совпадающая последовательность, такой что s[search(s,x)] == x.

search(string, "substring") = start:end при условии string[start:end] == "substring", или 0:-1 при отсутствии совпадения.

search(string, 'c') = index при условии string[index] == 'c', или 0 при отсутствии совпадения.

julia> search("Hello to the world", "z")
0:-1

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

Base.rsearchФункция

rsearch(s::AbstractString, chars::Chars, [start::Integer])

Аналогично search, но возвращает последнее вхождение заданных символов в данной строке, выполняя поиск в обратном порядке с start.

julia> rsearch("aaabbb","b")
6:6

Base.searchindexФункция

searchindex(s::AbstractString, substring, [start::Integer])

Аналогично search, но возвращает только начальный индекс, где найдена подстрока, или 0 , если её нет.

julia> searchindex("Hello to the world", "z")
0

julia> searchindex("JuliaLang","Julia")
1

julia> searchindex("JuliaLang","Lang")
6

Base.rsearchindexФункция

rsearchindex(s::AbstractString, substring, [start::Integer])

Аналогично rsearch, но возвращает только начальный индекс, где найдена подстрока, или 0 , если её нет.

julia> rsearchindex("aaabbb","b")
6

julia> rsearchindex("aaabbb","a")
3

Base.containsМетод

contains(haystack::AbstractString, needle::AbstractString)

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

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

Base.reverseМетод

reverse(s::AbstractString) -> AbstractString

Инвертирует строку.

julia> reverse("JuliaLang")
"gnaLailuJ"

Base.replaceФункция

replace(string::AbstractString, pat, r[, n::Integer=0])

Поиск заданного шаблона pat, и замена каждого вхождения на r. Если n предоставлен, заменяется не более n вхождений. Как и в случае с поиском, второй аргумент может быть одиночным символом, вектором или набором символов, строкой или регулярным выражением. Если r является функцией, каждое вхождение заменяется на r(s), где s - совпадающая подстрока. Если pat является регулярным выражением и r является SubstitutionString, то ссылки на группы захвата в r заменяются соответствующим совпадающим текстом.

Base.splitФункция

split(s::AbstractString, [chars]; limit::Integer=0, keep::Bool=true)

Возвращает массив подстрок, разделив заданную строку на вхождения заданных символов-разделителей, которые могут быть указаны в любом формате, разрешенном вторым аргументом search (т.е. одиночным символом, коллекцией символов, строкой или регулярным выражением). Если chars опущен, он по умолчанию устанавливается на множество всех пробельных символов, и keep принимается как false.

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

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

Base.rsplitФункция

rsplit(s::AbstractString, [chars]; limit::Integer=0, keep::Bool=true)

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

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

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

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

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

Base.stripФункция

strip(s::AbstractString, [chars::Chars])

Возвращает s со всеми начальными и конечными пробелами удалёнными. Если chars (символ или набор символов) предоставлен, вместо этого удаляются символы, содержащиеся в нём.

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

Base.lstripФункция

lstrip(s::AbstractString[, chars::Chars])

Возвращает s с удалением всех начальных пробелов и разделителей. По умолчанию удаляются разделители ' ', \t, \n, \v, \f, и \r. Если предоставлен chars (символ, или вектор или множество символов), вместо этого удаляются символы, содержащиеся в нём.

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

julia> lstrip(a)
"March"

Base.rstripФункция

rstrip(s::AbstractString[, chars::Chars])

Возвращает s с удалением всех конечных пробелов и разделителей. По умолчанию удаляются разделители ' ', \t, \n, \v, \f, и \r. Если предоставлен chars (символ, или вектор или множество символов), вместо этого удаляются символы, содержащиеся в нём.

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

julia> rstrip(a)
"March"

Base.startswithФункция

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

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

См. также endswith.

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

Base.endswithФункция

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

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

См. также startswith.

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

Base.uppercaseФункция

uppercase(s::AbstractString)

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

Пример

julia> uppercase("Julia")
"JULIA"

Base.lowercaseФункция

lowercase(s::AbstractString)

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

Пример

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

Base.titlecaseФункция

titlecase(s::AbstractString)

Преобразует первый символ каждого слова в s в верхний регистр.

Пример

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

Base.ucfirstФункция

ucfirst(s::AbstractString)

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

Пример

julia> ucfirst("python")
"Python"

Base.lcfirstФункция

lcfirst(s::AbstractString)

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

Пример

julia> lcfirst("Julia")
"julia"

Base.joinФункция

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

Объединяет массив strings в одну строку, вставляя указанный разделитель между соседними строками. Если last задано, оно будет использоваться вместо delim между двумя последними строками. Например,

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

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

Base.chopФункция

chop(s::AbstractString)

Удаляет последний символ из s.

julia> a = "March"
"March"

julia> chop(a)
"Marc"

Base.chompФункция

chomp(s::AbstractString)

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

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

Base.ind2chrФункция

ind2chr(s::AbstractString, i::Integer)

Преобразует индекс байта i в индекс символа относительно строки s.

См. также chr2ind.

Пример

julia> str = "αβγdef";

julia> ind2chr(str, 3)
2

julia> chr2ind(str, 2)
3

Base.chr2indФункция

chr2ind(s::AbstractString, i::Integer)

Преобразует индекс символа i в индекс байта.

См. также ind2chr.

Пример

julia> str = "αβγdef";

julia> chr2ind(str, 2)
3

julia> ind2chr(str, 3)
2

Base.nextindФункция

nextind(str::AbstractString, i::Integer)

Получает следующий допустимый индекс строки после i. Возвращает значение, большее endof(str) в конце или после конца строки.

Примеры

julia> str = "αβγdef";

julia> nextind(str, 1)
3

julia> endof(str)
9

julia> nextind(str, 9)
10

Base.previndФункция

prevind(str::AbstractString, i::Integer)

Получает предыдущий допустимый индекс строки перед i. Возвращает значение, меньшее 1 в начале строки.

Примеры

julia> prevind("αβγdef", 3)
1

julia> prevind("αβγdef", 1)
0

Base.Random.randstringФункция

randstring([rng,] len=8)

Создаёт случайную строку ASCII длиной len, состоящую из прописных и строчных букв и цифр от 0 до 9. Дополнительный аргумент rng определяет генератор случайных чисел, см. Случайные числа.

Пример

julia> rng = MersenneTwister(1234);

julia> randstring(rng, 4)
"mbDd"

Base.UTF8proc.charwidthФункция

charwidth(c)

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

Base.strwidthФункция

strwidth(s::AbstractString)

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

Пример

julia> strwidth("March")
5

Base.UTF8proc.isalnumФункция

isalnum(c::Char) -> Bool

Проверяет, является ли символ буквенно-цифровым. Символ считается буквенным, если он принадлежит к категории Unicode «Буква» или «Цифра», то есть, если код категории символа начинается с 'L' или 'N'.

Base.UTF8proc.isalphaФункция

isalpha(c::Char) -> Bool

Проверяет, является ли символ буквенным. Символ считается буквенным, если он принадлежит к категории Unicode «Буква», то есть, если код категории символа начинается с 'L'.

Base.isasciiФункция

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

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

Base.UTF8proc.iscntrlФункция

iscntrl(c::Char) -> Bool

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

Base.UTF8proc.isdigitФункция

isdigit(c::Char) -> Bool

Проверяет, является ли символ числовым разрядом (0-9).

Base.UTF8proc.isgraphФункция

isgraph(c::Char) -> Bool

Проверяет, является ли символ печатным (не пробелом). Любой символ, который заставит принтер использовать чернила, должен быть классифицирован как isgraph(c)==true.

Base.UTF8proc.islowerФункция

islower(c::Char) -> Bool

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

Base.UTF8proc.isnumberФункция

isnumber(c::Char) -> Bool

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

Base.UTF8proc.isprintФункция

isprint(c::Char) -> Bool

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

Base.UTF8proc.ispunctФункция

ispunct(c::Char) -> Bool

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

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

isspace(c::Char) -> Bool

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

Base.UTF8proc.isupperФункция

isupper(c::Char) -> Bool

Проверяет, является ли символ заглавной буквой. Символ классифицируется как заглавная буква, если он принадлежит к категории Unicode Lu, Буква: Заглавная, или Lt, Буква: Заголовок.

Base.isxdigitФункция

isxdigit(c::Char) -> Bool

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

Пример

julia> isxdigit('a')
true

julia> isxdigit('x')
false

Core.SymbolТип

Symbol(x...) -> Symbol

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

Base.escape_stringФункция

escape_string([io,] str::AbstractString[, esc::AbstractString]) -> AbstractString

Общая эскапизация традиционных C и Unicode escape-последовательностей. Любые символы в esc также эскапируются (с обратной косой чертой). См. также unescape_string.

Base.unescape_stringФункция

unescape_string([io,] s::AbstractString) -> AbstractString

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