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;
Флаг, указывающий, является ли поиск чувствительным к регистру.
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);
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 |
Строка для преобразования. |
Возвращает: Преобразованная строка.
Примеры: 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";
assert(lineSplitter(s).array == splitLines(s));
auto
stripLeft
(Range)(Range
input
)
if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);
-
Параметры: Range input |
Строка или лидирующий диапазон символов |
Возвращает: input
, лишенный ведущих пробелов.
Постусловия:
input
и возвращаемое значение будут иметь один и тот же хвост (смотрите std.array.sameTail).
Примеры: 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));
-
Параметры: Range str |
Строка или лидирующий диапазон символов |
Возвращает: Срез str
, лишённый хвостовых пробелов.
Примеры: 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
, лишенный ведущих и задних пробелов.
Примеры: 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 [] |
Примеры: 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-строкой) |
Примеры: 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 символов |
Возвращает: строку, память для которой выделена сборщиком мусора
Примеры: 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 символов |
Возвращает: строку, память для которой выделена сборщиком мусора
Примеры: 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, но выделяет таблицу перевода в куче, управляемой сборщиком мусора.
Примеры: 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");
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 |
Принимать ли разделительные символы или нет |
Примеры: Целые числа: (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);
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");
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");
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);