title: 数组

数组

数组方法库允许您通过简单的方式访问和操作数组。

Merge

将多个数组合并成一个数组。

Arr.Merge(new []{"1","2"} , new []{"3"}); // ["1" , "2" , "3"]

函数原型

T[] Merge<T>(params T[][] sources);

Rand

从规定数组中获取一个或者指定数量的随机值。

var result = Arr.Rand(new []{"1", "2", "3"});

如果获取的元素数量大于1，那么在随机过程中不会重复获得已经随机到的值 如果传入的数量大于提供的元素数量，将会返回default(T)空值

函数原型

T[] Rand<T>(T[] source, int number = 1)

Shuffle

将规定数组中的元素打乱(洗牌算法)。

var result = Arr.Shuffle(new []{"1", "2", "3"});

给定随机种子：

var result1 = Arr.Shuffle(new []{"1", "2", "3"}, 100); // ["2", "1", "3"]
var result2 = Arr.Shuffle(new []{"1", "2", "3"}, 100); // ["2", "1", "3"]

随机种子一致，则同元素顺序多次随机也将会一致。

函数原型

T[] Shuffle<T>(T[] source, int? seed = null)

Splice

从数组中移除指定长度的元素，如果给定了替换数组参数，那么替换数组中的元素将会从起始位置开始插入。

var data = new []{"1", "2", "3"};
var count = Arr.Splice(ref data , 1 , 1, new []{"4", "5"});
// data : ["1", "4", "5", "3"]
// count : 4

函数原型

T[] Splice<T>(ref T[] source, int start, int? length = null, T[] replSource = null);

Chunk

将数组分为新的数组块,其中每个数组的单元数目由大小参数决定。最后一个数组的单元数目可能会少几个。

var result = Arr.Chunk(new []{"1", "2", "3"}, 2);
// result : [["1", "2"], ["3"]]

函数原型

T[][] Chunk<T>(T[] source, int size);

Fill

对数组进行填充，如果传入了规定数组，那么会在规定数组的基础上进行填充

var result = Arr.Fill(2, 3, "100", new []{"1", "2", "3"});
// result : ["1","2","100","100","100","3"]

函数原型

T[] Fill<T>(int start, int length, T value, T[] source = null);

Remove

将数组每个值传给回调函数，如果回调函数返回 true，则移除数组中对应的元素，并返回被移除的元素

var data = new string[]{"1", "2", "3"};
var result = Arr.Remove(ref data,(v) => v == "2");
// result : ["2"]
// data: ["1", "3"]

函数原型

T[] Remove<T>(ref T[] source, Predicate<T> predicate);

Filter

输入数组中的每个值传给回调函数,如果回调函数和期望值相同，则把输入数组中的当前值加入结果数组中。

var result = Arr.Filter(new[]{"1", "2", "3", "4", "5"},(v) => (v % 2) == 0);
// result : ["2", "4"]

函数原型

T[] Filter<T>(T[] source, Predicate<T> predicate, bool expected = true);

Map

将数组值传入用户自定义函数，自定义函数返回的值作为新的数组值加入到结果集，该操作不会导致原始数组的值发生修改。

var result = Arr.Map(new[]{1, 2, 3} , (v) => v * 2);
// result : [2, 4, 6]

函数原型

TReturn[] Map<T, TReturn>(T[] source, Func<T, TReturn> callback);

函数原型

TReturn[] Map<T, TReturn>(IEnumerable<T> source, Func<T, TReturn> callback);

Pop

删除数组中的最后一个元素，并将删除的元素作为返回值返回

var data = new []{"1", "2", "3"};
var result = Arr.Pop(ref data);
// result : "3"
// data.Length : 2

函数原型

T Pop<T>(ref T[] source);

Push

将一个或多个元素加入数组尾端。

var data = new []{"1","2"};
var count = Arr.Push(ref data, "3","4","5");
// data : ["1","2","3","4" ,"5"]
// count : 5

函数原型

int Push<T>(ref T[] source, params T[] elements);

Reduce

向用户自定义函数发送数组中的值，并返回一个字符串。 如果数组是空的且未传递初始化参数，该函数返回 null。 如果指定了初始化参数，则该参数将被当成是数组中的第一个值来处理，如果数组为空的话就作为最终返回值(string)。

var result = Arr.Reduce(new []{"1", "2", "3"},(v1, v2)=> v1 + "-" + v2, "0");
// result : 0-1-2-3

函数原型

Reduce<T>(T[] source, Func<object, T, string> callback, object initial = null);

Slice

在数组中根据条件取出一段值，并返回。

var result = Arr.Slice(new []{"1", "2", "3", "4", "5"},1,3);
// result : ["2", "3", "4"]

函数原型

T[] Slice<T>(T[] source, int start, int? length = null);

Shift

删除数组中第一个元素，并返回被删除元素的值

var data = new []{"1", "2", "3"};
var result = Arr.Shift(ref data);
// result : "1"
// data.Length : 2

函数原型

T Shift<T>(ref T[] source);

Unshift

向数组插入新元素。新数组的值将被插入到数组的开头。

var data = new []{"2","3"};
var count = Arr.Unshift(ref data, "0", "1");
// count : 4
// data ["0", "1", "2", "3"]

函数原型

int Unshift<T>(ref T[] source, params T[] elements);

Reverse

以相反的顺序返回数组。

var result = Arr.Reverse(new []{"1", "2","3"});
// result : ["3", "2", "1"]

函数原型

T[] Reverse<T>(T[] source, int start = 0, int? length = null);

IndexOf

从数组中检索指定的值并返回所在的下标，如果返回-1则代表没有出现

var result = Arr.IndexOf(new []{"1", "2", "3", "4", "5"} , new []{ "2", "3" });
// result : 1

函数原型

int IndexOf<T>(T[] source, params T[] match);

IndexOfAny

从数组中检索指定的值并返回所在的下标，如果返回-1则代表没有出现，与IndexOf相比，只要有一个元素匹配则认为匹配成功。

var result = Arr.IndexOfAny(new []{"1", "2", "3", "4", "5"} , new []{ "5", "2" });
// result : 1

函数原型

int IndexOfAny<T>(T[] source, params T[] match);

Difference

从数组中排除指定的值

var result = Arr.Difference(new []{"1", "2", "3", "4", "5"} , new []{ "2", "3" });
// result : ["1", "4", "5"]

函数原型

T[] Difference<T>(T[] source, params T[] match);

RemoveAt

从数组中移除并返回指定下标的元素。

var src = new object[]{ "1", "2", "3" };
var result = Arr.RemoveAt(ref src, 1); // 2
// src : object[] { "1", "3" }

函数原型

T RemoveAt<T>(ref T[] source, int index);

Cut

裁剪指定的数组，正数为从前向后裁剪，负数为从尾部裁剪

var data = new char[] { '1', '2', '3', '4', '5' };
Arr.Cut(ref data, 1);
// data[0] == '2'

尾部裁剪

var data = new char[] { '1', '2', '3', '4', '5' };
Arr.Cut(ref data, -2);
// data[0] == '1'
// data[1] == '2'
// data[2] == '3'
// data.length = 3

函数原型

void Cut<T>(ref T[] source, int count);

Test

将规定数组传递给检查器进行检查。

只有当所有元素通过检查器均为false，那么函数返回false。

var src = new string[]{ "1", "2", "3" };
var result = Arr.Test(src, (item)=> item == "2"); // true

函数原型

bool Test<T>(T[] source, Predicate<T> predicate);

Set

查找规定数组中的指定元素，如果找到了则使用替代值替换，否则在规定数组尾部增加替换值。

var set = new[] { "a", "ab", "abc", "abcd", "abcdef" };
Arr.Set(ref set, (element) => element == "none", "hello");
// { "a", "ab", "abc", "abcd", "abcdef", "hello" }

函数原型

void Set<T>(ref T[] source, Predicate<T> predicate, T value);