std/parseutils

Source Edit

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

Для разбора необработанных байтов обратитесь к модулю streams.

let logs = @["2019-01-10: OK_", "2019-01-11: FAIL_", "2019-01: aaaa"]
var outp: seq[string]

for log in logs:
  var res: string
  if parseUntil(log, res, ':') == 10: # YYYY-MM-DD == 10
    outp.add(res & " - " & captureBetween(log, ' ', '_'))
doAssert outp == @["2019-01-10 - OK", "2019-01-11 - FAIL"]

from std/strutils import Digits, parseInt

let
  input1 = "2019 school start"
  input2 = "3 years back"
  startYear = input1[0 .. skipWhile(input1, Digits)-1] # 2019
  yearsBack = input2[0 .. skipWhile(input2, Digits)-1] # 3
  examYear = parseInt(startYear) + parseInt(yearsBack)
doAssert "Examination is in " & $examYear == "Examination is in 2022"

См. также:

модуль strutils для комбинированных и идентичных процедур разбора
модуль json для парсера JSON
модуль parsecfg для парсера файла конфигурации
модуль parsecsv для простого парсера CSV (значения, разделённые запятыми)
модуль parseopt для парсера командной строки
модуль parsexml для парсера XML/HTML
другие парсеры для других парсеров

Типы

InterpolatedKind = enum ikStr, ## ``str`` part of the interpolated string ikDollar, ## escaped ``$`` part of the interpolated string ikVar, ## ``var`` part of the interpolated string ikExpr ## ``expr`` part of the interpolated string: Описывает, какая часть интерполированной строки возвращается; например, в "str$$$var${expr}" Source Edit

Процедуры

proc captureBetween(s: openArray[char]; first: char; second = '\x00'): string {. ...raises: [], tags: [], forbids: [].}: Находит первое вхождение first, затем возвращает все символы до second (если second равно '0', используется first).
Пример:

doAssert captureBetween("Hello World", 'e') == "llo World" doAssert captureBetween("Hello World", 'e', 'r') == "llo Wo" doAssert captureBetween("Hello World".toOpenArray(6, "Hello World".high), 'l') == "d"
Исходный код Изменить
proc captureBetween(s: string; first: char; second = '\x00'; start = 0): string {. ...raises: [], tags: [], forbids: [].}: Находит первое вхождение first, затем возвращает все символы до second (если second равно '0', используется first).
Пример:

doAssert captureBetween("Hello World", 'e') == "llo World" doAssert captureBetween("Hello World", 'e', 'r') == "llo Wo" doAssert captureBetween("Hello World", 'l', start = 6) == "d"
Исходный код Изменить
proc parseBiggestFloat(s: openArray[char]; number: var BiggestFloat): int {. magic: "ParseBiggestFloat", importc: "nimParseBiggestFloat", noSideEffect, ...raises: [], tags: [], forbids: [].}: Парсит число с плавающей точкой и сохраняет значение в number. Результат — количество обработанных символов или 0 в случае ошибки парсинга. Исходный код Изменить
proc parseBiggestFloat(s: string; number: var BiggestFloat; start = 0): int {. noSideEffect, ...raises: [], tags: [], forbids: [].}: Парсит число с плавающей точкой, начиная с start и сохраняет значение в number. Результат — количество обработанных символов или 0 в случае ошибки парсинга. Исходный код Изменить
proc parseBiggestInt(s: openArray[char]; number: var BiggestInt): int {....gcsafe, extern: "npuParseBiggestInt", noSideEffect, ...raises: [ValueError], tags: [], forbids: [].}: Парсит целое число и сохраняет значение в number. Результат — количество обработанных символов или 0, если целого числа нет. ValueError генерируется, если парсируемое целое число выходит за допустимый диапазон.
Пример:

var res: BiggestInt doAssert parseBiggestInt("9223372036854775807", res) == 19 doAssert res == 9223372036854775807 doAssert parseBiggestInt("-2024_05_09", res) == 11 doAssert res == -20240509
Исходный код Изменить
proc parseBiggestInt(s: string; number: var BiggestInt; start = 0): int {. noSideEffect, ...raises: [ValueError], tags: [], forbids: [].}: Парсит целое число, начиная с start и сохраняет значение в number. Результат — количество обработанных символов или 0, если целого числа нет. ValueError генерируется, если парсируемое целое число выходит за допустимый диапазон.
Пример:

var res: BiggestInt doAssert parseBiggestInt("9223372036854775807", res, 0) == 19 doAssert res == 9223372036854775807 doAssert parseBiggestInt("-2024_05_09", res) == 11 doAssert res == -20240509 doAssert parseBiggestInt("-2024_05_02", res, 7) == 4 doAssert res == 502
Исходный код Изменить
proc parseBiggestUInt(s: openArray[char]; number: var BiggestUInt): int {. ...gcsafe, extern: "npuParseBiggestUInt", noSideEffect, ...raises: [ValueError], tags: [], forbids: [].}: Парсит целое беззнаковое число и сохраняет значение в number. ValueError генерируется, если парсируемое целое число выходит за допустимый диапазон.
Пример:

var res: BiggestUInt doAssert parseBiggestUInt("12", res, 0) == 2 doAssert res == 12 doAssert parseBiggestUInt("1111111111111111111", res, 0) == 19 doAssert res == 1111111111111111111'u64
Исходный код Изменить
proc parseBiggestUInt(s: string; number: var BiggestUInt; start = 0): int {. noSideEffect, ...raises: [ValueError], tags: [], forbids: [].}: Парсит целое беззнаковое число, начиная с start и сохраняет значение в number. ValueError генерируется, если парсируемое целое число выходит за допустимый диапазон.
Пример:

var res: BiggestUInt doAssert parseBiggestUInt("12", res, 0) == 2 doAssert res == 12 doAssert parseBiggestUInt("1111111111111111111", res, 0) == 19 doAssert res == 1111111111111111111'u64
Исходный код Изменить
proc parseBin[T: SomeInteger](s: openArray[char]; number: var T; maxLen = 0): int {. noSideEffect.}: Парсит двоичное число и сохраняет его значение в number.

Возвращает количество прочитанных символов или 0 в случае ошибки. При ошибке значение number не изменяется.

Если maxLen == 0, парсинг продолжается до первого символа, не являющегося двоичным, или до конца строки. В противном случае, не более maxLen символов парсятся, начиная с позиции start.

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

Пример:

var num: int doAssert parseBin("0100_1110_0110_1001_1110_1101", num) == 29 doAssert num == 5138925 doAssert parseBin("3", num) == 0 var num8: int8 doAssert parseBin("0b_0100_1110_0110_1001_1110_1101", num8) == 32 doAssert num8 == 0b1110_1101'i8 doAssert parseBin("0b_0100_1110_0110_1001_1110_1101", num8, 3, 9) == 9 doAssert num8 == 0b0100_1110'i8 var num8u: uint8 doAssert parseBin("0b_0100_1110_0110_1001_1110_1101", num8u) == 32 doAssert num8u == 237 var num64: int64 doAssert parseBin("0100111001101001111011010100111001101001", num64) == 40 doAssert num64 == 336784608873
Исходный код Изменить
proc parseBin[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int {. noSideEffect.}: Парсит двоичное число и сохраняет его значение в number.

Возвращает количество прочитанных символов или 0 в случае ошибки. При ошибке значение number не изменяется.

Если maxLen == 0, парсинг продолжается до первого символа, не являющегося двоичным, или до конца строки. В противном случае, не более maxLen символов парсятся, начиная с позиции start.

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

Пример:

var num: int doAssert parseBin("0100_1110_0110_1001_1110_1101", num) == 29 doAssert num == 5138925 doAssert parseBin("3", num) == 0 var num8: int8 doAssert parseBin("0b_0100_1110_0110_1001_1110_1101", num8) == 32 doAssert num8 == 0b1110_1101'i8 doAssert parseBin("0b_0100_1110_0110_1001_1110_1101", num8, 3, 9) == 9 doAssert num8 == 0b0100_1110'i8 var num8u: uint8 doAssert parseBin("0b_0100_1110_0110_1001_1110_1101", num8u) == 32 doAssert num8u == 237 var num64: int64 doAssert parseBin("0100111001101001111011010100111001101001", num64) == 40 doAssert num64 == 336784608873
Исходный код Изменить
proc parseChar(s: openArray[char]; c: var char): int {....raises: [], tags: [], forbids: [].}: Парсит одиночный символ, сохраняет его в c и возвращает 1. В случае ошибки (если start >= s.len) возвращает 0 и значение c не изменяется.
Пример:

var c: char doAssert "nim".parseChar(c, 3) == 0 doAssert c == '\0' doAssert "nim".parseChar(c, 0) == 1 doAssert c == 'n'
Исходный код Изменить
proc parseChar(s: string; c: var char; start = 0): int {....raises: [], tags: [], forbids: [].}: Парсит одиночный символ, сохраняет его в c и возвращает 1. В случае ошибки (если start >= s.len) возвращает 0 и значение c не изменяется.
Пример:

var c: char doAssert "nim".parseChar(c, 3) == 0 doAssert c == '\0' doAssert "nim".parseChar(c, 0) == 1 doAssert c == 'n'
Исходный код Изменить
proc parseFloat(s: openArray[char]; number: var float): int {....gcsafe, extern: "npuParseFloat", noSideEffect, ...raises: [], tags: [], forbids: [].}: Парсит число с плавающей точкой и сохраняет значение в number. Результат — количество обработанных символов или 0 в случае ошибки парсинга.
Пример:

var res: float doAssert parseFloat("32", res, 0) == 2 doAssert res == 32.0 doAssert parseFloat("32.57", res, 0) == 5 doAssert res == 32.57 doAssert parseFloat("32.57", res, 3) == 2 doAssert res == 57.00
Исходный код Изменить
proc parseFloat(s: string; number: var float; start = 0): int {.noSideEffect, ...raises: [], tags: [], forbids: [].}: Парсит число с плавающей точкой, начиная с start и сохраняет значение в number. Результат — количество обработанных символов или 0 в случае ошибки парсинга.
Пример:

var res: float doAssert parseFloat("32", res, 0) == 2 doAssert res == 32.0 doAssert parseFloat("32.57", res, 0) == 5 doAssert res == 32.57 doAssert parseFloat("32.57", res, 3) == 2 doAssert res == 57.00
Исходный код Изменить
proc parseHex[T: SomeInteger](s: openArray[char]; number: var T; maxLen = 0): int {. noSideEffect.}: Парсит шестнадцатеричное число и сохраняет его значение в number.

Возвращает количество прочитанных символов или 0 в случае ошибки. При ошибке значение number не изменяется.

Если maxLen == 0, парсинг продолжается до первого символа, не являющегося шестнадцатеричным, или до конца строки. В противном случае, не более maxLen символов парсятся, начиная с позиции start.

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

Пример:

var num: int doAssert parseHex("4E_69_ED", num) == 8 doAssert num == 5138925 doAssert parseHex("X", num) == 0 doAssert parseHex("#ABC", num) == 4 var num8: int8 doAssert parseHex("0x_4E_69_ED", num8) == 11 doAssert num8 == 0xED'i8 doAssert parseHex("0x_4E_69_ED", num8, 3, 2) == 2 doAssert num8 == 0x4E'i8 var num8u: uint8 doAssert parseHex("0x_4E_69_ED", num8u) == 11 doAssert num8u == 237 var num64: int64 doAssert parseHex("4E69ED4E69ED", num64) == 12 doAssert num64 == 86216859871725
Исходный код Изменить
proc parseHex[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int {. noSideEffect.}: Парсит шестнадцатеричное число и сохраняет его значение в number.

Возвращает количество прочитанных символов или 0 в случае ошибки. При ошибке значение number не изменяется.

Если maxLen == 0, парсинг продолжается до первого символа, не являющегося шестнадцатеричным, или до конца строки. В противном случае, не более maxLen символов парсятся, начиная с позиции start.

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

Пример:

var num: int doAssert parseHex("4E_69_ED", num) == 8 doAssert num == 5138925 doAssert parseHex("X", num) == 0 doAssert parseHex("#ABC", num) == 4 var num8: int8 doAssert parseHex("0x_4E_69_ED", num8) == 11 doAssert num8 == 0xED'i8 doAssert parseHex("0x_4E_69_ED", num8, 3, 2) == 2 doAssert num8 == 0x4E'i8 var num8u: uint8 doAssert parseHex("0x_4E_69_ED", num8u) == 11 doAssert num8u == 237 var num64: int64 doAssert parseHex("4E69ED4E69ED", num64) == 12 doAssert num64 == 86216859871725
Исходный код Изменить

proc parseIdent(s: openArray[char]): string {....raises: [], tags: [], forbids: [].}: Разбирает идентификатор и возвращает его или пустую строку в случае ошибки.
Пример:

doAssert parseIdent("Hello World", 0) == "Hello" doAssert parseIdent("Hello World", 1) == "ello" doAssert parseIdent("Hello World", 5) == "" doAssert parseIdent("Hello World", 6) == "World"
Исходный код Редактировать
proc parseIdent(s: openArray[char]; ident: var string): int {....raises: [], tags: [], forbids: [].}: Разбирает идентификатор и сохраняет его в ident. Возвращает количество проанализированных символов или 0 в случае ошибки. При ошибке значение ident не изменяется.
Пример:

var res: string doAssert parseIdent("Hello World", res, 0) == 5 doAssert res == "Hello" doAssert parseIdent("Hello World", res, 1) == 4 doAssert res == "ello" doAssert parseIdent("Hello World", res, 6) == 5 doAssert res == "World"
Исходный код Редактировать
proc parseIdent(s: string; ident: var string; start = 0): int {....raises: [], tags: [], forbids: [].}: Разбирает идентификатор и сохраняет его в ident. Возвращает количество проанализированных символов или 0 в случае ошибки. При ошибке значение ident не изменяется.
Пример:

var res: string doAssert parseIdent("Hello World", res, 0) == 5 doAssert res == "Hello" doAssert parseIdent("Hello World", res, 1) == 4 doAssert res == "ello" doAssert parseIdent("Hello World", res, 6) == 5 doAssert res == "World"
Исходный код Редактировать
proc parseIdent(s: string; start = 0): string {....raises: [], tags: [], forbids: [].}: Разбирает идентификатор и возвращает его или пустую строку в случае ошибки.
Пример:

doAssert parseIdent("Hello World", 0) == "Hello" doAssert parseIdent("Hello World", 1) == "ello" doAssert parseIdent("Hello World", 5) == "" doAssert parseIdent("Hello World", 6) == "World"
Исходный код Редактировать
proc parseInt(s: openArray[char]; number: var int): int {....gcsafe, extern: "npuParseInt", noSideEffect, ...raises: [ValueError], tags: [], forbids: [].}: Разбирает целое число и сохраняет значение в number. Результатом является количество обработанных символов или 0, если целого числа нет. ValueError возникает, если проанализированное целое число выходит за допустимый диапазон.
Пример:

var res: int doAssert parseInt("-2024_05_02", res) == 11 doAssert res == -20240502
Исходный код Редактировать
proc parseInt(s: string; number: var int; start = 0): int {.noSideEffect, ...raises: [ValueError], tags: [], forbids: [].}: Разбирает целое число, начиная с start и сохраняет значение в number. Результатом является количество обработанных символов или 0, если целого числа нет. ValueError возникает, если проанализированное целое число выходит за допустимый диапазон.
Пример:

var res: int doAssert parseInt("-2024_05_02", res) == 11 doAssert res == -20240502 doAssert parseInt("-2024_05_02", res, 7) == 4 doAssert res == 502
Исходный код Редактировать
proc parseOct[T: SomeInteger](s: openArray[char]; number: var T; maxLen = 0): int {. noSideEffect.}: Разбирает восьмеричное число и сохраняет его значение в number.

Возвращает количество проанализированных символов или 0 в случае ошибки. При ошибке значение number не изменяется.

Если maxLen == 0, разбор продолжается до первой невосьмеричной цифры или до конца строки. В противном случае, не более maxLen символов анализируются, начиная с позиции start.

Он не проверяет переполнение. Если значение, представленное строкой, слишком велико для number, только значение последних подходящих символов будет сохранено в number без генерации ошибки.

Пример:

var num: int doAssert parseOct("0o23464755", num) == 10 doAssert num == 5138925 doAssert parseOct("8", num) == 0 var num8: int8 doAssert parseOct("0o_1464_755", num8) == 11 doAssert num8 == -19 doAssert parseOct("0o_1464_755", num8, 3, 3) == 3 doAssert num8 == 102 var num8u: uint8 doAssert parseOct("1464755", num8u) == 7 doAssert num8u == 237 var num64: int64 doAssert parseOct("2346475523464755", num64) == 16 doAssert num64 == 86216859871725
Исходный код Редактировать
proc parseOct[T: SomeInteger](s: string; number: var T; start = 0; maxLen = 0): int {. noSideEffect.}: Разбирает восьмеричное число и сохраняет его значение в number.

Возвращает количество проанализированных символов или 0 в случае ошибки. При ошибке значение number не изменяется.

Если maxLen == 0, разбор продолжается до первой невосьмеричной цифры или до конца строки. В противном случае, не более maxLen символов анализируются, начиная с позиции start.

Он не проверяет переполнение. Если значение, представленное строкой, слишком велико для number, только значение последних подходящих символов будет сохранено в number без генерации ошибки.

Пример:

var num: int doAssert parseOct("0o23464755", num) == 10 doAssert num == 5138925 doAssert parseOct("8", num) == 0 var num8: int8 doAssert parseOct("0o_1464_755", num8) == 11 doAssert num8 == -19 doAssert parseOct("0o_1464_755", num8, 3, 3) == 3 doAssert num8 == 102 var num8u: uint8 doAssert parseOct("1464755", num8u) == 7 doAssert num8u == 237 var num64: int64 doAssert parseOct("2346475523464755", num64) == 16 doAssert num64 == 86216859871725
Исходный код Редактировать
proc parseSaturatedNatural(s: openArray[char]; b: var int): int {....raises: [], tags: [], forbids: [].}: Разбирает натуральное число в b. Это не может вызвать ошибку переполнения. high(int) возвращается при переполнении. Возвращается количество обработанных символов. Это обычно то, что вы действительно хотите использовать вместо parseInt.
Пример:

var res = 0 discard parseSaturatedNatural("848", res) doAssert res == 848
Исходный код Редактировать
proc parseSaturatedNatural(s: string; b: var int; start = 0): int {....raises: [], tags: [], forbids: [].}: Разбирает натуральное число в b. Это не может вызвать ошибку переполнения. high(int) возвращается при переполнении. Возвращается количество обработанных символов. Это обычно то, что вы действительно хотите использовать вместо parseInt.
Пример:

var res = 0 discard parseSaturatedNatural("848", res) doAssert res == 848
Исходный код Редактировать
func parseSize(s: openArray[char]; size: var int64; alwaysBin = false): int {. ...raises: [], tags: [], forbids: [].}: Разбирает размер, квалифицированный двоичными или метрическими единицами в size. Этот формат часто называется «человекочитаемым». Результатом является количество обработанных символов или 0 при ошибках разбора, а размер округляется до ближайшего целого числа. Позволяются и обнаруживаются trailing garbage, например, «/s» в «1k/s», с помощью result < s.len.

Для упрощения использования, следуя распространённым соглашениям, и поскольку дробные данные, такие как миллибайты, встречаются редко, соответствие единиц нечувствительно к регистру, но для 'i' в различении двоично-метрических и метрических единиц (которые не могут быть 'I').

Необязательная конечная 'B|b' игнорируется, но обрабатывается. То есть, вы все равно должны знать, являются ли единицы байтами | битами или вывести этот факт из регистра 's^[1]' (если можно полагаться на то, что пользователи будут использовать 'B' для байт и 'b' для битов или иметь это как 's^[1]').

Если alwaysBin==true, масштабы всегда двоично-метрические, но, например, «KiB» по-прежнему принимается для ясности. Если значение превышает диапазон int64, size насыщается до int64.high. Поддерживаемые метрические префиксы включают k, m, g, t, p, e, z, y (но z & y насыщаются, если число не является малой дробью).

См. также:

https://en.wikipedia.org/wiki/Binary_prefix

модуль formatSize для форматирования

Пример:

var res: int64 # caller must still know if 'b' refers to bytes|bits doAssert parseSize("10.5 MB", res) == 7 doAssert res == 10_500_000 # decimal metric Mega prefix doAssert parseSize("64 mib", res) == 6 doAssert res == 67108864 # 64 shl 20 doAssert parseSize("1G/h", res, true) == 2 # '/' stops parse doAssert res == 1073741824 # 1 shl 30, forced binary metric
Исходный код Редактировать
proc parseUInt(s: openArray[char]; number: var uint): int {....gcsafe, extern: "npuParseUInt", noSideEffect, ...raises: [ValueError], tags: [], forbids: [].}: Разбирает целое беззнаковое число и сохраняет значение в number. ValueError возникает, если проанализированное целое число выходит за допустимый диапазон.
Пример:

var res: uint doAssert parseUInt("3450", res) == 4 doAssert res == 3450 doAssert parseUInt("3450", res, 2) == 2 doAssert res == 50
Исходный код Редактировать
proc parseUInt(s: string; number: var uint; start = 0): int {.noSideEffect, ...raises: [ValueError], tags: [], forbids: [].}: Разбирает целое беззнаковое число, начиная с start и сохраняет значение в number. ValueError возникает, если проанализированное целое число выходит за допустимый диапазон.
Пример:

var res: uint doAssert parseUInt("3450", res) == 4 doAssert res == 3450 doAssert parseUInt("3450", res, 2) == 2 doAssert res == 50
Исходный код Редактировать

proc parseUntil(s: openArray[char]; token: var string; until: char): int {. inline, ...raises: [], tags: [], forbids: [].}: Парсит токен и сохраняет его в token. Возвращает количество прочитанных символов или 0 в случае ошибки. Токен состоит из любого символа, который не является символом until.
Пример:

var myToken: string doAssert parseUntil("Hello World", myToken, 'W') == 6 doAssert myToken == "Hello " doAssert parseUntil("Hello World", myToken, 'o') == 4 doAssert myToken == "Hell" doAssert parseUntil("Hello World", myToken, 'o', 2) == 2 doAssert myToken == "ll"
Исходный код Изменить
proc parseUntil(s: openArray[char]; token: var string; until: set[char]): int {. inline, ...raises: [], tags: [], forbids: [].}: Парсит токен и сохраняет его в token. Возвращает количество прочитанных символов или 0 в случае ошибки. Токен состоит из символов, не входящих в until.
Пример:

var myToken: string doAssert parseUntil("Hello World", myToken, {'W', 'o', 'r'}) == 4 doAssert myToken == "Hell" doAssert parseUntil("Hello World", myToken, {'W', 'r'}) == 6 doAssert myToken == "Hello " doAssert parseUntil("Hello World", myToken, {'W', 'r'}, 3) == 3 doAssert myToken == "lo "
Исходный код Изменить
proc parseUntil(s: openArray[char]; token: var string; until: string): int {. inline, ...raises: [], tags: [], forbids: [].}: Парсит токен и сохраняет его в token. Возвращает количество прочитанных символов или 0 в случае ошибки. Токен состоит из любого символа, предшествующего токену until.
Пример:

var myToken: string doAssert parseUntil("Hello World", myToken, "Wor") == 6 doAssert myToken == "Hello " doAssert parseUntil("Hello World", myToken, "Wor", 2) == 4 doAssert myToken == "llo "
Исходный код Изменить
proc parseUntil(s: string; token: var string; until: char; start = 0): int {. inline, ...raises: [], tags: [], forbids: [].}: Парсит токен и сохраняет его в token. Возвращает количество прочитанных символов или 0 в случае ошибки. Токен состоит из любого символа, который не является символом until.
Пример:

var myToken: string doAssert parseUntil("Hello World", myToken, 'W') == 6 doAssert myToken == "Hello " doAssert parseUntil("Hello World", myToken, 'o') == 4 doAssert myToken == "Hell" doAssert parseUntil("Hello World", myToken, 'o', 2) == 2 doAssert myToken == "ll"
Исходный код Изменить
proc parseUntil(s: string; token: var string; until: set[char]; start = 0): int {. inline, ...raises: [], tags: [], forbids: [].}: Парсит токен и сохраняет его в token. Возвращает количество прочитанных символов или 0 в случае ошибки. Токен состоит из символов, не входящих в until.
Пример:

var myToken: string doAssert parseUntil("Hello World", myToken, {'W', 'o', 'r'}) == 4 doAssert myToken == "Hell" doAssert parseUntil("Hello World", myToken, {'W', 'r'}) == 6 doAssert myToken == "Hello " doAssert parseUntil("Hello World", myToken, {'W', 'r'}, 3) == 3 doAssert myToken == "lo "
Исходный код Изменить
proc parseUntil(s: string; token: var string; until: string; start = 0): int {. inline, ...raises: [], tags: [], forbids: [].}: Парсит токен и сохраняет его в token. Возвращает количество прочитанных символов или 0 в случае ошибки. Токен состоит из любого символа, предшествующего токену until.
Пример:

var myToken: string doAssert parseUntil("Hello World", myToken, "Wor") == 6 doAssert myToken == "Hello " doAssert parseUntil("Hello World", myToken, "Wor", 2) == 4 doAssert myToken == "llo "
Исходный код Изменить
proc parseWhile(s: openArray[char]; token: var string; validChars: set[char]): int {. inline, ...raises: [], tags: [], forbids: [].}: Парсит токен и сохраняет его в token. Возвращает количество прочитанных символов или 0 в случае ошибки. Токен состоит из символов, входящих в validChars.
Пример:

var myToken: string doAssert parseWhile("Hello World", myToken, {'W', 'o', 'r'}, 0) == 0 doAssert myToken.len() == 0 doAssert parseWhile("Hello World", myToken, {'W', 'o', 'r'}, 6) == 3 doAssert myToken == "Wor"
Исходный код Изменить
proc parseWhile(s: string; token: var string; validChars: set[char]; start = 0): int {. inline, ...raises: [], tags: [], forbids: [].}: Парсит токен и сохраняет его в token. Возвращает количество прочитанных символов или 0 в случае ошибки. Токен состоит из символов, входящих в validChars.
Пример:

var myToken: string doAssert parseWhile("Hello World", myToken, {'W', 'o', 'r'}, 0) == 0 doAssert myToken.len() == 0 doAssert parseWhile("Hello World", myToken, {'W', 'o', 'r'}, 6) == 3 doAssert myToken == "Wor"
Исходный код Изменить
proc skip(s, token: openArray[char]): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает token, начиная с s[start]. Возвращает длину token или 0, если token не найден в s[start].
Пример:

doAssert skip("2019-01-22", "2019", 0) == 4 doAssert skip("2019-01-22", "19", 0) == 0 doAssert skip("2019-01-22", "19", 2) == 2 doAssert skip("CAPlow", "CAP", 0) == 3 doAssert skip("CAPlow", "cap", 0) == 0
Исходный код Изменить
proc skip(s, token: string; start = 0): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает token, начиная с s[start]. Возвращает длину token или 0, если token не найден в s[start].
Пример:

doAssert skip("2019-01-22", "2019", 0) == 4 doAssert skip("2019-01-22", "19", 0) == 0 doAssert skip("2019-01-22", "19", 2) == 2 doAssert skip("CAPlow", "CAP", 0) == 3 doAssert skip("CAPlow", "cap", 0) == 0
Исходный код Изменить
proc skipIgnoreCase(s, token: openArray[char]): int {....raises: [], tags: [], forbids: [].}: Аналогично skip, но регистр при поиске токена игнорируется.
Пример:

doAssert skipIgnoreCase("CAPlow", "CAP", 0) == 3 doAssert skipIgnoreCase("CAPlow", "cap", 0) == 3
Исходный код Изменить
proc skipIgnoreCase(s, token: string; start = 0): int {....raises: [], tags: [], forbids: [].}: Аналогично skip, но регистр при поиске токена игнорируется.
Пример:

doAssert skipIgnoreCase("CAPlow", "CAP", 0) == 3 doAssert skipIgnoreCase("CAPlow", "cap", 0) == 3
Исходный код Изменить
proc skipUntil(s: openArray[char]; until: char): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает все символы до тех пор, пока не встретится символ until или не будет достигнут конец. Возвращает количество пропущенных символов.
Пример:

doAssert skipUntil("Hello World", 'o', 0) == 4 doAssert skipUntil("Hello World", 'o', 4) == 0 doAssert skipUntil("Hello World", 'W', 0) == 6 doAssert skipUntil("Hello World", 'w', 0) == 11
Исходный код Изменить
proc skipUntil(s: openArray[char]; until: set[char]): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает все символы до тех пор, пока не встретится один из символов из набора until или не будет достигнут конец. Возвращает количество пропущенных символов.
Пример:

doAssert skipUntil("Hello World", {'W', 'e'}, 0) == 1 doAssert skipUntil("Hello World", {'W'}, 0) == 6 doAssert skipUntil("Hello World", {'W', 'd'}, 0) == 6
Исходный код Изменить
proc skipUntil(s: string; until: char; start = 0): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает все символы до тех пор, пока не встретится символ until или не будет достигнут конец. Возвращает количество пропущенных символов.
Пример:

doAssert skipUntil("Hello World", 'o', 0) == 4 doAssert skipUntil("Hello World", 'o', 4) == 0 doAssert skipUntil("Hello World", 'W', 0) == 6 doAssert skipUntil("Hello World", 'w', 0) == 11
Исходный код Изменить
proc skipUntil(s: string; until: set[char]; start = 0): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает все символы до тех пор, пока не встретится один из символов из набора until или не будет достигнут конец. Возвращает количество пропущенных символов.
Пример:

doAssert skipUntil("Hello World", {'W', 'e'}, 0) == 1 doAssert skipUntil("Hello World", {'W'}, 0) == 6 doAssert skipUntil("Hello World", {'W', 'd'}, 0) == 6
Исходный код Изменить
proc skipWhile(s: openArray[char]; toSkip: set[char]): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает все символы, пока не встретится один из символов из набора toSkip. Возвращает количество пропущенных символов.
Пример:

doAssert skipWhile("Hello World", {'H', 'e'}) == 2 doAssert skipWhile("Hello World", {'e'}) == 0 doAssert skipWhile("Hello World", {'W', 'o', 'r'}, 6) == 3
Исходный код Изменить
proc skipWhile(s: string; toSkip: set[char]; start = 0): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает все символы, пока не встретится один из символов из набора toSkip. Возвращает количество пропущенных символов.
Пример:

doAssert skipWhile("Hello World", {'H', 'e'}) == 2 doAssert skipWhile("Hello World", {'e'}) == 0 doAssert skipWhile("Hello World", {'W', 'o', 'r'}, 6) == 3
Исходный код Изменить
proc skipWhitespace(s: openArray[char]): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает пробелы, начиная с s[start]. Возвращает количество пропущенных символов.
Пример:

doAssert skipWhitespace("Hello World", 0) == 0 doAssert skipWhitespace(" Hello World", 0) == 1 doAssert skipWhitespace("Hello World", 5) == 1 doAssert skipWhitespace("Hello World", 5) == 2
Исходный код Изменить
proc skipWhitespace(s: string; start = 0): int {.inline, ...raises: [], tags: [], forbids: [].}: Пропускает пробелы, начиная с s[start]. Возвращает количество пропущенных символов.
Пример:

doAssert skipWhitespace("Hello World", 0) == 0 doAssert skipWhitespace(" Hello World", 0) == 1 doAssert skipWhitespace("Hello World", 5) == 1 doAssert skipWhitespace("Hello World", 5) == 2
Исходный код Изменить

Итераторы

iterator interpolatedFragments(s: openArray[char]): tuple[ kind: InterpolatedKind, value: string] {....raises: [ValueError], tags: [], forbids: [].}: Разбивает строку s на подстроки для целей интерполяции.
Пример:

var outp: seq[tuple[kind: InterpolatedKind, value: string]] for k, v in interpolatedFragments(" $this is ${an example} $$"): outp.add (k, v) doAssert outp == @[(ikStr, " "), (ikVar, "this"), (ikStr, " is "), (ikExpr, "an example"), (ikStr, " "), (ikDollar, "$")]
Исходный код Редактировать
iterator interpolatedFragments(s: string): tuple[kind: InterpolatedKind, value: string] {....raises: [ValueError], tags: [], forbids: [].}: Разбивает строку s на подстроки для целей интерполяции.
Пример:

var outp: seq[tuple[kind: InterpolatedKind, value: string]] for k, v in interpolatedFragments(" $this is ${an example} $$"): outp.add (k, v) doAssert outp == @[(ikStr, " "), (ikVar, "this"), (ikStr, " is "), (ikExpr, "an example"), (ikStr, " "), (ikDollar, "$")]
Исходный код Редактировать