数组

# 数组

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

# 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"]

1
2

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

# 函数原型

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

1
2
3
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"]]

1
2

# 函数原型

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"]

1
2

# 函数原型

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"]

1
2
3
4

# 函数原型

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"]

1
2

# 函数原型

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]

1
2

# 函数原型

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

1
2
3
4

# 函数原型

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

1
2
3
4

# 函数原型

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

1
2

# 函数原型

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"]

1
2

# 函数原型

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

1
2
3
4

# 函数原型

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"]

1
2
3
4

# 函数原型

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

参数	描述
`source`	规定数组
`elements`	需要被插入到数组开头的元素

# Reverse

以相反的顺序返回数组。

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

1
2

# 函数原型

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

1
2

# 函数原型

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

1
2

# 函数原型

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"]

1
2

# 函数原型

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" }

1
2
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'

1
2
3

尾部裁剪

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

1
2
3
4
5
6

# 函数原型

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

1
2

# 函数原型

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" }

1
2
3

# 函数原型

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

参数	描述
`source`	规定数组
`predicate`	返回true则覆盖当前元素内容
`value`	替换(设定)值

上次更新: 2023/10/17, 17:20:06 访问次数: 0

← 事件系统字符串→