std.string

Функции для работы со строками.

Объекты типов string, wstring, и dstring являются значениями и не могут быть изменены поэлементно. Для изменения при построении строк используйте char[], wchar[], или dchar[]. Типы xxxstring предпочтительнее, так как они не демонстрируют нежелательное алиасирование, делая код более надёжным.

Следующие функции импортированы публично:

См. также:

• std.algorithm и std.range для общих алгоритмов обработки диапазонов
• std.ascii для функций, работающих со строками ASCII
• std.uni для функций, работающих со строками Unicode

Лицензия:

Лицензия Boost 1.0.

Авторы:

Walter Bright, Andrei Alexandrescu, Jonathan M Davis, и David L. 'SpottedTiger' Davis

Источник

std/string.d

class StringException: object.Exception;

Исключение, выбрасываемое при ошибках в функциях std.string.

Примеры:

import std.exception : assertThrown;
auto bad = "      a\n\tb\n   c";
assertThrown!StringException(bad.outdent);

pure nothrow @nogc @system inout(Char)[] fromStringz(Char)(return scope inout(Char)* cString)
Constraints: if (isSomeChar!Char);

Параметры:

inout(Char)* cString

Строка C-стиля с нулевым завершением.

Возвращает:

Массив D-стиля типа char, wchar или dchar, ссылающийся на ту же строку. Возвращаемый массив будет иметь те же квалификаторы типа, что и входной. Важно: Возвращаемый массив является срезем исходного буфера. Исходные данные не изменяются и не копируются.

Примеры:

writeln(fromStringz("foo\0"c.ptr)); // "foo"c
writeln(fromStringz("foo\0"w.ptr)); // "foo"w
writeln(fromStringz("foo\0"d.ptr)); // "foo"d

writeln(fromStringz("福\0"c.ptr)); // "福"c
writeln(fromStringz("福\0"w.ptr)); // "福"w
writeln(fromStringz("福\0"d.ptr)); // "福"d

pure nothrow @trusted immutable(char)* toStringz(scope const(char)[] s);

pure nothrow @trusted immutable(char)* toStringz(return scope string s);

Параметры:

const(char)[] s

Строка D-стиля.

Возвращает:

Строку C-стиля с нулевым завершением, эквивалентную s. s не должен содержать вложенных '\0' символов, так как любая функция C будет рассматривать первый '\0' символ, который она встретит, как конец строки. Если s.empty является true, то возвращается строка, содержащая только '\0'. Важно: При передаче char* в функцию C, и если функция C сохраняет ее по какой-либо причине, убедитесь, что вы сохраняете ссылку на нее в вашем коде D. В противном случае она может стать недоступной во время цикла сбора мусора и привести к серьезной ошибке, когда код C попытается использовать ее.

Примеры:

import core.stdc.string : strlen;
import std.conv : to;

auto p = toStringz("foo");
writeln(strlen(p)); // 3
const(char)[] foo = "abbzxyzzy";
p = toStringz(foo[3 .. 5]);
writeln(strlen(p)); // 2

string test = "";
p = toStringz(test);
writeln(*p); // 0

test = "\0";
p = toStringz(test);
writeln(*p); // 0

test = "foo\0";
p = toStringz(test);
assert(p[0] == 'f' && p[1] == 'o' && p[2] == 'o' && p[3] == 0);

const string test2 = "";
p = toStringz(test2);
writeln(*p); // 0

alias CaseSensitive = std.typecons.Flag!"caseSensitive".Flag;

Флаг, указывающий, является ли поиск регистрозависимым.

ptrdiff_t indexOf(Range)(Range s, dchar c, CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isInputRange!Range && isSomeChar!(ElementType!Range) && !isSomeString!Range);

ptrdiff_t indexOf(C)(scope const(C)[] s, dchar c, CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!C);

ptrdiff_t indexOf(Range)(Range s, dchar c, size_t startIdx, CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isInputRange!Range && isSomeChar!(ElementType!Range) && !isSomeString!Range);

ptrdiff_t indexOf(C)(scope const(C)[] s, dchar c, size_t startIdx, CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!C);

Поиск символа в диапазоне.

Параметры:

Range s	строка или InputRange символов для поиска в правильном формате UTF
dchar c	символ для поиска
size_t startIdx	начальный индекс хорошо сформированного кодового пункта
CaseSensitive cs	Yes.caseSensitive или No.caseSensitive

Возвращает:

индекс первого вхождения c в s относительно начального индекса startIdx. Если c не найден, возвращается -1. Если c найден, значение возвращаемого индекса не меньше startIdx. Если параметры не являются валидным UTF, результат все равно будет в диапазоне [-1 .. s.length], но не будет надежным в противном случае.

Выбрасывает:

Если последовательность, начинающаяся с startIdx, не представляет собой хорошо сформированный кодовый пункт, может быть выброшено исключение std.utf.UTFException.

См. также:

std.algorithm.searching.countUntil

Примеры:

import std.typecons : No;

string s = "Hello World";
writeln(indexOf(s, 'W')); // 6
writeln(indexOf(s, 'Z')); // -1
writeln(indexOf(s, 'w', No.caseSensitive)); // 6

Примеры:

import std.typecons : No;

string s = "Hello World";
writeln(indexOf(s, 'W', 4)); // 6
writeln(indexOf(s, 'Z', 100)); // -1
writeln(indexOf(s, 'w', 3, No.caseSensitive)); // 6

ptrdiff_t indexOf(Range, Char)(Range s, const(Char)[] sub)
Constraints: if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && isSomeChar!Char);

ptrdiff_t indexOf(Range, Char)(Range s, const(Char)[] sub, in CaseSensitive cs)
Constraints: if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && isSomeChar!Char);

@safe ptrdiff_t indexOf(Char1, Char2)(const(Char1)[] s, const(Char2)[] sub, in size_t startIdx)
Constraints: if (isSomeChar!Char1 && isSomeChar!Char2);

@safe ptrdiff_t indexOf(Char1, Char2)(const(Char1)[] s, const(Char2)[] sub, in size_t startIdx, in CaseSensitive cs)
Constraints: if (isSomeChar!Char1 && isSomeChar!Char2);

Поиск подстроки в s.

Параметры:

Range s	строка или ForwardRange символов для поиска в правильном формате UTF
const(Char)[] sub	подстрока для поиска
size_t startIdx	индекс в s, с которого начинается поиск
CaseSensitive cs	Yes.caseSensitive (по умолчанию) или No.caseSensitive

Возвращает:

индекс первого вхождения sub в s относительно начального индекса startIdx. Если sub не найден, возвращается -1. Если данные не являются валидным UTF, результат все равно будет в диапазоне [-1 .. s.length], но не будет надежным в противном случае. Если sub найден, значение возвращаемого индекса не меньше startIdx.

Выбрасывает:

Если последовательность, начинающаяся с startIdx, не представляет собой хорошо сформированный кодовый пункт, может быть выброшено исключение std.utf.UTFException.

Ошибки:

Не работает с регистронезависимыми строками, где отображение функций tolower и toupper не является взаимно однозначным.

Примеры:

import std.typecons : No;

string s = "Hello World";
writeln(indexOf(s, "Wo", 4)); // 6
writeln(indexOf(s, "Zo", 100)); // -1
writeln(indexOf(s, "wo", 3, No.caseSensitive)); // 6

Примеры:

import std.typecons : No;

string s = "Hello World";
writeln(indexOf(s, "Wo")); // 6
writeln(indexOf(s, "Zo")); // -1
writeln(indexOf(s, "wO", No.caseSensitive)); // 6

pure @safe ptrdiff_t lastIndexOf(Char)(const(Char)[] s, in dchar c, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char);

pure @safe ptrdiff_t lastIndexOf(Char)(const(Char)[] s, in dchar c, in size_t startIdx, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char);

Параметры:

const(Char)[] s	строка для поиска
dchar c	символ для поиска
size_t startIdx	индекс в s, с которого начинается поиск
CaseSensitive cs	Yes.caseSensitive или No.caseSensitive

Возвращает:

Индекс последнего вхождения c в s. Если c не найден, возвращается -1. Срезы startIdx s выполняются следующим образом s[0 .. startIdx]. startIdx представляет индекс кодовой единицы в s.

Выбрасывает:

Если последовательность, заканчивающаяся в startIdx, не представляет собой хорошо сформированный кодовый пункт, может быть выброшено исключение std.utf.UTFException. cs указывает, являются ли сравнения регистрозависимыми.

Примеры:

import std.typecons : No;

string s = "Hello World";
writeln(lastIndexOf(s, 'l')); // 9
writeln(lastIndexOf(s, 'Z')); // -1
writeln(lastIndexOf(s, 'L', No.caseSensitive)); // 9

Примеры:

import std.typecons : No;

string s = "Hello World";
writeln(lastIndexOf(s, 'l', 4)); // 3
writeln(lastIndexOf(s, 'Z', 1337)); // -1
writeln(lastIndexOf(s, 'L', 7, No.caseSensitive)); // 3

pure @safe ptrdiff_t lastIndexOf(Char1, Char2)(const(Char1)[] s, const(Char2)[] sub, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char1 && isSomeChar!Char2);

pure @safe ptrdiff_t lastIndexOf(Char1, Char2)(const(Char1)[] s, const(Char2)[] sub, in size_t startIdx, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char1 && isSomeChar!Char2);

Параметры:

const(Char1)[] s	строка для поиска
const(Char2)[] sub	подстрока для поиска
size_t startIdx	индекс в s, с которого начинается поиск
CaseSensitive cs	Yes.caseSensitive или No.caseSensitive

Возвращает:

индекс последнего вхождения sub в s. Если sub не найден, возвращается -1. Срезы startIdx s выполняются следующим образом s[0 .. startIdx]. startIdx представляет индекс кодовой единицы в s.

Выбрасывает:

Если последовательность, заканчивающаяся в startIdx, не представляет собой хорошо сформированный кодовый пункт, может быть выброшено исключение std.utf.UTFException. cs указывает, являются ли сравнения регистрозависимыми.

Примеры:

import std.typecons : No;

string s = "Hello World";
writeln(lastIndexOf(s, "ll")); // 2
writeln(lastIndexOf(s, "Zo")); // -1
writeln(lastIndexOf(s, "lL", No.caseSensitive)); // 2

Примеры:

import std.typecons : No;

string s = "Hello World";
writeln(lastIndexOf(s, "ll", 4)); // 2
writeln(lastIndexOf(s, "Zo", 128)); // -1
writeln(lastIndexOf(s, "lL", 3, No.caseSensitive)); // -1

pure @safe ptrdiff_t indexOfAny(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char && isSomeChar!Char2);

pure @safe ptrdiff_t indexOfAny(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in size_t startIdx, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char && isSomeChar!Char2);

Возвращает индекс первого вхождения любого из элементов в needles в haystack. Если ни один элемент из needles не найден, то возвращается -1. Срезы startIdx над haystack выполняются следующим образом haystack[startIdx .. $]. startIdx представляет собой индекс кодовой единицы в haystack. Если последовательность, заканчивающаяся в startIdx, не представляет собой корректный кодовый символ, может быть выброшено исключение std.utf.UTFException.

Parameters:

const(Char)[] haystack	Строка для поиска иголок в ней.
const(Char2)[] needles	Строки для поиска в стоге.
size_t startIdx	срезы стога так haystack[startIdx .. $]. Если startIdx больше или равен длине стога, функция возвращает -1.
CaseSensitive cs	Указывает, чувствительны ли сравнения к регистру.

Examples:

import std.conv : to;

ptrdiff_t i = "helloWorld".indexOfAny("Wr");
writeln(i); // 5
i = "öällo world".indexOfAny("lo ");
writeln(i); // 4

Examples:

import std.conv : to;

ptrdiff_t i = "helloWorld".indexOfAny("Wr", 4);
writeln(i); // 5

i = "Foo öällo world".indexOfAny("lh", 3);
writeln(i); // 8

pure @safe ptrdiff_t lastIndexOfAny(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char && isSomeChar!Char2);

pure @safe ptrdiff_t lastIndexOfAny(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in size_t stopIdx, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char && isSomeChar!Char2);

Возвращает индекс последнего вхождения любого из элементов в needles в haystack. Если ни один элемент из needles не найден, возвращается -1. Срезы stopIdx над haystack выполняются следующим образом s[0 .. stopIdx]. stopIdx представляет собой индекс кодовой единицы в haystack. Если последовательность, заканчивающаяся в startIdx, не представляет собой корректного кодового символа, может быть выброшено исключение std.utf.UTFException.

Parameters:

const(Char)[] haystack	Строка для поиска иголок в ней.
const(Char2)[] needles	Строки для поиска в стоге.
size_t stopIdx	срезы стога так haystack[0 .. stopIdx]. Если stopIdx больше или равен длине стога, функция возвращает -1.
CaseSensitive cs	Указывает, чувствительны ли сравнения к регистру.

Examples:

ptrdiff_t i = "helloWorld".lastIndexOfAny("Wlo");
writeln(i); // 8

i = "Foo öäöllo world".lastIndexOfAny("öF");
writeln(i); // 8

Examples:

import std.conv : to;

ptrdiff_t i = "helloWorld".lastIndexOfAny("Wlo", 4);
writeln(i); // 3

i = "Foo öäöllo world".lastIndexOfAny("öF", 3);
writeln(i); // 0

pure @safe ptrdiff_t indexOfNeither(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char && isSomeChar!Char2);

pure @safe ptrdiff_t indexOfNeither(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in size_t startIdx, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char && isSomeChar!Char2);

Возвращает индекс первого вхождения любого символа, не являющегося элементом needles в haystack. Если все элементы haystack являются элементами needles, возвращается -1.

Parameters:

const(Char)[] haystack	Строка для поиска иголок в ней.
const(Char2)[] needles	Строки для поиска в стоге.
size_t startIdx	срезы стога так haystack[startIdx .. $]. Если startIdx больше или равен длине стога, функция возвращает -1.
CaseSensitive cs	Указывает, чувствительны ли сравнения к регистру.

Examples:

writeln(indexOfNeither("abba", "a", 2)); // 2
writeln(indexOfNeither("def", "de", 1)); // 2
writeln(indexOfNeither("dfefffg", "dfe", 4)); // 6

Examples:

writeln(indexOfNeither("def", "a")); // 0
writeln(indexOfNeither("def", "de")); // 2
writeln(indexOfNeither("dfefffg", "dfe")); // 6

pure @safe ptrdiff_t lastIndexOfNeither(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char && isSomeChar!Char2);

pure @safe ptrdiff_t lastIndexOfNeither(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in size_t stopIdx, in CaseSensitive cs = Yes.caseSensitive)
Constraints: if (isSomeChar!Char && isSomeChar!Char2);

Возвращает последний индекс первого вхождения любого символа, не являющегося элементом needles в haystack. Если все элементы haystack являются элементами needles, возвращается -1.

Parameters:

const(Char)[] haystack	Строка для поиска иголок в ней.
const(Char2)[] needles	Строки для поиска в стоге.
size_t stopIdx	срезы стога так haystack[0 .. stopIdx]. Если stopIdx больше или равен длине стога, функция возвращает -1.
CaseSensitive cs	Указывает, чувствительны ли сравнения к регистру.

Examples:

writeln(lastIndexOfNeither("abba", "a")); // 2
writeln(lastIndexOfNeither("def", "f")); // 1

Examples:

writeln(lastIndexOfNeither("def", "rsa", 3)); // -1
writeln(lastIndexOfNeither("abba", "a", 2)); // 1

pure nothrow @nogc @safe auto representation(Char)(Char[] s)
Constraints: if (isSomeChar!Char);

Возвращает представление строки, имеющее тот же тип, что и строка, за исключением того, что тип символа заменён на ubyte, ushort, или uint в зависимости от ширины символа.

Parameters:

Char[] s

Строка, для которой нужно вернуть представление.

Returns:

Представление переданной строки.

Examples:

string s = "hello";
static assert(is(typeof(representation(s)) == immutable(ubyte)[]));
assert(representation(s) is cast(immutable(ubyte)[]) s);
writeln(representation(s)); // [0x68, 0x65, 0x6c, 0x6c, 0x6f]

pure @trusted S capitalize(S)(S input)
Constraints: if (isSomeString!S);

Приводит первый символ s к верхнему регистру, а остальные символы s к нижнему регистру.

Parameters:

S input

Строка, которую нужно привести к верхнему регистру.

Returns:

Строка в верхнем регистре.

See Also:

std.uni.asCapitalized для ленивой версии диапазона, которая не выделяет память

Examples:

writeln(capitalize("hello")); // "Hello"
writeln(capitalize("World")); // "World"

alias KeepTerminator = std.typecons.Flag!"keepTerminator".Flag;

pure @safe C[][] splitLines(C)(C[] s, KeepTerminator keepTerm = No.keepTerminator)
Constraints: if (isSomeChar!C);

Разделяет s на массив строк в соответствии со стандартом Unicode, используя '\r', '\n', "\r\n", std.uni.lineSep, std.uni.paraSep, U+0085 (NEL), '\v' и '\f' в качестве разделителей. Если keepTerm установлено в KeepTerminator.yes, то разделитель включается в возвращаемые строки.

Не выбрасывает исключения при некорректном UTF; такой символ просто передается в выходные данные без изменений.

Выделяет память; используйте lineSplitter для альтернативы, которая этого не делает.

Соответствует Unicode 7.0.

Parameters:

C[] s	строка chars, wchars, или dchars, или любой пользовательский тип, который преобразуется в тип string
KeepTerminator keepTerm	включать или не включать разделитель в результаты

Returns:

массив строк, каждый элемент которого представляет собой строку, являющуюся фрагментом s

See Also:

lineSplitter std.algorithm.splitter std.regex.splitter

Examples:

string s = "Hello\nmy\rname\nis";
writeln(splitLines(s)); // ["Hello", "my", "name", "is"]

auto lineSplitter(KeepTerminator keepTerm = No.keepTerminator, Range)(Range r)
Constraints: if (hasSlicing!Range && hasLength!Range && isSomeChar!(ElementType!Range) && !isSomeString!Range);

auto lineSplitter(KeepTerminator keepTerm = No.keepTerminator, C)(C[] r)
Constraints: if (isSomeChar!C);

Разделить массив или срезу символов на ряд строк, используя '\r', '\n', '\v', '\f', "\r\n", std.uni.lineSep, std.uni.paraSep и '\u0085' (NEL) в качестве разделителей. Если keepTerm установлено в значение Yes.keepTerminator, то разделитель включается в возвращаемые срезы.

Не выбрасывает исключение при некорректном UTF; подобное просто передается в выходные данные без изменений.

Соответствует Unicode 7.0.

Не выделяет память.

Параметры:

Диапазон r	массив chars, wchars, или dchars или срез диапазона
keepTerm	включать ли разделитель в результаты

Возвращает:

диапазон срезов входного диапазона r

См. также:

splitLines std.algorithm.splitter std.regex.splitter

Примеры:

import std.array : array;

string s = "Hello\nmy\rname\nis";

/* notice the call to 'array' to turn the lazy range created by
lineSplitter comparable to the string[] created by splitLines.
*/
writeln(lineSplitter(s).array); // splitLines(s)

Примеры:

auto s = "\rpeter\n\rpaul\r\njerry\u2028ice\u2029cream\n\nsunday\nmon\u2030day\n";
auto lines = s.lineSplitter();
static immutable witness = ["", "peter", "", "paul", "jerry", "ice", "cream", "", "sunday", "mon\u2030day"];
uint i;
foreach (line; lines)
{
    writeln(line); // witness[i++]
}
writeln(i); // witness.length

auto stripLeft(Range)(Range input)
Constraints: if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isInfinite!Range && !isConvertibleToString!Range);

auto stripLeft(Range, Char)(Range input, const(Char)[] chars)
Constraints: if ((isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) || isConvertibleToString!Range) && isSomeChar!Char);

Удаляет начальные пробелы (определяемые std.uni.isWhite) или, как указано во втором аргументе.

Параметры:

Диапазон input	строка или последовательный диапазон символов
const(Char)[] chars	строка символов для удаления

Возвращает:

input без начальных пробелов или символов, указанных во втором аргументе.

Послеусловие

input и возвращаемое значение будут иметь одинаковый хвост (см. std.array.sameTail).

См. также:

Общие операции удаления для диапазонов: std.algorithm.mutation.stripLeft

Примеры:

import std.uni : lineSep, paraSep;
assert(stripLeft("     hello world     ") ==
       "hello world     ");
assert(stripLeft("\n\t\v\rhello world\n\t\v\r") ==
       "hello world\n\t\v\r");
assert(stripLeft(" \u2028hello world") ==
       "hello world");
assert(stripLeft("hello world") ==
       "hello world");
assert(stripLeft([lineSep] ~ "hello world" ~ lineSep) ==
       "hello world" ~ [lineSep]);
assert(stripLeft([paraSep] ~ "hello world" ~ paraSep) ==
       "hello world" ~ [paraSep]);

import std.array : array;
import std.utf : byChar;
assert(stripLeft("     hello world     "w.byChar).array ==
       "hello world     ");
assert(stripLeft("     \u2022hello world     ".byChar).array ==
       "\u2022hello world     ");

Примеры:

assert(stripLeft("     hello world     ", " ") ==
       "hello world     ");
assert(stripLeft("xxxxxhello world     ", "x") ==
       "hello world     ");
assert(stripLeft("xxxyy    hello world     ", "xy ") ==
       "hello world     ");

Примеры:

import std.array : array;
import std.utf : byChar, byWchar, byDchar;

assert(stripLeft("  xxxyy hello world     "w.byChar, "xy ").array ==
       "hello world     ");

assert(stripLeft("\u2028\u2020hello world\u2028"w.byWchar,
                 "\u2028").array == "\u2020hello world\u2028");
assert(stripLeft("\U00010001hello world"w.byWchar, " ").array ==
       "\U00010001hello world"w);
assert(stripLeft("\U00010001 xyhello world"d.byDchar,
                 "\U00010001 xy").array == "hello world"d);

writeln(stripLeft("\u2020hello"w, "\u2020"w)); // "hello"w
writeln(stripLeft("\U00010001hello"d, "\U00010001"d)); // "hello"d
writeln(stripLeft(" hello ", "")); // " hello "

auto stripRight(Range)(Range str)
Constraints: if (isSomeString!Range || isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && !isConvertibleToString!Range && isSomeChar!(ElementEncodingType!Range));

auto stripRight(Range, Char)(Range str, const(Char)[] chars)
Constraints: if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isConvertibleToString!Range) && isSomeChar!Char);

Удаляет хвостовые пробелы (определяемые std.uni.isWhite) или как указано во втором аргументе.

Параметры:

Диапазон str	строка или диапазон с произвольным доступом символов
const(Char)[] chars	строка символов для удаления

Возвращает:

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

См. также:

Общие операции удаления для диапазонов: std.algorithm.mutation.stripRight

Примеры:

import std.uni : lineSep, paraSep;
assert(stripRight("     hello world     ") ==
       "     hello world");
assert(stripRight("\n\t\v\rhello world\n\t\v\r") ==
       "\n\t\v\rhello world");
assert(stripRight("hello world") ==
       "hello world");
assert(stripRight([lineSep] ~ "hello world" ~ lineSep) ==
       [lineSep] ~ "hello world");
assert(stripRight([paraSep] ~ "hello world" ~ paraSep) ==
       [paraSep] ~ "hello world");

Примеры:

assert(stripRight("     hello world     ", "x") ==
       "     hello world     ");
assert(stripRight("     hello world     ", " ") ==
       "     hello world");
assert(stripRight("     hello worldxy     ", "xy ") ==
       "     hello world");

auto strip(Range)(Range str)
Constraints: if (isSomeString!Range || isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && !isConvertibleToString!Range && isSomeChar!(ElementEncodingType!Range));

auto strip(Range, Char)(Range str, const(Char)[] chars)
Constraints: if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isConvertibleToString!Range) && isSomeChar!Char);

auto strip(Range, Char)(Range str, const(Char)[] leftChars, const(Char)[] rightChars)
Constraints: if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isConvertibleToString!Range) && isSomeChar!Char);

Удаляет начальные и хвостовые пробелы (определяемые std.uni.isWhite) или как указано во втором аргументе.

Параметры:

Диапазон str	строка или диапазон с произвольным доступом символов
const(Char)[] chars	строка символов для удаления
const(Char)[] leftChars	строка начальных символов для удаления
const(Char)[] rightChars	строка хвостовых символов для удаления

Возвращает:

срез str без начальных и хвостовых пробелов или символов, указанных во втором аргументе.

См. также:

Общие операции удаления для диапазонов: std.algorithm.mutation.strip

Примеры:

import std.uni : lineSep, paraSep;
assert(strip("     hello world     ") ==
       "hello world");
assert(strip("\n\t\v\rhello world\n\t\v\r") ==
       "hello world");
assert(strip("hello world") ==
       "hello world");
assert(strip([lineSep] ~ "hello world" ~ [lineSep]) ==
       "hello world");
assert(strip([paraSep] ~ "hello world" ~ [paraSep]) ==
       "hello world");

Примеры:

assert(strip("     hello world     ", "x") ==
       "     hello world     ");
assert(strip("     hello world     ", " ") ==
       "hello world");
assert(strip("   xyxyhello worldxyxy     ", "xy ") ==
       "hello world");
writeln(strip("\u2020hello\u2020"w, "\u2020"w)); // "hello"w
writeln(strip("\U00010001hello\U00010001"d, "\U00010001"d)); // "hello"d
writeln(strip(" hello ", "")); // " hello "

Примеры:

writeln(strip("xxhelloyy", "x", "y")); // "hello"
assert(strip("   xyxyhello worldxyxyzz    ", "xy ", "xyz ") ==
       "hello world");
writeln(strip("\u2020hello\u2028"w, "\u2020"w, "\u2028"w)); // "hello"w
assert(strip("\U00010001hello\U00010002"d, "\U00010001"d, "\U00010002"d) ==
       "hello"d);
writeln(strip(" hello ", "", "")); // " hello "

Range chomp(Range)(Range str)
Constraints: if ((isRandomAccessRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);

Range chomp(Range, C2)(Range str, const(C2)[] delimiter)
Constraints: if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range && isSomeChar!C2);

Если str заканчивается на delimiter, то возвращается str без delimiter в конце. Если оно str не заканчивается на delimiter, то возвращается без изменений.

Если не указан delimiter, то удаляется один конечный '\r', '\n', "\r\n", '\f', '\v', std.uni.lineSep, std.uni.paraSep, или std.uni.nelSep из конца str. Если str не заканчивается ни на один из этих символов, то возвращается без изменений.

Параметры:

Диапазон str	строка или индексируемый диапазон символов
const(C2)[] delimiter	строка символов, которые нужно убрать с конца str[]

Возвращает:

срез str

Примеры:

import std.uni : lineSep, paraSep, nelSep;
import std.utf : decode;
writeln(chomp(" hello world  \n\r")); // " hello world  \n"
writeln(chomp(" hello world  \r\n")); // " hello world  "
writeln(chomp(" hello world  \f")); // " hello world  "
writeln(chomp(" hello world  \v")); // " hello world  "
writeln(chomp(" hello world  \n\n")); // " hello world  \n"
writeln(chomp(" hello world  \n\n ")); // " hello world  \n\n "
writeln(chomp(" hello world  \n\n" ~ [lineSep])); // " hello world  \n\n"
writeln(chomp(" hello world  \n\n" ~ [paraSep])); // " hello world  \n\n"
writeln(chomp(" hello world  \n\n" ~ [nelSep])); // " hello world  \n\n"
writeln(chomp(" hello world")); // " hello world"
writeln(chomp("")); // ""

writeln(chomp(" hello world", "orld")); // " hello w"
writeln(chomp(" hello world", " he")); // " hello world"
writeln(chomp("", "hello")); // ""

// Don't decode pointlessly
writeln(chomp("hello\xFE", "\r")); // "hello\xFE"

Range chompPrefix(Range, C2)(Range str, const(C2)[] delimiter)
Constraints: if ((isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range && isSomeChar!C2);

Если str начинается с delimiter, то возвращается часть str после delimiter. Если str не начинается с

delimiter, то возвращается без изменений.

Параметры:

Диапазон str	строка или последовательный диапазон символов
const(C2)[] delimiter	строка символов, которые нужно убрать с начала str[]

Возвращает:

срез str

Примеры:

writeln(chompPrefix("hello world", "he")); // "llo world"
writeln(chompPrefix("hello world", "hello w")); // "orld"
writeln(chompPrefix("hello world", " world")); // "hello world"
writeln(chompPrefix("", "hello")); // ""

Range chop(Range)(Range str)
Constraints: if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);

Возвращает str без последнего символа, если таковой имеется. Если str заканчивается на "\r\n", то оба удаляются. Если str пуста, то возвращается без изменений.

Параметры:

Диапазон str

строка (должна быть валидным UTF)

Возвращает:

срез str

Примеры:

writeln(chop("hello world")); // "hello worl"
writeln(chop("hello world\n")); // "hello world"
writeln(chop("hello world\r")); // "hello world"
writeln(chop("hello world\n\r")); // "hello world\n"
writeln(chop("hello world\r\n")); // "hello world"
writeln(chop("Walter Bright")); // "Walter Brigh"
writeln(chop("")); // ""

S leftJustify(S)(S s, size_t width, dchar fillChar = ' ')
Constraints: if (isSomeString!S);

Выровнять s по левому краю в поле шириной width символов. fillChar — символ, используемый для заполнения пробелов в поле, которые s не заполняет.

Параметры:

S s	строка
size_t width	минимальная ширина поля
dchar fillChar	используется для заполнения до width символов

Возвращает:

выделенная строка GC

См. также:

leftJustifier, которая не выделяет память

Примеры:

writeln(leftJustify("hello", 7, 'X')); // "helloXX"
writeln(leftJustify("hello", 2, 'X')); // "hello"
writeln(leftJustify("hello", 9, 'X')); // "helloXXXX"

auto leftJustifier(Range)(Range r, size_t width, dchar fillChar = ' ')
Constraints: if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

Выравнивание по левому краю s в поле шириной width символов. fillChar — это символ, который будет использоваться для заполнения пробелов в поле, которые s не заполнит.

Параметры:

Диапазон r	строка или диапазон символов
size_t width	минимальная ширина поля
dchar fillChar	используется для дополнения до width символов

Возвращаемое значение:

ленивый диапазон результата, выровненного по левому краю

См. также:

rightJustifier

Примеры:

import std.algorithm.comparison : equal;
import std.utf : byChar;
assert(leftJustifier("hello", 2).equal("hello".byChar));
assert(leftJustifier("hello", 7).equal("hello  ".byChar));
assert(leftJustifier("hello", 7, 'x').equal("helloxx".byChar));

S rightJustify(S)(S s, size_t width, dchar fillChar = ' ')
Constraints: if (isSomeString!S);

Выравнивание по правому краю s в поле шириной width символов. fillChar — это символ, который будет использоваться для заполнения пробелов в поле, которые s не заполнит.

Параметры:

S s	строка
size_t width	минимальная ширина поля
dchar fillChar	используется для дополнения до width символов

Возвращаемое значение:

строка, выделенная в памяти GC

См. также:

rightJustifier, которая не выделяет память

Примеры:

writeln(rightJustify("hello", 7, 'X')); // "XXhello"
writeln(rightJustify("hello", 2, 'X')); // "hello"
writeln(rightJustify("hello", 9, 'X')); // "XXXXhello"

auto rightJustifier(Range)(Range r, size_t width, dchar fillChar = ' ')
Constraints: if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

Выравнивание по правому краю s в поле шириной width символов. fillChar — это символ, который будет использоваться для заполнения пробелов в поле, которые s не заполнит.

Параметры:

Диапазон r	строка или прямой диапазон символов
size_t width	минимальная ширина поля
dchar fillChar	используется для дополнения до width символов

Возвращаемое значение:

ленивый диапазон результата, выровненного по правому краю

См. также:

leftJustifier

Примеры:

import std.algorithm.comparison : equal;
import std.utf : byChar;
assert(rightJustifier("hello", 2).equal("hello".byChar));
assert(rightJustifier("hello", 7).equal("  hello".byChar));
assert(rightJustifier("hello", 7, 'x').equal("xxhello".byChar));

S center(S)(S s, size_t width, dchar fillChar = ' ')
Constraints: if (isSomeString!S);

Центрирование s в поле шириной width символов. fillChar — это символ, который будет использоваться для заполнения пробелов в поле, которые s не заполнит.

Параметры:

S s	Строка, которую нужно центрировать
size_t width	Ширина поля, в котором нужно центрировать s
dchar fillChar	Символ, используемый для заполнения лишнего места в поле

Возвращаемое значение:

Результат центрирования строки. Возвращаемая строка выделяется в памяти GC. Чтобы избежать выделения памяти, используйте centerJustifier вместо этого.

Примеры:

writeln(center("hello", 7, 'X')); // "XhelloX"
writeln(center("hello", 2, 'X')); // "hello"
writeln(center("hello", 9, 'X')); // "XXhelloXX"

auto centerJustifier(Range)(Range r, size_t width, dchar fillChar = ' ')
Constraints: if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

Центрирование r в поле шириной width символов. fillChar — это символ, который будет использоваться для заполнения пробелов в поле, которые r не заполнит.

Параметры:

Диапазон r	строка или прямой диапазон символов
size_t width	минимальная ширина поля
dchar fillChar	используется для дополнения до width символов

Возвращаемое значение:

ленивый диапазон результата, центрированного по центру

См. также:

leftJustifier rightJustifier

Примеры:

import std.algorithm.comparison : equal;
import std.utf : byChar;
assert(centerJustifier("hello", 2).equal("hello".byChar));
assert(centerJustifier("hello", 8).equal(" hello  ".byChar));
assert(centerJustifier("hello", 7, 'x').equal("xhellox".byChar));

pure auto detab(Range)(auto ref Range s, size_t tabSize = 8)
Constraints: if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) || __traits(compiles, StringTypeOf!Range));

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

Параметры:

Диапазон s	строка
size_t tabSize	расстояние между позициями табуляции

Возвращаемое значение:

строка, выделенная в памяти GC, с заменёнными табуляциями на пробелы

Примеры:

writeln(detab(" \n\tx", 9)); // " \n         x"

auto detabber(Range)(Range r, size_t tabSize = 8)
Constraints: if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

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

Параметры:

Диапазон r	строка или прямой диапазон
size_t tabSize	расстояние между позициями табуляции

Возвращаемое значение:

ленивый прямой диапазон с заменёнными табуляциями на пробелы

Примеры:

import std.array : array;

writeln(detabber(" \n\tx", 9).array); // " \n         x"

auto entab(Range)(Range s, size_t tabSize = 8)
Constraints: if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range));

Заменяет пробелы в s на оптимальное количество символов табуляции. Все пробелы и табуляции в конце строки удаляются.

Параметры:

Диапазон s	Строка для преобразования.
size_t tabSize	Колонки табуляции находятся на расстоянии tabSize пробелов друг от друга.

Возвращаемое значение:

строка, выделенная в памяти GC, с заменёнными пробелами на табуляции; используйте entabber, чтобы не выделять память.

См. также:

entabber

Примеры:

writeln(entab("        x \n")); // "\tx\n"

auto entabber(Range)(Range r, size_t tabSize = 8)
Constraints: if (isForwardRange!Range && !isConvertibleToString!Range);

Заменяет пробелы в диапазоне r на оптимальное количество символов табуляции. Все пробелы и табуляции в конце строки удаляются.

Параметры:

Диапазон r	строка или прямой диапазон
size_t tabSize	расстояние между позициями табуляции

Возвращаемое значение:

ленивый прямой диапазон с заменёнными пробелами на табуляции

См. также:

entab

Примеры:

import std.array : array;
writeln(entabber("        x \n").array); // "\tx\n"

pure @safe C1[] translate(C1, C2 = immutable(char))(C1[] str, in dchar[dchar] transTable, const(C2)[] toRemove = null)
Constraints: if (isSomeChar!C1 && isSomeChar!C2);

pure @safe C1[] translate(C1, S, C2 = immutable(char))(C1[] str, in S[dchar] transTable, const(C2)[] toRemove = null)
Constraints: if (isSomeChar!C1 && isSomeString!S && isSomeChar!C2);

Заменяет символы в str, которые являются ключами в transTable, на соответствующие значения в transTable. transTable — это AA, ключами которого являются dchar, а значениями — либо dchar, либо какой-то тип строки. Кроме того, если toRemove задано, символы в нём удаляются из str перед переводом. str само не изменяется. Возвращается копия с изменениями.

См. также:

tr, std.array.replace, std.algorithm.iteration.substitute

Параметры:

C1[] str	Исходная строка.
dchar[dchar] transTable	AA, указывающий, какие символы заменить и на что.
const(C2)[] toRemove	Символы, которые нужно удалить из строки.

Примеры:

dchar[dchar] transTable1 = ['e' : '5', 'o' : '7', '5': 'q'];
writeln(translate("hello world", transTable1)); // "h5ll7 w7rld"

writeln(translate("hello world", transTable1, "low")); // "h5 rd"

string[dchar] transTable2 = ['e' : "5", 'o' : "orange"];
writeln(translate("hello world", transTable2)); // "h5llorange worangerld"

void translate(C1, C2 = immutable(char), Buffer)(const(C1)[] str, in dchar[dchar] transTable, const(C2)[] toRemove, Buffer buffer)
Constraints: if (isSomeChar!C1 && isSomeChar!C2 && isOutputRange!(Buffer, C1));

void translate(C1, S, C2 = immutable(char), Buffer)(C1[] str, in S[dchar] transTable, const(C2)[] toRemove, Buffer buffer)
Constraints: if (isSomeChar!C1 && isSomeString!S && isSomeChar!C2 && isOutputRange!(Buffer, S));

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

Параметры:

const(C1)[] str	Исходная строка.
dchar[dchar] transTable	AA, указывающий, какие символы заменить и на какие.
const(C2)[] toRemove	Символы для удаления из строки.
Buffer buffer	Диапазон вывода для записи содержимого.

Примеры:

import std.array : appender;
dchar[dchar] transTable1 = ['e' : '5', 'o' : '7', '5': 'q'];
auto buffer = appender!(dchar[])();
translate("hello world", transTable1, null, buffer);
writeln(buffer.data); // "h5ll7 w7rld"

buffer.clear();
translate("hello world", transTable1, "low", buffer);
writeln(buffer.data); // "h5 rd"

buffer.clear();
string[dchar] transTable2 = ['e' : "5", 'o' : "orange"];
translate("hello world", transTable2, null, buffer);
writeln(buffer.data); // "h5llorange worangerld"

pure nothrow @trusted C[] translate(C = immutable(char))(scope const(char)[] str, scope const(char)[] transTable, scope const(char)[] toRemove = null)
Constraints: if (is(immutable(C) == immutable(char)));

Это только ASCII перегрузка translate. Она не будет работать с Unicode. Она существует как оптимизация для случаев, когда обработка Unicode не требуется.

В отличие от других перегрузок translate, эта не принимает AA. Вместо этого она принимает string, сгенерированный makeTransTable.

Массив, сгенерированный makeTransTable, имеет длину 256 элементов, где индекс равен заменяемому ASCII-символу, а значение — символу, на который он заменяется. Обратите внимание, что translate не декодирует символы, поэтому вы можете передавать расширенные ASCII-символы (в ASCII фактически используются 128 символов), но будьте осторожны, что расширенные ASCII-символы не являются допустимыми Unicode и, следовательно, могут привести к ошибке UTFException от большинства других функций Phobos.

Также, так как декодирования не происходит, эту перегрузку можно использовать для транслирования ASCII-символов в строке UTF-8, не изменяя другие, не-ASCII символы. Она заменяет любой код больше 127 на другой код или заменяет любой код на другой код больше 127, что вызовет проблемы с валидацией UTF.

См. также:

tr, std.array.replace, std.algorithm.iteration.substitute

Параметры:

const(char)[] str	Исходная строка.
const(char)[] transTable	Строка, указывающая, какие символы заменить и на какие. Она генерируется makeTransTable.
const(char)[] toRemove	Символы для удаления из строки.

Примеры:

auto transTable1 = makeTrans("eo5", "57q");
writeln(translate("hello world", transTable1)); // "h5ll7 w7rld"

writeln(translate("hello world", transTable1, "low")); // "h5 rd"

pure nothrow @trusted string makeTrans(scope const(char)[] from, scope const(char)[] to);

Выполняет то же, что и makeTransTable, но выделяет таблицу трансляции в куче GC.

Используйте makeTransTable вместо этого.

Примеры:

auto transTable1 = makeTrans("eo5", "57q");
writeln(translate("hello world", transTable1)); // "h5ll7 w7rld"

writeln(translate("hello world", transTable1, "low")); // "h5 rd"

pure nothrow @nogc @safe char[256] makeTransTable(scope const(char)[] from, scope const(char)[] to);

Создает таблицу трансляции из 256 символов, где символы в from[] заменяются соответствующими символами в to[].

Параметры:

const(char)[] from	Массив символов, длина которого меньше или равна 256.
const(char)[] to	Соответствующий массив символов для трансляции.

Возвращает:

Массив трансляции

Примеры:

writeln(translate("hello world", makeTransTable("hl", "q5"))); // "qe55o wor5d"
writeln(translate("hello world", makeTransTable("12345", "67890"))); // "hello world"

pure @trusted void translate(C = immutable(char), Buffer)(scope const(char)[] str, scope const(char)[] transTable, scope const(char)[] toRemove, Buffer buffer)
Constraints: if (is(immutable(C) == immutable(char)) && isOutputRange!(Buffer, char));

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

Параметры:

const(char)[] str	Исходная строка.
const(char)[] transTable	Строка, указывающая, какие символы заменить и на какие. Она генерируется makeTransTable.
const(char)[] toRemove	Символы для удаления из строки.
Buffer buffer	Диапазон вывода для записи содержимого.

Примеры:

import std.array : appender;
auto buffer = appender!(char[])();
auto transTable1 = makeTransTable("eo5", "57q");
translate("hello world", transTable1, null, buffer);
writeln(buffer.data); // "h5ll7 w7rld"

buffer.clear();
translate("hello world", transTable1, "low", buffer);
writeln(buffer.data); // "h5 rd"

pure @safe S succ(S)(S s)
Constraints: if (isSomeString!S);

Возвращает строку, являющуюся 'преемником' s[]. Если крайний правый символ — a-zA-Z0-9, он инкрементируется в своем регистре или в качестве цифры. Если это приводит к переносу, процесс повторяется для символа слева от него.

Примеры:

writeln(succ("1")); // "2"
writeln(succ("9")); // "10"
writeln(succ("999")); // "1000"
writeln(succ("zz99")); // "aaa00"

C1[] tr(C1, C2, C3, C4 = immutable(char))(C1[] str, const(C2)[] from, const(C3)[] to, const(C4)[] modifiers = null);

Заменяет символы в str, которые находятся в from, на соответствующие символы в to и возвращает результирующую строку.

tr основана на Posix's tr, хотя она не делает всего, что делает утилита Posix.

Параметры:

C1[] str	Исходная строка.
const(C2)[] from	Символы для замены.
const(C3)[] to	Символы для замены на.
const(C4)[] modifiers	Строка, содержащая модификаторы.

Модификаторы

Модификатор	Описание
'c'	Дополнить список символов в from
'd'	Удалить соответствующие символы без соответствующей замены в to
's'	Удалить смежные дубликаты в замененных символах

Если модификатор 'd' присутствует, то количество символов в to может быть только 0 или 1. Если модификатор 'd' не присутствует, а to пуста, то to считается таким же, как from. Если модификатор 'd' не присутствует, а to короче from, то to расширяется за счет дублирования последнего символа в to. И from, и to могут содержать диапазоны, используя символ '-' (например, "a-d" эквивалентно "abcd"). Ни один из них не принимает ведущий '^' как означающий дополнение строки (используйте модификатор 'c' для этого).

См. также:

translate, std.array.replace, std.algorithm.iteration.substitute

Примеры:

writeln(tr("abcdef", "cd", "CD")); // "abCDef"
writeln(tr("1st March, 2018", "March", "MAR", "s")); // "1st MAR, 2018"
writeln(tr("abcdef", "ef", "", "d")); // "abcd"
writeln(tr("14-Jul-87", "a-zA-Z", " ", "cs")); // " Jul "

bool isNumeric(S)(S s, bool bAllowSep = false)
Constraints: if (isSomeString!S || isRandomAccessRange!S && hasSlicing!S && isSomeChar!(ElementType!S) && !isInfinite!S);

Принимает строку s и определяет, представляет ли она число. Эта функция также принимает необязательный параметр bAllowSep, который будет принимать разделители ',' и '__' в строке. Но эти символы должны быть удалены из строки перед использованием каких-либо функций преобразования, таких как to!int(), to!float(), и т. д., иначе произойдет ошибка.

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

Параметры:

S s	строка или диапазон случайного доступа для проверки
bool bAllowSep	принять разделители или нет

Возвращает:

bool

Примеры:

Целое целое число: (byte, ubyte, short, ushort, int, uint, long, и ulong) ['+'|'-']цифра(ы)[U|L|UL]

assert(isNumeric("123"));
assert(isNumeric("123UL"));
assert(isNumeric("123L"));
assert(isNumeric("+123U"));
assert(isNumeric("-123L"));

Примеры:

Число с плавающей точкой: (float, double, real, ifloat, idouble, и ireal) ['+'|'-']цифра(ы)[.][цифра(ы)][[e-|e+]цифра(ы)][i|f|L|Li|fi]] или [nan|nani|inf|-inf]

assert(isNumeric("+123"));
assert(isNumeric("-123.01"));
assert(isNumeric("123.3e-10f"));
assert(isNumeric("123.3e-10fi"));
assert(isNumeric("123.3e-10L"));

assert(isNumeric("nan"));
assert(isNumeric("nani"));
assert(isNumeric("-inf"));

Примеры:

Число с плавающей точкой: (cfloat, cdouble, и creal) ['+'|'-']цифра(ы)[.][цифра(ы)][[e-|e+]цифра(ы)][+] [цифра(ы)[.][цифра(ы)][[e-|e+]цифра(ы)][i|f|L|Li|fi]] или [nan|nani|nan+nani|inf|-inf]

enum a = isNumeric("123.00E-5+1234.45E-12Li");
enum b = isNumeric("12345xxxx890");

static assert( a);
static assert(!b);

Примеры:

isNumeric работает с CTFE

enum a = isNumeric("123.00E-5+1234.45E-12Li");
enum b = isNumeric("12345xxxx890");

static assert( a);
static assert(!b);

char[4] soundexer(Range)(Range str)
Constraints: if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

char[4] soundexer(Range)(auto ref Range str)
Constraints: if (isConvertibleToString!Range);

Алгоритм Soundex.

Алгоритм Soundex преобразует слово в 4 символа на основе того, как слово звучит фонетически. Идея в том, что два написания, которые звучат одинаково, будут иметь одинаковое значение Soundex, что означает, что Soundex может использоваться для неточного сопоставления имен.

Параметры:

Диапазон str

Строка или диапазон ввода для преобразования в представление Soundex.

Возвращает:

Массив из четырёх символов с результатом Soundex. В массиве содержатся нули, если для строки нет представления Soundex.

См. также:

Википедия, Система индексирования Soundex soundex

Примечание

Хорошо работает только с английскими именами.

Примеры:

writeln(soundexer("Gauss")); // "G200"
writeln(soundexer("Ghosh")); // "G200"

writeln(soundexer("Robert")); // "R163"
writeln(soundexer("Rupert")); // "R163"

writeln(soundexer("0123^&^^**&^")); // ['\0', '\0', '\0', '\0']

pure nothrow @safe char[] soundex(scope const(char)[] str, char[] buffer = null);

Подобно soundexer, но с другими параметрами и значением возврата.

Параметры:

const(char)[] str	Строка для преобразования в представление Soundex.
char[] buffer	Необязательный массив из 4 символов для размещения полученных символов Soundex. Если null, буфер для возвращаемого значения будет выделен в куче.

Возвращает:

Массив из четырёх символов с результатом Soundex. Возвращает null, если для строки нет представления Soundex.

См. также:

soundexer

Примеры:

writeln(soundex("Gauss")); // "G200"
writeln(soundex("Ghosh")); // "G200"

writeln(soundex("Robert")); // "R163"
writeln(soundex("Rupert")); // "R163"

writeln(soundex("0123^&^^**&^")); // null

pure @safe string[string] abbrev(string[] values);

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

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

Примеры:

import std.string;

static string[] list = [ "food", "foxy" ];
auto abbrevs = abbrev(list);
assert(abbrevs == ["fox": "foxy", "food": "food",
                   "foxy": "foxy", "foo": "food"]);

size_t column(Range)(Range str, in size_t tabsize = 8)
Constraints: if ((isInputRange!Range && isSomeChar!(Unqual!(ElementEncodingType!Range)) || isNarrowString!Range) && !isConvertibleToString!Range);

Вычислить номер столбца в конце выведенной формы строки, предполагая, что строка начинается в крайнем левом столбце, который нумеруется, начиная с 0.

Символы табуляции расширяются на достаточное количество пробелов для приведения номера столбца к следующему кратному значению tabsize. Если в строке несколько строк, возвращается номер столбца последней строки.

Параметры:

Диапазон str	Строка или диапазон ввода для анализа
size_t tabsize	Количество столбцов, которое представляет собой символ табуляции

Возвращает:

номер столбца

Примеры:

import std.utf : byChar, byWchar, byDchar;

writeln(column("1234 ")); // 5
writeln(column("1234 "w)); // 5
writeln(column("1234 "d)); // 5

writeln(column("1234 ".byChar())); // 5
writeln(column("1234 "w.byWchar())); // 5
writeln(column("1234 "d.byDchar())); // 5

// Tab stops are set at 8 spaces by default; tab characters insert enough
// spaces to bring the column position to the next multiple of 8.
writeln(column("\t")); // 8
writeln(column("1\t")); // 8
writeln(column("\t1")); // 9
writeln(column("123\t")); // 8

// Other tab widths are possible by specifying it explicitly:
writeln(column("\t", 4)); // 4
writeln(column("1\t", 4)); // 4
writeln(column("\t1", 4)); // 5
writeln(column("123\t", 4)); // 4

// New lines reset the column number.
writeln(column("abc\n")); // 0
writeln(column("abc\n1")); // 1
writeln(column("abcdefg\r1234")); // 4
writeln(column("abc\u20281")); // 1
writeln(column("abc\u20291")); // 1
writeln(column("abc\u00851")); // 1
writeln(column("abc\u00861")); // 5

S wrap(S)(S s, in size_t columns = 80, S firstindent = null, S indent = null, in size_t tabsize = 8)
Constraints: if (isSomeString!S);

Разбить текст на абзацы.

Входная строка текста s формируется в абзац, разбивая ее на последовательность строк, разделяемых \n, таким образом, чтобы количество столбцов на каждой строке не превышало заданного. Последняя строка завершается \n.

Параметры:

S s	строка текста, которая должна быть разбита на абзацы
size_t columns	максимальное количество столбцов в абзаце
S firstindent	строка, используемая для отступа первой строки абзаца
S indent	строка для использования в качестве отступа следующих строк абзаца
size_t tabsize	интервал столбцов табуляции в firstindent[] и indent[]

Возвращает:

результирующий абзац в виде выделенной строки

Примеры:

writeln(wrap("a short string", 7)); // "a short\nstring\n"

// wrap will not break inside of a word, but at the next space
writeln(wrap("a short string", 4)); // "a\nshort\nstring\n"

writeln(wrap("a short string", 7, "\t")); // "\ta\nshort\nstring\n"
writeln(wrap("a short string", 7, "\t", "    ")); // "\ta\n    short\n    string\n"

pure @safe S outdent(S)(S str)
Constraints: if (isSomeString!S);

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

Это равномерно выравнивает текст как можно сильнее. Лишь содержащие пробелы строки всегда преобразуются в пустые строки.

Память не выделяется, если она не выбрасывает исключение.

Параметры:

S str

многострочная строка

Возвращает:

строка с удаленным отступом

Исключения:

StringException, если отступ выполнен с помощью различных последовательностей символов пробела.

Примеры:

enum pretty = q{
   import std.stdio;
   void main() {
       writeln("Hello");
   }
}.outdent();

enum ugly = q{
import std.stdio;
void main() {
writeln("Hello");
}
};

writeln(pretty); // ugly

pure @safe S[] outdent(S)(S[] lines)
Constraints: if (isSomeString!S);

Удаляет один уровень отступа из массива однострочных строк.

Это равномерно выравнивает текст как можно сильнее. Лишь содержащие пробелы строки всегда преобразуются в пустые строки.

Параметры:

S[] lines

массив однострочных строк

Возвращает:

lines[] переписывается на месте с удаленными отступами

Исключения:

StringException, если отступ выполнен с помощью различных последовательностей символов пробела.

Примеры:

auto str1 = [
    "    void main()\n",
    "    {\n",
    "        test();\n",
    "    }\n"
];
auto str1Expected = [
    "void main()\n",
    "{\n",
    "    test();\n",
    "}\n"
];
writeln(str1.outdent); // str1Expected

auto str2 = [
    "void main()\n",
    "    {\n",
    "            test();\n",
    "    }\n"
];
writeln(str2.outdent); // str2

auto assumeUTF(T)(T[] arr)
Constraints: if (staticIndexOf!(immutable(T), immutable(ubyte), immutable(ushort), immutable(uint)) != -1);

Предполагается, что данный массив целых чисел arr — это правильно сформированная строка UTF, и она возвращается в виде строки UTF.

ubyte становится char, ushort становится wchar и uint становится dchar. Квалификаторы типов сохраняются.

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

Параметры:

T[] arr

массив байтов, ubyte, short, ushort, int или uint

Возвращает:

arr, переведенный в массив char, wchar или dchar

Исключения:

В отладочном режиме AssertError, когда результат не является правильно сформированной строкой UTF.

См. также:

representation

Примеры:

string a = "Hölo World";
immutable(ubyte)[] b = a.representation;
string c = b.assumeUTF;

writeln(c); // "Hölo World"