unicode

Этот модуль предоставляет поддержку обработки кодировки Unicode UTF-8.

В этом модуле нет специализированных insert, delete, add и contains процедур для seq[Rune] , так как общие варианты этих процедур в системном модуле уже работают с ней.

Текущая версия совместима с Unicode v12.0.0.

См. также:

• модуль strutils
• модуль unidecode
• модуль encodings

Типы

Rune = distinct RuneImpl

Тип, который может содержать один символ Unicode.

Один символ может быть составлен из других символов для отображения на экране. RuneImpl — это базовый тип, используемый для хранения символов, в настоящее время это int32.

Исходный код Редактировать

Процедуры

proc runeLen(s: string): int {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Возвращает количество рун в строке s.

Пример:

let a = "añyóng"
doAssert a.runeLen == 6
## note: a.len == 8

Исходный код Редактировать

proc runeLenAt(s: string; i: Natural): int {...}{.raises: [], tags: [].}

Возвращает количество байтов, занимаемых руной, начиная с s[i].

См. также:

• шаблон fastRuneAt

Пример:

let a = "añyóng"
doAssert a.runeLenAt(0) == 1
doAssert a.runeLenAt(1) == 2

Исходный код Редактировать

proc runeAt(s: string; i: Natural): Rune {...}{.raises: [], tags: [].}

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

См. также:

• процедура runeAtPos
• процедура runeStrAtPos
• шаблон fastRuneAt

Пример:

let a = "añyóng"
doAssert a.runeAt(1) == "ñ".runeAt(0)
doAssert a.runeAt(2) == "ñ".runeAt(1)
doAssert a.runeAt(3) == "y".runeAt(0)

Исходный код Редактировать

proc validateUtf8(s: string): int {...}{.raises: [], tags: [].}

Возвращает позицию некорректного байта в s если строка s не содержит корректные данные UTF-8. В противном случае возвращается -1.

См. также:

• процедура toUTF8
• $ proc псевдоним для toUTF8
• шаблон fastToUTF8Copy

Исходный код Редактировать

proc toUTF8(c: Rune): string {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Преобразует руну в её представление UTF-8.

См. также:

• процедура validateUtf8
• $ proc псевдоним для toUTF8
• итератор utf8
• шаблон fastToUTF8Copy

Пример:

let a = "añyóng"
doAssert a.runeAt(1).toUTF8 == "ñ"

Исходный код Редактировать

proc add(s: var string; c: Rune) {...}{.raises: [], tags: [].}

Добавляет руну c к строке s.

Пример:

var s = "abc"
let c = "ä".runeAt(0)
s.add(c)
doAssert s == "abcä"

Исходный код Редактировать

proc `$`(rune: Rune): string {...}{.raises: [], tags: [].}

Псевдоним для toUTF8.

См. также:

• процедура validateUtf8
• шаблон fastToUTF8Copy

Исходный код Редактировать

proc `$`(runes: seq[Rune]): string {...}{.raises: [], tags: [].}

Преобразует последовательность рун в строку.

См. также:

• toRunes для обратной операции

Пример:

let
  someString = "öÑ"
  someRunes = toRunes(someString)
doAssert $someRunes == someString

Исходный код Редактировать

proc runeOffset(s: string; pos: Natural; start: Natural = 0): int {...}{.raises: [],
    tags: [].}

Возвращает байтовую позицию руны в позиции pos в s с необязательной начальной байтовой позицией. Возвращает специальное значение -1, если выходит за пределы строки.

Внимание: Это может привести к неэффективному коду и медленной работе! Большинство проблем можно решить более эффективно с использованием итератора или преобразования в массив рун.

См. также:

• процедура runeReverseOffset

Пример:

let a = "añyóng"
doAssert a.runeOffset(1) == 1
doAssert a.runeOffset(3) == 4
doAssert a.runeOffset(4) == 6

Исходный код Редактировать

proc runeReverseOffset(s: string; rev: Positive): (int, int) {...}{.raises: [],
    tags: [].}

Возвращает кортеж с байтовой позицией руны в позиции rev в s, считая с конца (начиная с 1) и общее количество рун в строке.

Возвращает отрицательное значение для смещения, если в строке недостаточно рун для удовлетворения запроса.

Внимание: Это может привести к неэффективному коду и медленной работе! Большинство проблем можно решить более эффективно с использованием итератора или преобразования в массив рун.

См. также:

• процедура runeOffset

Исходный код Редактировать

proc runeAtPos(s: string; pos: int): Rune {...}{.raises: [], tags: [].}

Возвращает руну в позиции pos.

Внимание: Это может привести к неэффективному коду и медленной работе! Большинство проблем можно решить более эффективно с использованием итератора или преобразования в массив рун.

См. также:

• процедура runeAt
• процедура runeStrAtPos
• шаблон fastRuneAt

Исходный код Редактировать

proc runeStrAtPos(s: string; pos: Natural): string {...}{.raises: [], tags: [].}

Возвращает руну в позиции pos как строку UTF8.

Внимание: Это может привести к неэффективному коду и медленной работе! Большинство проблем можно решить более эффективно с использованием итератора или преобразования в массив рун.

См. также:

• процедура runeAt
• процедура runeAtPos
• шаблон fastRuneAt

Исходный код Редактировать

proc runeSubStr(s: string; pos: int; len: int = int.high): string {...}{.raises: [],
    tags: [].}

Возвращает подстроку UTF-8, начиная с кодовой точки pos с len кодовыми точками.

Если pos или len отрицательны, они считаются с конца строки. Если len не задано, это означает наибольшую возможную строку.

Пример:

let s = "Hänsel  ««: 10,00€"
doAssert(runeSubStr(s, 0, 2) == "Hä")
doAssert(runeSubStr(s, 10, 1) == ":")
doAssert(runeSubStr(s, -6) == "10,00€")
doAssert(runeSubStr(s, 10) == ": 10,00€")
doAssert(runeSubStr(s, 12, 5) == "10,00")
doAssert(runeSubStr(s, -6, 3) == "10,")

Исходный код Редактировать

proc `<=%`(a, b: Rune): bool {...}{.raises: [], tags: [].}

Проверяет, меньше ли или равно кодовая точка a кодовой точке b.

Пример:

let
  a = "ú".runeAt(0)
  b = "ü".runeAt(0)
doAssert a <=% b

Исходный код Редактировать

proc `<%`(a, b: Rune): bool {...}{.raises: [], tags: [].}

Проверяет, меньше ли кодовая точка a кодовой точки b.

Пример:

let
  a = "ú".runeAt(0)
  b = "ü".runeAt(0)
doAssert a <% b

Исходный код Редактировать

proc `==`(a, b: Rune): bool {...}{.raises: [], tags: [].}

Проверяет, равны ли две руны. Исходный код Редактировать

proc toLower(c: Rune): Rune {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Преобразует c в нижний регистр. Это работает для любой руны.

Если возможно, используйте toLower вместо toUpper.

См. также:

• процедура toUpper
• процедура toTitle
• процедура isLower

Исходный код Редактировать

proc toUpper(c: Rune): Rune {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Преобразует c в верхний регистр. Это работает для любой руны.

Если возможно, используйте toLower вместо toUpper.

См. также:

• процедура toLower
• процедура toTitle
• процедура isUpper

Исходный код Редактировать

proc toTitle(c: Rune): Rune {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Преобразует c в заголовок.

См. также:

• процедура toLower
• процедура toUpper
• процедура isTitle

Исходный код Редактировать

proc isLower(c: Rune): bool {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Возвращает true, если c является руной в нижнем регистре.

Если возможно, используйте isLower вместо isUpper.

См. также:

• процедура toLower
• процедура isUpper
• процедура isTitle

Исходный код Редактировать

proc isUpper(c: Rune): bool {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Возвращает true, если c является руной в верхнем регистре.

Если возможно, используйте isLower вместо isUpper.

См. также:

• процедура toUpper
• процедура isLower
• процедура isTitle
• процедура isAlpha
• процедура isWhiteSpace

Исходный код Редактировать

proc isAlpha(c: Rune): bool {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Возвращает true, если c является буквенной руной (т.е., буквой).

См. также:

• процедура isLower
• процедура isTitle
• процедура isAlpha
• процедура isWhiteSpace
• процедура isCombining

Исходный код Редактировать

proc isTitle(c: Rune): bool {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Возвращает true, если c — это кодовый символ Unicode в строчном стиле.

См. также:

• процедура toTitle
• процедура isLower
• процедура isUpper
• процедура isAlpha
• процедура isWhiteSpace

Исходный код Редактировать

proc isWhiteSpace(c: Rune): bool {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Возвращает true, если c — это кодовый символ Unicode пробела.

См. также:

• процедура isLower
• процедура isUpper
• процедура isTitle
• процедура isAlpha

Исходный код Редактировать

proc isCombining(c: Rune): bool {...}{.gcsafe, extern: "nuc$1", raises: [], tags: [].}

Возвращает true, если c является комбинирующим кодовым блоком Unicode.

См. также:

• процедура isLower
• процедура isUpper
• процедура isTitle
• процедура isAlpha

Исходный код Редактировать

proc isAlpha(s: string): bool {...}{.noSideEffect, gcsafe, extern: "nuc$1Str",
                                raises: [], tags: [].}

Возвращает true, если s содержит все буквенные руны.

Пример:

let a = "añyóng"
doAssert a.isAlpha

Исходный код Редактировать

proc isSpace(s: string): bool {...}{.noSideEffect, gcsafe, extern: "nuc$1Str",
                                raises: [], tags: [].}

Возвращает true, если s содержит все руны пробела.

Пример:

let a = "\t\l \v\r\f"
doAssert a.isSpace

Исходный код Редактировать

proc toUpper(s: string): string {...}{.noSideEffect, gcsafe, extern: "nuc$1Str",
                                  raises: [], tags: [].}

Преобразует s в руны верхнего регистра.

Пример:

doAssert toUpper("abγ") == "ABΓ"

Исходный код Редактировать

proc toLower(s: string): string {...}{.noSideEffect, gcsafe, extern: "nuc$1Str",
                                  raises: [], tags: [].}

Преобразует s в руны нижнего регистра.

Пример:

doAssert toLower("ABΓ") == "abγ"

Исходный код Редактировать

proc swapCase(s: string): string {...}{.noSideEffect, gcsafe, extern: "nuc$1",
                                   raises: [], tags: [].}

Меняет регистр рун в s.

Возвращает новую строку, в которой регистр всех рун поменян, если это возможно.

Пример:

doAssert swapCase("Αlpha Βeta Γamma") == "αLPHA βETA γAMMA"

Исходный код Редактировать

proc capitalize(s: string): string {...}{.noSideEffect, gcsafe, extern: "nuc$1",
                                     raises: [], tags: [].}

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

Пример:

doAssert capitalize("βeta") == "Βeta"

Исходный код Редактировать

proc translate(s: string; replacements: proc (key: string): string): string {...}{.
    gcsafe, extern: "nuc$1", raises: [], tags: [].}

Переводит слова в строке, используя процедуру replacements, чтобы заменить слова внутри s их заменами.

replacements — это любая процедура, которая принимает слово и возвращает новое слово для его замены.

Пример:

proc wordToNumber(s: string): string =
  case s
  of "one": "1"
  of "two": "2"
  else: s
let a = "one two three four"
doAssert a.translate(wordToNumber) == "1 2 three four"

Исходный код Редактировать

proc title(s: string): string {...}{.noSideEffect, gcsafe, extern: "nuc$1",
                                raises: [], tags: [].}

Преобразует s в заголовок Unicode.

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

Пример:

doAssert title("αlpha βeta γamma") == "Αlpha Βeta Γamma"

Исходный код Редактировать

proc toRunes(s: string): seq[Rune] {...}{.raises: [], tags: [].}

Получает последовательность, содержащую руны в s.

См. также:

• $ proc для обратной операции

Пример:

let a = toRunes("aáä")
doAssert a == @["a".runeAt(0), "á".runeAt(0), "ä".runeAt(0)]

Исходный код Редактировать

proc cmpRunesIgnoreCase(a, b: string): int {...}{.gcsafe, extern: "nuc$1",
    raises: [], tags: [].}

Сравнивает две строки UTF-8, игнорируя регистр. Возвращает:

0, если a == b
< 0, если a < b
> 0, если a > b

Исходный код Редактировать

proc reversed(s: string): string {...}{.raises: [], tags: [].}

Возвращает обратное значение s, интерпретируя его как руны.

Комбинирующие символы Unicode также интерпретируются правильно.

Пример:

assert reversed("Reverse this!") == "!siht esreveR"
assert reversed("先秦兩漢") == "漢兩秦先"
assert reversed("as⃝df̅") == "f̅ds⃝a"
assert reversed("a⃞b⃞c⃞") == "c⃞b⃞a⃞"

Исходный код Редактировать

proc graphemeLen(s: string; i: Natural): Natural {...}{.raises: [], tags: [].}

Количество байтов, принадлежащих индексу байта s[i], включая следующий комбинирующий кодовый блок.

Пример:

let a = "añyóng"
doAssert a.graphemeLen(1) == 2 ## ñ
doAssert a.graphemeLen(2) == 1
doAssert a.graphemeLen(4) == 2 ## ó

Исходный код Редактировать

proc lastRune(s: string; last: int): (Rune, int) {...}{.raises: [], tags: [].}

Длина последней руны в s[0..last]. Возвращает руну и её длину в байтах. Исходный код Редактировать

proc size(r: Rune): int {...}{.noSideEffect, raises: [], tags: [].}

Возвращает количество байтов, занимаемых руной r.

Пример:

let a = toRunes "aá"
doAssert size(a[0]) == 1
doAssert size(a[1]) == 2

Исходный код Редактировать

proc splitWhitespace(s: string): seq[string] {...}{.noSideEffect, gcsafe,
    extern: "ncuSplitWhitespace", raises: [], tags: [].}

То же, что и итератор splitWhitespace, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать

proc split(s: string; seps: openArray[Rune] = unicodeSpaces; maxsplit: int = -1): seq[
    string] {...}{.noSideEffect, gcsafe, extern: "nucSplitRunes", raises: [],
              tags: [].}

То же, что и итератор split, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать

proc split(s: string; sep: Rune; maxsplit: int = -1): seq[string] {...}{.
    noSideEffect, gcsafe, extern: "nucSplitRune", raises: [], tags: [].}

То же, что и итератор split, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать

proc strip(s: string; leading = true; trailing = true;
           runes: openArray[Rune] = unicodeSpaces): string {...}{.noSideEffect,
    gcsafe, extern: "nucStrip", raises: [], tags: [].}

Удаляет ведущие или хвостовые runes из s и возвращает получившуюся строку.

Если leading имеет значение true (по умолчанию), ведущие runes удаляются. Если trailing имеет значение true (по умолчанию), хвостовые runes удаляются. Если оба значения false, строка возвращается без изменений.

Пример:

let a = "\táñyóng   "
doAssert a.strip == "áñyóng"
doAssert a.strip(leading = false) == "\táñyóng"
doAssert a.strip(trailing = false) == "áñyóng   "

Исходный код Изменить

proc repeat(c: Rune; count: Natural): string {...}{.noSideEffect, gcsafe,
    extern: "nucRepeatRune", raises: [], tags: [].}

Возвращает строку count Руны c.

Возвращаемая строка будет иметь длину в рунах count.

Пример:

let a = "ñ".runeAt(0)
doAssert a.repeat(5) == "ñññññ"

Исходный код Изменить

proc align(s: string; count: Natural; padding = ' '.Rune): string {...}{.
    noSideEffect, gcsafe, extern: "nucAlignString", raises: [], tags: [].}

Выравнивает строку с юникодом s по padding, так что она имеет длину в рунах count.

padding символы (по умолчанию пробелы) добавляются перед s, что приводит к правому выравниванию. Если s.runelen >= count, пробелы не добавляются, и s возвращается без изменений. Если вам нужно выровнять строку по левому краю, используйте процедуру alignLeft proc.

Пример:

assert align("abc", 4) == " abc"
assert align("a", 0) == "a"
assert align("1232", 6) == "  1232"
assert align("1232", 6, '#'.Rune) == "##1232"
assert align("Åge", 5) == "  Åge"
assert align("×", 4, '_'.Rune) == "___×"

Исходный код Изменить

proc alignLeft(s: string; count: Natural; padding = ' '.Rune): string {...}{.
    noSideEffect, raises: [], tags: [].}

Выравнивает строку с юникодом s по левому краю с padding, так что она имеет длину в рунах count.

padding символы (по умолчанию пробелы) добавляются после s, что приводит к левому выравниванию. Если s.runelen >= count, пробелы не добавляются, и s возвращается без изменений. Если вам нужно выровнять строку по правому краю, используйте процедуру align proc.

Пример:

assert alignLeft("abc", 4) == "abc "
assert alignLeft("a", 0) == "a"
assert alignLeft("1232", 6) == "1232  "
assert alignLeft("1232", 6, '#'.Rune) == "1232##"
assert alignLeft("Åge", 5) == "Åge  "
assert alignLeft("×", 4, '_'.Rune) == "×___"

Исходный код Изменить

Итераторы

iterator runes(s: string): Rune {...}{.raises: [], tags: [].}

Итерируется по любой руне строки s, возвращая руны. Исходный код Изменить

iterator utf8(s: string): string {...}{.raises: [], tags: [].}

Итерируется по любой руне строки s, возвращая значения utf8.

См. также:

• validateUtf8 proc
• toUTF8 proc
• $ proc псевдоним для toUTF8
• fastToUTF8Copy шаблон

Исходный код Изменить

iterator split(s: string; seps: openArray[Rune] = unicodeSpaces;
               maxsplit: int = -1): string {...}{.raises: [], tags: [].}

Разбивает строку с юникодом s на подстроки, используя группу разделителей.

Подстроки разделяются подстрокой, содержащей только seps.

for word in split("this\lis an\texample"):
  writeLine(stdout, word)

...генерирует этот вывод:

"this"
"is"
"an"
"example"

И следующий код:

for word in split("this:is;an$example", {';', ':', '$'}):
  writeLine(stdout, word)

...выводит тот же результат, что и первый пример. Код:

let date = "2012-11-20T22:08:08.398990"
let separators = {' ', '-', ':', 'T'}
for number in split(date, separators):
  writeLine(stdout, number)

...приводит к:

"2012"
"11"
"20"
"22"
"08"
"08.398990"

Исходный код Изменить

iterator splitWhitespace(s: string): string {...}{.raises: [], tags: [].}

Разделяет строку с юникодом на подстроки по пробелам. Исходный код Изменить

iterator split(s: string; sep: Rune; maxsplit: int = -1): string {...}{.raises: [],
    tags: [].}

Разбивает строку с юникодом s на подстроки, используя один разделитель.

Подстроки разделяются руной sep. Код:

for word in split(";;this;is;an;;example;;;", ';'):
  writeLine(stdout, word)

Результат:

""
""
"this"
"is"
"an"
""
"example"
""
""
""

Исходный код Изменить

Шаблоны

template fastRuneAt(s: string; i: int; result: untyped; doInc = true)

Возвращает руну s[i] в result.

Если doInc == true (по умолчанию), i увеличивается на количество обработанных байтов.

Исходный код Изменить

template fastToUTF8Copy(c: Rune; s: var string; pos: int; doInc = true)

Копирует UTF-8 представление c в предварительно выделенную строку s, начиная с позиции pos.

Если doInc == true (по умолчанию), pos увеличивается на количество обработанных байтов.

Для наибольшей эффективности убедитесь, что s предварительно выделен с дополнительным объёмом, равным длине в байтах c.

См. также:

• validateUtf8 proc
• toUTF8 proc
• $ proc псевдоним для toUTF8

Исходный код Изменить