Строки

Core.AbstractCharТип

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

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

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

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

Core.CharТип

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

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

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

Base.codepointФункция

codepoint(c::AbstractChar) -> Integer

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

Base.lengthМетод

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

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

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

Примеры

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

Base.sizeofМетод

sizeof(str::AbstractString)

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

Примеры

julia> sizeof("")
0

julia> sizeof("∀")
3

Base.:*Метод

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

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

Примеры

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

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

Base.:^Метод

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

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

См. также: repeat

Примеры

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

Base.stringФункция

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

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

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

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

string(xs...)

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

Примеры

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

Base.repeatМетод

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

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

См. также: ^

Примеры

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

Base.repeatМетод

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

Повторяет символ r раз. Это эквивалентно вызову c^r.

Примеры

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

Base.reprМетод

repr(x; context=nothing)

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

Необязательный ключевой аргумент context может быть установлен в объект IO или IOContext, атрибуты которого используются для потока ввода-вывода, переданного функции show.

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

Примеры

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"

Core.StringМетод

String(s::AbstractString)

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

Base.SubStringТип

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

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

Примеры

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

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

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

Base.transcodeФункция

transcode(T, src)

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

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

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

Base.unsafe_stringФункция

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

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

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

Base.ncodeunitsМетод

ncodeunits(s::AbstractString) -> Int

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

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

Base.codeunitФункция

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

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

См. также: ncodeunits

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

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

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

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

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

Base.codeunitsФункция

codeunits(s::AbstractString)

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

Base.asciiФункция

ascii(s::AbstractString)

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

Примеры

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

julia> ascii("abcdefgh")
"abcdefgh"

Base.@r_strМакрос

@r_str -> Regex

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

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

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

Примеры

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

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

Base.SubstitutionStringТип

SubstitutionString(substr)

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

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

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

julia> typeof(subst)
SubstitutionString{String}

Base.@s_strМакрос

@s_str -> SubstitutionString

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

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

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

Base.@raw_strМакрос

@raw_str -> String

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

Примеры

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

julia> println(raw"\"")
"

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

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

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

@html_str -> Docs.HTML

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

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

@text_str -> Docs.Text

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

Base.isvalidМетод

isvalid(value) -> Bool

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

Примеры

julia> isvalid(Char(0xd800))
false

julia> isvalid(Char(0xd799))
true

Base.isvalidМетод

isvalid(T, value) -> Bool

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

Значения для AbstractChar могут быть типа AbstractChar или UInt32. Значения для String могут быть этого типа или Vector{UInt8}.

Примеры

julia> isvalid(Char, 0xd800)
false

julia> isvalid(Char, 0xd799)
true

Base.isvalidМетод

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

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

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

Примеры

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

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

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError("αβγdef", 2)
Stacktrace:
[...]

Base.matchФункция

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

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

Примеры

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

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

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

julia> m.match
"aba"

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

Base.eachmatchФункция

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

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

Примеры

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

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator(r"a.a", "a1a2a3a", false)

julia> collect(m)
2-element Array{RegexMatch,1}:
 RegexMatch("a1a")
 RegexMatch("a3a")

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

Base.islessМетод

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

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

Примеры

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

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

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

Base.:==Метод

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

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

Примеры

julia> "abc" == "abc"
true

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

Base.cmpМетод

cmp(a::AbstractString, b::AbstractString) -> Int

Сравнение двух строк. Возвращает 0, если у обеих строк одинаковая длина и символ в каждом индексе одинаков в обеих строках. Возвращает -1, если a является префиксом b, или если a стоит перед b в алфавитном порядке. Возвращает 1, если b является префиксом a, или если b стоит перед a в алфавитном порядке (технически, в лексикографическом порядке по кодам Юникода).

Примеры

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

Base.lpadФункция

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

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

Примеры

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

Base.rpadФункция

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

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

Примеры

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

Base.findfirstМетод

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

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

Примеры

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

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

Base.findnextМетод

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

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

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

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

Примеры

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

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

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

Base.findlastМетод

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

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

Примеры

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

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

Base.findprevМетод

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

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

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

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

Примеры

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

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

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

Base.occursinФункция

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

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

Примеры

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

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

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

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

Base.reverseМетод

reverse(s::AbstractString) -> AbstractString

Инвертирует строку. Технически, эта функция инвертирует коды символов в строке, и её основное применение — для обработки строк в обратном порядке, особенно при поиске в обратном порядке по регулярному выражению. Также см. reverseind для преобразования индексов в s в индексы в reverse(s) и наоборот, и graphemes из модуля Unicode для работы с видимыми пользователю «символами» (графем) вместо кодов символов. Также см. Iterators.reverse для итерации в обратном порядке без создания копии. Пользовательские типы строк должны самостоятельно реализовывать функцию reverse, и, как правило, должны возвращать строку того же типа и кодирования. Если они возвращают строку с другим кодированием, они также должны переопределять reverseind для этого типа строки, чтобы удовлетворить s[reverseind(s,i)] == reverse(s)[i].

Примеры

julia> reverse("JuliaLang")
"gnaLailuJ"

julia> reverse("ax̂e") # combining characters can lead to surprising results
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # reverses graphemes
"ex̂a"

Base.replaceМетод

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

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

Примеры

julia> replace("Python is a programming language.", "Python" => "Julia")
"Julia is a programming language."

julia> replace("The quick foxes run quickly.", "quick" => "slow", count=1)
"The slow foxes run quickly."

julia> replace("The quick foxes run quickly.", "quick" => "", count=1)
"The  foxes run quickly."

julia> replace("The quick foxes run quickly.", r"fox(es)?" => s"bus\1")
"The quick buses run quickly."

Base.splitФункция

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

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

Если dlm опущено, по умолчанию используется isspace.

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

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

См. также rsplit.

Примеры

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

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

Base.rsplitФункция

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

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

Примеры

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

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

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

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

Base.stripФункция

strip(str::AbstractString, [chars])

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

Дополнительный аргумент chars указывает символы для удаления: это может быть одиночный символ, вектор или набор символов, или предикат-функция.

Примеры

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

Base.lstripФункция

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

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

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

Примеры

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

julia> lstrip(a)
"March"

Base.rstripФункция

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

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

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

Примеры

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

julia> rstrip(a)
"March"

Base.startswithФункция

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

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

См. также endswith.

Примеры

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

Base.endswithФункция

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

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

См. также startswith.

Примеры

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

Base.firstМетод

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

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

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

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

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

Base.lastМетод

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

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

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

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

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

Base.Unicode.uppercaseФункция

uppercase(s::AbstractString)

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

Примеры

julia> uppercase("Julia")
"JULIA"

Base.Unicode.lowercaseФункция

lowercase(s::AbstractString)

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

Примеры

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

Base.Unicode.titlecaseФункция

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

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

Примеры

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

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

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

Base.Unicode.uppercasefirstФункция

uppercasefirst(s::AbstractString) -> String

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

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

Примеры

julia> uppercasefirst("python")
"Python"

Base.Unicode.lowercasefirstФункция

lowercasefirst(s::AbstractString)

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

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

Примеры

julia> lowercasefirst("Julia")
"julia"

Base.joinФункция

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

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

Примеры

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

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

Base.chopФункция

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

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

Примеры

julia> a = "March"
"March"

julia> chop(a)
"Marc"

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

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

Base.chompФункция

chomp(s::AbstractString)

Удалить единственный символ новой строки в конце строки.

Примеры

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

Base.thisindФункция

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

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

Примеры

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

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

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

Base.nextindФункция

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

• Случай n == 1

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

• Случай n > 1

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

• Случай n == 0

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

Примеры

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

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

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

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

Base.previndФункция

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

• Случай n == 1

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

• Случай n > 1

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

• Случай n == 0

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

Примеры

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

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

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

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

Base.Unicode.textwidthФункция

textwidth(c)

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

Примеры

julia> textwidth('α')
1

julia> textwidth('❤')
2

textwidth(s::AbstractString)

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

Примеры

julia> textwidth("March")
5

Base.isasciiФункция

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

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

Примеры

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

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

iscntrl(c::AbstractChar) -> Bool

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

Примеры

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

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

isdigit(c::AbstractChar) -> Bool

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

Примеры

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

Base.Unicode.isletterФункция

isletter(c::AbstractChar) -> Bool

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

Примеры

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

Base.Unicode.islowercaseФункция

islowercase(c::AbstractChar) -> Bool

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

Примеры

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

Base.Unicode.isnumericФункция

isnumeric(c::AbstractChar) -> Bool

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

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

Примеры

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

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

isprint(c::AbstractChar) -> Bool

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

Примеры

julia> isprint('\x01')
false

julia> isprint('A')
true

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

ispunct(c::AbstractChar) -> Bool

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

Примеры

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

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

isspace(c::AbstractChar) -> Bool

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

Примеры

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

Base.Unicode.isuppercaseФункция

isuppercase(c::AbstractChar) -> Bool

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

Примеры

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

Base.Unicode.isxdigitФункция

isxdigit(c::AbstractChar) -> Bool

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

Примеры

julia> isxdigit('a')
true

julia> isxdigit('x')
false

Core.SymbolТип

Symbol

Тип объекта, используемого для представления идентификаторов в разобранном коде Julia (AST). Также часто используется как имя или метка для идентификации сущности (например, в качестве ключа словаря). Symbol можно ввести с помощью оператора :.

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

Symbol также можно создать из строк или других значений, вызвав конструктор Symbol(x...).

Symbol неизменяемы и должны сравниваться с помощью ===. Реализация повторно использует один и тот же объект для всех Symbol с одинаковым именем, поэтому сравнение обычно эффективно (можно просто сравнить указатели).

В отличие от строк, Symbol — это "атомарные" или "скалярные" сущности, которые не поддерживают итерацию по символам.

Base.escape_stringФункция

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

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

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

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

Примеры

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

julia> escape_string("\xfe\xff") # invalid utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # unambiguous
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 would be ambiguous
"ℵ\\x000"

См. также

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

Base.unescape_stringФункция

unescape_string(str::AbstractString)::AbstractString
unescape_string(io, str::AbstractString)::Nothing

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

Распознаются следующие escape-последовательности:

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

Примеры

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

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

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

См. также

escape_string.