strutils

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

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

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

import 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 strutils
from 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, macros, unicode, since

Типы

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

Константы

Whitespace = {' ', '\t', '\v', '\c', '\n', '\f'}

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

Letters = {'A'..'Z', 'a'..'z'}

набор букв Исходный код Изменить

Digits = {'0'..'9'}

набор цифр Исходный код Изменить

HexDigits = {'0'..'9', 'A'..'F', 'a'..'f'}

набор шестнадцатеричных цифр Исходный код Изменить

IdentChars = {'a'..'z', 'A'..'Z', '0'..'9', '_'}

набор символов, из которых может состоять идентификатор Исходный код Изменить

IdentStartChars = {'a'..'z', 'A'..'Z', '_'}

набор символов, с которых может начинаться идентификатор Исходный код Изменить

Newlines = {'\c', '\n'}

набор символов, с которых может начинаться символ завершения новой строки (возврат каретки, перевод строки) Исходный код Изменить

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

Набор со всеми возможными символами.

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

let invalid = AllChars - Digits
doAssert "01234".find(invalid) == -1
doAssert "01A34".find(invalid) == 2

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

Процедуры

proc isAlphaAscii(c: char): bool {...}{.noSideEffect, gcsafe, extern: "nsuIsAlphaAsciiChar", raises: [], tags: [].}

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

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

Пример:

doAssert isAlphaAscii('e') == true
doAssert isAlphaAscii('E') == true
doAssert isAlphaAscii('8') == false

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

proc isAlphaNumeric(c: char): bool {...}{.noSideEffect, gcsafe, extern: "nsuIsAlphaNumericChar", raises: [], tags: [].}

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

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

Пример:

doAssert isAlphaNumeric('n') == true
doAssert isAlphaNumeric('8') == true
doAssert isAlphaNumeric(' ') == false

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

proc isDigit(c: char): bool {...}{.noSideEffect, gcsafe, extern: "nsuIsDigitChar", raises: [], tags: [].}

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

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

Пример:

doAssert isDigit('n') == false
doAssert isDigit('8') == true

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

proc isSpaceAscii(c: char): bool {...}{.noSideEffect, gcsafe, extern: "nsuIsSpaceAsciiChar", raises: [], tags: [].}

Проверяет, является ли c символом пробела.

Пример:

doAssert isSpaceAscii('n') == false
doAssert isSpaceAscii(' ') == true
doAssert isSpaceAscii('\t') == true

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

proc isLowerAscii(c: char): bool {...}{.noSideEffect, gcsafe, extern: "nsuIsLowerAsciiChar", raises: [], tags: [].}

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

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

См. также:

процедуру toLowerAscii

Пример:

doAssert isLowerAscii('e') == true
doAssert isLowerAscii('E') == false
doAssert isLowerAscii('7') == false

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

proc isUpperAscii(c: char): bool {...}{.noSideEffect, gcsafe, extern: "nsuIsUpperAsciiChar", raises: [], tags: [].}

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

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

См. также:

процедуру toUpperAscii

Пример:

doAssert isUpperAscii('e') == false
doAssert isUpperAscii('E') == true
doAssert isUpperAscii('7') == false

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

proc toLowerAscii(c: char): char {...}{.noSideEffect, gcsafe, extern: "nsuToLowerAsciiChar", raises: [], tags: [].}

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

Работает только для букв A-Z. См. unicode.toLower для версии, работающей с любым символом Юникода.

См. также:

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

Пример:

doAssert toLowerAscii('A') == 'a'
doAssert toLowerAscii('e') == 'e'

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

proc toLowerAscii(s: string): string {...}{.noSideEffect, gcsafe, extern: "nsuToLowerAsciiStr", raises: [], tags: [].}

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

Работает только для букв A-Z. См. unicode.toLower для версии, работающей с любым символом Юникода.

См. также:

процедуру normalize

Пример:

doAssert toLowerAscii("FooBar!") == "foobar!"

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

proc toUpperAscii(c: char): char {...}{.noSideEffect, gcsafe, extern: "nsuToUpperAsciiChar", raises: [], tags: [].}

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

Работает только для букв A-Z. См. unicode.toUpper для версии, работающей с любым символом Юникода.

См. также:

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

Пример:

doAssert toUpperAscii('a') == 'A'
doAssert toUpperAscii('E') == 'E'

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

proc toUpperAscii(s: string): string {...}{.noSideEffect, gcsafe, extern: "nsuToUpperAsciiStr", raises: [], tags: [].}

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

Работает только для букв A-Z. См. unicode.toUpper для версии, работающей с любым символом Юникода.

См. также:

процедуру capitalizeAscii

Пример:

doAssert toUpperAscii("FooBar!") == "FOOBAR!"

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

proc capitalizeAscii(s: string): string {...}{.noSideEffect, gcsafe, extern: "nsuCapitalizeAscii", raises: [], tags: [].}

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

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

См. также:

процедуру toUpperAscii

Пример:

doAssert capitalizeAscii("foo") == "Foo"
doAssert capitalizeAscii("-bar") == "-bar"

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

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

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

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

Пример:

doAssert nimIdentNormalize("Foo_bar") == "Foobar"

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

proc normalize(s: string): string {...}{.noSideEffect, gcsafe, extern: "nsuNormalize", raises: [], tags: [].}

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

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

См. также:

процедуру toLowerAscii

Пример:

doAssert normalize("Foo_bar") == "foobar"
doAssert normalize("Foo Bar") == "foo bar"

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

proc cmpIgnoreCase(a, b: string): int {...}{.noSideEffect, gcsafe, extern: "nsuCmpIgnoreCase", raises: [], tags: [].}

Сравнивает две строки без учета регистра. Возвращает:

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

Пример:

doAssert cmpIgnoreCase("FooBar", "foobar") == 0
doAssert cmpIgnoreCase("bar", "Foo") < 0
doAssert cmpIgnoreCase("Foo5", "foo4") > 0

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

proc cmpIgnoreStyle(a, b: string): int {...}{.noSideEffect, gcsafe, extern: "nsuCmpIgnoreStyle", raises: [], tags: [].}

Семантически идентично 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

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

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

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

См. также:

итератор split
процедура rsplit
процедура splitLines
процедура splitWhitespace

Пример:

doAssert "a,b,c".split(',') == @["a", "b", "c"]
doAssert "".split(' ') == @[""]

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

proc split(s: string; seps: set[char] = Whitespace; maxsplit: int = -1): seq[ string] {...}{.noSideEffect, gcsafe, extern: "nsuSplitCharSet", raises: [], tags: [].}

См. также:

итератор split
процедура rsplit
процедура splitLines
процедура splitWhitespace

Пример:

doAssert "a,b;c".split({',', ';'}) == @["a", "b", "c"]
doAssert "".split({' '}) == @[""]

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

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

Разделяет строку 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"]

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

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

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

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

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

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

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

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

См. также:

итератор rsplit
процедура split
процедура splitLines
процедура splitWhitespace

strutils

Импорты

Типы

Константы

Процедуры

Итераторы

Экспорт