Spec-Zone.ru › Nim

std/unicode

SourceEdit

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

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

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

См. также:

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

Импорты

strbasics

Типы

Rune = distinct RuneImpl

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

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

Source Edit

Процедуры

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

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

См. также:

  • validateUtf8 proc
  • fastToUTF8Copy шаблон
Исходный код Изменить 
proc `$`(runes: seq[Rune]): string {....raises: [], tags: [], forbids: [].}

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

См. также:

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

Пример:

let
  someString = "öÑ"
  someRunes = toRunes(someString)
doAssert $someRunes == someString
Исходный код Изменить 
proc `<%`(a, b: Rune): bool {....raises: [], tags: [], forbids: [].}
Проверяет, является ли код символа a меньше, чем код символа b.

Пример:

let
  a = "ú".runeAt(0)
  b = "ü".runeAt(0)
doAssert a <% b
Исходный код Изменить 
proc `<=%`(a, b: Rune): bool {....raises: [], tags: [], forbids: [].}
Проверяет, является ли код символа a меньше или равен коду символа b.

Пример:

let
  a = "ú".runeAt(0)
  b = "ü".runeAt(0)
doAssert a <=% b
Исходный код Изменить 
proc `==`(a, b: Rune): bool {....raises: [], tags: [], forbids: [].}
Проверяет, равны ли две руны. Исходный код Изменить 
proc add(s: var string; c: Rune) {....raises: [], tags: [], forbids: [].}
Добавляет руну c к строке s.

Пример:

var s = "abc"
let c = "ä".runeAt(0)
s.add(c)
doAssert s == "abcä"
Исходный код Изменить 
proc align(s: openArray[char]; count: Natural; padding = ' '.Rune): string {.
    noSideEffect, ...gcsafe, extern: "nucAlignString", raises: [], tags: [],
    forbids: [].}

Выравнивает строку 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 align(s: string; count: Natural; padding = ' '.Rune): string {.
    noSideEffect, inline, ...raises: [], tags: [], forbids: [].}

Выравнивает строку 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: openArray[char]; count: Natural; padding = ' '.Rune): string {.
    noSideEffect, ...raises: [], tags: [], forbids: [].}

Выравнивает строку 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) == "×___"
Исходный код Изменить 
proc alignLeft(s: string; count: Natural; padding = ' '.Rune): string {.
    noSideEffect, inline, ...raises: [], tags: [], forbids: [].}

Выравнивает строку 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) == "×___"
Исходный код Изменить 
proc capitalize(s: openArray[char]): string {.noSideEffect, ...gcsafe,
    extern: "nuc$1", raises: [], tags: [], forbids: [].}
Преобразует первый символ s в руну верхнего регистра.

Пример:

doAssert capitalize("βeta") == "Βeta"
Исходный код Изменить 
proc capitalize(s: string): string {.noSideEffect, ...raises: [], tags: [],
                                     forbids: [].}
Преобразует первый символ s в руну верхнего регистра.

Пример:

doAssert capitalize("βeta") == "Βeta"
Исходный код Изменить 
proc cmpRunesIgnoreCase(a, b: openArray[char]): int {....gcsafe, extern: "nuc$1",
    raises: [], tags: [], forbids: [].}
Сравнивает две строки UTF-8, игнорируя регистр. Возвращает:

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

Исходный код Изменить 
proc cmpRunesIgnoreCase(a, b: string): int {.inline, ...raises: [], tags: [],
    forbids: [].}
Сравнивает две строки UTF-8, игнорируя регистр. Возвращает:

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

Исходный код Изменить 
proc graphemeLen(s: openArray[char]; i: Natural): Natural {....raises: [],
    tags: [], forbids: [].}
Количество байтов, принадлежащих индексу байта s[i], включая последующие объединяющие кодовые единицы.

Пример:

let a = "añyóng"
doAssert a.graphemeLen(1) == 2 ## ñ
doAssert a.graphemeLen(2) == 1
doAssert a.graphemeLen(4) == 2 ## ó
Исходный код Изменить 
proc graphemeLen(s: string; i: Natural): Natural {.inline, ...raises: [], tags: [],
    forbids: [].}
Количество байтов, принадлежащих индексу байта s[i], включая последующие объединяющие кодовые единицы.

Пример:

let a = "añyóng"
doAssert a.graphemeLen(1) == 2 ## ñ
doAssert a.graphemeLen(2) == 1
doAssert a.graphemeLen(4) == 2 ## ó
Исходный код Изменить 
proc isAlpha(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                              forbids: [].}

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

См. также:

  • isLower proc
  • isTitle proc
  • isAlpha proc
  • isWhiteSpace proc
  • isCombining proc
Исходный код Изменить 
proc isAlpha(s: openArray[char]): bool {.noSideEffect, ...gcsafe,
    extern: "nuc$1Str", raises: [], tags: [], forbids: [].}
Возвращает true, если s содержит все буквенные руны.

Пример:

let a = "añyóng"
doAssert a.isAlpha
Исходный код Изменить 
proc isAlpha(s: string): bool {.noSideEffect, inline, ...raises: [], tags: [],
                                forbids: [].}
Возвращает true, если s содержит все буквенные руны.

Пример:

let a = "añyóng"
doAssert a.isAlpha
Исходный код Изменить 
proc isCombining(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                                  forbids: [].}

Возвращает true, если c является объединяющей кодовой единицей Unicode.

См. также:

  • isLower proc
  • isUpper proc
  • isTitle proc
  • isAlpha proc
Исходный код Изменить 
proc isLower(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                              forbids: [].}

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

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

См. также:

  • процедура toLower
  • процедура isUpper
  • процедура isTitle
Исходный код Редактировать 
proc isSpace(s: openArray[char]): bool {.noSideEffect, ...gcsafe,
    extern: "nuc$1Str", raises: [], tags: [], forbids: [].}
Возвращает true, если s содержит все пробельные руны.

Пример:

let a = "\t\l \v\r\f"
doAssert a.isSpace
Исходный код Редактировать 
proc isSpace(s: string): bool {.noSideEffect, inline, ...raises: [], tags: [],
                                forbids: [].}
Возвращает true, если s содержит все пробельные руны.

Пример:

let a = "\t\l \v\r\f"
doAssert a.isSpace
Исходный код Редактировать 
proc isTitle(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                              forbids: [].}

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

См. также:

  • процедура toTitle
  • процедура isLower
  • процедура isUpper
  • процедура isAlpha
  • процедура isWhiteSpace
Исходный код Редактировать 
proc isUpper(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                              forbids: [].}

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

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

См. также:

  • процедура toUpper
  • процедура isLower
  • процедура isTitle
  • процедура isAlpha
  • процедура isWhiteSpace
Исходный код Редактировать 
proc isWhiteSpace(c: Rune): bool {....gcsafe, extern: "nuc$1", raises: [],
                                   tags: [], forbids: [].}

Возвращает true, если c является кодовой точкой Unicode пробела.

См. также:

  • процедура isLower
  • процедура isUpper
  • процедура isTitle
  • процедура isAlpha
Исходный код Редактировать 
proc lastRune(s: openArray[char]; last: int): (Rune, int) {....raises: [],
    tags: [], forbids: [].}
Длина последней руны в s[0..last]. Возвращает руну и ее длину в байтах. Исходный код Редактировать 
proc lastRune(s: string; last: int): (Rune, int) {.inline, ...raises: [], tags: [],
    forbids: [].}
Длина последней руны в s[0..last]. Возвращает руну и ее длину в байтах. Исходный код Редактировать 
proc repeat(c: Rune; count: Natural): string {.noSideEffect, ...gcsafe,
    extern: "nucRepeatRune", raises: [], tags: [], forbids: [].}

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

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

Пример:

let a = "ñ".runeAt(0)
doAssert a.repeat(5) == "ñññññ"
Исходный код Редактировать 
proc reversed(s: openArray[char]): string {....raises: [], tags: [], forbids: [].}

Возвращает обратную 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 reversed(s: string): string {.inline, ...raises: [], tags: [], forbids: [].}

Возвращает обратную 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 runeAt(s: openArray[char]; i: Natural): Rune {....raises: [], tags: [],
    forbids: [].}

Возвращает руну в 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 runeAt(s: string; i: Natural): Rune {.inline, ...raises: [], tags: [],
    forbids: [].}

Возвращает руну в 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 runeAtPos(s: openArray[char]; pos: int): Rune {....raises: [], tags: [],
    forbids: [].}

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

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

См. также:

  • процедура runeAt
  • процедура runeStrAtPos
  • шаблон fastRuneAt
Исходный код Редактировать 
proc runeAtPos(s: string; pos: int): Rune {.inline, ...raises: [], tags: [],
    forbids: [].}

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

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

См. также:

  • процедура runeAt
  • процедура runeStrAtPos
  • шаблон fastRuneAt
Исходный код Редактировать 
proc runeLen(s: openArray[char]): int {....gcsafe, extern: "nuc$1", raises: [],
                                        tags: [], forbids: [].}
Возвращает количество рун в строке s.

Пример:

let a = "añyóng"
doAssert a.runeLen == 6
## note: a.len == 8
Исходный код Редактировать 
proc runeLen(s: string): int {.inline, ...raises: [], tags: [], forbids: [].}
Возвращает количество рун в строке s.

Пример:

let a = "añyóng"
doAssert a.runeLen == 6
## note: a.len == 8
Исходный код Редактировать 
proc runeLenAt(s: openArray[char]; i: Natural): int {....raises: [], tags: [],
    forbids: [].}

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

См. также:

  • шаблон fastRuneAt

Пример:

let a = "añyóng"
doAssert a.runeLenAt(0) == 1
doAssert a.runeLenAt(1) == 2
Исходный код Редактировать 
proc runeLenAt(s: string; i: Natural): int {.inline, ...raises: [], tags: [],
    forbids: [].}

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

См. также:

  • шаблон fastRuneAt

Пример:

let a = "añyóng"
doAssert a.runeLenAt(0) == 1
doAssert a.runeLenAt(1) == 2
Исходный код Редактировать
END_OF_DOCUMENT_MARKER 
proc runeOffset(s: openArray[char]; pos: Natural; start: Natural = 0): int {.
    ...raises: [], tags: [], forbids: [].}

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

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

См. также:

  • процедура runeReverseOffset

Пример:

let a = "añyóng"
doAssert a.runeOffset(1) == 1
doAssert a.runeOffset(3) == 4
doAssert a.runeOffset(4) == 6
Исходный код Редактировать 
proc runeOffset(s: string; pos: Natural; start: Natural = 0): int {.inline,
    ...raises: [], tags: [], forbids: [].}

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

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

См. также:

  • процедура runeReverseOffset

Пример:

let a = "añyóng"
doAssert a.runeOffset(1) == 1
doAssert a.runeOffset(3) == 4
doAssert a.runeOffset(4) == 6
Исходный код Редактировать 
proc runeReverseOffset(s: openArray[char]; rev: Positive): (int, int) {.
    ...raises: [], tags: [], forbids: [].}

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

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

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

См. также:

  • процедура runeOffset
Исходный код Редактировать 
proc runeReverseOffset(s: string; rev: Positive): (int, int) {.inline,
    ...raises: [], tags: [], forbids: [].}

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

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

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

См. также:

  • процедура runeOffset
Исходный код Редактировать 
proc runeStrAtPos(s: openArray[char]; pos: Natural): string {....raises: [],
    tags: [], forbids: [].}

Возвращает символ (rune) в позиции pos как UTF8 строку.

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

См. также:

  • процедура runeAt
  • процедура runeAtPos
  • шаблон fastRuneAt
Исходный код Редактировать 
proc runeStrAtPos(s: string; pos: Natural): string {.inline, ...raises: [],
    tags: [], forbids: [].}

Возвращает символ (rune) в позиции pos как UTF8 строку.

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

См. также:

  • процедура runeAt
  • процедура runeAtPos
  • шаблон fastRuneAt
Исходный код Редактировать 
proc runeSubStr(s: openArray[char]; pos: int; len: int = int.high): string {.
    ...raises: [], tags: [], forbids: [].}

Возвращает подстроку 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 runeSubStr(s: string; pos: int; len: int = int.high): string {.inline,
    ...raises: [], tags: [], forbids: [].}

Возвращает подстроку 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 size(r: Rune): int {.noSideEffect, ...raises: [], tags: [], forbids: [].}
Возвращает количество байтов, занимаемых символом (rune) r.

Пример:

let a = toRunes "aá"
doAssert size(a[0]) == 1
doAssert size(a[1]) == 2
Исходный код Редактировать 
proc split(s: openArray[char]; sep: Rune; maxsplit: int = -1): seq[string] {.
    noSideEffect, ...gcsafe, extern: "nucSplitRune", raises: [], tags: [],
    forbids: [].}
То же, что и итератор split, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать 
proc split(s: openArray[char]; seps: openArray[Rune] = unicodeSpaces;
           maxsplit: int = -1): seq[string] {.noSideEffect, ...gcsafe,
    extern: "nucSplitRunes", raises: [], tags: [], forbids: [].}
То же, что и итератор split, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать 
proc split(s: string; sep: Rune; maxsplit: int = -1): seq[string] {.
    noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
То же, что и итератор split, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать 
proc split(s: string; seps: openArray[Rune] = unicodeSpaces; maxsplit: int = -1): seq[
    string] {.noSideEffect, inline, ...raises: [], tags: [], forbids: [].}
То же, что и итератор split, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать 
proc splitWhitespace(s: openArray[char]): seq[string] {.noSideEffect, ...gcsafe,
    extern: "ncuSplitWhitespace", raises: [], tags: [], forbids: [].}
То же, что и итератор splitWhitespace, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать 
proc splitWhitespace(s: string): seq[string] {.noSideEffect, inline, ...raises: [],
    tags: [], forbids: [].}
То же, что и итератор splitWhitespace, но это процедура, которая возвращает последовательность подстрок. Исходный код Редактировать 
proc strip(s: openArray[char]; leading = true; trailing = true;
           runes: openArray[Rune] = unicodeSpaces): string {.noSideEffect,
    ...gcsafe, extern: "nucStrip", raises: [], tags: [], forbids: [].}

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

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

Пример:

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 strip(s: string; leading = true; trailing = true;
           runes: openArray[Rune] = unicodeSpaces): string {.noSideEffect,
    inline, ...raises: [], tags: [], forbids: [].}

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

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

Пример:

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 swapCase(s: openArray[char]): string {.noSideEffect, ...gcsafe,
    extern: "nuc$1", raises: [], tags: [], forbids: [].}

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

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

Пример:

doAssert swapCase("Αlpha Βeta Γamma") == "αLPHA βETA γAMMA"
Исходный код Изменить 
proc swapCase(s: string): string {.noSideEffect, inline, ...raises: [], tags: [],
                                   forbids: [].}

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

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

Пример:

doAssert swapCase("Αlpha Βeta Γamma") == "αLPHA βETA γAMMA"
Исходный код Изменить 
proc title(s: openArray[char]): string {.noSideEffect, ...gcsafe, extern: "nuc$1",
    raises: [], tags: [], forbids: [].}

Преобразует s в заголовок Юникода.

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

Пример:

doAssert title("αlpha βeta γamma") == "Αlpha Βeta Γamma"
Исходный код Изменить 
proc title(s: string): string {.noSideEffect, inline, ...raises: [], tags: [],
                                forbids: [].}

Преобразует s в заголовок Юникода.

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

Пример:

doAssert title("αlpha βeta γamma") == "Αlpha Βeta Γamma"
Исходный код Изменить 
proc toLower(c: Rune): Rune {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                              forbids: [].}

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

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

См. также:

  • toUpper proc
  • toTitle proc
  • isLower proc
Исходный код Изменить 
proc toLower(s: openArray[char]): string {.noSideEffect, ...gcsafe,
    extern: "nuc$1Str", raises: [], tags: [], forbids: [].}
Преобразует s в руны нижнего регистра.

Пример:

doAssert toLower("ABΓ") == "abγ"
Исходный код Изменить 
proc toLower(s: string): string {.noSideEffect, inline, ...raises: [], tags: [],
                                  forbids: [].}
Преобразует s в руны нижнего регистра.

Пример:

doAssert toLower("ABΓ") == "abγ"
Исходный код Изменить 
proc toRunes(s: openArray[char]): seq[Rune] {....raises: [], tags: [], forbids: [].}

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

См. также:

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

Пример:

let a = toRunes("aáä")
doAssert a == @["a".runeAt(0), "á".runeAt(0), "ä".runeAt(0)]
Исходный код Изменить 
proc toRunes(s: string): seq[Rune] {.inline, ...raises: [], tags: [], forbids: [].}

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

См. также:

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

Пример:

let a = toRunes("aáä")
doAssert a == @["a".runeAt(0), "á".runeAt(0), "ä".runeAt(0)]
Исходный код Изменить 
proc toTitle(c: Rune): Rune {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                              forbids: [].}

Преобразует c в строчный регистр.

См. также:

  • toLower proc
  • toUpper proc
  • isTitle proc
Исходный код Изменить 
proc toUpper(c: Rune): Rune {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                              forbids: [].}

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

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

См. также:

  • toLower proc
  • toTitle proc
  • isUpper proc
Исходный код Изменить 
proc toUpper(s: openArray[char]): string {.noSideEffect, ...gcsafe,
    extern: "nuc$1Str", raises: [], tags: [], forbids: [].}
Преобразует s в руны верхнего регистра.

Пример:

doAssert toUpper("abγ") == "ABΓ"
Исходный код Изменить 
proc toUpper(s: string): string {.noSideEffect, inline, ...raises: [], tags: [],
                                  forbids: [].}
Преобразует s в руны верхнего регистра.

Пример:

doAssert toUpper("abγ") == "ABΓ"
Исходный код Изменить 
proc toUTF8(c: Rune): string {....gcsafe, extern: "nuc$1", raises: [], tags: [],
                               forbids: [].}

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

См. также:

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

Пример:

let a = "añyóng"
doAssert a.runeAt(1).toUTF8 == "ñ"
Исходный код Изменить 
proc translate(s: openArray[char]; replacements: proc (key: string): string): string {.
    ...gcsafe, extern: "nuc$1", effectsOf: replacements, ...raises: [], tags: [],
    forbids: [].}

Переводит слова в строке, используя replacements proc для замены слов внутри 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 translate(s: string; replacements: proc (key: string): string): string {.
    effectsOf: replacements, inline, ...raises: [], tags: [], forbids: [].}

Переводит слова в строке, используя replacements proc для замены слов внутри 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 validateUtf8(s: openArray[char]): int {....raises: [], tags: [], forbids: [].}

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

См. также:

  • toUTF8 proc
  • $ proc псевдоним для toUTF8
  • fastToUTF8Copy шаблон
Исходный код Изменить 
proc validateUtf8(s: string): int {.inline, ...raises: [], tags: [], forbids: [].}

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

См. также:

  • toUTF8 proc
  • $ proc псевдоним для toUTF8
  • fastToUTF8Copy шаблон
Исходный код Изменить

Итераторы

iterator runes(s: openArray[char]): Rune {....raises: [], tags: [], forbids: [].}
Перебирает любой символ в строке s, возвращая руны. Исходный код Редактировать 
iterator runes(s: string): Rune {....raises: [], tags: [], forbids: [].}
Перебирает любой символ в строке s, возвращая руны. Исходный код Редактировать 
iterator split(s: openArray[char]; sep: Rune; maxsplit: int = -1): string {.
    ...raises: [], tags: [], forbids: [].}
Разделяет строку Юникода s на подстроки, используя один разделитель. Подстроки разделены руной sep.

Пример:

import std/sequtils

assert toSeq(split(";;hÃllo;this;is;an;;example;;;是", ";".runeAt(0))) ==
  @["", "", "hÃllo", "this", "is", "an", "", "example", "", "", "是"]
Исходный код Редактировать 
iterator split(s: openArray[char]; seps: openArray[Rune] = unicodeSpaces;
               maxsplit: int = -1): string {....raises: [], tags: [], forbids: [].}

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

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

Пример:

import std/sequtils

assert toSeq("hÃllo\lthis\lis an\texample\l是".split) ==
  @["hÃllo", "this", "is", "an", "example", "是"]

# And the following code splits the same string using a sequence of Runes.
assert toSeq(split("añyóng:hÃllo;是$example", ";:$".toRunes)) ==
  @["añyóng", "hÃllo", "是", "example"]

# example with a `Rune` separator and unused one `;`:
assert toSeq(split("ab是de:f:", ";:是".toRunes)) == @["ab", "de", "f", ""]

# Another example that splits a string containing a date.
let date = "2012-11-20T22:08:08.398990"

assert toSeq(split(date, " -:T".toRunes)) ==
  @["2012", "11", "20", "22", "08", "08.398990"]
Исходный код Редактировать 
iterator split(s: string; sep: Rune; maxsplit: int = -1): string {....raises: [],
    tags: [], forbids: [].}
Разделяет строку Юникода s на подстроки, используя один разделитель. Подстроки разделены руной sep.

Пример:

import std/sequtils

assert toSeq(split(";;hÃllo;this;is;an;;example;;;是", ";".runeAt(0))) ==
  @["", "", "hÃllo", "this", "is", "an", "", "example", "", "", "是"]
Исходный код Редактировать 
iterator split(s: string; seps: openArray[Rune] = unicodeSpaces;
               maxsplit: int = -1): string {....raises: [], tags: [], forbids: [].}

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

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

Пример:

import std/sequtils

assert toSeq("hÃllo\lthis\lis an\texample\l是".split) ==
  @["hÃllo", "this", "is", "an", "example", "是"]

# And the following code splits the same string using a sequence of Runes.
assert toSeq(split("añyóng:hÃllo;是$example", ";:$".toRunes)) ==
  @["añyóng", "hÃllo", "是", "example"]

# example with a `Rune` separator and unused one `;`:
assert toSeq(split("ab是de:f:", ";:是".toRunes)) == @["ab", "de", "f", ""]

# Another example that splits a string containing a date.
let date = "2012-11-20T22:08:08.398990"

assert toSeq(split(date, " -:T".toRunes)) ==
  @["2012", "11", "20", "22", "08", "08.398990"]
Исходный код Редактировать 
iterator splitWhitespace(s: openArray[char]): string {....raises: [], tags: [],
    forbids: [].}
Разделяет строку Юникода по пробелам. Исходный код Редактировать 
iterator splitWhitespace(s: string): string {....raises: [], tags: [], forbids: [].}
Разделяет строку Юникода по пробелам. Исходный код Редактировать 
iterator utf8(s: openArray[char]): string {....raises: [], tags: [], forbids: [].}

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

См. также:

  • validateUtf8 функция
  • toUTF8 функция
  • $ функция псевдоним для toUTF8
  • шаблон fastToUTF8Copy
Исходный код Редактировать 
iterator utf8(s: string): string {....raises: [], tags: [], forbids: [].}

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

См. также:

  • validateUtf8 функция
  • toUTF8 функция
  • $ функция псевдоним для toUTF8
  • шаблон fastToUTF8Copy
Исходный код Редактировать

Шаблоны

template fastRuneAt(s: openArray[char] or 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 функция
  • toUTF8 функция
  • $ функция псевдоним для toUTF8
Исходный код Редактировать

© 2006–2024 Andreas Rumpf
Licensed under the MIT License.
https://nim-lang.org/docs/unicode.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API