数组

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

Merge

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

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

函数原型
T[] Merge<T>(params T[][] sources);
参数 描述
sources 规定数组

Rand

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

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

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


函数原型
T[] Rand<T>(T[] source, int number = 1)
参数 描述
sources 规定数组
number 需要获取的元素数量

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)
参数 描述
sources 规定数组
seed 给定的随机种子

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);
参数 描述
sources 规定数组
start 删除元素的开始位置。如果为负数则从后向前计算。
length 删除元素的个数,也是被返回数组的长度。如果为负数则保留到结尾指定元素数量,如:-1则意味着删除到数组的倒数第一个元素前。
replSource 在删除起始位置插入的元素。

Chunk

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

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

函数原型
T[][] Chunk<T>(T[] source, int size);
参数 描述
source 规定数组
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);
参数 描述
start 起始下标
length 填充长度
value 填充的值
source 规定数组

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);
参数 描述
source 规定数组
predicate 判断函数,如果返回值为true则被删除

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);
参数 描述
source 规定数组
predicate 判断函数,如果返回值和期望值相同则将结果加入数组
expected 期望值

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);
参数 描述
source 规定数组
callback 处理函数,返回值会被认为是新值

函数原型
TReturn[] Map<T, TReturn>(IEnumerable<T> source, Func<T, TReturn> callback);
参数 描述
source 规定迭代器
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);
参数 描述
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);
参数 描述
source 规定数组
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);
参数 描述
source 规定数组
callback 自定义处理函数,第一个参数为前序处理的结果值,第二个参数为规定数组元素,返回值为字符串
initial 第一次触发自定义处理函数时,提供的前序处理的初始值

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);
参数 描述
source 规定数组
start 起始位置,如果为负数则从后向前获取起始位置
length 截取的长度,如果为负数则从后向前计算终止的位置。

Shift

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

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

函数原型
T Shift<T>(ref T[] source);
参数 描述
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);
参数 描述
source 规定数组
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);
参数 描述
source 规定数组
start 起始位置,如果为负数则从后向前获取起始位置
length 处理的长度(终止位置),如果为负数则从后向前计算终止的位置。

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);
参数 描述
source 规定数组
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);
参数 描述
source 规定数组
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);
参数 描述
source 规定数组
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);
参数 描述
source 规定数组
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);
参数 描述
source 规定数组
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);
参数 描述
source 规定数组
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);
参数 描述
source 规定数组
predicate 返回true则覆盖当前元素内容
value 替换(设定)值
© 2017~ 随风逐叶 all right reserved,powered by Gitbook文章修订时间: 2021-07-15 09:41:42

results matching ""

    No results matching ""