Array2D

函数:

version() → {String}

说明:

• Array2D函数库版本号

返回值:

Type

String

例子

console.log(ok2D.version()) //输出 1.0.0 版本升级版本号会增加 最新版可到教学群回复 案例文件
当前版本 v1.0.0

z平均值(arr, 列选择函数) → {Number}

说明:

• 这个函数用于计算指定列的平均值

别名:

• average
• average

参数列表:

返回值:

Type

Number

例子

var arr = [[1, 2, 3],[4,5,6],[7,8,9]];
var average =Array2D.z平均值(arr, 'f1');//选择第一列 字符串简写模式
var average =Array2D.average(arr, r=>r[0]);//完整回调函数形式
console.log(average); // 输出平均值
//输出结果
4

average(arr, 列选择函数) → {Number}

说明:

• 这个函数用于计算指定列的平均值

别名:

• z平均值
• z平均值

参数列表:

返回值:

Type

Number

例子

var arr = [[1, 2, 3],[4,5,6],[7,8,9]];
var average =Array2D.z平均值(arr, 'f1');//选择第一列 字符串简写模式
var average =Array2D.average(arr, r=>r[0]);//完整回调函数形式
console.log(average); // 输出平均值
//输出结果
4

z上下连接(arr, brr) → {Array}

说明:

• 这个函数用于将两个数组按行连接

别名:

• concat

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3],[4, 5, 6],[7 ,8 , 9]];
var brr = [[11, 22, 33],[44,55,66],[7,8,9]];
var result = Array2D.z上下连接(arr, brr);
logjson(result);
//输出结果
[[1,2,3],
[4,5,6],
[7,8,9],
[11,22,33],
[44,55,66],
[7,8,9]]

concat(arr, brr) → {Array}

说明:

• 这个函数用于将两个或者多个数组按行连接

别名:

• z上下连接

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3];
var brr = [4, 5, 6];
var result = Array2D.concat(arr, brr);
logjson(result);
//输出结果
[[1],
[2],
[3],4,5,6]

z复制到指定位置(arr) → {Array}

说明:

• 这个函数用于将数组复制到指定位置

别名:

• copyWithin
• copyWithin

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3, 4, 5];
var result = Array2D.z复制到指定位置(arr);
logjson(result); // 输出复制后的数组
//输出结果
[[1],
[2],
[3],
[4],
[5]]

copyWithin(arr) → {Array}

说明:

• 这个函数用于将数组复制到指定位置

别名:

• z复制到指定位置
• z复制到指定位置

参数列表:

返回值:

Type

Array

例子

var arr =  [[1, 2, 3],[4, 5, 6],[7 ,8 , 9]];
var result = Array2D.copyWithin(arr,2,1);
logjson(result);// 输出复制后的数组
//输出结果
[[1,2,3],
[4,5,6],
[4,5,6]]

z数量(arr) → {Number}

说明:

• 这个函数用于计算数组元素的数量

别名:

• count
• count

参数列表:

返回值:

Type

Number

例子

var arr = [1, 2, 3, 4, 5];
var result = Array2D.z数量(arr);
console.log(result); // 输出数组元素的数量
//输出结果
5

count(arr) → {Number}

说明:

• 这个函数用于计算数组元素的数量

别名:

• z数量
• z数量

参数列表:

返回值:

Type

Number

例子

var arr = [[1,2],[3,4]];
var result = Array2D.count(arr);
console.log(result); // 输出数组行数 2
//输出结果
2

z笛卡尔积(arr, brr) → {Array}

说明:

• 这个函数用于计算两个数组的笛卡尔积

别名:

• crossjoin
• crossjoin

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3];
var brr = [4, 5, 6];
var result = Array2D.z笛卡尔积(arr, brr);
logjson(result); // 输出笛卡尔积数组
//输出结果
[[1,4],
[1,5],
[1,6],
[2,4],
[2,5],
[2,6],
[3,4],
[3,5],
[3,6]]

crossjoin(arr, brr) → {Array}

说明:

• 这个函数用于计算两个数组的笛卡尔积

别名:

• z笛卡尔积
• z笛卡尔积

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3];
var brr = [4, 5, 6];
var result = Array2D.crossjoin(arr, brr);
logjson(result);// 输出笛卡尔积数组
//输出结果
[[1,4],
[1,5],
[1,6],
[2,4],
[2,5],
[2,6],
[3,4],
[3,5],
[3,6]]

z批量删除列(arr, 列号数组) → {Array}

说明:

• 这个函数用于批量删除指定列

别名:

• deleteCols
• deleteCols

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var 列号数组 = [1, 2];
var result = Array2D.z批量删除列(arr, 列号数组);
logjson(result); // 输出删除指定列后的数组
//输出结果
[[1],
[4],
[7]]

deleteCols(arr, 列号数组) → {Array}

说明:

• 这个函数用于批量删除指定列

别名:

• z批量删除列
• z批量删除列

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
['a','b','c']];
var result = Array2D.deleteCols(arr,  [0, 2]);//删除第1列和第3列
logjson(result);
//输出结果
[[2],
[5],
[8],
["b"]]
var result = Array2D.deleteCols(arr, 'f3');//删除第3列 以f数字形式按1数列
logjson(result);
//输出结果
[[1,2],
[4,5],
[7,8],
["a","b"]]

z批量删除行(arr, 行号数组) → {Array}

说明:

• 这个函数用于批量删除指定行

别名:

• deleteRows
• deleteRows

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var 行号数组 = [1, 2];
var result = Array2D.z批量删除行(arr, 行号数组);
logjson(result); // 输出删除指定行后的数组
//输出结果
[[1,2,3]]

deleteRows(arr, 行号数组) → {Array}

说明:

• 这个函数用于批量删除指定行

别名:

• z批量删除行
• z批量删除行

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
['a','b','c']];
var 行号数组 = [1, 2];
var result = Array2D.deleteRows(arr, 行号数组);
logjson(result); // 输出删除指定行后的数组
//输出结果
[[1,2,3],
["a","b","c"]]
var result = Array2D.deleteRows(arr, 'f2-f4');//也可以写删除2到4行 只留下第一行
logjson(result); // 输出两次删除后的数组
//输出结果
[[1,2,3]]

z去重(arr, col, 结果列选择器) → {Array}

说明:

• 这个函数用于去除数组中的重复元素

别名:

• distinct

参数列表:

返回值:

Type

Array

例子

var arr =[[1, 2, 3],
[1, 2, 6],
[1, 2, 3],
['a','b','c']];;
log("按整行去重")
var result = Array2D.z去重(arr);//整行去重
logjson(result);
//输出结果
按整行去重
[[1,2,3],
[1,5,6],
["a","b","c"]]
var result = Array2D.z去重(arr,row=>row[0],'');//按指定规则 这里按第一列去重
var result = Array2D.z去重(arr,'f1,f2','');//按列号去重
log("按第一列去重")
logjson(result); // 输出去重后的数组
//输出结果
按第1 2列去重
[[1,2,3],
["a","b","c"]]

distinct(arr, col, resultSelector) → {Array}

说明:

• 这个函数用于去除数组中的重复元素

别名:

• z去重

参数列表:

返回值:

Type

Array

例子

var arr =[[1, 2, 3],
[1, 2, 6],
[1, 2, 3],
['a','b','c']];;
log("按整行去重")
var result = Array2D.z去重(arr);//整行去重
logjson(result);
//输出结果
按整行去重
[[1,2,3],
[1,5,6],
["a","b","c"]]
var result = Array2D.z去重(arr,row=>row[0],'');//按指定规则 这里按第一列去重
var result = Array2D.z去重(arr,'f1,f2','');//按列号去重
log("按第一列去重")
logjson(result); // 输出去重后的数组
//输出结果
按第1 2列去重
[[1,2,3],
["a","b","c"]]

z全部满足(arr, 关键字选择器) → {Boolean}

说明:

• 这个函数用于判断数组中的所有元素是否都满足给定的条件

别名:

• every

参数列表:

返回值:

Type

Boolean

例子

var arr = [1, 2, 3, 4, 5];
var conditionCallback = (element) => element > 0; // 判断元素是否大于0
var result = Array2D.z全部满足(arr, conditionCallback);
console.log(result); // 输出是否所有元素都满足条件
//输出结果
true

every(arr, 条件回调函数) → {Boolean}

说明:

• 这个函数用于判断数组中的所有元素是否都满足给定的条件

别名:

• z全部满足

参数列表:

返回值:

Type

Boolean

例子

var arr = [1, 2, 3, 4, 5];
var result = Array2D.every(arr, element => element > 0); // 判断元素是否大于0
console.log(result); // 输出是否所有元素都满足条件
//输出结果
true

z排除(arr, brr, 左表列选择器, 右表列选择器) → {Array}

说明:

• 这个函数用于从左表中排除右表中的元素

别名:

• except

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3, 4, 5];
var brr = [3, 4, 5, 6, 7];
var leftColumnSelector = (element) => element; // 选择元素本身进行比较
var rightColumnSelector = (element) => element; // 选择元素本身进行比较
var result = Array2D.z排除(arr, brr, leftColumnSelector, rightColumnSelector);
logjson(result); // 输出排除后的数组
//输出结果
[[1],
[2],
[3],
[4],
[5]]

except(arr, brr, 左表列选择器, 右表列选择器) → {Array}

说明:

• 这个函数用于从左表中排除右表中的元素

别名:

• z排除

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
['a','b','c']];
var brr = [
[1, 2, 3],
[7, 5, 9]]
log('按整行比较')
var result = Array2D.except(arr,brr);//按整行比较 只有1,2,3这行排除
logjson(result);
//输出结果
按整行比较
[[4,5,6],
[7,8,9],
["a","b","c"]]
log('按指定列比较');
var result = Array2D.except(arr,brr,a=>a[2],b=>b[2]);//按第3列比较
logjson(result); // 输出排除后的数组
//输出结果
按指定列比较
[[4,5,6],
["a","b","c"]]

z批量填充(arr, 值) → {Array}

说明:

• 这个函数用于批量填充数组的所有元素为指定值

别名:

• fill

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3, 4, 5];
var value = 0;
var result = Array2D.z批量填充(arr, value);
logjson(result);  // 输出填充后的数组
//输出结果
[[0],
[0],
[0],
[0],
[0]]

fill(arr, 值) → {Array}

说明:

• 这个函数用于批量填充数组的所有元素为指定值

别名:

• z批量填充

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3, 4, 5];
var value = 0;
var result = Array2D.fill(arr, value);
logjson(result); // 输出填充后的数组
//输出结果
[[0],
[0],
[0],
[0],
[0]]

z筛选(arr, 条件回调) → {Array}

说明:

• 这个函数用于根据指定的条件筛选数组的元素

别名:

• filter

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3, 4, 5];
var conditionCallback = (element) => element > 2; // 判断元素是否大于2
var result = Array2D.z筛选(arr, conditionCallback);
logjson(result); // 输出筛选后的数组
//输出结果
[[3],
[4],
[5]]

filter(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于根据指定的条件筛选数组的元素

别名:

• z筛选

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3, 4, 5];
var conditionCallback = (element) => element > 2; // 判断元素是否大于2
var result = Array2D.filter(arr, conditionCallback);
logjson(result); // 输出筛选后的数组
//输出结果
[[3],
[4],
[5]]

z查找单个(arr, 条件回调) → {Object}

说明:

• 这个函数用于在数组中查找满足条件的单个元素

别名:

• find

参数列表:

返回值:

Type

Object

例子

var arr = [1, 2, 3, 4, 5];
var conditionCallback = (element) => element > 2; // 判断元素是否大于2
var result = Array2D.z查找单个(arr, conditionCallback);
logjson(result); // 输出查找到的单个元素
//输出结果
[3]

find(arr, 条件回调) → {Object}

说明:

• 这个函数用于在数组中查找满足条件的单个元素

别名:

• z查找单个

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
['a','b','c']];  
var result = Array2D.find(arr, row=>row[0]>2);
logjson(result);// 输出查找到的单个元素
//输出结果
[4,5,6]

z查找所有下标(arr, 条件回调) → {Array}

说明:

• 这个函数用于在数组中查找满足条件的所有元素的下标

别名:

• findAllIndex

参数列表:

返回值:

Type

Array

例子

var arr = [1, 2, 3, 4, 5];
var conditionCallback = (element) => element > 2; // 判断元素是否大于2
var result = Array2D.z查找所有下标(arr, conditionCallback);
logjson(result); // 输出查找到的所有元素的下标
//输出结果
[2,3,4]

findAllIndex(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于在数组中查找满足条件的所有元素的下标

别名:

• z查找所有下标

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
['a','b','c']];
var result = Array2D.findAllIndex(arr, row=>row[0]>2);
logjson(result);  // 输出查找到的所有元素的下标
//输出结果
[1,2]

z查找元素下标(arr) → {Number}

说明:

• 这个函数用于在数组中查找指定元素的下标

别名:

• findIndex

参数列表:

返回值:

Type

Number

例子

var arr = [1, 2, 3, 4, 5];
var result = Array2D.z查找元素下标(arr);
logjson(result); // 输出指定元素的下标
//输出结果
0

findIndex(arr) → {Number}

说明:

• 这个函数用于在数组中查找指定元素的下标

别名:

• z查找元素下标

参数列表:

返回值:

Type

Number

z第一个(arr) → {Array}

说明:

• 这个函数用于获取二维数组的第一个子数组

别名:

• first

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z第一个(arr);
logjson(result); // 输出第一个子数组
//输出结果
[[1,2]]

first(arr, 条件回调函数, 默认值) → {Array}

说明:

• 这个函数用于获取二维数组中满足条件的第一个子数组，如果没有满足条件的子数组，则返回默认值

别名:

• z第一个

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var defaultValue = [];
var result = Array2D.first(arr, conditionCallback, defaultValue);
logjson(result);  // 输出满足条件的第一个子数组或默认值
//输出结果
[[3,4]]

z降维(arr, 深度) → {Array}

说明:

• 这个函数用于将二维数组降维为一维数组

别名:

• flat

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var depth = 2;
var result = Array2D.z降维(arr, depth);
logjson(result); // 输出降维后的一维数组
//输出结果
[[1],
[2],
[3],
[4],
[5],
[6]]

flat(arr, 深度) → {Array}

说明:

• 这个函数用于将二维数组降维为一维数组

别名:

• z降维

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var depth = 2;
var result = Array2D.flat(arr, depth);
logjson(result); // 输出降维后的一维数组
//输出结果
[[1],
[2],
[3],
[4],
[5],
[6]]

z遍历执行(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于遍历执行二维数组的每个子数组，并返回执行结果组成的数组

别名:

• forEach

参数列表:

返回值:

Type

Array

例子

var brr = [[1, 2], [3, 4], [5, 6]];    
Array2D.z遍历执行(brr, row=>{
console.log(row[0]*2);//对每行的第1列*2输出
});
//输出结果
2
6
10
//for each回调完整形态也可以写回数据
var result = Array2D.z遍历执行(brr,
(row,index,arr)=>{//注意这里的arr相当于指向操作目标arr
arr[index][0]=arr[index][0]*2; //对数组操作后写入原数组
});
log("改变原数组")
logjson(brr); //输出数组
//输出结果
改变原数组
[[2,2],
[6,4],
[10,6]]

forEach(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于遍历执行二维数组的每个子数组，并返回执行结果组成的数组

别名:

• z遍历执行

参数列表:

返回值:

Type

Array

例子

var brr = [[1, 2], [3, 4], [5, 6]];    
Array2D.forEach(brr, row=>{
console.log(row[0]*2);//对每行的第1列*2输出
});
//输出结果
2
6
10
//for each回调完整形态也可以写回数据
var result = Array2D.forEach(brr,
(row,index,arr)=>{//注意这里的arr相当于指向操作目标arr
arr[index][0]=arr[index][0]*2; //对数组操作后写入原数组
});
log("改变原数组")
logjson(brr); //输出数组
//输出结果
改变原数组
[[2,2],
[6,4],
[10,6]]

z倒序遍历执行(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于倒序遍历执行二维数组的每个子数组，并返回执行结果组成的数组

别名:

• forEachRev

参数列表:

返回值:

Type

Array

例子

var brr = [[1, 2], [3, 4], [5, 6]];   
Array2D.z倒序遍历执行(brr, row=>{
console.log(row[0]*2);//对每行的第1列*2输出 注意输出的顺序
});
//输出结果
10
6
2
logjson(brr); //输出数组	
//输出结果
[[1,2],
[3,4],
[5,6]]

forEachRev(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于倒序遍历执行二维数组的每个子数组，并返回执行结果组成的数组

别名:

• z倒序遍历执行

参数列表:

返回值:

Type

Array

例子

var brr = [[1, 2], [3, 4], [5, 6]];   
Array2D.forEachRev(brr, row=>{
console.log(row[0]*2);//对每行的第1列*2输出 注意输出的顺序
});
//输出结果
10
6
2
logjson(brr); //输出数组
//输出结果
[[1,2],
[3,4],
[5,6]]

z分页取数(arr, 第几页, 每页数量) → {Array}

说明:

• 这个函数用于分页取二维数组的数据

别名:

• forPage

参数列表:

返回值:

Type

Array

forPage(arr, 第几页, 每页数量) → {Array}

说明:

• 这个函数用于分页取二维数组的数据

别名:

• z分页取数

参数列表:

返回值:

Type

Array

z左右全连接(arr, brr, 左表列选择器, 右表列选择器, 结果选择器) → {Array}

说明:

• 这个函数用于对两个二维数组进行左右全连接操作，并返回连接后的结果数组

别名:

• fulljoin

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'],
[2, 'B'],
[3, 'C']];
var brr = [[2, 'B'],
[3, 'Y'], 
[4, 'Z']];
var result = Array2D.z左右全连接(arr, brr, 'f1', 'f1');
logjson(result);
//输出结果
[[1,"A","",""],
[2,"B",2,"B"],
[3,"C",3,"Y"]]
log("自定义结果选择集")
//结果选择集可以用完整箭头函数 (a,b)=>a.concat(b)
var result = Array2D.z左右全连接(arr, brr, 'f2', 'f2','a.f1,b.f2');
logjson(result);
//输出结果
自定义结果选择集
[[1,""],
[2,"B"],
[3,""]]

fulljoin(arr, brr, 左表列选择器, 右表列选择器, 结果选择器) → {Array}

说明:

• 这个函数用于对两个二维数组进行左右全连接操作，并返回连接后的结果数组

别名:

• z左右全连接

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'],
[2, 'B'],
[3, 'C']];
var brr = [[2, 'B'],
[3, 'Y'], 
[4, 'Z']];
var result = Array2D.fulljoin(arr, brr, 'f1', 'f1');
logjson(result);
//输出结果
[[1,"A","",""],
[2,"B",2,"B"],
[3,"C",3,"Y"],
["","",3,"Y"],
["","",4,"Z"]]
log("自定义结果选择集")
//结果选择集可以用完整箭头函数 (a,b)=>a.concat(b)
var result = Array2D.fulljoin(arr, brr, 'f2', 'f2','a.f1,b.f2');
logjson(result);
//输出结果
自定义结果选择集
[[1,""],
[2,"B"],
[3,""],
["","Y"],
["","Z"]]

z分组(arr, 关键字选择器, 分隔符) → {Map}

说明:

• 这个函数用于对二维数组进行分组，并返回分组后的结果Map

别名:

• groupBy

参数列表:

返回值:

Type

Map

groupBy(arr, 关键字选择器, 分隔符) → {Map}

说明:

• 这个函数用于对二维数组进行分组，并返回分组后的结果Map

别名:

• z分组

参数列表:

返回值:

Type

Map

例子

var arr = [[1, 'A'],
[2, 'B'],
[3, 'C'], 
[4, 'B'], 
[5, 'A']];
var result = Array2D.groupBy(arr, 'f2');//注意结果是一个map
logjson(Array.from(result),false);
//输出结果
[["A",[[1,"A"],
[5,"A"]]],
["B",[[2,"B"],
[4,"B"]]],
["C",[[3,"C"]]]]

z分组汇总(arr, 关键字选择器, 结果选择器, 分隔符) → {Array}

说明:

• 这个函数用于对二维数组进行分组汇总，并返回汇总后的结果数组

别名:

• groupInto

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A', 10],
[2, 'B', 20], 
[3, 'A', 30], 
[1, 'B', 40],
[1, 'B', 10],
[1, 'A', 10]];
log("按第2列分组汇总,汇总列 第1列求和 每组行数 第3列max")
var result = Array2D.z分组汇总(arr, 'f2','sum("f1"),count(),max("f3")');
logjson(result);
//输出结果
按第2列分组汇总,汇总列 第1列求和 每组行数 第3列max
[["A",5,3,30],
["B",4,3,40]]
log("先按首列排序,再按1+2列分组汇总,汇总列 第1列求和 第2列数据用+连接 第3列求和")
var result = Array2D.z分组汇总(Array2D.sortBy(arr,'f1'), 'f1,f2','sum("f1"),textjoin("f2","+"),sum("f3")');
logjson(result);
//输出结果
先按首列排序,再按1+2列分组汇总,汇总列 第1列求和 第2列数据用+连接 第3列求和
[["1","A",2,"A+A",20],
["1","B",2,"B+B",50],
["2","B",2,"B",20],
["3","A",3,"A",30]]

groupInto(arr, 关键字选择器, 结果选择器, 分隔符) → {Array}

说明:

• 这个函数用于对二维数组进行分组汇总，并返回汇总后的结果数组

别名:

• z分组汇总

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A', 10],
[2, 'B', 20], 
[3, 'A', 30], 
[1, 'B', 40],
[1, 'B', 10],
[1, 'A', 10]];
log("按第2列分组汇总,汇总列 第1列求和 每组行数 第3列max")
var result = Array2D.groupInto(arr, 'f2','sum("f1"),count(),max("f3")');
logjson(result);
//输出结果
按第2列分组汇总,汇总列 第1列求和 每组行数 第3列max
[["A",5,3,30],
["B",4,3,40]]
log("先按首列排序,再按1+2列分组汇总,汇总列 第1列求和 第2列数据用+连接 第3列求和")
var result = Array2D.groupInto(Array2D.sorByCols(arr,'f1'), 'f1,f2','sum("f1"),textjoin("f2","+"),sum("f3")');
logjson(result);
//输出结果
先按首列排序,再按1+2列分组汇总,汇总列 第1列求和 第2列数据用+连接 第3列求和
[["1","A",2,"A+A",20],
["1","B",2,"B+B",50],
["2","B",2,"B",20],
["3","A",3,"A",30]]

z是否包含值(arr, 值) → {Boolean}

说明:

• 这个函数用于判断数组是否包含指定的值

别名:

• includes

参数列表:

返回值:

Type

Boolean

例子

var arr = [1, 2, 3, 4, 5];
var value = 3;
var result = Array2D.z是否包含值(arr, value);
console.log(result); // 输出是否包含指定的值
//输出结果
true

includes(arr, 值) → {Boolean}

说明:

• 这个函数用于判断数组是否包含指定的值

别名:

• z是否包含值

参数列表:

返回值:

Type

Boolean

例子

var arr =  [[1, 'A'],
[2, 'B'],
[3, 'C'], 
[4, 'B'], 
[5, 'A']];
var result = Array2D.includes(arr, 1);
console.log(result); // 输出是否包含指定的值
//输出结果
true

z下标数组(arr) → {Array}

说明:

• 这个函数用于获取二维数组的下标数组

别名:

• indexArray

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z下标数组(arr);
logjson(result);  // 输出下标数组
//输出结果
["0","1","2"]

indexArray(arr) → {Array}

说明:

• 这个函数用于获取二维数组的下标数组

别名:

• z下标数组

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.indexArray(arr);
logjson(result);  // 输出下标数组
//输出结果
[0,1,2]

z值位置(arr, 值) → {Array}

说明:

• 这个函数用于获取值在二维数组中的位置数组

别名:

• indexOf

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var value = 4;
var result = Array2D.z值位置(arr, value);
logjson(result); // 输出值的位置数组
//输出结果
[1,1]

indexOf(arr, 值) → {Array}

说明:

• 这个函数用于获取值在二维数组中的位置数组

别名:

• z值位置

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.indexOf(arr, 3);
logjson(result);//[1,0] 行列坐标 
//输出结果
[1,0]

z批量插入列(arr, 列选择器, 值, 数量) → {Array}

说明:

• 这个函数用于批量插入列到二维数组

别名:

• insertCols

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[0] + 1; // 选择第一列的值加1作为要插入的列的值
var value = '';
var count = 2;
var result = Array2D.z批量插入列(arr, columnSelector, value, count);
logjson(result); // 输出插入列后的二维数组
//输出结果
[[1,2],
[3,4],
[5,6]]

insertCols(arr, 列选择器, 值, 数量) → {Array}

说明:

• 这个函数用于批量插入列到二维数组

别名:

• z批量插入列

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4 , 5, 6], [7, 8 , 9]];
var result = Array2D.insertCols(arr, 'f2');//第2列插入空列
logjson(result); // 输出插入列后的二维数组
//输出结果
[[1,"",2,3],
[4,"",5,6],
[7,"",8,9]]
var result = Array2D.insertCols(arr, '0-2','*');//每一列前面插入一列 并填充*
logjson(result); // 输出插入列后的二维数组
//输出结果
[["*",1,"*",2,"*",3],
["*",4,"*",5,"*",6],
["*",7,"*",8,"*",9]]

z批量插入行(arr, 行号数组, 值, 数量) → {Array}

说明:

• 这个函数用于批量插入行到二维数组

别名:

• insertRows

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4 , 5, 6], [7, 8 , 9]];
var result = Array2D.z批量插入行(arr, 'f2', "*", 2);//第2行插入2行 填充*
logjson(result);
//输出结果
[[1,2,3],
["*","*","*"],
["*","*","*"],
[4,5,6],
[7,8,9]]

insertRows(arr, 行号数组, 值, 数量) → {Array}

说明:

• 这个函数用于批量插入行到二维数组

别名:

• z批量插入行

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4 , 5, 6], [7, 8 , 9]];
var result = Array2D.insertRows(arr, 'f2', "*", 2);//第2行插入2行 填充*
logjson(result);
//输出结果
[[1,2,3],
["*","*","*"],
["*","*","*"],
[4,5,6],
[7,8,9]]

z插入行号(arr, 首行序号) → {Array}

说明:

• 插入行号函数

别名:

• insertRowNum

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4 , 5, 6], [7, 8 , 9]];
var result = Array2D.z插入行号(arr);//首列插入行号
[[0,1,2,3],
[1,4,5,6],
[2,7,8,9]]

insertRowNum(arr, 首行序号) → {Array}

说明:

• 根据首行序号插入行号函数

别名:

• z插入行号

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4 , 5, 6], [7, 8 , 9]];
var result = Array2D.z插入行号(arr);//首列插入行号
[[0,1,2,3],
[1,4,5,6],
[2,7,8,9]]

z取交集(arr, brr) → {Array}

说明:

• 这个函数用于获取两个二维数组的交集

别名:

• intersect

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var brr = [[3, 4], [5, 6], [7, 8]];
var result = Array2D.z取交集(arr, brr);
logjson(result); // 输出交集数组
//输出结果
[[3,4],
[5,6]]

intersect(arr, brr) → {Array}

说明:

• 这个函数用于获取两个二维数组的交集

别名:

• z取交集

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6],[3, 4],[7, 9]];
var brr = [[3, 4], [5, 6], [7, 8]];
var result = Array2D.intersect(arr, brr);//完全一样的行
logjson(result); // 输出交集数组
//输出结果
[[3,4],
[5,6],
[3,4]]
logjson(Array2D.intersect(arr, brr,'f1','f1'));//可按参考列取交集
//输出结果
[[3,4],
[5,6],
[3,4],
[7,9]]

z空结果(arr) → {boolean}

说明:

• 这个函数用于判断二维数组是否为空

别名:

• isEmpty

参数列表:

返回值:

Type

boolean

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z空结果(arr);
console.log(result); // 输出false
//输出结果
false

isEmpty(arr) → {boolean}

说明:

• 这个函数用于判断二维数组是否为空

别名:

• z空结果

参数列表:

返回值:

Type

boolean

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.isEmpty(arr);
console.log(result); // 输出false
//输出结果
false
console.log(Array2D.isEmpty([])); // 输出true
//输出结果
true

z文本连接(arr, 分隔符) → {string}

说明:

• 这个函数用于将二维数组中的每个子数组连接成文本，并使用指定的分隔符分隔

别名:

• join

参数列表:

返回值:

Type

string

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var separator = "-";
var result = Array2D.z文本连接(arr, separator);
logjson(result); // 输出连接后的文本
//输出结果
"1\n2\n3-4\n5-6"

join(arr, 分隔符) → {string}

说明:

• 这个函数用于将二维数组中的每个子数组连接成文本，并使用指定的分隔符分隔

别名:

• z文本连接

参数列表:

返回值:

Type

string

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var separator = "-";
var result = Array2D.join(arr, separator);
logjson(result); // 输出连接后的文本
//输出结果
"1\n2\n3-4\n5-6"

z最后一个(arr, 条件回调函数, 没找到返回默认值) → {Object}

说明:

• 这个函数用于返回满足条件的最后一个子数组

别名:

• last

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var defaultValue = [];
var result = Array2D.z最后一个(arr, conditionCallback, defaultValue);
logjson(result); // 输出满足条件的最后一个子数组或默认值
//输出结果
[5,6]

last(arr, 条件回调函数, 没找到返回默认值) → {Object}

说明:

• 这个函数用于返回满足条件的最后一个子数组

别名:

• z最后一个

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var defaultValue = [];
var result = Array2D.last(arr, conditionCallback, defaultValue);
logjson(result); // 输出满足条件的最后一个子数组或默认值
//输出结果
[5,6]

z从后往前值位置(arr) → {number}

说明:

• 这个函数用于返回从后往前数值的位置

别名:

• lastIndexOf

参数列表:

返回值:

Type

number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z从后往前值位置(arr);
logjson(result); // 输出从后往前数值的位置
//输出结果
[-1,-1]

lastIndexOf(arr, 值) → {number}

说明:

• 这个函数用于返回指定值在二维数组中从后往前数的位置

别名:

• z从后往前值位置

参数列表:

返回值:

Type

number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var value = 4;
var result = Array2D.lastIndexOf(arr, value);
logjson(result); // 输出指定值在二维数组中从后往前数的位置
//输出结果
[1,1]

z一对多连接(arr, brr, 左表列选择器, 右表列选择器, 结果选择器) → {Array}

说明:

• 这个函数用于对两个二维数组进行一对多连接操作，并返回连接后的结果数组

别名:

• leftFulljoin

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'],
[2, 'B'], 
[3, 'C']];
var brr = [ [2, 'X','C1'],
[1, 'A','C2'],
[1, 'A','C3'],//2个1会被
[4, 'Z','C4']];
var result = Array2D.z一对多连接(arr, brr);//整行比较没有命中的所以右侧都会空
logjson(result);
//输出结果
[[1,"A","","",""],
[2,"B","","",""],
[3,"C","","",""]]
var result = Array2D.z一对多连接(arr, brr,'f1','f1');
logjson(result);
//输出结果
[[1,"A",1,"A","C2"],
[1,"A",1,"A","C3"],
[2,"B",2,"X","C1"],
[3,"C","","",""]]
log('lamda函数写法完全体')
var result = Array2D.z一对多连接(
arr,
brr,
a=>a[0],
b=>b[0],
(a,b)=>[a[0]+'-'+b[0],b[1],a[0]]
);
logjson(result);
//输出结果
lamda函数写法完全体
[["1-1","A",1],
["1-1","A",1],
["2-2","X",2],
["3-","",3]]

leftFulljoin(arr, brr, 左表列选择器, 右表列选择器, 结果选择器) → {Array}

说明:

• 这个函数用于对两个二维数组进行左外连接操作，并返回连接后的结果数组

别名:

• z一对多连接

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'],
[2, 'B'], 
[3, 'C']];
var brr = [ [2, 'X','C1'],
[1, 'A','C2'],
[1, 'A','C3'],//2个1会被
[4, 'Z','C4']];
var result = Array2D.leftFulljoin(arr, brr);//整行比较没有命中的所以右侧都会空
logjson(result);
//输出结果
[[1,"A","","",""],
[2,"B","","",""],
[3,"C","","",""]]
var result = Array2D.leftFulljoin(arr, brr,'f1','f1');
logjson(result);
//输出结果
[[1,"A",1,"A","C2"],
[1,"A",1,"A","C3"],
[2,"B",2,"X","C1"],
[3,"C","","",""]]
log('lamda函数写法完全体')
var result = Array2D.leftFulljoin(
arr,
brr,
a=>a[0],
b=>b[0],
(a,b)=>[a[0]+'-'+b[0],b[1],a[0]]
);
logjson(result);
//输出结果
lamda函数写法完全体
[["1-1","A",1],
["1-1","A",1],
["2-2","X",2],
["3-","",3]]

z左连接(arr, brr, 左表列选择器, 右表列选择器, 结果选择器) → {Array}

说明:

• 这个函数用于对两个二维数组进行左外连接操作，并返回连接后的结果数组

别名:

• leftjoin

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'],
[2, 'B'], 
[3, 'C']];
var brr = [ [2, 'X','C1'],
[1, 'A','C2'],
[1, 'A','C3'],//2个1只会连接第一个
[4, 'Z','C4']];	
var result = Array2D.z左连接(arr, brr);//整行比较没有命中的所以右侧都会空
logjson(result);
//输出结果
[[1,"A","","",""],
[2,"B","","",""],
[3,"C","","",""]]
log('选择列作为连接比较器')//右侧对应关系找到的首行连接过来 左侧的总行数不会变
var result = Array2D.z左连接(arr, brr,'f1','f1');
logjson(result);
//输出结果
选择列作为连接比较器
[[1,"A",1,"A","C2"],
[2,"B",2,"X","C1"],
[3,"C","","",""]]
log('lamda函数写法完全体')
var result = Array2D.z左连接(
arr,
brr,
a=>a[0],
b=>b[0],
(a,b)=>[a[0]+'-'+b[0],b[1],a[0]]
);
logjson(result);
//输出结果
lamda函数写法完全体
[["1-1","A",1],
["2-2","X",2],
["3-","",3]]

leftjoin(arr, brr, 左表列选择器, 右表列选择器, 结果选择器) → {Array}

说明:

• 这个函数用于对两个二维数组进行左外连接操作，并返回连接后的结果数组

别名:

• z左连接

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'],
[2, 'B'], 
[3, 'C']];
var brr = [ [2, 'X','C1'],
[1, 'A','C2'],
[1, 'A','C3'],//2个1只会连接第一个
[4, 'Z','C4']];	
var result = Array2D.leftjoin(arr, brr);//整行比较没有命中的所以右侧都会空
logjson(result);
//输出结果
[[1,"A","","",""],
[2,"B","","",""],
[3,"C","","",""]]
log('选择列作为连接比较器')//右侧对应关系找到的首行连接过来 左侧的总行数不会变
var result = Array2D.leftjoin(arr, brr,'f1','f1');
logjson(result);
//输出结果
选择列作为连接比较器
[[1,"A",1,"A","C2"],
[2,"B",2,"X","C1"],
[3,"C","","",""]]
log('lamda函数写法完全体')
var result = Array2D.leftjoin(
arr,
brr,
a=>a[0],
b=>b[0],
(a,b)=>[a[0]+'-'+b[0],b[1],a[0]]
);
logjson(result);
//输出结果
lamda函数写法完全体
[["1-1","A",1],
["2-2","X",2],
["3-","",3]]

z映射生成(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于根据条件回调函数对二维数组进行映射生成新的数组

别名:

• map

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (element) => element[0]*  2; // 对每个元素的第一个值进行乘以2的操作
var result = Array2D.z映射生成(arr, conditionCallback);
logjson(result);
//输出结果
[[2],
[6],
[10]]

map(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于根据条件回调函数对二维数组进行映射生成新的数组

别名:

• z映射生成

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (element) => element[0]*  2; // 对每个元素的第一个值进行乘以2的操作
var result = Array2D.map(arr, conditionCallback);
logjson(result);
//输出结果
[[2],
[6],
[10]]

z最大值(arr, 列选择函数) → {Number}

说明:

• 这个函数用于计算二维数组中指定列的最大值

别名:

• max

参数列表:

返回值:

Type

Number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1]; // 选择第二列进行比较
var result = Array2D.z最大值(arr, columnSelector);
console.log(result); // 输出最大值
//输出结果
6

max(arr, 列选择函数) → {Number}

说明:

• 这个函数用于计算二维数组中指定列的最大值

别名:

• z最大值

参数列表:

返回值:

Type

Number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1]; // 选择第二列进行比较
var result = Array2D.max(arr, columnSelector);
console.log(result); // 输出最大值
//输出结果
6

z中位数(arr, 列选择函数) → {Number}

说明:

• 这个函数用于计算二维数组中指定列的中位数

别名:

• median

参数列表:

返回值:

Type

Number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1]; // 选择第二列进行比较
var result = Array2D.z中位数(arr, columnSelector);
console.log(result); // 输出中位数
//输出结果
4

median(arr, 列选择函数) → {Number}

说明:

• 这个函数用于计算二维数组中指定列的中位数

别名:

• z中位数

参数列表:

返回值:

Type

Number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1]; // 选择第二列进行比较
var result = Array2D.median(arr, columnSelector);
console.log(result); // 输出中位数
//输出结果
4

z最小值(arr, 列选择函数) → {Number}

说明:

• 这个函数用于计算二维数组中指定列的最小值

别名:

• min

参数列表:

返回值:

Type

Number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1]; // 选择第二列进行比较
var result = Array2D.z最小值(arr, columnSelector);
console.log(result); // 输出最小值
//输出结果
2

min(arr, 列选择函数) → {Number}

说明:

• 这个函数用于计算二维数组中指定列的最小值

别名:

• z最小值

参数列表:

返回值:

Type

Number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1]; // 选择第二列进行比较
var result = Array2D.min(arr, columnSelector);
console.log(result); // 输出最小值
//输出结果
2

z间隔取数(arr, 间隔, 偏移) → {Object}

说明:

• 这个函数用于间隔取二维数组的数据，并返回取到的结果对象

别名:

• nth

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var interval = 2;
var offset = 1;
var result = Array2D.z间隔取数(arr, interval, offset);
logjson(result); // 输出取到的结果对象
//输出结果
[[3,4],
[7,8]]

nth(arr, 间隔, 偏移) → {Object}

说明:

• 这个函数用于间隔取二维数组的数据，并返回取到的结果对象

别名:

• z间隔取数

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var interval = 2;
var offset = 1;
var result = Array2D.nth(arr, interval, offset);
logjson(result); // 输出取到的结果对象
//输出结果
[[3,4],
[7,8]]

z补齐数组(arr, 大小, 补齐值) → {Array}

说明:

• 这个函数用于补齐二维数组的大小，并返回补齐后的新数组

别名:

• pad

参数列表:

返回值:

Type

Array

例子

var arr = [ [1, 'A'],
[2, 'B'], 
[3, 'C'] ];
logjson(Array2D.z补齐数组(arr,4,4,null));//扩充数组行数列数默认填充null 也可填充指定值
//输出结果
[[1,"A",null,null],
[2,"B",null,null],
[3,"C",null,null],
[null,null,null,null]]

pad(arr, 大小, 补齐值) → {Array}

说明:

• 这个函数用于补齐二维数组的大小，并返回补齐后的新数组

别名:

• z补齐数组

参数列表:

返回值:

Type

Array

例子

var arr = [ [1, 'A'],
[2, 'B'], 
[3, 'C'] ];
logjson(Array2D.pad(arr,4,4,null));//扩充数组行数列数默认填充null 也可填充指定值
//输出结果
[[1,"A",null,null],
[2,"B",null,null],
[3,"C",null,null],
[null,null,null,null]]

z按页数分页(arr, 总页数) → {Array}

说明:

• 这个函数用于按照总页数对二维数组进行分页，并返回分页后的新数组

别名:

• pageByCount

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var totalPages = 3;
var result = Array2D.z按页数分页(arr, totalPages);
logjson(result);  // 输出分页后的新数组
//输出结果
[[[1,2],
[3,4]],
[[5,6],
[7,8]],
[[9,10]]]

pageByCount(arr, 总页数) → {Array}

说明:

• 这个函数用于按照总页数对二维数组进行分页，并返回分页后的新数组

别名:

• z按页数分页

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var totalPages = 3;
var result = Array2D.pageByCount(arr, totalPages);
logjson(result);  // 输出分页后的新数组
//输出结果
[[[1,2],
[3,4]],
[[5,6],
[7,8]],
[[9,10]]]

z按行数分页(arr, 每页数量) → {Array}

说明:

• 这个函数用于按照每页数量对二维数组进行分页，并返回分页后的新数组

别名:

• pageByRows

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var pageSize = 2;
var result = Array2D.z按行数分页(arr, pageSize);
logjson(result); // 输出分页后的新数组
//输出结果
[[[1,2],
[3,4]],
[[5,6],
[7,8]],
[[9,10]]]

pageByRows(arr, 每页数量) → {Array}

说明:

• 这个函数用于按照每页数量对二维数组进行分页，并返回分页后的新数组

别名:

• z按行数分页

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var pageSize = 2;
var result = Array2D.pageByRows(arr, pageSize);
logjson(result);  // 输出分页后的新数组
//输出结果
[[[1,2],
[3,4]],
[[5,6],
[7,8]],
[[9,10]]]

pageByIndexs(arr, 下标数组) → {Array}

说明:

• 这个函数用于按照每页数量对二维数组进行分页，并返回分页后的新数组

参数列表:

返回值:

Type

Array

z尾部弹出一项(arr) → {Object}

说明:

• 这个函数用于从二维数组的尾部弹出一项，并返回弹出的项

别名:

• pop

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z尾部弹出一项(arr);
console.log(result); // 输出弹出的项

pop(arr) → {Object}

说明:

• 这个函数用于从二维数组的尾部弹出一项，并返回弹出的项

别名:

• z尾部弹出一项

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.pop(arr);
logjson(result);  // 输出弹出的项
//输出结果
//[5,6]	    

z删除指定项(arr, 条件回调函数, 默认值) → {Object}

说明:

• 这个函数用于删除二维数组中满足条件的指定项，并返回删除后的数组，如果没有满足条件的项，则返回默认值

别名:

• pull

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 'A'],
[2, 'B'], 
[3, 'C']];
logjson(Array2D.z删除指定项(arr,row=>row[0]>2));//删除首列大于2的行
//输出结果
[[1,"A"],
[2,"B"]]

pull(arr, 关键字选择器, 默认值) → {Object}

说明:

• 这个函数用于删除二维数组中满足条件的指定项，并返回删除后的数组，如果没有满足条件的项，则返回默认值

别名:

• z删除指定项

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 'A'],
[2, 'B'], 
[3, 'C']];
logjson(Array2D.pull(arr,row=>row[0]>2));//删除首列大于2的行
//输出结果
//[[1,"A"],
//[2,"B"]]	       

z追加一项(arr, 单行数组) → {Object}

说明:

• 这个函数用于在二维数组的末尾追加一项，并返回追加后的数组

别名:

• push

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var newRow = [7, 8];
var result = Array2D.z追加一项(arr, newRow);
logjson(result);  //输出追加后的数组
//输出结果
[[1,2],
[3,4],
[5,6],
[7,8]]

push(arr, 单行数组) → {Object}

说明:

• 这个函数用于在二维数组的末尾追加一项，并返回追加后的数组

别名:

• z追加一项

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var newRow = [7, 8];
var result = Array2D.push(arr, newRow);
logjson(result);  //输出追加后的数组
//输出结果
//[[1,2],
//[3,4],
//[5,6],
//[7,8]]

z随机一项(arr) → {Array}

说明:

• 这个函数用于从二维数组中随机选择一项，并返回选择的项

别名:

• random

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z随机一项(arr);
logjson(result);   // 输出选择的项
//输出结果
//[[5,6]]

random(arr) → {Array}

说明:

• 这个函数用于从二维数组中随机选择一项，并返回选择的项

别名:

• z随机一项

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.random(arr);
logjson(result);   // 输出选择的项
//输出结果
[[3,4]]

z按范围遍历(arr, 范围, 条件回调函数) → {Array}

说明:

• 这个函数用于按范围遍历二维数组，并返回遍历结果组成的数组

别名:

• rangeForEach

参数列表:

返回值:

Type

Array

例子

var arr = [
["A1", "B1", "C1", "D1", "E1", "F1"],
["A2", "B2", "C2", "D2", "E2", "F2"],
["A3", "B3", "C3", "D3", "E3", "F3"],
["A4", "B4", "C4", "D4", "E4", "F4"],
["A5", "B5", "C5", "D5", "E5", "F5"]];
// 遍历范围为前两行两列
Array2D.z按范围遍历(
arr,
[0, 0, 2, 2], //行,列,行数,列数 这里 代表 A1:B2这个区域
(item,i,j,arr)=>{//当前元素,行号,列号,原数组
console.log([item,i,j].toString())
});
//输出结果
A1,0,0
B1,0,1
A2,1,0
B2,1,1
//也可以使用原数组参数来直接对原数组进行修改:
Array2D.z按范围遍历(
arr,
[0, 0, 2, 2], //行,列,行数,列数 这里 代表 A1:B2这个区域
(item,i,j,arr)=>{//当前元素,行号,列号,原数组
arr[i][j]=item+' 修改';//对原数组局部区域修改
});
logjson(arr);  //输出数组
//输出结果
[["A1 修改","B1 修改","C1","D1","E1","F1"],
["A2 修改","B2 修改","C2","D2","E2","F2"],
["A3","B3","C3","D3","E3","F3"],
["A4","B4","C4","D4","E4","F4"],
["A5","B5","C5","D5","E5","F5"]]

rangeForEach(arr, 范围, 条件回调函数) → {Array}

说明:

• 这个函数用于按范围遍历二维数组，并返回遍历结果组成的数组

别名:

• z按范围遍历

参数列表:

返回值:

Type

Array

例子

var arr = [
["A1", "B1", "C1", "D1", "E1", "F1"],
["A2", "B2", "C2", "D2", "E2", "F2"],
["A3", "B3", "C3", "D3", "E3", "F3"],
["A4", "B4", "C4", "D4", "E4", "F4"],
["A5", "B5", "C5", "D5", "E5", "F5"]];
// 遍历范围为前两行两列
Array2D.rangeForEach(
arr,
[0, 0, 2, 2], //行,列,行数,列数 这里 代表 A1:B2这个区域
(item,i,j,arr)=>{//当前元素,行号,列号,原数组
console.log([item,i,j].toString())
});
////输出结果
//A1,0,0
//B1,0,1
//A2,1,0
//B2,1,1
//也可以使用原数组参数来直接对原数组进行修改:
Array2D.rangeForEach(
arr,
[0, 0, 2, 2], //行,列,行数,列数 这里 代表 A1:B2这个区域
(item,i,j,arr)=>{//当前元素,行号,列号,原数组
arr[i][j]=item+' 修改';//对原数组局部区域修改
});
logjson(arr);  //输出数组
////输出结果
//[["A1 修改","B1 修改","C1","D1","E1","F1"],
//["A2 修改","B2 修改","C2","D2","E2","F2"],
//["A3","B3","C3","D3","E3","F3"],
//["A4","B4","C4","D4","E4","F4"],
//["A5","B5","C5","D5","E5","F5"]]

z局部映射(arr, 范围, 条件回调函数) → {Array}

说明:

• 这个函数用于对二维数组的指定范围进行局部映射，并返回映射后的数组

别名:

• rangeMap

参数列表:

返回值:

Type

Array

例子

var arr = [
["A1", "B1", "C1", "D1", "E1", "F1"],
["A2", "B2", "C2", "D2", "E2", "F2"],
["A3", "B3", "C3", "D3", "E3", "F3"],
["A4", "B4", "C4", "D4", "E4", "F4"],
["A5", "B5", "C5", "D5", "E5", "F5"]];
//3行2列 + 这个区域加**后缀
var result = Array2D.z局部映射(arr, [0, 0, 3, 2], x=>x+'**');
logjson(result);
//输出结果
[["A1**","B1**","C1","D1","E1","F1"],
["A2**","B2**","C2","D2","E2","F2"],
["A3**","B3**","C3","D3","E3","F3"],
["A4","B4","C4","D4","E4","F4"],
["A5","B5","C5","D5","E5","F5"]]

rangeMap(arr, 范围, 条件回调函数) → {Array}

说明:

• 这个函数用于对二维数组的指定范围进行局部映射，并返回映射后的数组

别名:

• z局部映射

参数列表:

返回值:

Type

Array

例子

var arr = [
["A1", "B1", "C1", "D1", "E1", "F1"],
["A2", "B2", "C2", "D2", "E2", "F2"],
["A3", "B3", "C3", "D3", "E3", "F3"],
["A4", "B4", "C4", "D4", "E4", "F4"],
["A5", "B5", "C5", "D5", "E5", "F5"]];
//3行2列 + 这个区域加**后缀
var result = Array2D.rangeMap(arr, [0, 0, 3, 2], x=>x+'**');
logjson(result);
//输出结果
[["A1**","B1**","C1","D1","E1","F1"],
["A2**","B2**","C2","D2","E2","F2"],
["A3**","B3**","C3","D3","E3","F3"],
["A4","B4","C4","D4","E4","F4"],
["A5","B5","C5","D5","E5","F5"]]

z矩阵操作(arr, 范围, 条件回调函数) → {Array}

说明:

• 这个函数用于对二维数组的指定范围进行矩阵操作，并返回操作后的数组

别名:

• rangeMarix

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], 
[4, 5, 6],
[7, 8, 9]];
var brr = [[1, 2, 3],
[4, 5, 6], 
[7, 8, 9]];
//2个一样大小的数组 元素相加得到一个结果数组
var result = Array2D.z矩阵操作(arr, [] , brr, (a,b)=>a+b);
//A数组中选取一个区域 与B数组运算 一般B数组传入一个和A数组选中的区域一样大小的区域    
//B数组的第2列与A数组的第2列进行计算
var result = Array2D.z矩阵操作(arr, [0,1,3,1] ,Array2D.selectCols(brr,'f2'), (a,b)=>a+b);
logjson(result);
//输出结果
[[1,4,3],
[4,10,6],
[7,16,9]]

rangeMarix(arr, 范围, 条件回调函数) → {Array}

说明:

• 这个函数用于对二维数组的指定范围进行矩阵操作，并返回操作后的数组

别名:

• z矩阵操作

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], 
[4, 5, 6],
[7, 8, 9]];
var brr = [[1, 2, 3],
[4, 5, 6], 
[7, 8, 9]];
//2个一样大小的数组 元素相加得到一个结果数组
var result = Array2D.rangeMarix(arr, [] , brr, (a,b)=>a+b);
//A数组中选取一个区域 与B数组运算 一般B数组传入一个和A数组选中的区域一样大小的区域    
//B数组的第2列与A数组的第2列进行计算
var result = Array2D.rangeMarix(arr, [0,1,3,1] ,Array2D.selectCols(brr,'f2'), (a,b)=>a+b);
logjson(result);
//输出结果
[[1,4,3],
[4,10,6],
[7,16,9]]

z按范围选择(arr, 范围) → {Array}

说明:

• 这个函数用于按范围选择二维数组的部分元素，并返回选择后的数组

别名:

• rangeSelect

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var range = [0, 0, 2, 2]; // 选择范围为前两行两列
var result = Array2D.z按范围选择(arr, range);
logjson(result); // 输出选择后的数组
//输出结果
[[1,2],
[4,5]]

rangeSelect(arr, 范围) → {Array}

说明:

• 这个函数用于按范围选择二维数组的部分元素，并返回选择后的数组

别名:

• z按范围选择

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var range = [0, 0, 2, 2]; // 选择范围为前两行两列
var result = Array2D.rangeSelect(arr, range);
logjson(result);  // 输出选择后的数组
//输出结果
[[1,2],
[4,5]]

z聚合(arr, 聚合回调函数, 种子初始值) → {Object}

说明:

• 这个函数用于对二维数组进行聚合操作，并返回聚合结果对象

别名:

• reduce

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var aggregateCallback = (accumulator, current) => accumulator + current; // 对每个元素进行累加操作
var initialValue = 0; // 初始值为0
var result = Array2D.z聚合(arr, aggregateCallback, initialValue);
Console.log(result);  // 输出聚合结果对象
//输出结果
01,23,45,6

reduce(arr, 聚合回调函数, 种子初始值) → {Object}

说明:

• 这个函数用于对二维数组进行聚合操作，并返回聚合结果对象

别名:

• z聚合

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var aggregateCallback = (accumulator, current) => accumulator + current; // 对每个元素进行累加操作
var initialValue = 0; // 初始值为0
var result = Array2D.reduce(arr, aggregateCallback, initialValue);
Console.log(result);  // 输出聚合结果对象
//输出结果
01,23,45,6

z倒序聚合(arr, 聚合回调函数, 种子初始值) → {Object}

说明:

• 这个函数用于对二维数组进行倒序聚合操作，并返回聚合结果对象

别名:

• reduceRight

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var aggregateCallback = (accumulator, current) => accumulator + current; // 对每个元素进行累加操作
var initialValue = 0; // 初始值为0
var result = Array2D.z倒序聚合(arr, aggregateCallback, initialValue);
console.log(result); // 输出聚合结果对象
//输出结果
05,63,41,2

reduceRight(arr, 聚合回调函数, 种子初始值) → {Object}

说明:

• 这个函数用于对二维数组进行倒序聚合操作，并返回聚合结果对象

别名:

• z倒序聚合

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var aggregateCallback = (accumulator, current) => accumulator + current; // 对每个元素进行累加操作
var initialValue = 0; // 初始值为0
var result = Array2D.reduceRight(arr, aggregateCallback, initialValue);
console.log(result); // 输出聚合结果对象
//输出结果
05,63,41,2

z重复N次(arr, 个数) → {Array}

说明:

• 这个函数用于将二维数组重复N次，并返回重复后的结果数组

别名:

• repeat

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4]];
var count = 3;
var result = Array2D.z重复N次(arr, count);
logjson(result); // 输出重复后的结果数组
//输出结果
[[1,2],
[3,4],
[1,2],
[3,4],
[1,2],
[3,4]]

repeat(arr, 个数) → {Array}

说明:

• 这个函数用于将二维数组重复N次，并返回重复后的结果数组

别名:

• z重复N次

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4]];
var result = Array2D.repeat(arr, 3);
logjson(result);  // 输出重复后的结果数组
//输出结果  
[[1,2],
[3,4],
[1,2],
[3,4],
[1,2],
[3,4]]

z结果(arr) → {Array}

说明:

• 这个函数用于获取二维数组的结果部分（去除第一列）

别名:

• res

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var result = Array2D.z结果(arr);
logjson(result); // 输出结果部分的数组
//输出结果
[[1,"A"],
[2,"B"],
[3,"C"]]

res(arr) → {Array}

说明:

• 这个函数用于获取二维数组的结果部分（去除第一列）

别名:

• z结果

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var result = asArray2D(arr).filter('f1>1').map('f1**2').res();
logjson(result);  // 输出结果部分的数组
//输出结果
[[4],
[9]]

z反转(arr) → {Array}

说明:

• 这个函数用于对二维数组进行反转操作，并返回反转后的结果数组

别名:

• reverse

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z反转(arr);
logjson(result); // 输出反转后的结果数组
//输出结果
[[5,6],
[3,4],
[1,2]]

reverse(arr) → {Array}

说明:

• 这个函数用于对二维数组进行反转操作，并返回反转后的结果数组

别名:

• z反转

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.reverse(arr);
logjson(result); // 输出反转后的结果数组
//输出结果
[[5,6],
[3,4],
[1,2]]

z选择列(arr, 列号数组) → {Array}

说明:

• 这个函数用于选择二维数组中指定的列，并返回选择后的结果数组 可以按首行表头选择

别名:

• selectCols

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var columnIndexes = [0, 2]; // 选择第一列和第三列
var result = Array2D.z选择列(arr, columnIndexes);
logjson(result);  // 输出选择后的结果数组
//输出结果
[[1,3],
[4,6],
[7,9]]
//下面是按表头
var arr=[['a','b','c'],
         [1,2,3],
         [4,5,6],
         [7,8,9]];
logjson($$.selectCols(arr,['c','b','a']));//按首行表头 错位选择
logjson($$.selectCols(arr,['x','z'],['x','y','z']));//按自定义表头 第2个数组为每列依次指定新的表头

selectCols(arr, 列号数组) → {Array}

说明:

• 这个函数用于选择二维数组中指定的列，并返回选择后的结果数组

别名:

• z选择列

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var columnIndexes = [0, 2]; // 选择第一列和第三列
var result = Array2D.z选择列(arr, columnIndexes);
logjson(result);  // 输出选择后的结果数组
//输出结果
[[1,3],
[4,6],
[7,9]]
//下面是按表头
var arr=[['a','b','c'],
         [1,2,3],
         [4,5,6],
         [7,8,9]];
logjson($$.z选择列(arr,['c','b','a']));//按首行表头 错位选择
logjson($$.z选择列(arr,['x','z'],['x','y','z']));//按自定义表头 第2个数组为每列依次指定新的表头

z选择行(arr, 行号数组) → {Array}

说明:

• 这个函数用于选择二维数组中指定的行，并返回选择后的结果数组

别名:

• selectRows

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var rowIndexes = [0, 2]; // 选择第一行和第三行
var result = Array2D.z选择行(arr, rowIndexes);
logjson(result);  // 输出选择后的结果数组
//输出结果
[[1,2,3],
[7,8,9]]

selectRows(arr, 行号数组) → {Array}

说明:

• 这个函数用于选择二维数组中指定的行，并返回选择后的结果数组

别名:

• z选择行

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var rowIndexes = [0, 2]; // 选择第一行和第三行
var result = Array2D.selectRows(arr, rowIndexes);
logjson(result);  // 输出选择后的结果数组
//输出结果
[[1,2,3],
[7,8,9]]

z删除第一个(arr, 个数) → {Object}

说明:

• 这个函数用于删除二维数组中的前N个元素，并返回删除后的结果数组

别名:

• shift

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var count = 2; // 删除前两个元素
var result = Array2D.z删除第一个(arr, count);
logjson(result);
//输出结果
[[1,2,3],
[4,5,6]]

shift(arr, 个数) → {Object}

说明:

• 这个函数用于删除二维数组中的前N个元素，并返回删除后的结果数组

别名:

• z删除第一个

参数列表:

返回值:

Type

Object

例子

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];    
var result = Array2D.shift(arr, 2);
log("返回的是弹出的内容")
logjson(result);
//输出结果
返回的是弹出的内容
[[1,2,3],
[4,5,6]]
log("原数组被改变")
logjson(arr);//返回的是弹出的内容
//输出结果
原数组被改变
[[7,8,9]]

z随机打乱(arr) → {Array}

说明:

• 这个函数用于随机打乱二维数组中的元素顺序，并返回打乱后的结果数组

别名:

• shuffle

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z随机打乱(arr);
logjson(result);  // 输出打乱后的结果数组
//输出结果
[[5,6],
[3,4],
[1,2]]

shuffle(arr) → {Array}

说明:

• 这个函数用于随机打乱二维数组中的元素顺序，并返回打乱后的结果数组

别名:

• z随机打乱

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.shuffle(arr);
logjson(result);  // 输出打乱后的结果数组
//输出结果
[[3,4],
[5,6],
[1,2]]

z跳过前N个(arr, 个数) → {Array}

说明:

• 这个函数用于跳过二维数组中的前N个元素，并返回跳过后的结果数组

别名:

• skip

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var count = 2; // 跳过前两个元素
var result = Array2D.z跳过前N个(arr, count);
logjson(result);  // 输出跳过后的结果数组
//输出结果
[[5,6]]

skip(arr, 个数) → {Array}

说明:

• 这个函数用于跳过二维数组中的前N个元素，并返回跳过后的结果数组

别名:

• z跳过前N个

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var count = 2; // 跳过前两个元素
var result = Array2D.skip(arr, count);
logjson(result);  // 输出跳过后的结果数组
//输出结果
[[5,6]]

z跳过前面连续不满足(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于跳过二维数组中前面连续不满足条件的元素，并返回跳过后的结果数组

别名:

• skipUntil

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var result = Array2D.z跳过前面连续不满足(arr, conditionCallback);
logjson(result);  // 输出跳过后的结果数组
//输出结果
[[3,4],
[5,6]]

skipUntil(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于跳过二维数组中前面连续不满足条件的元素，并返回跳过后的结果数组

别名:

• z跳过前面连续不满足

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6],[[1, 2]]];
var result = Array2D.skipUntil(arr, row=>row[0]>3);
logjson(result);  // 输出跳过后的结果数组
//输出结果
[[5,6],
[[1,2]]]

z跳过前面连续满足(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于跳过二维数组中前面连续满足条件的元素，并返回跳过后的结果数组

别名:

• skipWhile

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var result = Array2D.z跳过前面连续满足(arr, conditionCallback);
logjson(result);  // 输出跳过后的结果数组
//输出结果
[[1,2],
[3,4],
[5,6]]

skipWhile(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于跳过二维数组中前面连续满足条件的元素，并返回跳过后的结果数组

别名:

• z跳过前面连续满足

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 2], [4, 4], [5, 6],[1, 2],[4, 2]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var result = Array2D.skipWhile(arr, conditionCallback);
logjson(result);  // 输出跳过后的结果数组
//输出结果
[[1,2],
[4,2]]     

z行切片(arr, 位置, 个数) → {Array}

说明:

• 这个函数用于对二维数组进行行切片操作，并返回切片后的结果数组

别名:

• slice

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var start = 1; // 切片起始位置
var count = 2; // 切片行数
var result = Array2D.z行切片(arr, start, count);
console.log(result); // 输出切片后的结果数组

slice(arr, 位置, 个数) → {Array}

说明:

• 这个函数用于对二维数组进行行切片操作，并返回切片后的结果数组

别名:

• z行切片

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var result = Array2D.slice(arr, 1, 2);
logjson(result);    // 输出切片后的结果数组
//输出结果
[[3,4],
[5,6]]

z满足条件(arr, 条件回调函数) → {Boolean}

说明:

• 这个函数用于判断二维数组中是否存在满足条件的元素

别名:

• some

参数列表:

返回值:

Type

Boolean

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var result = Array2D.z满足条件(arr, conditionCallback);
console.log(result); // 输出是否存在满足条件的元素
//输出结果
true

some(arr, 条件回调函数) → {Boolean}

说明:

• 这个函数用于判断二维数组中是否存在满足条件的元素

别名:

• z满足条件

参数列表:

返回值:

Type

Boolean

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var result = Array2D.some(arr, conditionCallback);
console.log(result); // 输出是否存在满足条件的元素
//输出结果
true

z升序排序(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于对二维数组进行升序排序，并返回排序后的结果数组

别名:

• sort

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var conditionCallback = (a, b) => a[0] - b[0]; // 按照子数组的第一个元素进行升序排序
var result = Array2D.z升序排序(arr, conditionCallback);
logjson(result);  // 输出排序后的结果数组
//输出结果
[[3,"C"],
[1,"A"],
[2,"B"]]

sort(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于对二维数组进行升序排序，并返回排序后的结果数组

别名:

• z升序排序

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var conditionCallback = (a, b) => a[0] - b[0]; // 按照子数组的第一个元素进行升序排序
var result = Array2D.sort(arr, conditionCallback);
logjson(result);   // 输出排序后的结果数组
//输出结果
[[3,"C"],
[1,"A"],
[2,"B"]]

z按规则升序(arr, 列选择器, 表头行号) → {Array}

说明:

• 这个函数用于对二维数组进行按规则升序排序，并返回排序后的结果数组

别名:

• sortBy

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var columnSelector = (row) => row[0]; // 选择子数组的第一个元素作为排序列
var result = Array2D.z按规则升序(arr, columnSelector);
logjson(result);   // 输出排序后的结果数组
//输出结果
[[1,"A"],
[2,"B"],
[3,"C"]]

sortBy(arr, 列选择器, 表头行号) → {Array}

说明:

• 这个函数用于对二维数组进行按规则升序排序，并返回排序后的结果数组

别名:

• z按规则升序

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var columnSelector = (row) => row[0]; // 选择子数组的第一个元素作为排序列
var result = Array2D.sortBy(arr, columnSelector);
logjson(result);   // 输出排序后的结果数组
//输出结果
[[1,"A"],
[2,"B"],
[3,"C"]]

z按规则降序(arr, 列选择器) → {Array}

说明:

• 这个函数用于对二维数组进行按规则降序排序，并返回排序后的结果数组

别名:

• sortByDesc

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var columnSelector = (row) => row[0]; // 选择子数组的第一个元素作为排序列
var result = Array2D.z按规则降序(arr, columnSelector);
logjson(result);  // 输出排序后的结果数组
//输出结果
[[3,"C"],
[2,"B"],
[1,"A"]]

sortByDesc(arr, 列选择器) → {Array}

说明:

• 这个函数用于对二维数组进行按规则降序排序，并返回排序后的结果数组

别名:

• z按规则降序

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var columnSelector = (row) => row[0]; // 选择子数组的第一个元素作为排序列
var result = Array2D.sortByDesc(arr, columnSelector);
logjson(result);  // 输出排序后的结果数组
//输出结果
[[3,"C"],
[2,"B"],
[1,"A"]]

z降序排序(arr) → {Array}

说明:

• 这个函数用于对二维数组进行降序排序，并返回排序后的结果数组

别名:

• sortDesc

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.z降序排序(arr);
logjson(result);   // 输出排序后的结果数组
//输出结果
[[3,"C"],
[2,"B"],
[1,"A"]]

sortDesc(arr) → {Array}

说明:

• 这个函数用于对二维数组进行降序排序，并返回排序后的结果数组

别名:

• z降序排序

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.sortDesc(arr);
logjson(result);  // 输出排序后的结果数组
//输出结果
[[3,"C"],
[2,"B"],
[1,"A"]]

z自定义排序(arr, list) → {Array}

说明:

• 自定义排序函数

别名:

• sortByList

参数列表:

返回值:

Type

Array

例子

var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.z自定义排序(arr,0,[2,3,1]);

sortByList(arr, list) → {Array}

说明:

• 根据列表排序函数

别名:

• z自定义排序

参数列表:

返回值:

Type

Array

例子

* var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.sortByList(arr,0,[2,3,1]);

z多列排序(arr, cols) → {Array}

说明:

• 多列排序函数

别名:

• sortByCols

参数列表:

返回值:

Type

Array

例子

* var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.z多列排序(arr,'f1+,f2-');//先按第2列降序 再按第1列升序

sortByCols(arr, cols) → {Array}

说明:

• 根据多列排序函数

别名:

• z多列排序

参数列表:

返回值:

Type

Array

例子

* var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.sortByCols(arr,'f1+,f2-');//先按第2列降序 再按第1列升序

z行切片删除行(arr, 位置, 数量, 替换值) → {Array}

说明:

• 这个函数用于删除二维数组中指定位置的行，并返回删除后的结果数组

别名:

• splice

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'], [2, 'B'], [3, 'C'], [4, 'D']];
var position = 1;
var count = 2;
var replacement = [5, 'E'];
var result = Array2D.z行切片删除行(arr, position, count, replacement);
console.log(result); // 输出删除后的结果数组

splice(arr, 位置, 数量, 替换值) → {Array}

说明:

• 这个函数用于删除二维数组中指定位置的行，并返回删除后的结果数组

别名:

• z行切片删除行

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 'A'], 
[2, 'B'],
[3, 'C'],
[4, 'D']];
var 开始行 = 1;
var 结束行 = 2;
var 原位替换 = [5, 'E'];
var result = Array2D.splice(arr, 开始行, 结束行, 原位替换);
logjson(result);
//输出结果
[[2,"B"],
[3,"C"]]
log('替换是替换到原数组')
logjson(arr);
//输出结果
替换是替换到原数组
[[1,"A"],
[5,"E"],
[4,"D"]]

z求和(arr, 列选择函数) → {number}

说明:

• 这个函数用于对二维数组中的指定列进行求和，并返回求和结果

别名:

• sum

参数列表:

返回值:

Type

number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1]; // 选择第二列进行求和
var result = Array2D.z求和(arr, columnSelector);
console.log(result); // 输出求和结果
//输出结果
12

sum(arr, 列选择函数) → {number}

说明:

• 这个函数用于对二维数组中的指定列进行求和，并返回求和结果

别名:

• z求和

参数列表:

返回值:

Type

number

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1]; // 选择第二列进行求和
var result = Array2D.sum(arr, columnSelector);
console.log(result); // 输出求和结果
//输出结果
12

z超级查找(arr, brr, 左表列选择器, 右表列选择器, 双表结果选择器) → {Array}

说明:

• 这个函数用于对两个二维数组进行超级查找操作，并返回查找结果数组

别名:

• superLookup

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 'A'], [2, 'B'], [3, 'C']];
const brr = [[2, 'X'], [3, 'Y'], [4, 'Z']];
const leftKeySelector = (row) => row[0]; // 选择左表的第一列作为查找列
const rightKeySelector = (row) => row[0]; // 选择右表的第一列作为查找列
const resultSelector = (a, b) => a.concat(b); // 查找结果的选择器
const result = Array2D.z超级查找(arr, brr, leftKeySelector, rightKeySelector, resultSelector);
logjson(result);  // 输出查找结果数组
//输出结果
[[1,"A","",""],
[2,"B",2,"X"],
[3,"C",3,"Y"]]

superLookup(arr, brr, 左表列选择器, 右表列选择器, 双表结果选择器) → {Array}

说明:

• 这个函数用于对两个二维数组进行超级查找操作，并返回查找结果数组

别名:

• z超级查找

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 'A'], [2, 'B'], [3, 'C']];
const brr = [[2, 'X'], [3, 'Y'], [4, 'Z']];
const leftKeySelector = (row) => row[0]; // 选择左表的第一列作为查找列
const rightKeySelector = (row) => row[0]; // 选择右表的第一列作为查找列
const resultSelector = (a, b) => a.concat(b); // 查找结果的选择器
const result = Array2D.superLookup(arr, brr, leftKeySelector, rightKeySelector, resultSelector);
logjson(result);  // 输出查找结果数组
//输出结果
[[1,"A","",""],
[2,"B",2,"X"],
[3,"C",3,"Y"]]

z取前N个(arr, 个数) → {Array}

说明:

• 这个函数用于从二维数组中取前N个元素，并返回取到的结果数组

别名:

• take

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 2], [3, 4], [5, 6], [7, 8]];
const count = 2;
const result = Array2D.z取前N个(arr, count);
logjson(result);  // 输出取到的结果数组
//输出结果
[[1,2],
[3,4]]

take(arr, 个数) → {Array}

说明:

• 这个函数用于从二维数组中取前N个元素，并返回取到的结果数组

别名:

• z取前N个

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 2], [3, 4], [5, 6], [7, 8]];
const count = 2;
const result = Array2D.take(arr, count);
logjson(result);  
//输出结果
[[1,2],
[3,4]]

z取前面连续不满足(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于从二维数组中取前面连续不满足条件的元素，并返回取到的结果数组

别名:

• takeUntil

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 2], [3, 4], [5, 6], [7, 8]];
const conditionCallback = (element) => element[0] > 3; // 判断元素的第一个值是否大于3
const result = Array2D.z取前面连续不满足(arr, conditionCallback);
logjson(result);  // 输出取到的结果数组
//输出结果
[[1,2],
[3,4]]

takeUntil(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于从二维数组中取前面连续不满足条件的元素，并返回取到的结果数组

别名:

• z取前面连续不满足

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 2], [3, 4], [5, 6], [7, 8]];
const conditionCallback = (element) => element[0] > 3; // 判断元素的第一个值是否大于3
const result = Array2D.takeUntil(arr, conditionCallback);
logjson(result);  // 输出取到的结果数组
//输出结果
[[1,2],
[3,4]]

z取前面连续满足(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于从二维数组中取前面连续满足条件的元素，并返回取到的结果数组

别名:

• takeWhile

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 2], [3, 4], [5, 6], [7, 8]];
const conditionCallback = (element) => element[0] > 3; // 判断元素的第一个值是否大于3
const result = Array2D.z取前面连续满足(arr, conditionCallback);
console.log(result); // 输出取到的结果数组

takeWhile(arr, 条件回调函数) → {Array}

说明:

• 这个函数用于从二维数组中取前面连续满足条件的元素，并返回取到的结果数组

别名:

• z取前面连续满足

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 2], [3, 4], [5, 6], [7, 8]];
const conditionCallback = (element) => element[0] > 3; // 判断元素的第一个值是否大于3
const result = Array2D.takeWhile(arr, conditionCallback);
console.log(result); // 输出取到的结果数组

z多次遍历执行(arr, 个数, 条件回调函数) → {*}

说明:

• 这个函数用于多次遍历执行二维数组的每个子数组，并返回执行结果

别名:

• times

参数列表:

返回值:

Type

*

例子

const arr = [[1, 2], [3, 4], [5, 6]];
const count = 3;
const conditionCallback = (subArray) => subArray[0] * 2; // 对每个子数组的第一个元素进行乘以2的操作
const result = Array2D.z多次遍历执行(arr, count, conditionCallback);
console.log(result); // 输出执行结果

times(arr, 个数, 条件回调函数) → {*}

说明:

• 这个函数用于多次遍历执行二维数组的每个子数组，并返回执行结果

别名:

• z多次遍历执行

参数列表:

返回值:

Type

*

例子

const arr = [[1, 2], [3, 4], [5, 6]];
const count = 3;
const conditionCallback = (subArray) => subArray[0] * 2; // 对每个子数组的第一个元素进行乘以2的操作
const result = Array2D.times(arr, count, conditionCallback);
console.log(result); // 输出执行结果

z转数组(arr) → {Array}

说明:

• 这个函数用于将二维数组转换为数组，并返回转换后的结果

别名:

• toArray

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 2], [3, 4], [5, 6]];
const result = Array2D.z转数组(arr);
logjson(result);  // 输出转换后的结果数组
//输出结果
[[1,2],
[3,4],
[5,6]]

toArray(arr) → {Array}

说明:

• 这个函数用于将二维数组转换为数组，并返回转换后的结果

别名:

• z转数组

参数列表:

返回值:

Type

Array

z转JSON字符串(arr) → {String}

说明:

• 这个函数用于将二维数组转换为JSON字符串，并返回转换后的结果

别名:

• toJson

参数列表:

返回值:

Type

String

例子

const arr = [[1, 2], [3, 4], [5, 6]];
const result = Array2D.z转JSON字符串(arr);
console.log(result); // 输出转换后的结果字符串
//输出结果
[[1,2],
[3,4],
[5,6]]

toJson(arr) → {String}

说明:

• 这个函数用于将二维数组转换为JSON字符串，并返回转换后的结果

别名:

• z转JSON字符串

参数列表:

返回值:

Type

String

例子

const arr = [[1, 2], [3, 4], [5, 6]];
const result = Array2D.toJson(arr);
console.log(result); // 输出转换后的结果字符串
//输出结果
[[1,2],
[3,4],
[5,6]]

z转字符串(arr) → {String}

说明:

• 这个函数用于将二维数组转换为字符串，并返回转换后的结果

别名:

• toString

参数列表:

返回值:

Type

String

例子

const arr = [[1, 2], [3, 4], [5, 6]];
const result = Array2D.z转字符串(arr);
console.log(result); // 输出转换后的结果字符串
//输出结果
1,2,3,4,5,6

toString(arr) → {String}

说明:

• 这个函数用于将二维数组转换为字符串，并返回转换后的结果

别名:

• z转字符串

参数列表:

返回值:

Type

String

例子

const arr = [[1, 2], [3, 4], [5, 6]];
const result = Array2D.toString(arr);
console.log(result); // 输出转换后的结果字符串
//输出结果
1,2,3,4,5,6

z去重并集(arr, brr) → {Array}

说明:

• 这个函数用于对两个二维数组进行去重并集操作，并返回操作后的结果数组

别名:

• union

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var brr = [[3, 4], [1, 8], [9, 10]];
//二维数组上下合并后 按整行去重
var result = Array2D.z去重并集(arr, brr);
logjson(result);
//输出结果
[[1,2],
[3,4],
[5,6],
[1,8],
[9,10]]
//按首列去重
var result = Array2D.z去重并集(arr, brr,x=>x[0]);
logjson(result);
//输出结果
[[1,2],
[3,4],
[5,6],
[9,10]]

union(arr, brr) → {Array}

说明:

• 这个函数用于对两个二维数组进行去重并集操作，并返回操作后的结果数组

别名:

• z去重并集

参数列表:

返回值:

Type

Array

例子

var arr = [[1, 2], [3, 4], [5, 6]];
var brr = [[3, 4], [1, 8], [9, 10]];
//二维数组上下合并后 按整行去重
var result = Array2D.union(arr, brr);
logjson(result);
//输出结果
[[1,2],
[3,4],
[5,6],
[1,8],
[9,10]]
//按首列去重
var result = Array2D.union(arr, brr,x=>x[0]);
logjson(result);
//输出结果
[[1,2],
[3,4],
[5,6],
[9,10]]

z左右连接(arr, brr) → {Array}

说明:

• 这个函数用于对两个二维数组进行左右连接操作，并返回操作后的结果数组

别名:

• zip

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 'A'], [2, 'B'], [3, 'C']];
const brr = [[2, 'X'], [3, 'Y'], [4, 'Z']];
const result = Array2D.z左右连接(arr, brr);
logjson(result);  // 输出左右连接操作后的结果数组
//输出结果
[[1,"A",2,"X"],
[2,"B",3,"Y"],
[3,"C",4,"Z"]]

zip(arr, brr) → {Array}

说明:

• 这个函数用于对两个二维数组进行左右连接操作，并返回操作后的结果数组

别名:

• z左右连接

参数列表:

返回值:

Type

Array

例子

const arr = [[1, 'A'], [2, 'B'], [3, 'C']];
const brr = [[2, 'X'], [3, 'Y'], [4, 'Z']];
const result = Array2D.zip(arr, brr);
logjson(result);   // 输出左右连接操作后的结果数组
//输出结果
[[1,"A",2,"X"],
[2,"B",3,"Y"],
[3,"C",4,"Z"]]