Spec-Zone.ru › Nim

std/strutils

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

Модуль системы определяет несколько общих функций для работы со строками, таких как:

  • $ для преобразования других типов данных в строки
  • & для конкатенации строк
  • add для добавления нового символа или строки к существующей
  • in (псевдоним для contains) и notin для проверки, есть ли символ в строке

Этот модуль расширяет эти возможности, предоставляя дополнительную функциональность в виде процедур, итераторов и шаблонов для строк.

Пример:

import std/strutils
let
  numbers = @[867, 5309]
  multiLineString = "first line\nsecond line\nthird line"

let jenny = numbers.join("-")
assert jenny == "867-5309"

assert splitLines(multiLineString) ==
       @["first line", "second line", "third line"]
assert split(multiLineString) == @["first", "line", "second",
                                   "line", "third", "line"]
assert indent(multiLineString, 4) ==
       "    first line\n    second line\n    third line"
assert 'z'.repeat(5) == "zzzzz"
Цепочка функций возможна благодаря синтаксису вызова методов:

Пример:

import std/strutils
from std/sequtils import map

let jenny = "867-5309"
assert jenny.split('-').map(parseInt) == @[867, 5309]

assert "Beetlejuice".indent(1).repeat(3).strip ==
       "Beetlejuice Beetlejuice Beetlejuice"
Этот модуль доступен для цели JavaScript.

См. также:

  • модуль strformat для интерполяции и форматирования строк
  • модуль unicode для обработки Unicode UTF-8
  • модуль sequtils для операций над контейнерными типами (включая строки)
  • модуль parsecsv для высокопроизводительного парсера CSV
  • модуль parseutils для низкоуровневого парсинга токенов, чисел, идентификаторов и т. д.
  • модуль parseopt для парсинга командной строки
  • модуль pegs для поддержки PEG (Parsing Expression Grammar)
  • модуль strtabs для эффективных хеш-таблиц (словники, в некоторых языках программирования) с отображением строк на строки
  • модуль ropes для типа данных rope, который может эффективно представлять очень длинные строки
  • модуль re для поддержки регулярных выражений (regex)
  • strscans для scanf и scanp макросов, которые предлагают более простой способ извлечения подстрок, чем регулярные выражения

Импорты

parseutils, math, algorithm, enumutils, unicode, since, jsutils, strimpl

Типы

BinaryPrefixMode = enum
  bpIEC, bpColloquial
Разные имена двоичных префиксов. Исходный код Изменить 
FloatFormatMode = enum
  ffDefault,                ## use the shorter floating point notation
  ffDecimal,                ## use decimal floating point notation
  ffScientific               ## use scientific notation (using `e` character)
Разные режимы форматирования чисел с плавающей точкой. Исходный код Изменить 
SkipTable = array[char, int]
Таблица символов для эффективного поиска подстрок. Исходный код Изменить

Константы

AllChars = {'\x00'..'\xFF'}

Множество со всеми возможными символами.

Не очень полезно само по себе, вы можете использовать его для создания обратных множеств, чтобы функция find искала недопустимые символы в строках. Пример:

let invalid = AllChars - Digits
doAssert "01234".find(invalid) == -1
doAssert "01A34".find(invalid) == 2
Исходный код Изменить 
Digits = {'0'..'9'}
Множество цифр. Исходный код Изменить 
HexDigits = {'0'..'9', 'A'..'F', 'a'..'f'}
Множество шестнадцатеричных цифр. Исходный код Изменить 
IdentChars = {'a'..'z', 'A'..'Z', '0'..'9', '_'}
Множество символов, из которых может состоять идентификатор. Исходный код Изменить 
IdentStartChars = {'a'..'z', 'A'..'Z', '_'}
Множество символов, с которых может начинаться идентификатор. Исходный код Изменить 
Letters = {'A'..'Z', 'a'..'z'}
Множество букв. Исходный код Изменить 
LowercaseLetters = {'a'..'z'}
Множество строчных букв ASCII. Исходный код Изменить 
Newlines = {'\r', '\n'}
Множество символов, с которых может начинаться символ конца строки (возврат каретки, перевод строки). Исходный код Изменить 
PrintableChars = {'\t'..'\r', ' '..'~'}
Множество всех печатаемых символов ASCII (буквы, цифры, пробелы и знаки препинания). Исходный код Изменить 
PunctuationChars = {'!'..'/', ':'..'@', '['..'`', '{'..'~'}
Множество всех знаков препинания ASCII. Исходный код Изменить 
UppercaseLetters = {'A'..'Z'}
Множество заглавных букв ASCII. Исходный код Изменить 
Whitespace = {' ', '\t', '\v', '\r', '\n', '\f'}
Все символы, считающиеся пробелами (пробел, табуляция, вертикальная табуляция, возврат каретки, перевод строки, подача страницы). Исходный код Изменить

Процедуры

func `%`(formatstr, a: string): string {....gcsafe, extern: "nsuFormatSingleElem",
    raises: [ValueError], tags: [], forbids: [].}
Это то же самое, что и formatstr % [a] (см. % func). Исходный код Редактировать 
func `%`(formatstr: string; a: openArray[string]): string {....gcsafe,
    extern: "nsuFormatOpenArray", raises: [ValueError], tags: [], forbids: [].}

Интерполирует строку формата с значениями из a.

Оператор подстановки выполняет подстановку строк в formatstr и возвращает изменённую строку formatstr. Это часто называется интерполяцией строк.

Это лучше всего объяснить на примере:

"$1 eats $2." % ["The cat", "fish"]

Результатом будет:

"The cat eats fish."

Переменные подстановки (то, что идёт после $) нумеруются от 1 до a.len. Чтобы получить строку без интерполяции, используйте $$. Запись $# может использоваться для ссылки на следующую переменную подстановки:

"$# eats $#." % ["The cat", "fish"]

Переменные подстановки также могут быть словами (то есть [A-Za-z_]+[A-Za-z0-9_]*), в этом случае аргументы в a с чётными индексами являются ключами, а с нечётными — соответствующими значениями. Пример:

"$animal eats $food." % ["animal", "The cat", "food", "fish"]

Результатом будет:

"The cat eats fish."

Переменные сравниваются с cmpIgnoreStyle. ValueError генерируется, если в оператор % была передана некорректная строка формата.

См. также:

  • модуль strformat для интерполяции и форматирования строк
Исходный код Редактировать 
func abbrev(s: string; possibilities: openArray[string]): int {....raises: [],
    tags: [], forbids: [].}

Возвращает индекс первого элемента в possibilities, который начинается с s, если он однозначно определяется.

Возвращает -1, если элемент не найден, и -2, если совпадений несколько.

Пример:

doAssert abbrev("fac", ["college", "faculty", "industry"]) == 1
doAssert abbrev("foo", ["college", "faculty", "industry"]) == -1 # Not found
doAssert abbrev("fac", ["college", "faculty", "faculties"]) == -2 # Ambiguous
doAssert abbrev("college", ["college", "colleges", "industry"]) == 0
Исходный код Редактировать 
func addf(s: var string; formatstr: string; a: varargs[string, `$`]) {....gcsafe,
    extern: "nsuAddf", raises: [ValueError], tags: [], forbids: [].}
То же, что и add(s, formatstr % a), но более эффективно. Исходный код Редактировать 
func addSep(dest: var string; sep = ", "; startLen: Natural = 0) {.inline,
    ...raises: [], tags: [], forbids: [].}

Добавляет разделитель к dest только если его длина больше startLen.

Сокращённая запись для:

if dest.len > startLen: add(dest, sep)

Это часто полезно при генерации кода, где элементы должны быть разделены символом sep. sep добавляется только если dest длиннее startLen. Следующий пример создаёт строку, описывающую массив целых чисел.

Пример:

var arr = "["
for x in items([2, 3, 5, 7, 11]):
  addSep(arr, startLen = len("["))
  add(arr, $x)
add(arr, "]")
doAssert arr == "[2, 3, 5, 7, 11]"
Исходный код Редактировать 
func align(s: string; count: Natural; padding = ' '): string {....gcsafe,
    extern: "nsuAlignString", raises: [], tags: [], forbids: [].}

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

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

См. также:

  • alignLeft func
  • spaces func
  • indent func
  • center func

Пример:

assert align("abc", 4) == " abc"
assert align("a", 0) == "a"
assert align("1232", 6) == "  1232"
assert align("1232", 6, '#') == "##1232"
Исходный код Редактировать 
func alignLeft(s: string; count: Natural; padding = ' '): string {....raises: [],
    tags: [], forbids: [].}

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

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

См. также:

  • align func
  • spaces func
  • indent func
  • center func

Пример:

assert alignLeft("abc", 4) == "abc "
assert alignLeft("a", 0) == "a"
assert alignLeft("1232", 6) == "1232  "
assert alignLeft("1232", 6, '#') == "1232##"
Исходный код Редактировать 
func allCharsInSet(s: string; theSet: set[char]): bool {....raises: [], tags: [],
    forbids: [].}
Возвращает true, если каждый символ s находится в множестве theSet.

Пример:

doAssert allCharsInSet("aeea", {'a', 'e'}) == true
doAssert allCharsInSet("", {'a', 'e'}) == true
Исходный код Редактировать 
func capitalizeAscii(s: string): string {....gcsafe, extern: "nsuCapitalizeAscii",
    raises: [], tags: [], forbids: [].}

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

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

См. также:

  • toUpperAscii func

Пример:

doAssert capitalizeAscii("foo") == "Foo"
doAssert capitalizeAscii("-bar") == "-bar"
Исходный код Редактировать 
func center(s: string; width: int; fillChar: char = ' '): string {....gcsafe,
    extern: "nsuCenterString", raises: [], tags: [], forbids: [].}

Возвращает содержимое s, центрированное в строке длиной width, используя fillChar (по умолчанию пробел) в качестве заполнителя.

Исходная строка возвращается, если width меньше или равно s.len.

См. также:

  • align func
  • alignLeft func
  • spaces func
  • indent func

Пример:

let a = "foo"
doAssert a.center(2) == "foo"
doAssert a.center(5) == " foo "
doAssert a.center(6) == " foo  "
Исходный код Редактировать 
func cmpIgnoreCase(a, b: string): int {....gcsafe, extern: "nsuCmpIgnoreCase",
                                        raises: [], tags: [], forbids: [].}
Сравнивает две строки без учёта регистра. Возвращает:

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

Пример:

doAssert cmpIgnoreCase("FooBar", "foobar") == 0
doAssert cmpIgnoreCase("bar", "Foo") < 0
doAssert cmpIgnoreCase("Foo5", "foo4") > 0
Исходный код Редактировать 
func cmpIgnoreStyle(a, b: string): int {....gcsafe, extern: "nsuCmpIgnoreStyle",
    raises: [], tags: [], forbids: [].}

Семантически эквивалентно cmp(normalize(a), normalize(b)). Просто оптимизировано для того, чтобы не выделять временные строки. Не следует использовать для сравнения имён идентификаторов Nim. Используйте macros.eqIdent для этого.

Возвращает:

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

Пример:

doAssert cmpIgnoreStyle("foo_bar", "FooBar") == 0
doAssert cmpIgnoreStyle("foo_bar_5", "FooBar4") > 0
Исходный код Редактировать 
func contains(s, sub: string): bool {....raises: [], tags: [], forbids: [].}

То же, что и find(s, sub) >= 0.

См. также:

  • find func
Исходный код Редактировать 
func contains(s: string; chars: set[char]): bool {....raises: [], tags: [],
    forbids: [].}

То же, что и find(s, chars) >= 0.

См. также:

  • find func
Исходный код Редактировать 
func continuesWith(s, substr: string; start: Natural): bool {....gcsafe,
    extern: "nsuContinuesWith", raises: [], tags: [], forbids: [].}

Возвращает true, если s продолжается с substr в позиции start.

Если substr == "" возвращается true.

См. также:

  • функция startsWith
  • функция endsWith

Пример:

let a = "abracadabra"
doAssert a.continuesWith("ca", 4) == true
doAssert a.continuesWith("ca", 5) == false
doAssert a.continuesWith("dab", 6) == true
Исходный код Редактировать 
func count(s: string; sub: char): int {....gcsafe, extern: "nsuCountChar",
                                        raises: [], tags: [], forbids: [].}

Подсчитывает вхождения символа sub в строке s.

См. также:

  • функция countLines
Исходный код Редактировать 
func count(s: string; sub: string; overlapping: bool = false): int {....gcsafe,
    extern: "nsuCountString", raises: [], tags: [], forbids: [].}

Подсчитывает вхождения подстроки sub в строке s. Перекрывающиеся вхождения sub учитываются только тогда, когда overlapping установлено в true (по умолчанию: false).

См. также:

  • функция countLines
Исходный код Редактировать 
func count(s: string; subs: set[char]): int {....gcsafe, extern: "nsuCountCharSet",
    raises: [], tags: [], forbids: [].}

Подсчитывает вхождения группы символов subs в строке s.

См. также:

  • функция countLines
Исходный код Редактировать 
func countLines(s: string): int {....gcsafe, extern: "nsuCountLines", raises: [],
                                  tags: [], forbids: [].}

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

Это то же самое, что и len(splitLines(s)), но намного эффективнее, потому что не изменяет строку и не создает временных объектов. Поддерживаются все комбинации символов новой строки (CR, LF, CR-LF).

В данном контексте строка - это любая строка, разделенная комбинацией символов новой строки. Строка может быть пустой.

См. также:

  • функция splitLines

Пример:

doAssert countLines("First line\l and second line.") == 2
Исходный код Редактировать 
func dedent(s: string; count: Natural = indentation(s)): string {....gcsafe,
    extern: "nsuDedent", raises: [], tags: [], forbids: [].}

Убирает отступы с каждой строки в s на count количество padding. Единственное отличие от функции unindent заключается в том, что по умолчанию эта функция удаляет только количество отступов, которые общие для всех строк s в отличие от всех отступов. Она поддерживает только пробелы в качестве отступа.

Примечание: Это не сохраняет символы новой строки, используемые в s.

См. также:

  • функция unindent
  • функция align
  • функция alignLeft
  • функция spaces
  • функция indent

Пример:

let x = """
      Hello
        There
    """.dedent()

doAssert x == "Hello\n  There\n"
Исходный код Редактировать 
func delete(s: var string; first, last: int) {....gcsafe, extern: "nsuDelete",
    deprecated: "use `delete(s, first..last)`", raises: [], tags: [],
    forbids: [].}
Устарело: используйте `delete(s, first..last)`
Удаляет в s символы в позициях first .. last (включая оба конца).

Пример: cmd: --warning:deprecated:off

var a = "abracadabra"

a.delete(4, 5)
doAssert a == "abradabra"

a.delete(1, 6)
doAssert a == "ara"

a.delete(2, 999)
doAssert a == "ar"
Исходный код Редактировать 
func delete(s: var string; slice: Slice[int]) {....raises: [], tags: [],
    forbids: [].}

Удаляет элементы s[slice], вызывая IndexDefect если срез содержит элементы вне диапазона.

Эта операция перемещает все элементы после s[slice] за линейное время и является аналогом sequtils.delete для строк.

Пример:

var a = "abcde"
doAssertRaises(IndexDefect): a.delete(4..5)
assert a == "abcde"
a.delete(4..4)
assert a == "abcd"
a.delete(1..2)
assert a == "ad"
a.delete(1..<1) # empty slice
assert a == "ad"
Исходный код Редактировать 
func endsWith(s, suffix: string): bool {....gcsafe, extern: "nsuEndsWith",
    raises: [], tags: [], forbids: [].}

Возвращает true, если s заканчивается на suffix.

Если suffix == "" возвращается true.

См. также:

  • функция startsWith
  • функция continuesWith
  • функция removeSuffix

Пример:

let a = "abracadabra"
doAssert a.endsWith("abra") == true
doAssert a.endsWith("dab") == false
Исходный код Редактировать 
func endsWith(s: string; suffix: char): bool {.inline, ...raises: [], tags: [],
    forbids: [].}

Возвращает true, если s заканчивается на suffix.

См. также:

  • функция startsWith
  • функция continuesWith
  • функция removeSuffix

Пример:

let a = "abracadabra"
doAssert a.endsWith('a') == true
doAssert a.endsWith('b') == false
Исходный код Редактировать 
func escape(s: string; prefix = "\""; suffix = "\""): string {....gcsafe,
    extern: "nsuEscape", raises: [], tags: [], forbids: [].}
Экранирует строку s.
Примечание: Схема экранирования отличается от system.addEscapedChar.
  • заменяет '\0'..'\31' и '\127'..'\255' на \xHH, где HH - её шестнадцатеричное значение
  • заменяет \ на \\
  • заменяет ' на \'
  • заменяет " на \"

Полученная строка префиксна prefix и суффиксна suffix. Оба могут быть пустыми строками.

См. также:

  • процедура addEscapedChar
  • функция unescape для обратной операции
Исходный код Редактировать 
func find(a: SkipTable; s, sub: string; start: Natural = 0; last = -1): int {.
    ...gcsafe, extern: "nsuFindStrA", raises: [], tags: [], forbids: [].}

Ищет sub в s в диапазоне start..last с использованием предварительно обработанной таблицы a. Если last не указано, используется значение по умолчанию s.high (последний элемент).

Поиск регистрозависимый. Если sub не содержится в s, возвращается -1.

См. также:

  • Функция initSkipTable
  • Функция initSkipTable
Исходный код Редактировать 
func find(s, sub: string; start: Natural = 0; last = -1): int {....gcsafe,
    extern: "nsuFindStr", raises: [], tags: [], forbids: [].}

Ищет sub в s в диапазоне start..last (включая оба конца). Если last не указано или отрицательно, используется значение по умолчанию s.high (последний элемент).

Поиск регистрозависимый. Если sub не содержится в s, возвращается -1. В противном случае возвращаемый индекс относится к s[0], а не к start. Вычтите start из результата для получения индекса, отсчитываемого от start.

См. также:

  • Функция rfind
  • Функция replace
Исходный код Редактировать 
func find(s: string; chars: set[char]; start: Natural = 0; last = -1): int {.
    ...gcsafe, extern: "nsuFindCharSet", raises: [], tags: [], forbids: [].}

Ищет chars в s в диапазоне start..last (включая оба конца). Если last не указано или отрицательно, используется значение по умолчанию s.high (последний элемент).

Если s не содержит ни одного символа из chars, возвращается -1. В противном случае возвращаемый индекс относится к s[0], а не к start. Вычтите start из результата для получения индекса, отсчитываемого от start.

См. также:

  • Функция rfind
  • Функция multiReplace
Исходный код Редактировать 
func find(s: string; sub: char; start: Natural = 0; last = -1): int {....gcsafe,
    extern: "nsuFindChar", raises: [], tags: [], forbids: [].}

Ищет sub в s в диапазоне start..last (включая оба конца). Если last не указано или отрицательно, используется значение по умолчанию s.high (последний элемент).

Поиск регистрозависимый. Если sub не содержится в s, возвращается -1. В противном случае возвращаемый индекс относится к s[0], а не к start. Вычтите start из результата для получения индекса, отсчитываемого от start.

См. также:

  • Функция rfind
  • Функция replace
Исходный код Редактировать 
func format(formatstr: string; a: varargs[string, `$`]): string {....gcsafe,
    extern: "nsuFormatVarargs", raises: [ValueError], tags: [], forbids: [].}

Это то же самое, что и formatstr % a (см. % функция), за исключением того, что она поддерживает автоматическое форматирование строк.

См. также:

  • Модуль strformat для интерполяции строк и форматирования
Исходный код Редактировать 
func formatBiggestFloat(f: BiggestFloat; format: FloatFormatMode = ffDefault;
                        precision: range[-1 .. 32] = 16; decimalSep = '.'): string {.
    ...gcsafe, extern: "nsu$1", raises: [], tags: [], forbids: [].}

Преобразует значение с плавающей точкой f в строку.

Если format == ffDecimal, то точность — это количество цифр после десятичной точки. Если format == ffScientific, то точность — это максимальное количество значащих цифр. Значение по умолчанию для precision — максимальное количество значащих цифр после десятичной точки для типа biggestFloat в Nim.

Если precision == -1, то производится попытка красивого форматирования.

Пример:

let x = 123.456
doAssert x.formatBiggestFloat() == "123.4560000000000"
doAssert x.formatBiggestFloat(ffDecimal, 4) == "123.4560"
doAssert x.formatBiggestFloat(ffScientific, 2) == "1.23e+02"
Исходный код Редактировать 
func formatEng(f: BiggestFloat; precision: range[0 .. 32] = 10;
               trim: bool = true; siPrefix: bool = false; unit: string = "";
               decimalSep = '.'; useUnitSpace = false): string {....raises: [],
    tags: [], forbids: [].}

Преобразует значение с плавающей точкой f в строку, используя инженерную запись.

Числа в диапазоне -1000.0<f<1000.0 будут отформатированы без экспоненты. Числа за пределами этого диапазона будут отформатированы как мантисса в диапазоне -1000.0<f<1000.0 и экспонента, которая всегда будет целым кратным 3, соответствующим масштабу SI-префикса k, M, G, T и т. д. для чисел с абсолютным значением больше 1 и m, μ, n, p и т. д. для чисел с абсолютным значением меньше 1.

По умолчанию (trim=true и precision=10) отображается наименьшая форма, которая точно (до максимум 10 десятичных знаков) отображает значение. Например, 4.100000 будет отображено как 4.1 (что математически идентично), а 4.1000003 будет отображено как 4.1000003.

Если trim установлено в true, конечные нули будут удалены; если false, количество цифр, указанное precision, всегда будет показано.

precision можно использовать для задания количества цифр после десятичной точки или (если trim true) максимального количества цифр.

formatEng(0, 2, trim=false) == "0.00"
 formatEng(0, 2) == "0"
 formatEng(0.053, 0) == "53e-3"
 formatEng(52731234, 2) == "52.73e6"
 formatEng(-52731234, 2) == "-52.73e6"

Если siPrefix установлено в true, число будет отображаться с SI-префиксом, соответствующим экспоненте. Например, 4100 будет отображаться как «4.1 k» вместо «4.1e3». Обратите внимание, что u используется для микро- вместо греческой буквы мю (μ) в соответствии с ISO 2955. Числа с абсолютным значением вне диапазона 1e-18<f<1000e18 (1a<f<1000E) будут отображаться с экспонентой, а не с SI-префиксом, независимо от того, siPrefix true.

Если useUnitSpace true, указанный единица будет добавлен к строке (с пробелом, как требуется стандартом SI). Это поведение немного отличается от добавления единицы к результату, так как расположение пробела изменяется в зависимости от того, есть ли экспонента.

formatEng(4100, siPrefix=true, unit="V") == "4.1 kV"
 formatEng(4.1, siPrefix=true, unit="V") == "4.1 V"
 formatEng(4.1, siPrefix=true) == "4.1" # Note lack of space
 formatEng(4100, siPrefix=true) == "4.1 k"
 formatEng(4.1, siPrefix=true, unit="") == "4.1 " # Space with unit=""
 formatEng(4100, siPrefix=true, unit="") == "4.1 k"
 formatEng(4100) == "4.1e3"
 formatEng(4100, unit="V") == "4.1e3 V"
 formatEng(4100, unit="", useUnitSpace=true) == "4.1e3 " # Space with useUnitSpace=true

decimalSep используется в качестве десятичного разделителя.

См. также:

  • Модуль strformat для интерполяции строк и форматирования
Исходный код Редактировать 
func formatFloat(f: float; format: FloatFormatMode = ffDefault;
                 precision: range[-1 .. 32] = 16; decimalSep = '.'): string {.
    ...gcsafe, extern: "nsu$1", raises: [], tags: [], forbids: [].}

Преобразует значение с плавающей точкой f в строку.

Если format == ffDecimal, то точность — это количество цифр после десятичной точки. Если format == ffScientific, то точность — это максимальное количество значащих цифр. Значение по умолчанию для precision — максимальное количество значащих цифр после десятичной точки для типа float в Nim.

Если precision == -1, то производится попытка красивого форматирования.

Пример:

let x = 123.456
doAssert x.formatFloat() == "123.4560000000000"
doAssert x.formatFloat(ffDecimal, 4) == "123.4560"
doAssert x.formatFloat(ffScientific, 2) == "1.23e+02"
Исходный код Редактировать 
func formatSize(bytes: int64; decimalSep = '.'; prefix = bpIEC;
                includeSpace = false): string {....raises: [], tags: [],
    forbids: [].}

Округляет и форматирует bytes.

По умолчанию использует двоичные префиксы стандарта IEC/ISO, поэтому 1024 будет отформатировано как 1KiB. Установите префикс в bpColloquial для использования разговорных имен из стандарта SI (например, k для 1000, который используется повторно для 1024).

includeSpace может быть установлено в true, чтобы включить (предпочтительный для SI) пробел между числом и единицей (например, 1 KiB).

См. также:

  • Модуль strformat для интерполяции строк и форматирования

Пример:

doAssert formatSize((1'i64 shl 31) + (300'i64 shl 20)) == "2.293GiB"
doAssert formatSize((2.234*1024*1024).int) == "2.234MiB"
doAssert formatSize(4096, includeSpace = true) == "4 KiB"
doAssert formatSize(4096, prefix = bpColloquial, includeSpace = true) == "4 kB"
doAssert formatSize(4096) == "4KiB"
doAssert formatSize(5_378_934, prefix = bpColloquial, decimalSep = ',') == "5,13MB"
Исходный код Редактировать 
func fromBin[T: SomeInteger](s: string): T

Парсит двоичное целое значение из строки s.

Если s не является допустимым двоичным целым значением, поднимается ValueError. s может иметь один из следующих необязательных префиксов: 0b, 0B. Подчеркивания в s игнорируются.

Не проверяет переполнение. Если значение, представленное s, слишком велико для типа возвращаемого значения, возвращается только значение самых правых двоичных разрядов s без генерации ошибки.

Пример:

let s = "0b_0100_1000_1000_1000_1110_1110_1001_1001"
doAssert fromBin[int](s) == 1216933529
doAssert fromBin[int8](s) == 0b1001_1001'i8
doAssert fromBin[int8](s) == -103'i8
doAssert fromBin[uint8](s) == 153
doAssert s.fromBin[:int16] == 0b1110_1110_1001_1001'i16
doAssert s.fromBin[:uint64] == 1216933529'u64
Исходный код Редактировать 
func fromHex[T: SomeInteger](s: string): T

Парсит шестнадцатеричное целое значение из строки s.

Если s не является допустимым шестнадцатеричным целым числом, то поднимается исключение ValueError . s может иметь один из следующих необязательных префиксов: 0x, 0X, #. Подчеркивания в s игнорируются.

Не проверяет переполнение. Если значение, представленное s слишком большое для возвращаемого типа, то возвращается только значение наиболее значимых шестнадцатеричных цифр s без генерации ошибки.

Пример:

let s = "0x_1235_8df6"
doAssert fromHex[int](s) == 305499638
doAssert fromHex[int8](s) == 0xf6'i8
doAssert fromHex[int8](s) == -10'i8
doAssert fromHex[uint8](s) == 246'u8
doAssert s.fromHex[:int16] == -29194'i16
doAssert s.fromHex[:uint64] == 305499638'u64
Исходный код Редактировать 
func fromOct[T: SomeInteger](s: string): T

Парсит восьмеричное целое значение из строки s.

Если s не является допустимым восьмеричным целым числом, то поднимается исключение ValueError . s может иметь один из следующих необязательных префиксов: 0o, 0O. Подчеркивания в s игнорируются.

Не проверяет переполнение. Если значение, представленное s слишком большое для возвращаемого типа, то возвращается только значение наиболее значимых восьмеричных цифр s без генерации ошибки.

Пример:

let s = "0o_123_456_777"
doAssert fromOct[int](s) == 21913087
doAssert fromOct[int8](s) == 0o377'i8
doAssert fromOct[int8](s) == -1'i8
doAssert fromOct[uint8](s) == 255'u8
doAssert s.fromOct[:int16] == 24063'i16
doAssert s.fromOct[:uint64] == 21913087'u64
Исходный код Редактировать 
func indent(s: string; count: Natural; padding: string = " "): string {....gcsafe,
    extern: "nsuIndent", raises: [], tags: [], forbids: [].}

Отступает каждую строку в s на count количество padding.

Примечание: Это не сохраняет символы новой строки, используемые в s.

См. также:

  • функцию align
  • функцию alignLeft
  • функцию spaces
  • функцию unindent
  • функцию dedent

Пример:

doAssert indent("First line\c\l and second line.", 2) ==
         "  First line\l   and second line."
Исходный код Редактировать 
func indentation(s: string): Natural {....raises: [], tags: [], forbids: [].}
Возвращает количество отступов, общих для всех строк s, игнорируя строки, состоящие только из пробелов. Исходный код Редактировать 
func initSkipTable(a: var SkipTable; sub: string) {....gcsafe,
    extern: "nsuInitSkipTable", raises: [], tags: [], forbids: [].}

Инициализирует таблицу a для эффективного поиска подстроки sub.

См. также:

  • функцию initSkipTable
  • функцию find
Исходный код Редактировать 
func initSkipTable(sub: string): SkipTable {.noinit, ...gcsafe,
    extern: "nsuInitNewSkipTable", raises: [], tags: [], forbids: [].}

Возвращает новую таблицу, инициализированную для sub.

См. также:

  • функцию initSkipTable
  • функцию find
Исходный код Редактировать 
func insertSep(s: string; sep = '_'; digits = 3): string {....gcsafe,
    extern: "nsuInsertSep", raises: [], tags: [], forbids: [].}

Вставляет разделитель sep после digits символов (по умолчанию: 3) справа налево.

Хотя алгоритм работает с любой строкой s, он полезен только если s содержит число.

Пример:

doAssert insertSep("1000000") == "1_000_000"
Исходный код Редактировать 
func intToStr(x: int; minchars: Positive = 1): string {....gcsafe,
    extern: "nsuIntToStr", raises: [], tags: [], forbids: [].}

Преобразует x в его десятичное представление.

Полученная строка будет иметь минимальную длину minchars символов. Это достигается добавлением ведущих нулей.

Пример:

doAssert intToStr(1984) == "1984"
doAssert intToStr(1984, 6) == "001984"
Исходный код Редактировать 
func isAlphaAscii(c: char): bool {....gcsafe, extern: "nsuIsAlphaAsciiChar",
                                   raises: [], tags: [], forbids: [].}

Проверяет, является ли символ c буквенным.

Проверяет только ASCII символы a-z, A-Z. Используйте модуль Unicode для поддержки UTF-8.

Пример:

doAssert isAlphaAscii('e') == true
doAssert isAlphaAscii('E') == true
doAssert isAlphaAscii('8') == false
Исходный код Редактировать 
func isAlphaNumeric(c: char): bool {....gcsafe, extern: "nsuIsAlphaNumericChar",
                                     raises: [], tags: [], forbids: [].}

Проверяет, является ли c буквенно-цифровым.

Проверяет только ASCII символы a-z, A-Z, 0-9.

Пример:

doAssert isAlphaNumeric('n') == true
doAssert isAlphaNumeric('8') == true
doAssert isAlphaNumeric(' ') == false
Исходный код Редактировать 
func isDigit(c: char): bool {....gcsafe, extern: "nsuIsDigitChar", raises: [],
                              tags: [], forbids: [].}

Проверяет, является ли c числом.

Проверяет только ASCII символы 0-9.

Пример:

doAssert isDigit('n') == false
doAssert isDigit('8') == true
Исходный код Редактировать 
func isEmptyOrWhitespace(s: string): bool {....gcsafe,
    extern: "nsuIsEmptyOrWhitespace", raises: [], tags: [], forbids: [].}
Проверяет, пуста ли строка s или состоит ли она только из пробелов. Исходный код Редактировать 
func isLowerAscii(c: char): bool {....gcsafe, extern: "nsuIsLowerAsciiChar",
                                   raises: [], tags: [], forbids: [].}

Проверяет, является ли c символом строчных букв.

Проверяет только ASCII символы. Используйте модуль Unicode для поддержки UTF-8.

См. также:

  • функцию toLowerAscii

Пример:

doAssert isLowerAscii('e') == true
doAssert isLowerAscii('E') == false
doAssert isLowerAscii('7') == false
Исходный код Редактировать 
func isSpaceAscii(c: char): bool {....gcsafe, extern: "nsuIsSpaceAsciiChar",
                                   raises: [], tags: [], forbids: [].}
Проверяет, является ли c символом пробела.

Пример:

doAssert isSpaceAscii('n') == false
doAssert isSpaceAscii(' ') == true
doAssert isSpaceAscii('\t') == true
Исходный код Редактировать 
func isUpperAscii(c: char): bool {....gcsafe, extern: "nsuIsUpperAsciiChar",
                                   raises: [], tags: [], forbids: [].}

Проверяет, является ли c символом заглавных букв.

Проверяет только ASCII символы. Используйте модуль Unicode для поддержки UTF-8.

См. также:

  • функцию toUpperAscii

Пример:

doAssert isUpperAscii('e') == false
doAssert isUpperAscii('E') == true
doAssert isUpperAscii('7') == false
Исходный код Редактировать 
func join(a: openArray[string]; sep: string = ""): string {....gcsafe,
    extern: "nsuJoinSep", raises: [], tags: [], forbids: [].}
Объединяет все строки в контейнере a, разделяя их sep.

Пример:

doAssert join(["A", "B", "Conclusion"], " -> ") == "A -> B -> Conclusion"
Исходный код Редактировать 
proc join[T: not string](a: openArray[T]; sep: string = ""): string
Преобразует все элементы в контейнере a в строки с помощью $, и объединяет их с sep.

Пример:

doAssert join([1, 2, 3], " -> ") == "1 -> 2 -> 3"
Исходный код Редактировать 
func multiReplace(s: string; replacements: varargs[(string, string)]): string {.
    ...raises: [], tags: [], forbids: [].}

То же самое, что и replace, но специализировано для выполнения нескольких замен за один проход по входной строке.

multiReplace сканирует входную строку слева направо и заменяет соответствующие подстроки в том же порядке, что и в списке аргументов.

Последствия порядка сканирования строки и сопоставления замен:

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

Если полученная строка не длиннее исходной входной строки, требуется только одно выделение памяти.

Пример:

# Swapping occurrences of 'a' and 'b':
doAssert multireplace("abba", [("a", "b"), ("b", "a")]) == "baab"

# The second replacement ("ab") is matched and performed first, the scan then
# continues from 'c', so the "bc" replacement is never matched and thus skipped.
doAssert multireplace("abc", [("bc", "x"), ("ab", "_b")]) == "_bc"
Исходный код Изменить 
func nimIdentNormalize(s: string): string {....raises: [], tags: [], forbids: [].}

Нормализует строку s как идентификатор Nim.

Это означает преобразование в нижний регистр и удаление любого «_» для всех символов, кроме первого.

Предупреждение: Обратные кавычки (`) не обрабатываются: они остаются без изменений, и пробелы сохраняются. Обратитесь к nimIdentBackticksNormalize для альтернативного подхода.

Пример:

doAssert nimIdentNormalize("Foo_bar") == "Foobar"
Исходный код Изменить 
func normalize(s: string): string {....gcsafe, extern: "nsuNormalize", raises: [],
                                    tags: [], forbids: [].}

Нормализует строку s.

Это означает преобразование в нижний регистр и удаление любого «_». Это НЕ следует использовать для нормализации имён идентификаторов Nim.

См. также:

  • функцию toLowerAscii

Пример:

doAssert normalize("Foo_bar") == "foobar"
doAssert normalize("Foo Bar") == "foo bar"
Исходный код Изменить 
func parseBiggestInt(s: string): BiggestInt {....gcsafe,
    extern: "nsuParseBiggestInt", raises: [ValueError], tags: [], forbids: [].}

Парсит значение целого десятичного числа, содержащееся в s.

Если s не является допустимым целым числом, поднимается исключение ValueError.

Исходный код Изменить 
func parseBiggestUInt(s: string): BiggestUInt {....gcsafe,
    extern: "nsuParseBiggestUInt", raises: [ValueError], tags: [], forbids: [].}

Парсит значение беззнакового целого десятичного числа, содержащееся в s.

Если s не является допустимым целым числом, поднимается исключение ValueError.

Исходный код Изменить 
func parseBinInt(s: string): int {....gcsafe, extern: "nsuParseBinInt",
                                   raises: [ValueError], tags: [], forbids: [].}

Парсит значение двоичного целого числа, содержащееся в s.

Если s не является допустимым двоичным целым числом, поднимается исключение ValueError . s может иметь один из следующих необязательных префиксов: 0b, 0B. Подчеркивания в s игнорируются.

Пример:

let
  a = "0b11_0101"
  b = "111"
doAssert a.parseBinInt() == 53
doAssert b.parseBinInt() == 7
Исходный код Изменить 
func parseBool(s: string): bool {....raises: [ValueError], tags: [], forbids: [].}

Парсит значение в bool.

Если s имеет одно из следующих значений: y, yes, true, 1, on, то возвращает true. Если s имеет одно из следующих значений: n, no, false, 0, off, то возвращает false. В противном случае поднимается исключение ValueError.

Пример:

let a = "n"
doAssert parseBool(a) == false
Исходный код Изменить 
func parseEnum[T: enum](s: string): T

Парсит перечисление T . При этом ошибка возникает во время компиляции, если данный тип перечисления содержит несколько полей с одинаковым строковым значением.

Поднимает ValueError для недопустимого значения в s . Сравнение выполняется нечувствительным к стилю (первая буква по-прежнему чувствительна к регистру).

Пример:

type
  MyEnum = enum
    first = "1st",
    second,
    third = "3rd"

doAssert parseEnum[MyEnum]("1_st") == first
doAssert parseEnum[MyEnum]("second") == second
doAssertRaises(ValueError):
  echo parseEnum[MyEnum]("third")
Исходный код Изменить 
func parseEnum[T: enum](s: string; default: T): T

Парсит перечисление T . При этом ошибка возникает во время компиляции, если данный тип перечисления содержит несколько полей с одинаковым строковым значением.

Использует default для недопустимого значения в s . Сравнение выполняется нечувствительным к стилю (первая буква по-прежнему чувствительна к регистру).

Пример:

type
  MyEnum = enum
    first = "1st",
    second,
    third = "3rd"

doAssert parseEnum[MyEnum]("1_st") == first
doAssert parseEnum[MyEnum]("second") == second
doAssert parseEnum[MyEnum]("last", third) == third
Исходный код Изменить 
func parseFloat(s: string): float {....gcsafe, extern: "nsuParseFloat",
                                    raises: [ValueError], tags: [], forbids: [].}

Парсит значение десятичного числа с плавающей запятой, содержащееся в s.

Если s не является допустимым числом с плавающей запятой, поднимается исключение ValueError. NAN, INF, -INF также поддерживаются (сравнение без учета регистра).

Пример:

doAssert parseFloat("3.14") == 3.14
doAssert parseFloat("inf") == 1.0/0
Исходный код Изменить 
func parseHexInt(s: string): int {....gcsafe, extern: "nsuParseHexInt",
                                   raises: [ValueError], tags: [], forbids: [].}

Парсит значение шестнадцатеричного целого числа, содержащееся в s.

Если s не является допустимым шестнадцатеричным целым числом, поднимается исключение ValueError. s может иметь один из следующих необязательных префиксов: 0x, 0X, # . Подчеркивания в s игнорируются.

Исходный код Изменить 
func parseHexStr(s: string): string {....gcsafe, extern: "nsuParseHexStr",
                                      raises: [ValueError], tags: [],
                                      forbids: [].}

Преобразует строку, закодированную в шестнадцатеричном формате, в строку байтов, например:

Поднимает ValueError для недопустимых шестнадцатеричных значений. Сравнение нечувствительно к регистру.

См. также:

  • функцию toHex для обратной операции

Пример:

let
  a = "41"
  b = "3161"
  c = "00ff"
doAssert parseHexStr(a) == "A"
doAssert parseHexStr(b) == "1a"
doAssert parseHexStr(c) == "\0\255"
Исходный код Изменить 
func parseInt(s: string): int {....gcsafe, extern: "nsuParseInt",
                                raises: [ValueError], tags: [], forbids: [].}

Парсит значение целого десятичного числа, содержащееся в s.

Если s не является допустимым целым числом, поднимается исключение ValueError.

Пример:

doAssert parseInt("-0042") == -42
Исходный код Изменить 
func parseOctInt(s: string): int {....gcsafe, extern: "nsuParseOctInt",
                                   raises: [ValueError], tags: [], forbids: [].}

Парсит значение восьмеричного целого числа, содержащееся в s.

Если s не является допустимым восьмеричным целым числом, поднимается исключение ValueError . s может иметь один из следующих необязательных префиксов: 0o, 0O . Подчеркивания в s игнорируются.

Исходный код Изменить 
func parseUInt(s: string): uint {....gcsafe, extern: "nsuParseUInt",
                                  raises: [ValueError], tags: [], forbids: [].}

Парсит значение беззнакового целого десятичного числа, содержащееся в s.

Если s не является допустимым целым числом, поднимается исключение ValueError.

Исходный код Изменить 
func removePrefix(s: var string; c: char) {....gcsafe,
    extern: "nsuRemovePrefixChar", raises: [], tags: [], forbids: [].}

Удаляет все вхождения одного символа (на месте) с начала строки.

См. также:

  • функция removeSuffix
  • функция startsWith

Пример:

var ident = "pControl"
ident.removePrefix('p')
doAssert ident == "Control"
Исходный код Редактировать 
func removePrefix(s: var string; chars: set[char] = Newlines) {....gcsafe,
    extern: "nsuRemovePrefixCharSet", raises: [], tags: [], forbids: [].}

Удаляет все символы из chars с начала строки s (на месте).

См. также:

  • функция removeSuffix

Пример:

var userInput = "\r\n*~Hello World!"
userInput.removePrefix
doAssert userInput == "*~Hello World!"
userInput.removePrefix({'~', '*'})
doAssert userInput == "Hello World!"

var otherInput = "?!?Hello!?!"
otherInput.removePrefix({'!', '?'})
doAssert otherInput == "Hello!?!"
Исходный код Редактировать 
func removePrefix(s: var string; prefix: string) {....gcsafe,
    extern: "nsuRemovePrefixString", raises: [], tags: [], forbids: [].}

Удаляет первое совпадающее префиксное значение (на месте) из строки.

См. также:

  • функция removeSuffix
  • функция startsWith

Пример:

var answers = "yesyes"
answers.removePrefix("yes")
doAssert answers == "yes"
Исходный код Редактировать 
func removeSuffix(s: var string; c: char) {....gcsafe,
    extern: "nsuRemoveSuffixChar", raises: [], tags: [], forbids: [].}

Удаляет все вхождения одного символа (на месте) с конца строки.

См. также:

  • функция removePrefix
  • функция endsWith

Пример:

var table = "users"
table.removeSuffix('s')
doAssert table == "user"

var dots = "Trailing dots......."
dots.removeSuffix('.')
doAssert dots == "Trailing dots"
Исходный код Редактировать 
func removeSuffix(s: var string; chars: set[char] = Newlines) {....gcsafe,
    extern: "nsuRemoveSuffixCharSet", raises: [], tags: [], forbids: [].}

Удаляет все символы из chars с конца строки s (на месте).

См. также:

  • функция removePrefix

Пример:

var userInput = "Hello World!*~\r\n"
userInput.removeSuffix
doAssert userInput == "Hello World!*~"
userInput.removeSuffix({'~', '*'})
doAssert userInput == "Hello World!"

var otherInput = "Hello!?!"
otherInput.removeSuffix({'!', '?'})
doAssert otherInput == "Hello"
Исходный код Редактировать 
func removeSuffix(s: var string; suffix: string) {....gcsafe,
    extern: "nsuRemoveSuffixString", raises: [], tags: [], forbids: [].}

Удаляет первое совпадающее суффиксное значение (на месте) из строки.

См. также:

  • функция removePrefix
  • функция endsWith

Пример:

var answers = "yeses"
answers.removeSuffix("es")
doAssert answers == "yes"
Исходный код Редактировать 
func repeat(c: char; count: Natural): string {....gcsafe, extern: "nsuRepeatChar",
    raises: [], tags: [], forbids: [].}
Возвращает строку длиной count, состоящую только из символа c.

Пример:

let a = 'z'
doAssert a.repeat(5) == "zzzzz"
Исходный код Редактировать 
func repeat(s: string; n: Natural): string {....gcsafe, extern: "nsuRepeatStr",
    raises: [], tags: [], forbids: [].}
Возвращает строку s , конкатенированную n раз.

Пример:

doAssert "+ foo +".repeat(3) == "+ foo ++ foo ++ foo +"
Исходный код Редактировать 
func replace(s, sub: string; by = ""): string {....gcsafe, extern: "nsuReplaceStr",
    raises: [], tags: [], forbids: [].}

Заменяет каждое вхождение строки sub в s на строку by.

См. также:

  • функция find
  • функция replace для замены отдельных символов
  • функция replaceWord
  • функция multiReplace
Исходный код Редактировать 
func replace(s: string; sub, by: char): string {....gcsafe,
    extern: "nsuReplaceChar", raises: [], tags: [], forbids: [].}

Заменяет каждое вхождение символа sub в s на символ by.

Оптимизированная версия replace для символов.

См. также:

  • функция find
  • функция replaceWord
  • функция multiReplace
Исходный код Редактировать 
func replaceWord(s, sub: string; by = ""): string {....gcsafe,
    extern: "nsuReplaceWord", raises: [], tags: [], forbids: [].}

Заменяет каждое вхождение строки sub в s на строку by.

Каждое вхождение sub должно быть окружено границами слова (сравнимо с \b в регулярных выражениях), в противном случае оно не заменяется.

Исходный код Редактировать 
func rfind(s, sub: string; start: Natural = 0; last = -1): int {....gcsafe,
    extern: "nsuRFindStr", raises: [], tags: [], forbids: [].}

Ищет sub в s в диапазоне start..last (обе границы включительно) в обратном порядке — начиная с высоких индексов и перемещаясь вниз к первому символу или start. Если last не указано, оно по умолчанию равно s.high (последний элемент).

Поиск регистрозависимый. Если sub не содержится в s, возвращается -1. В противном случае возвращаемый индекс относится к s[0], а не к start. Вычтите start из результата для индекса с началом в start.

См. также:

  • функция find
Исходный код Редактировать 
func rfind(s: string; chars: set[char]; start: Natural = 0; last = -1): int {.
    ...gcsafe, extern: "nsuRFindCharSet", raises: [], tags: [], forbids: [].}

Ищет chars в s в диапазоне start..last (обе границы включительно) в обратном порядке — начиная с высоких индексов и перемещаясь вниз к первому символу или start. Если last не указано, оно по умолчанию равно s.high (последний элемент).

Если s не содержит ни одного символа из chars, возвращается -1. В противном случае возвращаемый индекс относится к s[0], а не к start. Вычтите start из результата для индекса с началом в start.

См. также:

  • функция find
Исходный код Редактировать 
func rfind(s: string; sub: char; start: Natural = 0; last = -1): int {....gcsafe,
    extern: "nsuRFindChar", raises: [], tags: [], forbids: [].}

Ищет sub в s в диапазоне start..last (обе границы включительно) в обратном порядке — начиная с высоких индексов и перемещаясь вниз к первому символу или start. Если last не указано, оно по умолчанию равно s.high (последний элемент).

Поиск регистрозависимый. Если sub не содержится в s, возвращается -1. В противном случае возвращаемый индекс относится к s[0], а не к start. Вычтите start из результата для индекса с началом в start.

См. также:

  • функция find
Исходный код Редактировать 
func rsplit(s: string; sep: char; maxsplit: int = -1): seq[string] {....gcsafe,
    extern: "nsuRSplitChar", raises: [], tags: [], forbids: [].}

То же самое, что и итератор rsplit, но является функцией, которая возвращает последовательность подстрок в исходном порядке.

Возможный распространенный случай использования rsplit — обработка путей, особенно на системах, которые не используют общий разделитель.

Например, если на системе разделителем был #, вы можете сделать следующее, чтобы получить хвост пути:

var tailSplit = rsplit("Root#Object#Method#Index", '#', maxsplit=1)

В результате tailSplit будет содержать:

@["Root#Object#Method", "Index"]

См. также:

  • итератор rsplit
  • функция split
  • функция splitLines
  • функция splitWhitespace
Исходный код Редактировать 
func rsplit(s: string; sep: string; maxsplit: int = -1): seq[string] {....gcsafe,
    extern: "nsuRSplitString", raises: [], tags: [], forbids: [].}

То же самое, что и итератор rsplit, но является функцией, которая возвращает последовательность подстрок в исходном порядке.

Возможный распространенный случай использования rsplit — обработка путей, особенно на системах, которые не используют общий разделитель.

Например, если на системе разделителем был #, вы можете сделать следующее, чтобы получить хвост пути:

var tailSplit = rsplit("Root#Object#Method#Index", "#", maxsplit=1)

В результате tailSplit будет содержать:

@["Root#Object#Method", "Index"]
Примечание: Пустая строка-разделитель приводит к возвращению исходной строки, следуя интерпретации «разделение по отсутствию элемента».

См. также:

  • итератор rsplit
  • функция split
  • функция splitLines
  • функция splitWhitespace

Пример:

doAssert "a  largely    spaced sentence".rsplit(" ", maxsplit = 1) == @[
    "a  largely    spaced", "sentence"]
doAssert "a,b,c".rsplit(",") == @["a", "b", "c"]
doAssert "a man a plan a canal panama".rsplit("a ") == @["", "man ",
    "plan ", "canal panama"]
doAssert "".rsplit("Elon Musk") == @[""]
doAssert "a  largely    spaced sentence".rsplit(" ") == @["a", "",
    "largely", "", "", "", "spaced", "sentence"]
doAssert "empty sep returns unsplit s".rsplit("") == @["empty sep returns unsplit s"]
Исходный код Редактировать 
func rsplit(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): seq[
    string] {....gcsafe, extern: "nsuRSplitCharSet", raises: [], tags: [],
              forbids: [].}

То же самое, что и итератор rsplit, но является функцией, которая возвращает последовательность подстрок в исходном порядке.

Возможный распространенный случай использования rsplit — обработка путей, особенно на системах, которые не используют общий разделитель.

Например, если на системе разделителем был #, вы можете сделать следующее, чтобы получить хвост пути:

var tailSplit = rsplit("Root#Object#Method#Index", {'#'}, maxsplit=1)

В результате tailSplit будет содержать:

@["Root#Object#Method", "Index"]
Примечание: Пустое множество-разделитель приводит к возвращению исходной строки, следуя интерпретации «разделение по отсутствию элемента».

См. также:

  • итератор rsplit
  • функция split
  • функция splitLines
  • функция splitWhitespace
Исходный код Редактировать 
func spaces(n: Natural): string {.inline, ...raises: [], tags: [], forbids: [].}

Возвращает строку с n пробелами. Вы можете использовать эту функцию для выравнивания строк по левому краю.

См. также:

  • функция align
  • функция alignLeft
  • функция indent
  • функция center

Пример:

let
  width = 15
  text1 = "Hello user!"
  text2 = "This is a very long string"
doAssert text1 & spaces(max(0, width - text1.len)) & "|" ==
         "Hello user!    |"
doAssert text2 & spaces(max(0, width - text2.len)) & "|" ==
         "This is a very long string|"
Исходный код Редактировать 
func split(s: string; sep: char; maxsplit: int = -1): seq[string] {....gcsafe,
    extern: "nsuSplitChar", raises: [], tags: [], forbids: [].}

То же самое, что и итератор split (см. его документацию), но является функцией, которая возвращает последовательность подстрок.

См. также:

  • итератор split
  • функция rsplit
  • функция splitLines
  • функция splitWhitespace

Пример:

doAssert "a,b,c".split(',') == @["a", "b", "c"]
doAssert "".split(' ') == @[""]
Исходный код Редактировать 
func split(s: string; sep: string; maxsplit: int = -1): seq[string] {....gcsafe,
    extern: "nsuSplitString", raises: [], tags: [], forbids: [].}

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

Подстроки разделяются строкой sep. Это оболочка вокруг итератора split.

Примечание: Пустая строка-разделитель приводит к возвращению исходной строки, следуя интерпретации «разделение по отсутствию элемента».

См. также:

  • итератор split
  • функция rsplit
  • функция splitLines
  • функция splitWhitespace

Пример:

doAssert "a,b,c".split(",") == @["a", "b", "c"]
doAssert "a man a plan a canal panama".split("a ") == @["", "man ", "plan ", "canal panama"]
doAssert "".split("Elon Musk") == @[""]
doAssert "a  largely    spaced sentence".split(" ") == @["a", "", "largely",
    "", "", "", "spaced", "sentence"]
doAssert "a  largely    spaced sentence".split(" ", maxsplit = 1) == @["a", " largely    spaced sentence"]
doAssert "empty sep returns unsplit s".split("") == @["empty sep returns unsplit s"]
Исходный код Редактировать 
func split(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): seq[
    string] {....gcsafe, extern: "nsuSplitCharSet", raises: [], tags: [],
              forbids: [].}
То же самое, что и итератор split (см. его документацию), но является функцией, которая возвращает последовательность подстрок.
Примечание: Пустое множество-разделитель приводит к возвращению исходной строки, следуя интерпретации «разделение по отсутствию элемента».

См. также:

  • итератор split
  • функция rsplit
  • функция splitLines
  • функция splitWhitespace

Пример:

doAssert "a,b;c".split({',', ';'}) == @["a", "b", "c"]
doAssert "".split({' '}) == @[""]
doAssert "empty seps return unsplit s".split({}) == @["empty seps return unsplit s"]
Исходный код Редактировать 
func splitLines(s: string; keepEol = false): seq[string] {....gcsafe,
    extern: "nsuSplitLines", raises: [], tags: [], forbids: [].}

То же самое, что и итератор splitLines (см. его документацию), но является функцией, которая возвращает последовательность подстрок.

См. также:

  • итератор splitLines
  • функция splitWhitespace
  • функция countLines
Исходный код Редактировать 
func splitWhitespace(s: string; maxsplit: int = -1): seq[string] {....gcsafe,
    extern: "nsuSplitWhitespace", raises: [], tags: [], forbids: [].}

То же самое, что и итератор splitWhitespace (см. его документацию), но является функцией, которая возвращает последовательность подстрок.

См. также:

  • итератор splitWhitespace
  • функция splitLines
Исходный код Редактировать 
func startsWith(s, prefix: string): bool {....gcsafe, extern: "nsuStartsWith",
    raises: [], tags: [], forbids: [].}

Возвращает true, если s начинается со строки prefix.

Если prefix == "" true возвращается.

См. также:

  • функция endsWith
  • функция continuesWith
  • функция removePrefix

Пример:

let a = "abracadabra"
doAssert a.startsWith("abra") == true
doAssert a.startsWith("bra") == false
Исходный код Редактировать 
func startsWith(s: string; prefix: char): bool {.inline, ...raises: [], tags: [],
    forbids: [].}

Возвращает true, если s начинается с символа prefix.

См. также:

  • функция endsWith
  • функция continuesWith
  • функция removePrefix

Пример:

let a = "abracadabra"
doAssert a.startsWith('a') == true
doAssert a.startsWith('b') == false
Исходный код Редактировать 
func strip(s: string; leading = true; trailing = true;
           chars: set[char] = Whitespace): string {....gcsafe, extern: "nsuStrip",
    raises: [], tags: [], forbids: [].}

Удаляет ведущие или хвостовые chars (по умолчанию: символы пробела) из s и возвращает получившуюся строку.

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

См. также:

  • процедура strip Встроенная версия.
  • функция stripLineEnd

Пример:

let a = "  vhellov   "
let b = strip(a)
doAssert b == "vhellov"

doAssert a.strip(leading = false) == "  vhellov"
doAssert a.strip(trailing = false) == "vhellov   "

doAssert b.strip(chars = {'v'}) == "hello"
doAssert b.strip(leading = false, chars = {'v'}) == "vhello"

let c = "blaXbla"
doAssert c.strip(chars = {'b', 'a'}) == "laXbl"
doAssert c.strip(chars = {'b', 'a', 'l'}) == "X"
Исходный код Редактировать 
func stripLineEnd(s: var string) {....raises: [], tags: [], forbids: [].}
Удаляет один из этих суффиксов из s на месте: \r, \n, \r\n, \f, \v (по максимуму один раз). Например, может быть полезен в сочетании с osproc.execCmdEx. псевдоним: chomp

Пример:

var s = "foo\n\n"
s.stripLineEnd
doAssert s == "foo\n"
s = "foo\r\n"
s.stripLineEnd
doAssert s == "foo"
Исходный код Редактировать 
func toBin(x: BiggestInt; len: Positive): string {....gcsafe, extern: "nsuToBin",
    raises: [], tags: [], forbids: [].}

Преобразует x в его двоичное представление.

Полученная строка всегда имеет длину len символов. Нет префикса 0b.

Пример:

let
  a = 29
  b = 257
doAssert a.toBin(8) == "00011101"
doAssert b.toBin(8) == "00000001"
doAssert b.toBin(9) == "100000001"
Исходный код Редактировать 
func toHex(s: string): string {....gcsafe, raises: [], tags: [], forbids: [].}

Преобразует строку байтов в её шестнадцатеричное представление.

Длина результата в два раза больше длины входных данных. Не генерируется префикс, такой как 0x.

См. также:

  • parseHexStr функция для обратной операции

Пример:

let
  a = "1"
  b = "A"
  c = "\0\255"
doAssert a.toHex() == "31"
doAssert b.toHex() == "41"
doAssert c.toHex() == "00FF"
Исходный код Редактировать 
func toHex[T: SomeInteger](x: T): string
Краткая форма для toHex(x, T.sizeof * 2)

Пример:

doAssert toHex(1984'i64) == "00000000000007C0"
doAssert toHex(1984'i16) == "07C0"
Исходный код Редактировать 
func toHex[T: SomeInteger](x: T; len: Positive): string

Преобразует x в его шестнадцатеричное представление.

Полученная строка будет иметь ровно len символов. Не генерируется префикс, такой как 0x. x обрабатывается как беззнаковое значение.

Пример:

let
  a = 62'u64
  b = 4097'u64
doAssert a.toHex(3) == "03E"
doAssert b.toHex(3) == "001"
doAssert b.toHex(4) == "1001"
doAssert toHex(62, 3) == "03E"
doAssert toHex(-8, 6) == "FFFFF8"
Исходный код Редактировать 
func toLowerAscii(c: char): char {....gcsafe, extern: "nsuToLowerAsciiChar",
                                   raises: [], tags: [], forbids: [].}

Возвращает строчное представление символа c.

Работает только для букв A-Z. Для любого символа Юникода используйте unicode.toLower.

См. также:

  • isLowerAscii функция
  • toLowerAscii функция для преобразования строки

Пример:

doAssert toLowerAscii('A') == 'a'
doAssert toLowerAscii('e') == 'e'
Исходный код Редактировать 
func toLowerAscii(s: string): string {....gcsafe, extern: "nsuToLowerAsciiStr",
                                       raises: [], tags: [], forbids: [].}

Преобразует строку s в строчные буквы.

Работает только для букв A-Z. Для любого символа Юникода используйте unicode.toLower.

См. также:

  • normalize функция

Пример:

doAssert toLowerAscii("FooBar!") == "foobar!"
Исходный код Редактировать 
func toOct(x: BiggestInt; len: Positive): string {....gcsafe, extern: "nsuToOct",
    raises: [], tags: [], forbids: [].}

Преобразует x в его восьмеричное представление.

Полученная строка всегда имеет длину len символов. Нет префикса 0o.

Не путайте с toOctal функцией.

Пример:

let
  a = 62
  b = 513
doAssert a.toOct(3) == "076"
doAssert b.toOct(3) == "001"
doAssert b.toOct(5) == "01001"
Исходный код Редактировать 
func toOctal(c: char): string {....gcsafe, extern: "nsuToOctal", raises: [],
                                tags: [], forbids: [].}

Преобразует символ c в его восьмеричное представление.

Полученная строка может не иметь ведущего нуля. Её длина всегда ровно 3.

Не путайте с toOct функцией.

Пример:

doAssert toOctal('1') == "061"
doAssert toOctal('A') == "101"
doAssert toOctal('a') == "141"
doAssert toOctal('!') == "041"
Исходный код Редактировать 
func toUpperAscii(c: char): char {....gcsafe, extern: "nsuToUpperAsciiChar",
                                   raises: [], tags: [], forbids: [].}

Преобразует символ c в заглавные буквы.

Работает только для букв A-Z. Для любого символа Юникода используйте unicode.toUpper.

См. также:

  • isUpperAscii функция
  • toUpperAscii функция для преобразования строки
  • capitalizeAscii функция

Пример:

doAssert toUpperAscii('a') == 'A'
doAssert toUpperAscii('E') == 'E'
Исходный код Редактировать 
func toUpperAscii(s: string): string {....gcsafe, extern: "nsuToUpperAsciiStr",
                                       raises: [], tags: [], forbids: [].}

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

Работает только для букв A-Z. Для любого символа Юникода используйте unicode.toUpper.

См. также:

  • capitalizeAscii функция

Пример:

doAssert toUpperAscii("FooBar!") == "FOOBAR!"
Исходный код Редактировать 
func trimZeros(x: var string; decimalSep = '.') {....raises: [], tags: [],
    forbids: [].}

Удаляет хвостовые нули из отформатированного значения с плавающей точкой x (должно быть объявлено как var).

Изменяет само значение x, не возвращает копию.

Пример:

var x = "123.456000000"
x.trimZeros()
doAssert x == "123.456"
Исходный код Редактировать 
func unescape(s: string; prefix = "\""; suffix = "\""): string {....gcsafe,
    extern: "nsuUnescape", raises: [ValueError], tags: [], forbids: [].}

Распаковывает строку s.

Это дополнение к escape функции, так как выполняет обратные операции.

Если s не начинается с prefix и не заканчивается suffix, будет выброшено исключение ValueError.

Исходный код Редактировать 
func unindent(s: string; count: Natural = int.high; padding: string = " "): string {.
    ...gcsafe, extern: "nsuUnindent", raises: [], tags: [], forbids: [].}

Сдвигает влево каждую строку в s на количество count padding.

Примечание: Это не сохраняет символы новой строки, используемые в s.

См. также:

  • dedent функция
  • align функция
  • alignLeft функция
  • spaces функция
  • indent функция

Пример:

let x = """
      Hello
        There
    """.unindent()

doAssert x == "Hello\nThere\n"
Исходный код Редактировать 
func validIdentifier(s: string): bool {....gcsafe, extern: "nsuValidIdentifier",
                                        raises: [], tags: [], forbids: [].}

Возвращает true, если s является допустимым идентификатором.

Допустимый идентификатор начинается с символа из набора IdentStartChars и продолжается любым количеством символов из набора IdentChars.

Пример:

doAssert "abc_def08".validIdentifier
Исходный код Редактировать

Итераторы

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

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

for piece in "foo:bar".rsplit(':'):
  echo piece

Результаты:

"bar"
"foo"

Подстроки разделены справа символом sep.

См. также:

  • итератор split
  • итератор splitLines
  • итератор splitWhitespace
  • функция rsplit
Исходный код Редактировать 
iterator rsplit(s: string; sep: string; maxsplit: int = -1;
                keepSeparators: bool = false): string {....raises: [], tags: [],
    forbids: [].}

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

for piece in "foothebar".rsplit("the"):
  echo piece

Результаты:

"bar"
"foo"

Подстроки разделены справа строкой sep

Примечание: Пустая строка-разделитель приводит к возвращению исходной строки, следуя интерпретации "разделить по отсутствию элемента".

См. также:

  • итератор split
  • итератор splitLines
  • итератор splitWhitespace
  • функция rsplit
Исходный код Редактировать 
iterator rsplit(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): string {.
    ...raises: [], tags: [], forbids: [].}

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

for piece in "foo bar".rsplit(WhiteSpace):
  echo piece

Результаты:

"bar"
"foo"

Подстроки разделены справа набором символов seps

Примечание: Пустой набор разделителей приводит к возвращению исходной строки, следуя интерпретации "разделить по отсутствию элемента".

См. также:

  • итератор split
  • итератор splitLines
  • итератор splitWhitespace
  • функция rsplit
Исходный код Редактировать 
iterator split(s: string; sep: char; maxsplit: int = -1): string {....raises: [],
    tags: [], forbids: [].}

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

Подстроки разделены символом sep. Код:

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

Результаты:

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

См. также:

  • итератор rsplit
  • итератор splitLines
  • итератор splitWhitespace
  • функция split
Исходный код Редактировать 
iterator split(s: string; sep: string; maxsplit: int = -1): string {....raises: [],
    tags: [], forbids: [].}

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

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

for word in split("thisDATAisDATAcorrupted", "DATA"):
  writeLine(stdout, word)

Результаты:

"this"
"is"
"corrupted"
Примечание: Пустая строка-разделитель приводит к возвращению исходной строки, следуя интерпретации "разделить по отсутствию элемента".

См. также:

  • итератор rsplit
  • итератор splitLines
  • итератор splitWhitespace
  • функция split
Исходный код Редактировать 
iterator split(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): string {.
    ...raises: [], tags: [], forbids: [].}

Разделяет строку 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"
Примечание: Пустой набор разделителей приводит к возвращению исходной строки, следуя интерпретации "разделить по отсутствию элемента".

См. также:

  • итератор rsplit
  • итератор splitLines
  • итератор splitWhitespace
  • функция split
Исходный код Редактировать 
iterator splitLines(s: string; keepEol = false): string {....raises: [], tags: [],
    forbids: [].}

Разделяет строку s на составляющие её строки.

Поддерживаются все сочетания символов новой строки (CR, LF, CR-LF). Результирующие строки не содержат заключительных символов новой строки, если параметр keepEol не установлен в true.

Пример:

for line in splitLines("\nthis\nis\nan\n\nexample\n"):
  writeLine(stdout, line)

Результаты:

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

См. также:

  • итератор splitWhitespace
  • функция splitLines
Исходный код Редактировать 
iterator splitWhitespace(s: string; maxsplit: int = -1): string {....raises: [],
    tags: [], forbids: [].}

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

Следующий код:

let s = "  foo \t bar  baz  "
for ms in [-1, 1, 2, 3]:
  echo "------ maxsplit = ", ms, ":"
  for item in s.splitWhitespace(maxsplit=ms):
    echo '"', item, '"'

…приводит к:

------ maxsplit = -1:
"foo"
"bar"
"baz"
------ maxsplit = 1:
"foo"
"bar  baz  "
------ maxsplit = 2:
"foo"
"bar"
"baz  "
------ maxsplit = 3:
"foo"
"bar"
"baz"

См. также:

  • итератор splitLines
  • функция splitWhitespace
Исходный код Редактировать 
iterator tokenize(s: string; seps: set[char] = Whitespace): tuple[token: string,
    isSep: bool] {....raises: [], tags: [], forbids: [].}

Разбивает строку s на подстроки.

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

for word in tokenize("  this is an  example  "):
  writeLine(stdout, word)

Результаты:

("  ", true)
("this", false)
(" ", true)
("is", false)
(" ", true)
("an", false)
("  ", true)
("example", false)
("  ", true)
Исходный код Редактировать

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

Spec-Zone.ru

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