Переместиться к: Appender · appender · array · assocArray · byPair · insertInPlace · join · minimallyInitializedArray · RefAppender · replace · replaceFirst · replaceInPlace · replaceInto · replaceLast · replaceSlice · replicate · sameHead · sameTail · split · splitter · uninitializedArray
Function Name | Description |
---|---|
array | Возвращает копию входа во вновь размещённый динамический массив. |
appender | Возвращает новую структуру Appender, инициализированную данным массивом. |
assocArray | Возвращает вновь размещённый ассоциативный массив из диапазона кортежей ключ/значение. |
byPair | Строит диапазон, итерируя на ассоциативном массиве по кортежам ключ/значение. |
insertInPlace | Вставляет в существующий массив в данной позиции. |
join | Сцепляет диапазон диапазонов в один массив |
minimallyInitializedArray | Возвращает новый массив типа T. |
replace | Возвращает новый массив с заменой всех вхождений некоторого поддиапазона. |
replaceFirst | Возвращает новый массив с заменой первого вхождения определенного поддиапазона. |
replaceInPlace | Заменяет определённый поддиапазон и помещает результат в данный массив. |
replaceInto | Заменяет все вхождения определенного поддиапазона и помещает результат в выходной диапазон. |
replaceLast | Возвращает новый массив с заменой последнего вхождения определенного поддиапазона. |
replaceSlice | Возвращает новый массив с заменой данного среза. |
replicate | Создает новый массив из нескольких копий входного массива или диапазона. |
sameHead | Проверяет, ссылаются ли начальные сегменты двух массивов на одно и то же место в памяти. |
sameTail | Проверяет, ссылаются ли конечные сегменты двух массивов на одно и то же место в памяти. |
split | Жадно разделить диапазон или строку на массив. |
uninitializedArray | Возвращает новый массив типа T без инициализации элементов. |
Исходный код: std/array.d
Переместиться к: 2
array
(Range)(Range r
)array
и инициализирует его с копиями элементов диапазона r
.
Range r |
диапазон (или агрегат с функцией opApply), чьи элементы копируются в размещённый массив array |
array
auto a = array([1, 2, 3, 4, 5][]); assert(a == [ 1, 2, 3, 4, 5 ]);
array
(String)(String str
)assocArray
(Range)(Range r
)Range r |
Входной диапазон кортежей из ключей и значений. |
null
, если дан пустой диапазон.
Дубликаты:
Ассоциативный массив имеет уникальные ключи. Если r
содержит дубликаты ключей, тогда результат будет содержать значение последней пары для этого ключа в r
.
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"]);
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
uninitializedArray
(T, I...)(I sizes
)sizes
могут быть определены для любого количества измерений в T.
uninitializedArray
является nothrow и слабо чистой (weakly pure).
uninitializedArray
является @system, если тип неинициализируемых элементов имеет указатели.uninitializedArray
(T, I...)(I sizes
)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);
minimallyInitializedArray
(T, I...)(I sizes
)minimallyInitializedArray
является nothrow и слабо чистой (weakly pure).insertInPlace
(T, U...)(ref T[] array
, size_t pos
, U stuff
)insertInPlace
(T, U...)(ref T[] array
, size_t pos
, U stuff
)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]);
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));
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));
replicate
(S)(S s
, size_t n
)replicate
(S)(S s
, size_t n
)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 == []);
s
на массив слов, используя пробелы как разделители. Подряд идущие пробелы объединяются вместе (пустые слова не производятся).
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]]);
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));
split
(Range, Separator)(Range range
, Separator sep
)split
(Range, Separator)(Range range
, Separator sep
)split
(alias isTerminator, Range)(Range range
)range
.front))));
range
в массив, используя sep
в качестве разделителя.
range
или он может быть другим лидирующим диапазоном.
Замечание:
Если range
является строкой string, sep
может быть char или другой
string. Возвращаемый тип будет массивом строк. Если range
является
массивом int, sep
может быть int или другим массивом int.
Возвращаемый тип будет массивом массивов int.
Range range |
лидирующий диапазон. |
Separator sep |
величина того же самого типа, что и элементы диапазона range , или другой лидирующий диапазон. |
range
.
join
(RoR, R)(RoR ror
, R sep
)join
(RoR, E)(RoR ror
, E sep
)join
(RoR)(RoR ror
)ror
вместе (со сборщиком мусора) в один массив, используя sep
как разделитель, если присутствует.
RoR ror |
Входной диапазон входных диапазонов |
R sep |
Входной дипазон или единичный элемент, который соединяет диапазоны |
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
replace
(E, R1, R2)(E[] subject
, R1 from
, R2 to
)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");
replaceInto
(E, Sink, R1, R2)(Sink sink
, E[] subject
, R1 from
, R2 to
)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]);
replace
(T, Range)(T[] subject
, size_t from
, size_t to
, Range stuff
)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 ]);
replaceInPlace
(T, Range)(ref T[] array
, size_t from
, size_t to
, Range stuff
)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]);
replaceFirst
(E, R1, R2)(E[] subject
, R1 from
, R2 to
)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");
replaceLast
(E, R1, R2)(E[] subject
, R1 from
, R2 to
)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);
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]);
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 ]);
arr
);
arr.capacity
, он будет использоваться appender. После инициализации appender на массив, добавление к оригинальному массиву будет перераспределять память.reserve
(size_t newCapacity
);
newCapacity
элементов для добавления. Заметьте, что может быть зарезервировано больше элементов, чем запрошено. Если newCapacity
<= capacity, тогда ничего не происходит.capacity
();
capacity
массива (возможность, максимальное количество элементов, которое управляемый массив может разместить перед запуском перераспределения памяти). Если любое добавление вызовет перераспределение, capacity
возвращает 0.data
();
item
в управляемый массив.put
(Range)(Range items
)item
в управляемый массив.opOpAssign
(string op : "~", Range)(Range items
)clear
();
clear
отключена для типов элементов immutable или const, из-за возможности для Appender перезаписать неизменные данные.shrinkTo
(size_t newlength
);
newlength
больше, чем текущая длина массива.arr
);
arr.capacity
, он будет использоваться appender.
RefAppender предполагает, что значение arr
— не null
.
item
в управляемый массив.opOpAssign
(string op : "~", Range)(Range items
)capacity
();
capacity
массива (возможность, максимальное количество элементов, которое управляемый массив может разместить перед запуском перераспределения памяти). Если любое добавление вызовет перераспределение, capacity
возвращает 0.data
();
Переместиться к: 2
appender
(A)()appender
(A : E[], E)(auto ref A array
);
array
.appender
(A : E[]*, E)(A array
);
array
. Не используйте null
для указателя на массив, вместо этого используйте другую версию appender
.