Spec-Zone.ru › Nim 1

parseutils

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

Чтобы распаковать необработанные байты, обратитесь к модулю 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 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}" Исходный код Редактировать

Процедуры

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 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 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: string; ident: var string; start = 0): int {...}{.raises: [],
    tags: [].}
Парсит идентификатор и сохраняет его в ident. Возвращает количество прочитанных символов или 0 в случае ошибки.

Пример:

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: [].}
Парсит идентификатор и возвращает его или пустую строку в случае ошибки.

Пример:

doAssert parseIdent("Hello World", 0) == "Hello"
doAssert parseIdent("Hello World", 1) == "ello"
doAssert parseIdent("Hello World", 5) == ""
doAssert parseIdent("Hello World", 6) == "World"
Исходный код Редактировать 
proc skipWhitespace(s: string; start = 0): int {...}{.inline, raises: [], tags: [].}
Пропускает пробелы, начиная с 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 skip(s, token: string; start = 0): int {...}{.inline, raises: [], tags: [].}
Пропускает 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: string; start = 0): int {...}{.raises: [], tags: [].}
То же, что и skip, но регистр при поиске токенов игнорируется.

Пример:

doAssert skipIgnoreCase("CAPlow", "CAP", 0) == 3
doAssert skipIgnoreCase("CAPlow", "cap", 0) == 3
Исходный код Редактировать 
proc skipUntil(s: string; until: set[char]; start = 0): int {...}{.inline,
    raises: [], tags: [].}
Пропускает все символы, пока не найдёт символ из набора 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: [].}
Пропускает все символы до тех пор, пока не найдёт символ 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 skipWhile(s: string; toSkip: set[char]; start = 0): int {...}{.inline,
    raises: [], tags: [].}
Пропускает все символы, пока не найдёт символ из набора token. Возвращает количество пропущенных символов.

Пример:

doAssert skipWhile("Hello World", {'H', 'e'}) == 2
doAssert skipWhile("Hello World", {'e'}) == 0
doAssert skipWhile("Hello World", {'W', 'o', 'r'}, 6) == 3
Исходный код Редактировать 
proc parseUntil(s: string; token: var string; until: set[char]; start = 0): int {...}{.
    inline, raises: [], tags: [].}
Парсит токен и сохраняет его в 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: char; start = 0): int {...}{.
    inline, raises: [], tags: [].}
Парсит токен и сохраняет его в 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: string; start = 0): int {...}{.
    inline, raises: [], tags: [].}
Парсит токен и сохраняет его в 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: string; token: var string; validChars: set[char]; start = 0): int {...}{.
    inline, raises: [], tags: [].}
Парсит токен и сохраняет его в 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 captureBetween(s: string; first: char; second = '\x00'; start = 0): string {...}{.
    raises: [], tags: [].}
Находит первое вхождение 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 parseBiggestInt(s: string; number: var BiggestInt; start = 0): int {...}{.
    gcsafe, extern: "npuParseBiggestInt", noSideEffect, raises: [ValueError],
    tags: [].}
Парсит целое число, начиная с start, и сохраняет значение в number. Результат — количество обработанных символов или 0, если целого числа нет. ValueError генерируется, если обработанное целое число выходит за допустимый диапазон.

Пример:

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

Пример:

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

Пример:

var res = 0
discard parseSaturatedNatural("848", res)
doAssert res == 848
Исходный код Редактировать 
proc parseBiggestUInt(s: string; number: var BiggestUInt; start = 0): int {...}{.
    gcsafe, extern: "npuParseBiggestUInt", noSideEffect, raises: [ValueError],
    tags: [].}
Парсит целое беззнаковое число, начиная с 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 parseUInt(s: string; number: var uint; start = 0): int {...}{.gcsafe,
    extern: "npuParseUInt", noSideEffect, raises: [ValueError], tags: [].}
Парсит целое беззнаковое число, начиная с start, и сохраняет значение в number. ValueError генерируется, если парсируемое целое число выходит за допустимый диапазон.

Пример:

var res: uint
doAssert parseUInt("3450", res) == 4
doAssert res == 3450
doAssert parseUInt("3450", res, 2) == 2
doAssert res == 50
Исходный код Изменить 
proc parseBiggestFloat(s: string; number: var BiggestFloat; start = 0): int {...}{.
    magic: "ParseBiggestFloat", importc: "nimParseBiggestFloat", noSideEffect.}
Парсит число с плавающей точкой, начиная с start, и сохраняет значение в number. Результат — количество обработанных символов или 0, если произошла ошибка парсинга. Исходный код Изменить 
proc parseFloat(s: string; number: var float; start = 0): int {...}{.gcsafe,
    extern: "npuParseFloat", noSideEffect, raises: [], tags: [].}
Парсит число с плавающей точкой, начиная с 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
Исходный код Изменить

Итераторы

iterator interpolatedFragments(s: string): tuple[kind: InterpolatedKind,
    value: string] {...}{.raises: [ValueError], tags: [].}
Токенизирует строку 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, "$")]
Исходный код Изменить

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

Spec-Zone.ru

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