std.string

Функции обработки строк.
Категория Функции
Поиск column  inPattern  indexOf  indexOfAny  indexOfNeither  lastIndexOf  lastIndexOfAny  lastIndexOfNeither 
Сравнение countchars  isNumeric 
Изменение capitalize  munch  removechars  squeeze 
Отрезание и заполнение Pruning and Filling center  chomp  chompPrefix  chop  detabber  detab  entab  entabber  leftJustify  outdent  rightJustify  strip  stripLeft  stripRight  wrap 
Замена abbrev  soundex  soundexer  succ  tr  translate 
Разное assumeUTF  fromStringz  lineSplitter  representation  splitLines  toStringz 
Объекты типов string, wstring, и dstring являются типами-значениями, и их нельзя изменять поэлементно. Для использования изменений во время построения строк используйте char[], wchar[] или dchar[]. Типы xxxstring предпочтительнее, поскольку они не проявляют нежелательных искажений (артефактов), что делает код более надёжным.
Следующие функции импортируются публично:
Модуль Функции
    Публично импортированные функции
std.algorithm cmp count endsWith startsWith
std.array join replace replaceInPlace split empty
std.format format sformat
std.uni icmp toLower toLowerInPlace toUpper toUpperInPlace
Существует богатый набор функций для обработки строк, определенных в других модулях. Функции, связанные с Unicode и ASCII, находятся в std.uni и std.ascii, соответственно. Другие функции, более общие, чем просто работающие со строками, можно найти в std.algorithm и std.range.
Смотрите также:
В документации этого не видно, но в исходных текстах модуля сказано, что функции inPattern, countchars, removechars, squeeze и munch считаются устаревшими, и будут удалены в мае 2018 года. Вместо них предлагается использовать функции из модулей std.regex и std.algorithm
З.ы. Пока переводил этот модуль, появилась версия компилятора 2.075, в описании которой эти грозные предупреждения уже есть. – прим.пер.
Лицензия:
Boost License 1.0.
Авторы:
Walter Bright, Andrei Alexandrescu, Jonathan M Davis, and David L. 'SpottedTiger' Davis

Исходный код: std/string.d

Переместиться к: this

class StringException: object.Exception;
Исключение, вызываемое ошибками в функциях std.string.
pure nothrow @safe this(string msg, string file = __FILE__, size_t line = __LINE__, Throwable next = null);
Параметры:
string msg Сообщение об исключении.
string file Файл, в котором произошло исключение.
size_t line Номер строки, в которой произошло исключение.
Throwable next Предыдущее исключение в цепочке исключений, если оно есть.
pure nothrow @nogc @system inout(char)[] fromStringz(inout(char)* cString);
Параметры:
inout(char)* cString Оканчивающаяся нулём строка в c-стиле.
Возвращает:
Массив символов char в D-стиле, ссылающийся на ту же строку. Возвращаемый массив будет сохранять квалификаторы тех же типов, что и входной.
Важное замечание: Возвращаемый массив представляет собой срез исходного буфера. Исходные данные не изменяются и не копируются.
Примеры:
assert(fromStringz(null) == null);
assert(fromStringz("foo") == "foo");
pure nothrow @trusted immutable(char)* toStringz(const(char)[] s);

pure nothrow @trusted immutable(char)* toStringz(in 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");
assert(strlen(p) == 3);
const(char)[] foo = "abbzxyzzy";
p = toStringz(foo[3..5]);
assert(strlen(p) == 2);

string test = "";
p = toStringz(test);
assert(*p == 0);

test = "\0";
p = toStringz(test);
assert(*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);
assert(*p == 0);
alias CaseSensitive = std.typecons.Flag!"caseSensitive".Flag;
Флаг, указывающий, является ли поиск чувствительным к регистру.

Переместиться к: 2

ptrdiff_t indexOf(Range)(Range s, in dchar c, in CaseSensitive cs = Yes.caseSensitive)
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

ptrdiff_t indexOf(Range)(Range s, in dchar c, in size_t startIdx, in CaseSensitive cs = Yes.caseSensitive)
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
Ищет символ в диапазоне.
Параметры:
Range s строка или входной диапазон символов для поиска в корректном 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.
Примеры:
string s = "Hello World";
assert(indexOf(s, 'W') == 6);
assert(indexOf(s, 'Z') == -1);
assert(indexOf(s, 'w', No.caseSensitive) == 6);
Примеры:
string s = "Hello World";
assert(indexOf(s, 'W', 4) == 6);
assert(indexOf(s, 'Z', 100) == -1);
assert(indexOf(s, 'w', 3, No.caseSensitive) == 6);
ptrdiff_t indexOf(Range, Char)(Range s, const(Char)[] sub, in CaseSensitive cs = Yes.caseSensitive)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && isSomeChar!Char);

@safe ptrdiff_t indexOf(Char1, Char2)(const(Char1)[] s, const(Char2)[] sub, in size_t startIdx, in CaseSensitive cs = Yes.caseSensitive)
if (isSomeChar!Char1 && isSomeChar!Char2);
Ищет подстроку в строке s.
Параметры:
Range s Строка или лидирующий диапазон символов в правильном 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 не даст полного совпадения.
Примеры:
string s = "Hello World";
assert(indexOf(s, "Wo", 4) == 6);
assert(indexOf(s, "Zo", 100) == -1);
assert(indexOf(s, "wo", 3, No.caseSensitive) == 6);
Примеры:
string s = "Hello World";
assert(indexOf(s, "Wo") == 6);
assert(indexOf(s, "Zo") == -1);
assert(indexOf(s, "wO", No.caseSensitive) == 6);

Переместиться к: 2

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

pure @safe ptrdiff_t lastIndexOf(Char)(const(Char)[] s, in dchar c, in size_t startIdx, in CaseSensitive cs = Yes.caseSensitive)
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 указывает, являются ли сравнения чувствительными к регистру.
Примеры:
string s = "Hello World";
assert(lastIndexOf(s, 'l') == 9);
assert(lastIndexOf(s, 'Z') == -1);
assert(lastIndexOf(s, 'L', No.caseSensitive) == 9);
Примеры:
string s = "Hello World";
assert(lastIndexOf(s, 'l', 4) == 3);
assert(lastIndexOf(s, 'Z', 1337) == -1);
assert(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)
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)
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 указывает, являются ли сравнения чувствительными к регистру.
Примеры:
string s = "Hello World";
assert(lastIndexOf(s, "ll") == 2);
assert(lastIndexOf(s, "Zo") == -1);
assert(lastIndexOf(s, "lL", No.caseSensitive) == 2);
Примеры:
string s = "Hello World";
assert(lastIndexOf(s, "ll", 4) == 2);
assert(lastIndexOf(s, "Zo", 128) == -1);
assert(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)
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)
if (isSomeChar!Char && isSomeChar!Char2);
Возвращает индекс первого появления любого элемента из needles в haystack. Если ни один элемент из needles не найден, возвращается -1. Присутствие startIdx выделяет срез из haystack следующим образом: haystack[startIdx .. $]. startIdx представляет индекс кодового блока в haystack. Если последовательность, начинающаяся со startIdx, не представляет собой хорошо сформированную кодовую точку, то может быть брошено исключение std.utf.UTFException.
Параметры:
const(Char)[] haystack Строка, в которой ищутся needles.
const(Char2)[] needles Искомые строки из haystack.
size_t startIdx Выделяет срез haystack такого вида haystack[startIdx .. $]. Если startIdx больше или равен длине haystack, функция вернёт -1.
CaseSensitive cs Указывает, являются ли сравнения чувствительными к регистру.
Примеры:
import std.conv : to;

ptrdiff_t i = "helloWorld".indexOfAny("Wr");
assert(i == 5);
i = "öällo world".indexOfAny("lo ");
assert(i == 4, to!string(i));
Примеры:
import std.conv : to;

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

i = "Foo öällo world".indexOfAny("lh", 3);
assert(i == 8, to!string(i));
pure @safe ptrdiff_t lastIndexOfAny(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in CaseSensitive cs = Yes.caseSensitive)
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)
if (isSomeChar!Char && isSomeChar!Char2);
Возвращает индекс последнего появления любого элемента из needles в haystack. Если ни один элемент из needles не найден, возвращается -1. Присутствие stopIdx выделяет срез из haystack следующим образом: haystack[0 .. stopIdx]. stopIdx представляет индекс кодового блока в haystack. Если последовательность, заканчивающаяся startIdx, не представляет собой хорошо сформированную кодовую точку, то может быть брошено исключение std.utf.UTFException.
Параметры:
const(Char)[] haystack Строка, в которой ищутся needles.
const(Char2)[] needles Искомые строки из haystack.
size_t stopIdx Выделяет срез haystack такого вида haystack[0 .. stopIdx]. Если stopIdx больше или равен длине haystack, функция вернёт -1.
CaseSensitive cs Указывает, являются ли сравнения чувствительными к регистру.
Примеры:
ptrdiff_t i = "helloWorld".lastIndexOfAny("Wlo");
assert(i == 8);

i = "Foo öäöllo world".lastIndexOfAny("öF");
assert(i == 8);
Примеры:
import std.conv : to;

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

i = "Foo öäöllo world".lastIndexOfAny("öF", 3);
assert(i == 0);
pure @safe ptrdiff_t indexOfNeither(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in CaseSensitive cs = Yes.caseSensitive)
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)
if (isSomeChar!Char && isSomeChar!Char2);
Возвращает индекс первого появления в haystack любого символа, не являющегося элементом needles. Если все элементы haystack являются элементами needles , возвращается -1.
Параметры:
const(Char)[] haystack Строка для поиска needles.
const(Char2)[] needles Строки, которые ищутся в haystack.
size_t startIdx Выделяет срез haystack такого вида haystack[startIdx .. $]. Если startIdx больше или равен длине haystack, функция вернёт -1.
CaseSensitive cs Указывает, являются ли сравнения чувствительными к регистру.
Примеры:
assert(indexOfNeither("abba", "a", 2) == 2);
assert(indexOfNeither("def", "de", 1) == 2);
assert(indexOfNeither("dfefffg", "dfe", 4) == 6);
Примеры:
assert(indexOfNeither("def", "a") == 0);
assert(indexOfNeither("def", "de") == 2);
assert(indexOfNeither("dfefffg", "dfe") == 6);
pure @safe ptrdiff_t lastIndexOfNeither(Char, Char2)(const(Char)[] haystack, const(Char2)[] needles, in CaseSensitive cs = Yes.caseSensitive)
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)
if (isSomeChar!Char && isSomeChar!Char2);
Возвращает индекс последнего появления в haystack любого символа, не являющегося элементом needles. Если все элементы haystack являются элементами needles , возвращается -1.
Параметры:
const(Char)[] haystack Строка для поиска needles.
const(Char2)[] needles Строки, которые ищутся в haystack.
size_t stopIdx Выделяет срез haystack такого вида haystack[0 .. stopIdx]. Если stopIdx больше или равен длине haystack, функция вернёт -1.
CaseSensitive cs Указывает, являются ли сравнения чувствительными к регистру.
Примеры:
assert(lastIndexOfNeither("abba", "a") == 2);
assert(lastIndexOfNeither("def", "f") == 1);
Примеры:
assert(lastIndexOfNeither("def", "rsa", 3) == -1);
assert(lastIndexOfNeither("abba", "a", 2) == 1);
pure nothrow @nogc @safe auto representation(Char)(Char[] s)
if (isSomeChar!Char);
Возвращает представление строки, которая имеет тот же тип, что и строка, за исключением того, что тип символа заменяется на ubyte, ushort или uint в зависимости от ширины символа.
Параметры:
Char[] s Строка, представление которой надо вернуть.
Возвращает:
Представление переданной строки.
Примеры:
string s = "hello";
static assert(is(typeof(representation(s)) == immutable(ubyte)[]));
assert(representation(s) is cast(immutable(ubyte)[]) s);
assert(representation(s) == [0x68, 0x65, 0x6c, 0x6c, 0x6f]);
pure @trusted S capitalize(S)(S input)
if (isSomeString!S);
Делает первый символ строки заглавным и преобразует остальную её часть в нижний регистр.
Параметры:
S input Строка для преобразования.
Возвращает:
Преобразованная строка.
Смотрите также:
std.uni.asCapitalized – версию с ленивым диапазоном, которая не выделяет память
Примеры:
assert(capitalize("hello") == "Hello");
assert(capitalize("World") == "World");
alias KeepTerminator = std.typecons.Flag!"keepTerminator".Flag;

pure @safe S[] splitLines(S)(S s, in KeepTerminator keepTerm = No.keepTerminator)
if (isSomeString!S);
Разделяет 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.
Параметры:
S s Строка из char, wchar или dchar, или любой пользовательский тип, который преобразуется к строковому типу
KeepTerminator keepTerm Включается ли разделитель в результат или нет
Возвращает:
Массив строк, каждый элемент которого – это строка, являющаяся срезом s
Примеры:
string s = "Hello\nmy\rname\nis";
assert(splitLines(s) == ["Hello", "my", "name", "is"]);
auto lineSplitter(KeepTerminator keepTerm = No.keepTerminator, Range)(Range r)
if ((hasSlicing!Range && hasLength!Range && isSomeChar!(ElementType!Range) || isSomeString!Range) && !isConvertibleToString!Range);
Разделяет s на массив строк в соответствии со стандартом unicode, используя '\r', '\n', "\r\n", std.uni.lineSep, std.uni.paraSep, U+0085 (NEL), '\v' и '\f' в качестве разделителей. Если параметр keepTerm установлен в значение KeepTerminator.yes, то разделитель включается в возвращаемые строки.
Не бросает исключений при недопустимом UTF; в этом случае просто передаёт на выход без изменений.
Придерживается Unicode 7.0.
Не выделяет память.
Параметры:
Range r Массив из char, wchar или dchar, или диапазон с поддержкой срезов
keepTerm Включается ли разделитель в результат или нет
Возвращает:
Диапазон из срезов входного диапазона r
Примеры:
import std.array : array;

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

/* Обратите внимание на вызов $(D array), чтобы сделать ленивый диапазон, созданный 
функцией lineSplitter, сравнимым с $(D string[]), созданным функцией splitLines.
*/
assert(lineSplitter(s).array == splitLines(s));
auto stripLeft(Range)(Range input)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
Убирает ведущие пробельные символы (определямые функцией std.uni.isWhite).
Параметры:
Range input Строка или лидирующий диапазон символов
Возвращает:
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("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     ");
auto stripRight(Range)(Range str)
if (isSomeString!Range || isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && !isConvertibleToString!Range && isSomeChar!(ElementEncodingType!Range));
Убирает задние пробельные символы (определямые функцией std.uni.isWhite).
Параметры:
Range str Строка или лидирующий диапазон символов
Возвращает:
Срез 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");
auto strip(Range)(Range str)
if (isSomeString!Range || isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && !isConvertibleToString!Range && isSomeChar!(ElementEncodingType!Range));
Отрезает как ведущие, так и конечные пробельные символы (определямые функцией std.uni.isWhite).
Параметры:
Range str Строка или лидирующий диапазон символов
Возвращает:
Срез 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");
Range chomp(Range)(Range str)
if ((isRandomAccessRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);

Range chomp(Range, C2)(Range str, const(C2)[] delimiter)
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 не заканчивается ни одним из этих символов, то она возвращается без изменений.
Параметры:
Range str Строка или индексируемый диапазон символов
const(C2)[] delimiter Строка символов, подлежащих отрезанию от конца str[]
Возвращает:
срез строки str
Примеры:
import std.uni : lineSep, paraSep, nelSep;
import std.utf : decode;
assert(chomp(" hello world  \n\r") == " hello world  \n");
assert(chomp(" hello world  \r\n") == " hello world  ");
assert(chomp(" hello world  \f") == " hello world  ");
assert(chomp(" hello world  \v") == " hello world  ");
assert(chomp(" hello world  \n\n") == " hello world  \n");
assert(chomp(" hello world  \n\n ") == " hello world  \n\n ");
assert(chomp(" hello world  \n\n" ~ [lineSep]) == " hello world  \n\n");
assert(chomp(" hello world  \n\n" ~ [paraSep]) == " hello world  \n\n");
assert(chomp(" hello world  \n\n" ~ [ nelSep]) == " hello world  \n\n");
assert(chomp(" hello world") == " hello world");
assert(chomp("") == "");

assert(chomp(" hello world", "orld") == " hello w");
assert(chomp(" hello world", " he") == " hello world");
assert(chomp("", "hello") == "");

// Не декодировать бессмысленно 
assert(chomp("hello\xFE", "\r") == "hello\xFE");
Range chompPrefix(Range, C2)(Range str, const(C2)[] delimiter)
if ((isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range && isSomeChar!C2);
Если str начинается с delimiter, возвращается часть str, следующая после delimiter. Если str не начинается с delimiter, то она возвращается без изменений.
Параметры:
Range str Строка или лидирующий диапазон символов
const(C2)[] delimiter Строка символов, подлежащих отзрезанию спереди str[]
Возвращает:
срез str
Примеры:
assert(chompPrefix("hello world", "he") == "llo world");
assert(chompPrefix("hello world", "hello w") == "orld");
assert(chompPrefix("hello world", " world") == "hello world");
assert(chompPrefix("", "hello") == "");
Range chop(Range)(Range str)
if ((isBidirectionalRange!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);
Возвращает str без последнего символа, если таковой имеется. Если str заканчивается на "\r\n", то удаляются оба. Если str пуста, тогда она возвращается без изменений.
Параметры:
Range str строка (должна быть действительной UTF-строкой)
Возвращает:
срез str
Примеры:
assert(chop("hello world") == "hello worl");
assert(chop("hello world\n") == "hello world");
assert(chop("hello world\r") == "hello world");
assert(chop("hello world\n\r") == "hello world\n");
assert(chop("hello world\r\n") == "hello world");
assert(chop("Walter Bright") == "Walter Brigh");
assert(chop("") == "");
S leftJustify(S)(S s, size_t width, dchar fillChar = ' ')
if (isSomeString!S);
Выровнять по левому краю s в поле шириной width символов. fillChar – это символ, который будет использоваться для заполнения пустого места поля.
Параметры:
S s строка
size_t width минимальная ширина поля
dchar fillChar используемый заполнитель до ширины width символов
Возвращает:
строку, память для которой выделена сборщиком мусора
Смотрите также:
функция leftJustifier, которая не выделяет память
Примеры:
assert(leftJustify("hello", 7, 'X') == "helloXX");
assert(leftJustify("hello", 2, 'X') == "hello");
assert(leftJustify("hello", 9, 'X') == "helloXXXX");
auto leftJustifier(Range)(Range r, size_t width, dchar fillChar = ' ')
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
Выровнять по левому краю s в поле шириной width символов. fillChar – это символ, который будет использоваться для заполнения пустого места поля.
Параметры:
Range r строка или диапазон символов
size_t width минимальная ширина поля
dchar fillChar используемый заполнитель до ширины width символов
Возвращает:
Ленивый диапазон с выровненным по левому краю результатом
Смотрите также:
Примеры:
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 = ' ')
if (isSomeString!S);
Выровнять по правому краю s в поле шириной width символов. fillChar – это символ, который будет использоваться для заполнения пустого места поля.
Параметры:
S s строка
size_t width минимальная ширина поля
dchar fillChar используемый заполнитель до ширины width символов
Возвращает:
строку, память для которой выделена сборщиком мусора
Смотрите также:
функция rightJustifier, которая не выделяет память
Примеры:
assert(rightJustify("hello", 7, 'X') == "XXhello");
assert(rightJustify("hello", 2, 'X') == "hello");
assert(rightJustify("hello", 9, 'X') == "XXXXhello");
auto rightJustifier(Range)(Range r, size_t width, dchar fillChar = ' ')
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
Выровнять по правому краю s в поле шириной width символов. fillChar – это символ, который будет использоваться для заполнения пустого места поля.
Параметры:
Range r строка или диапазон символов
size_t width минимальная ширина поля
dchar fillChar используемый заполнитель до ширины width символов
Возвращает:
Ленивый диапазон с выровненным по правому краю результатом
Смотрите также:
Примеры:
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 = ' ')
if (isSomeString!S);
Отцентрировать s в поле шириной width символов. fillChar – это символ, который будет использоваться для заполнения пустого места поля.
Параметры:
S s Центрируемая строка
size_t width Ширина поля, в котором центрируется s
dchar fillChar Символ, используемый для заполнения лишнего пространства в поле
Возвращает:
Результат выравнивания строки по центру. Возвращаемая строка выделена сборщиком мусора. Чтобы избежать выделения памяти сборщиком, вместо этой функции используйте centerJustifier.
Примеры:
assert(center("hello", 7, 'X') == "XhelloX");
assert(center("hello", 2, 'X') == "hello");
assert(center("hello", 9, 'X') == "XXhelloXX");
auto centerJustifier(Range)(Range r, size_t width, dchar fillChar = ' ')
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
Отцентрировать s в поле шириной width символов. fillChar – это символ, который будет использоваться для заполнения пустого места поля.
Параметры:
Range r строка или диапазон символов
size_t width минимальная ширина поля
dchar fillChar используемый заполнитель до ширины width символов
Возвращает:
Ленивый диапазон с выровненным по центру результатом
Смотрите также:
Примеры:
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)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) || __traits(compiles, StringTypeOf!Range));
Заменяет каждый символ табуляции в s на количество пробелов, необходимое для выравнивания следующего символа до следующей позиции табуляции.
Параметры:
Range s строка
size_t tabSize расстояние между позициями табуляции
Возвращает:
строку, память для которой выделил сборщик мусора, в которой символы табуляции заменены на пробелы
Примеры:
assert(detab(" \n\tx", 9) == " \n         x");
auto detabber(Range)(Range r, size_t tabSize = 8)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
Заменяет каждый символ табуляции в s на количество пробелов, необходимое для выравнивания следующего символа до следующей позиции табуляции.
Параметры:
Range r строка или лидирующий диапазон
size_t tabSize расстояние между позициями табуляции
Возвращает:
ленивый лидирующий диапазон, у которого символы табуляции заменены на пробелы
Примеры:
import std.array : array;

assert(detabber(" \n\tx", 9).array == " \n         x");
auto entab(Range)(Range s, size_t tabSize = 8)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range));
Заменяет пробелы в s на оптимальное количество символов табуляции. Все пробелы и символы табуляции в конце строки удаляются.
Параметры:
Range s Строка для преобразования.
size_t tabSize Символы табуляции отделяют по tabSize пробелов.
Возвращает:
Строку, память для которой выделил сборщик мусора, в которой пробелы заменены символами табуляции; используйте функцию entabber, чтобы не выделять память.
Смотрите также:
Примеры:
assert(entab("        x \n") == "\tx\n");
auto entabber(Range)(Range r, size_t tabSize = 8)
if (isForwardRange!Range && !isConvertibleToString!Range);
Заменяет пробелы в диапазоне r на оптимальное количество символов табуляции. Все пробелы и символы табуляции в конце строки удаляются.
Параметры:
Range r строка или лидирующий диапазон
size_t tabSize расстояние между позициями табуляции
Возвращает:
Ленивый лидирующий диапазон с пробелами, заменёнными символами табуляции
Смотрите также:
Примеры:
import std.array : array;
assert(entabber("        x \n").array == "\tx\n");

Переместиться к: 2 · 3 · 4

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

pure @safe C1[] translate(C1, S, C2 = immutable(char))(C1[] str, in S[dchar] transTable, const(C2)[] toRemove = null)
if (isSomeChar!C1 && isSomeString!S && isSomeChar!C2);
Заменяет символы в str, которые являются ключами в transTable на соответствующие значения в transTable. transTable – это асоциативный массив, в котором ключи являются dchar, а его значения – либо dchar, либо некоторый строковый тип. Кроме того, если задано toRemove, символы, присутствующие в нём, удаляются из str до замены. Сама строка не изменяется. Возвращается её копия с изменениями.
Смотрите также:
Параметры:
C1[] str Исходная строка.
dchar[dchar] transTable Ассоциативный массив, указывающий, какие символы заменить и на что их заменить.
const(C2)[] toRemove Символы для удаления из строки.
Примеры:
dchar[dchar] transTable1 = ['e' : '5', 'o' : '7', '5': 'q'];
assert(translate("hello world", transTable1) == "h5ll7 w7rld");

assert(translate("hello world", transTable1, "low") == "h5 rd");

string[dchar] transTable2 = ['e' : "5", 'o' : "orange"];
assert(translate("hello world", transTable2) == "h5llorange worangerld");
void translate(C1, C2 = immutable(char), Buffer)(C1[] str, in dchar[dchar] transTable, const(C2)[] toRemove, Buffer buffer)
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)
if (isSomeChar!C1 && isSomeString!S && isSomeChar!C2 && isOutputRange!(Buffer, S));
Это перегрузка функции translate, которая принимает существующий буфер buffer для записи содержимого.
Параметры:
C1[] str Исходная строка.
dchar[dchar] transTable Ассоциативный массив, указывающий, какие символы заменить и на что их заменить.
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);
assert(buffer.data == "h5ll7 w7rld");

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

buffer.clear();
string[dchar] transTable2 = ['e' : "5", 'o' : "orange"];
translate("hello world", transTable2, null, buffer);
assert(buffer.data == "h5llorange worangerld");
pure nothrow @trusted C[] translate(C = immutable(char))(in char[] str, in char[] transTable, in char[] toRemove = null)
if (is(Unqual!C == char));
Это исключительно ASCII-версия функции translate. Она не будет работать с Unicode. Она существует как оптимизация для случаев, когда обработка Unicode не требуется.
В отличие от других перегрузок translate, эта не принимает ассоциативный массив. Вместо этого, она принимает строку, сгенерированную функцией makeTransTable.
Массив, сгенерированный makeTransTable, имеет длину 256 элементов, таким образом индекс равен заменяемому символу ASCII, а значение равно символу, на который производится замена. Обратите внимание, что translate не декодирует никакие символы, поэтому вы можете передать в неё расширенные символы ASCII, если вы хотите (ASCII использует только 128 символов), но следует предупредить, что расширенные символы ASCII не являются действительными символами Unicode и, следовательно, для них будет выбрасываться исключение UTFException в большинстве других функций Phobos.
К тому же, поскольку декодирования не происходит, можно использовать эту перегрузку для перевода символов ASCII в правильную строку UTF-8 без изменения других символов, отличных от ASCII. Она заменит любой кодовый блок более 127 на другой кодовый блок, или заменит любой кодовый блок другим кодовым блоком больше 127, что вызовет проблемы при UTF-валидации.
Смотрите также:
Параметры:
char[] str Исходная строка.
char[] transTable Строка, указывающая, какие символы и на что заменять. Она генерируется функцией makeTransTable.
char[] toRemove Символы, удаляемые из строки.
pure nothrow @trusted string makeTrans(in char[] from, in char[] to);
Делает то же самое, что и makeTransTable, но выделяет таблицу перевода в куче, управляемой сборщиком мусора.
Вместо этого используйте makeTransTable.
Примеры:
auto transTable1 = makeTrans("eo5", "57q");
assert(translate("hello world", transTable1) == "h5ll7 w7rld");

assert(translate("hello world", transTable1, "low") == "h5 rd");
pure nothrow @nogc @safe char[256] makeTransTable(in char[] from, in char[] to);
Строит таблицу преобразования длиной 256 символов, где символы из from[] заменяются соответствующими символами из to[].
Параметры:
char[] from Массив символов, длина которого меньше или равна 256
char[] to Соответствующий массив символов, в которые происходит перевод
Возвращает:
Массив перевода
pure @trusted void translate(C = immutable(char), Buffer)(in char[] str, in char[] transTable, in char[] toRemove, Buffer buffer)
if (is(Unqual!C == char) && isOutputRange!(Buffer, char));
Это исключительно ASCII-версия фуекции translate, которая принимает уже существующий буфер buffer для записи содержимого.
Параметры:
char[] str Исходная строка.
char[] transTable Строка, указывающая, какие символы и на что заменять. Она генерируется функцией makeTransTable.
char[] toRemove Символы, удаляемые из строки.
Buffer buffer Выходной диапазон для записи содержимого.
Примеры:
import std.array : appender;
auto buffer = appender!(char[])();
auto transTable1 = makeTransTable("eo5", "57q");
translate("hello world", transTable1, null, buffer);
assert(buffer.data == "h5ll7 w7rld");

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

Переместиться к: 2

pure @nogc @safe bool inPattern(S)(dchar c, in S pattern)
if (isSomeString!S);
Смотрит, находится ли символ c в шаблоне pattern.

Шаблоны: Шаблон pattern представляет собой массив символов, очень похожий на класс символов (character class) в регулярных выражениях. Можно указать последовательность символов, например "abcde". '-' может представлять диапазон символов, поскольку "a-e" представляет собой тот же шаблон, что и "abcde". "a-fA-F0-9" представляет собой все шестнадцатеричные символы. Если первый символ шаблона равен '^', тогда шаблон отрицается, т.е. "^0-9" означает любой символ, кроме цифры. Функции inPattern, countchars, removeschars и squeeze используют шаблоны.

Замечание: В будущем синтаксис шаблона pattern может быть улучшен, чтобы быть более похожим на классы символов регулярных выражений.

pure @nogc @safe bool inPattern(S)(dchar c, S[] patterns)
if (isSomeString!S);
Смотрит, находится ли символ c в пересечении шаблонов patterns.
pure @nogc @safe size_t countchars(S, S1)(S s, in S1 pattern)
if (isSomeString!S && isSomeString!S1);
Считает символы в s, соответствующие шаблону pattern.
pure @safe S removechars(S)(S s, in S pattern)
if (isSomeString!S);
Возвращает строку получаемую из s, в которой удалены все символы, соответствующие шаблону pattern.
S squeeze(S)(S s, in S pattern = null);
Возвращает строку, где последовательности символа в s[] из шаблона pattern[] заменяются одним экземпляром этого символа. Если pattern имеет значение null, он по умолчанию соответствует всем символам.
pure @nogc @safe S1 munch(S1, S2)(ref S1 s, S2 pattern);
Находит позицию pos первого символа в s, которая не соответствует шаблону pattern (в терминологии, используемой функцией std.string.inPattern). Делает замену s = s[pos..$]. Возвращает срез от начала исходной (до обновления) строки до pos, исключая саму pos.
Функция munch по большей части удобна для пропуска определенной категории символов (например, пробелов) при разборе строк. (В этих случаях возвращаемое значение не используется.)
Примеры:
string s = "123abc";
string t = munch(s, "0123456789");
assert(t == "123" && s == "abc");
t = munch(s, "0123456789");
assert(t == "" && s == "abc");
pure @safe S succ(S)(S s)
if (isSomeString!S);
Возвращает строку, которая является «преемником» для s[]. Если самый правый символ - это a-zA-Z0-9, он увеличивается на единицу. Если при этом генерируется перенос, процесс повторяется с символом слева от него.
Примеры:
assert(succ("1") == "2");
assert(succ("9") == "10");
assert(succ("999") == "1000");
assert(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 основана на утилите tr из Posix, хотя она делает не всё, что делает 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.
И from, и to может содержать диапазоны с использованием символа '-' (например, "a-d" является синонимом "abcd".) Ни один из них не принимает ведущий '^', означающий дополнение к строке (используйте для этого модификатор 'c').
bool isNumeric(S)(S s, bool bAllowSep = false)
if (isSomeString!S || isRandomAccessRange!S && hasSlicing!S && isSomeChar!(ElementType!S) && !isInfinite!S);
Принимает строку s и определяет, представляет ли она число. Эта функция также принимает необязательный параметр bAllowSep, который будет принимать разделяющие символы ',' и '_' внутри строки. Но эти символы должны быть удалены из строки перед использованием любых функций преобразования, таких как to!int(), to!float() и т.д., иначе произойдёт ошибка.
Также обратите внимание, что пробелы не допускаются внутри строки s в любом месте, будь то в начале, в конце, или между символами, таким образом, их тоже нужно удалить из строки перед использованием этой функции, или любой из функций преобразования.
Параметры:
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]
assert(isNumeric("-123e-1+456.9e-10Li"));
assert(isNumeric("+123e+10+456i"));
assert(isNumeric("123+456"));
Примеры:
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)
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
Алгоритм Soundex.
Алгоритм Soundex преобразует слово в 4 символа в зависимости от того, как слово звучит фонетически. Идея состоит в том, что два звука, которые звучат одинаково, будут иметь одно и то же Soundex-значение, а это значит, что Soundex может использоваться для нечеткого сопоставления имен.
(Как я понимаю, это работает только для англоязычной фонетики – прим.пер.)
Параметры:
Range str Строка или Входной диапазон для преобразования в Soundex-представление.
Возвращает:
Массив из четырёх символов с результатом алгоритма Soundex. Массив будет содержать null, если для строки не существует Soundex-представления.
Недостатки:
Хорошо работает только с английскими именами. Существуют и другие, возможно, лучше, чем Soundex-алгоритмы, но этот является стандартным.
pure nothrow @safe char[] soundex(const(char)[] str, char[] buffer = null);
Как soundexer, но с отличающимися параметрами и возвращаемым значением.
Параметры:
const(char)[] str Строка для преобразования в Soundex-представление.
char[] buffer Необязательный 4-х символьный массив для размещения результирующих Soundex-символов. Если null, то буфер для возвращаемого значения будет выделен в куче.
Возвращает:
Массив из четырёх символов с результатом алгоритма Soundex. Возвращает null, если если для строки не существует Soundex-представления.
Смотрите также:
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)
if ((isInputRange!Range && isSomeChar!(Unqual!(ElementEncodingType!Range)) || isNarrowString!Range) && !isConvertibleToString!Range);
Вычисляет номер столбца в конце напечатанной формы строки, предполагая, что строка начинается в крайнем левом столбце, столбцы нумеруются начиная с 0.
Cимволы табуляции расширяются до достаточного пространства, чтобы привести номер столбца к следующей табуляции. Если str многострочная, возвращается номер столбца последней строки.
Параметры:
Range str анализируемая строка или Входной диапазон
size_t tabsize количество столбцов, которое представляет символ табуляции
Возвращает:
Номер столбца
Примеры:
import std.utf : byChar, byWchar, byDchar;

assert(column("1234 ") == 5);
assert(column("1234 "w) == 5);
assert(column("1234 "d) == 5);

assert(column("1234 ".byChar()) == 5);
assert(column("1234 "w.byWchar()) == 5);
assert(column("1234 "d.byDchar()) == 5);

// По умолчанию табуляция составляет набор из 8 пробелов; Символы табуляции вставляют достаточно  
// пробелов, чтобы привести столбец к следующей позиции, кратной 8. 
assert(column("\t") == 8);
assert(column("1\t") == 8);
assert(column("\t1") == 9);
assert(column("123\t") == 8);

// Возможна другая ширина табуляции, если указать её явно:
assert(column("\t", 4) == 4);
assert(column("1\t", 4) == 4);
assert(column("\t1", 4) == 5);
assert(column("123\t", 4) == 4);

// Переводы строк сбрасывают номер столбца.
assert(column("abc\n") == 0);
assert(column("abc\n1") == 1);
assert(column("abcdefg\r1234") == 4);
assert(column("abc\u20281") == 1);
assert(column("abc\u20291") == 1);
assert(column("abc\u00851") == 1);
assert(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)
if (isSomeString!S);
Заворачивает текст в абзац. Wrap text into a paragraph.
Входная текстовая строка s переформатируется в абзац, посредсвом разбивки её на последовательность строк, разделённую переводами строки \n, так чтобы количество столбцов не превышало columns в каждой строке. Последняя строка завершается символом \n.
Параметры:
S s строка текста, которая будет завёрнута
size_t columns максимальное количество столбцов в абзаце
S firstindent строка, используемая для отступа первой строки абзаца
S indent строка, используемая для отступов в последующих строках абзаца
size_t tabsize расстояние между позициями табуляции в firstindent[] и indent[]
Возвращает:
полученный абзац в качестве строки, размещённой в памяти
Примеры:
assert(wrap("a short string", 7) == "a short\nstring\n");

// wrap не будет разрывать слова внутри них, а только в следующем пробельном символе
assert(wrap("a short string", 4) == "a\nshort\nstring\n");

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

Переместиться к: 2

pure @safe S outdent(S)(S str)
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");
}
};

assert(pretty == ugly);
pure @safe S[] outdent(S)(S[] lines)
if (isSomeString!S);
Удаляет один уровень отступов из массива одинарных строк.
Эта функция равномерно втягивает текст как можно сильнее. Строки, состоящие только из пробельных символов, всегда преобразуются в пустые строки.
Параметры:
S[] lines Массив однострочных строк
Возвращает:
lines[], перезаписанные по-месту с втянутыми отступами
Исключения:
StringException, если отступы делаются с помощью различных последовательностей пробельных символов.
pure auto assumeUTF(T)(T[] arr)
if (staticIndexOf!(Unqual!T, ubyte, ushort, uint) != -1);
Предполагает, что заданный массив целых чисел arr является хорошо сформированной UTF-строкой, и возвращает её в виде UTF-строки.
ubyte становится char, ushort становится wchar и uint становится dchar. Квалификаторы типов сохраняются.
Параметры:
T[] arr массив из типов byte, ubyte, short, ushort, int, или uint
Возвращает:
массив arr, перетипизированный на char, wchar, или dchar
Смотрите также:
Примеры:
string a = "Hölo World";
immutable(ubyte)[] b = a.representation;
string c = b.assumeUTF;

assert(a == c);