std.array

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

ForeachType!Range[] array(Range)(Range r)
if (isIterable!Range && !isNarrowString!Range && !isInfinite!Range);

Распределяет массив array и инициализирует его с копиями элементов диапазона r.

Узкие строки (Narrow strings, см. ниже) обрабатываются как специальный случай в перегрузке.

Параметры:

Range r

диапазон (или агрегат с функцией opApply), чьи элементы копируются в размещённый массив array

Возвращает:

размещённый и инициализированный массив array

Примеры:

auto a = array([1, 2, 3, 4, 5][]);
assert(a == [ 1, 2, 3, 4, 5 ]);

ElementType!String[] array(String)(String str)
if (isNarrowString!String);

Конвертирует узкую строку в массив, тип которого полностью поддерживает произвольный доступ. Это обрабатывается как специальный случай и всегда возвращается dchar[], const(dchar)[], или immutable(dchar)[] в зависимости от квалификатора неизменяемости входного параметра.

Узкие строки (Narrow strings): в модуле std.traits определён предикат isNarrowString, который срабатывает, если на входе char[], string, wchar[] или wstring, т.е. это байтовые или двухбайтовые строки — прим. пер.

auto assocArray(Range)(Range r)
if (isInputRange!Range);

Возвращает вновь размещённый ассоциативный массив из диапазона кортежей ключ/значение.

Параметры:

Range r

Входной диапазон кортежей из ключей и значений.

Возвращает:

Вновь размещённый ассоциативный массив из элементов входного диапазона, который должен быть диапазоном кортежей (Ключ, Значение). Возвращает null, если дан пустой диапазон.

Дубликаты: Ассоциативный массив имеет уникальные ключи. Если r содержит дубликаты ключей, тогда результат будет содержать значение последней пары для этого ключа в r.

Смотрите также:

std.typecons.Tuple

Примеры:

import std.range;
import std.typecons;
auto a = assocArray(zip([0, 1, 2], ["a", "b", "c"]));
assert(is(typeof(a) == string[int]));
assert(a == [0:"a", 1:"b", 2:"c"]);

auto b = assocArray([ tuple("foo", "bar"), tuple("baz", "quux") ]);
assert(is(typeof(b) == string[string]));
assert(b == ["foo":"bar", "baz":"quux"]);

auto byPair(Key, Value)(Value[Key] aa);

Строит диапазон, итерируя на ассоциативном массиве по кортежам ключ/значение.

Параметры:

Value[Key] aa

Ассоциативный массив, по которому будет проходить итерация.

Возвращает:

Лидирующий диапазон Кортежей пар ключей и значений из данного ассоциативного массива.

Примеры:

import std.typecons : tuple, Tuple;
import std.algorithm.sorting : sort;

auto aa = ["a": 1, "b": 2, "c": 3];
Tuple!(string, int)[] pairs;

// Итерация над парами ключ/значение.
foreach (pair; aa.byPair)
{
    pairs ~= pair;
}

// Порядок итерации зависит от реализации, так что мы должны отсортировать массив для 
// получения фиксированного порядка.
sort(pairs);
assert(pairs == [
    tuple("a", 1),
    tuple("b", 2),
    tuple("c", 3)
]);

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

nothrow @system auto uninitializedArray(T, I...)(I sizes)
if (isDynamicArray!T && allSatisfy!(isIntegral, I) && hasIndirections!(ElementEncodingType!T));

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

uninitializedArray является nothrow и слабо чистой (weakly pure).

uninitializedArray является @system, если тип неинициализируемых элементов имеет указатели.

nothrow @trusted auto uninitializedArray(T, I...)(I sizes)
if (isDynamicArray!T && allSatisfy!(isIntegral, I) && !hasIndirections!(ElementEncodingType!T));

Примеры:

double[] arr = uninitializedArray!(double[])(100);
assert(arr.length == 100);

double[][] matrix = uninitializedArray!(double[][])(42, 31);
assert(matrix.length == 42);
assert(matrix[0].length == 31);

char*[] ptrs = uninitializedArray!(char*[])(100);
assert(ptrs.length == 100);

nothrow @trusted auto minimallyInitializedArray(T, I...)(I sizes)
if (isDynamicArray!T && allSatisfy!(isIntegral, I));

Возвращает новый массив типа T, распределённый в куче со сборкой мусора.

Частичная инициализация выполняется для типов с косвенной адресацией, для сохранения безопасности памяти. Заметьте, что элементы будут инициализированы только в 0, но не обязательно в .init типа элемента.

minimallyInitializedArray является nothrow и слабо чистой (weakly pure).

void insertInPlace(T, U...)(ref T[] array, size_t pos, U stuff)
if (!isSomeString!(T[]) && allSatisfy!(isInputRangeOrConvertible!T, U) && U.length > 0);

void insertInPlace(T, U...)(ref T[] array, size_t pos, U stuff)
if (isSomeString!(T[]) && allSatisfy!(isCharOrStringOrDcharRange, U));

Вставляет stuff (который должен быть входным диапазоном или любым количеством неявно конвертируемых элементов) в массив array в позицию pos.

Параметры:

T[] array	Массив array, в который нужно вставить stuff.
size_t pos	Позиция в array для вставки stuff.
U stuff	Входной диапазон или любое количество неявно конвертируемых элементов для вставки внутрь array.

Примеры:

int[] a = [ 1, 2, 3, 4 ];
a.insertInPlace(2, [ 1, 2 ]);
assert(a == [ 1, 2, 1, 2, 3, 4 ]);
a.insertInPlace(3, 10u, 11);
assert(a == [ 1, 2, 1, 10, 11, 2, 3, 4]);

pure nothrow @safe bool sameHead(T)(in T[] lhs, in T[] rhs);

Определяет, ссылаются ли массивы lhs и rhs спереди на одно и то же место в памяти, что означает, что один из них создан срезом другого, начиная с индекса 0.

Примеры:

auto a = [1, 2, 3, 4, 5];
auto b = a[0..2];

assert(a.sameHead(b));

pure nothrow @trusted bool sameTail(T)(in T[] lhs, in T[] rhs);

Определяет, ссылаются ли массивы lhs и rhs сзади на одно и то же место в памяти, что означает, что один из них создан срезом другого, заканчивая индексом $.

Примеры:

auto a = [1, 2, 3, 4, 5];
auto b = a[3..$];

assert(a.sameTail(b));

ElementEncodingType!S[] replicate(S)(S s, size_t n)
if (isDynamicArray!S);

ElementType!S[] replicate(S)(S s, size_t n)
if (isInputRange!S && !isDynamicArray!S);

Возвращает массив, который состоит из s (которое должно быть входным диапазоном), повторенного n раз. Эта функция распределяет, заполняет, и возвращает новый массив. Для ленивой версии обратитесь к std.range.repeat.

Примеры:

auto a = "abc";
auto s = replicate(a, 3);

assert(s == "abcabcabc");

auto b = [1, 2, 3];
auto c = replicate(b, 3);

assert(c == [1, 2, 3, 1, 2, 3, 1, 2, 3]);

auto d = replicate(b, 0);

assert(d == []);

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

pure @safe S[] split(S)(S s)
if (isSomeString!S);

Жадно разделяет строку s на массив слов, используя пробелы как разделители. Подряд идущие пробелы объединяются вместе (пустые слова не производятся).

@safe, pure и CTFE-able.

Смотрите также:

std.algorithm.iteration.splitter для версии, разделяющей с использованием любого разделителя.

std.regex.splitter для версии, которая разделяет с использованием разделителя, заданного регулярным выражением.

Examples:

assert(split("hello world") == ["hello","world"]);
assert(split("192.168.0.1", ".") == ["192", "168", "0", "1"]);

auto a = split([1, 2, 3, 4, 5, 1, 2, 3, 4, 5], [2, 3]);
assert(a == [[1], [4, 5, 1], [4, 5]]);

deprecated alias splitter = std.algorithm.iteration.splitter(alias pred = "a == b", Range, Separator)(Range r, Separator s) if (is(typeof(binaryFun!pred(r.front, s)) : bool) && (hasSlicing!Range && hasLength!Range || isNarrowString!Range));

Deprecated. Use std.algorithm.iteration.splitter instead. This will be removed in January 2017.

Alias for std.algorithm.iteration.splitter.

auto split(Range, Separator)(Range range, Separator sep)
if (isForwardRange!Range && is(typeof(ElementType!Range.init == Separator.init)));

auto split(Range, Separator)(Range range, Separator sep)
if (isForwardRange!Range && isForwardRange!Separator && is(typeof(ElementType!Range.init == ElementType!Separator.init)));

auto split(alias isTerminator, Range)(Range range)
if (isForwardRange!Range && is(typeof(unaryFun!isTerminator(range.front))));

Жадно разделяет диапазон range в массив, используя sep в качестве разделителя.

Диапазон должен быть лидирующим диапазоном. Разделитель может быть величиной того же самого типа, что и элементы в range или он может быть другим лидирующим диапазоном.

Замечание: Если range является строкой string, sep может быть char или другой string. Возвращаемый тип будет массивом строк. Если range является массивом int, sep может быть int или другим массивом int. Возвращаемый тип будет массивом массивов int.

Параметры:

Range range	лидирующий диапазон.
Separator sep	величина того же самого типа, что и элементы диапазона range, или другой лидирующий диапазон.

Возвращает:

Массив, содержащий разделённые части диапазона range.

Смотрите также:

std.algorithm.iteration.splitter для ленивой версии этой функции.

ElementEncodingType!(ElementType!RoR)[] join(RoR, R)(RoR ror, R sep)
if (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)) && isInputRange!R && is(Unqual!(ElementType!(ElementType!RoR)) == Unqual!(ElementType!R)));

ElementEncodingType!(ElementType!RoR)[] join(RoR, E)(RoR ror, E sep)
if (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)) && is(E : ElementType!(ElementType!RoR)));

ElementEncodingType!(ElementType!RoR)[] join(RoR)(RoR ror)
if (isInputRange!RoR && isInputRange!(Unqual!(ElementType!RoR)));

Жадно сцепляет все диапазоны в ror вместе (со сборщиком мусора) в один массив, используя sep как разделитель, если присутствует.

Параметры:

RoR ror	Входной диапазон входных диапазонов
R sep	Входной дипазон или единичный элемент, который соединяет диапазоны

Возвращает:

Массив элементов

Смотрите также:

Для ленивой версии, смотрите std.algorithm.iteration.joiner

Примеры:

assert(join(["hello", "silly", "world"], " ") == "hello silly world");
assert(join(["hello", "silly", "world"]) == "hellosillyworld");

assert(join([[1, 2, 3], [4, 5]], [72, 73]) == [1, 2, 3, 72, 73, 4, 5]);
assert(join([[1, 2, 3], [4, 5]]) == [1, 2, 3, 4, 5]);

const string[] arr = ["apple", "banana"];
assert(arr.join(",") == "apple,banana");
assert(arr.join() == "applebanana");

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

E[] replace(E, R1, R2)(E[] subject, R1 from, R2 to)
if (isDynamicArray!(E[]) && isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2));

Заменяет вхождения from на to в subject. Возвращает новый массив без изменения содержания subject, или оригинальный массив, если совпадений не обнаружено.

Примеры:

assert("Hello Wörld".replace("o Wö", "o Wo") == "Hello World");
assert("Hello Wörld".replace("l", "h") == "Hehho Wörhd");

void replaceInto(E, Sink, R1, R2)(Sink sink, E[] subject, R1 from, R2 to)
if (isOutputRange!(Sink, E) && isDynamicArray!(E[]) && isForwardRange!R1 && isForwardRange!R2 && (hasLength!R2 || isSomeString!R2));

Также, как выше, но выводит результат через выходной диапазон sink. Если совпадений не обнаружено, исходный массив передаётся в sink как есть.

Примеры:

auto arr = [1, 2, 3, 4, 5];
auto from = [2, 3];
auto to = [4, 6];
auto sink = appender!(int[])();

replaceInto(sink, arr, from, to);

assert(sink.data == [1, 4, 6, 4, 5]);

T[] replace(T, Range)(T[] subject, size_t from, size_t to, Range stuff)
if (isInputRange!Range && (is(ElementType!Range : T) || isSomeString!(T[]) && is(ElementType!Range : dchar)));

Заменяет элементы из массива subject с индексами от from (включительно) до to (исключительно) содержимым диапазона stuff. Возвращает новый массив, не изменяя содержимое subject.

Примеры:

auto a = [ 1, 2, 3, 4 ];
auto b = a.replace(1, 3, [ 9, 9, 9 ]);
assert(a == [ 1, 2, 3, 4 ]);
assert(b == [ 1, 9, 9, 9, 4 ]);

void replaceInPlace(T, Range)(ref T[] array, size_t from, size_t to, Range stuff)
if (is(typeof(replace(array, from, to, stuff))));

Заменяет элементы из массива array с индексами в пределах от from (включительно) до to (исключительно) содержимым диапазона stuff. Если требуется, расширяет или уменьшает массив array.

Примеры:

int[] a = [1, 4, 5];
replaceInPlace(a, 1u, 2u, [2, 3, 4]);
assert(a == [1, 2, 3, 4, 5]);
replaceInPlace(a, 1u, 2u, cast(int[])[]);
assert(a == [1, 3, 4, 5]);
replaceInPlace(a, 1u, 3u, a[2 .. 4]);
assert(a == [1, 4, 5, 5]);

E[] replaceFirst(E, R1, R2)(E[] subject, R1 from, R2 to)
if (isDynamicArray!(E[]) && isForwardRange!R1 && is(typeof(appender!(E[])().put(from[0..1]))) && isForwardRange!R2 && is(typeof(appender!(E[])().put(to[0..1]))));

Заменяет первое вхождение from на to в массиве subject. Возвращает новый массив без изменения содержимого subject, или оригинальный массив, если не обнаружено совпадений.

Примеры:

auto a = [1, 2, 2, 3, 4, 5];
auto b = a.replaceFirst([2], [1337]);
assert(b == [1, 1337, 2, 3, 4, 5]);

auto s = "This is a foo foo list";
auto r = s.replaceFirst("foo", "silly");
assert(r == "This is a silly foo list");

E[] replaceLast(E, R1, R2)(E[] subject, R1 from, R2 to)
if (isDynamicArray!(E[]) && isForwardRange!R1 && is(typeof(appender!(E[])().put(from[0..1]))) && isForwardRange!R2 && is(typeof(appender!(E[])().put(to[0..1]))));

Заменяет последнее вхождение from на to в массиве subject. Возвращает новый массив без изменения содержимого subject, или оригинальный массив, если не обнаружено совпадений.

Примеры:

auto a = [1, 2, 2, 3, 4, 5];
auto b = a.replaceLast([2], [1337]);
assert(b == [1, 2, 1337, 3, 4, 5]);

auto s = "This is a foo foo list";
auto r = s.replaceLast("foo", "silly");
assert(r == "This is a foo silly list", r);

inout(T)[] replaceSlice(T)(inout(T)[] s, in T[] slice, in T[] replacement);

Возвращает новый массив, построенный из s с заменой среза slice на replacement[].

Примеры:

auto a = [1, 2, 3, 4, 5];
auto b = replaceSlice(a, a[1..4], [0, 0, 0]);

assert(b == [1, 0, 0, 0, 5]);

Переместиться к: capacity · clear · data · opOpAssign · put · reserve · shrinkTo · this

struct Appender(A) if (isDynamicArray!A);

Реализует выходной диапазон, который добавляет данные в массив. Он рекомендуется при использовании a ~= data, когда добавляется множество элементов, поскольку он более эффективен.

Примеры:

auto app = appender!string();
string b = "abcdefg";
foreach (char c; b)
    app.put(c);
assert(app.data == "abcdefg");

int[] a = [ 1, 2 ];
auto app2 = appender(a);
app2.put(3);
app2.put([ 4, 5, 6 ]);
assert(app2.data == [ 1, 2, 3, 4, 5, 6 ]);

pure nothrow @trusted this(T[] arr);

Строит appender с данным массивом. Заметьте, что this не копирует данные. Если массив имеет большую емкость, определенную с помощью arr.capacity, он будет использоваться appender. После инициализации appender на массив, добавление к оригинальному массиву будет перераспределять память.

pure nothrow @safe void reserve(size_t newCapacity);

Резервирует по крайней мере newCapacity элементов для добавления. Заметьте, что может быть зарезервировано больше элементов, чем запрошено. Если newCapacity <= capacity, тогда ничего не происходит.

const pure nothrow @property @safe size_t capacity();

Возвращает capacity массива (возможность, максимальное количество элементов, которое управляемый массив может разместить перед запуском перераспределения памяти). Если любое добавление вызовет перераспределение, capacity возвращает 0.

inout pure nothrow @property @trusted inout(T)[] data();

Возвращает управляемый массив.

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

void put(U)(U item)
if (canPutItem!U);

Добавляет один элемент item в управляемый массив.

void put(Range)(Range items)
if (canPutRange!Range);

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

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

void opOpAssign(string op : "~", U)(U item)
if (canPutItem!U);

Добавляет один элемент item в управляемый массив.

void opOpAssign(string op : "~", Range)(Range items)
if (canPutRange!Range);

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

pure nothrow @trusted void clear();

Очищает управляемый массив. Это предоставляет элементы массива, которые будут повторно использоваться для добавления.

Заметьте, что clear отключена для типов элементов immutable или const, из-за возможности для Appender перезаписать неизменные данные.

pure @trusted void shrinkTo(size_t newlength);

Сокращает управляемый массив до данной длины.

Throws:

Исключение, если newlength больше, чем текущая длина массива.

Переместиться к: capacity · data · opOpAssign · this

struct RefAppender(A) if (isDynamicArray!A);

Appender, который может обновлять массив на-месте. Он перенаправляет все вызовы лежащему в основе его реализации appender. Любые вызовы к appender также корректируют указатель на исходный массив, переданный в него.

this(T[]* arr);

Строит ref appender с данной ссылкой на массив. This не копирует данные. Если массив имеет большую емкость, определенную с помощью arr.capacity, он будет использоваться appender. RefAppender предполагает, что значение arr — не null.

Заметьте, не используйте встроенное добавление (то есть ~=) на оригинальном массиве, переданном в appender, пока вы с ним не закончите, поскольку вызовы на appender переопределяют эти добавления.

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

void opOpAssign(string op : "~", U)(U item)
if (AppenderType.canPutItem!U);

Добавляет один элемент item в управляемый массив.

void opOpAssign(string op : "~", Range)(Range items)
if (AppenderType.canPutRange!Range);

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

const @property size_t capacity();

Возвращает capacity массива (возможность, максимальное количество элементов, которое управляемый массив может разместить перед запуском перераспределения памяти). Если любое добавление вызовет перераспределение, capacity возвращает 0.

inout @property inout(T)[] data();

Возвращает управляемый массив.

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

Appender!A appender(A)()
if (isDynamicArray!A);

Appender!(E[]) appender(A : E[], E)(auto ref A array);

Удобная функция, которая возвращает объект Appender!A, инициализированный массивом array.

RefAppender!(E[]) appender(A : E[]*, E)(A array);

Удобная функция, которая возвращает объект RefAppender!A, инициализированный массивом array. Не используйте null для указателя на массив, вместо этого используйте другую версию appender.