Array2D

命名空间

Array2D

说明:
  • 一行代码完成二维数组筛选及分类汇总 一行代码完成行列批量操作 甚至是按某个区域批量操作
作者:
  • 郑广学 2023.9.30 微信EXCEL880B 公众号EXCEL880 官网vbayyds.com 淘宝店 郑广学工作室
别名:
  • z二维数组

函数:

version() → {String}

说明:
  • 这个函数用于返回Array2D函数库版本号
返回值:
返回当前版本号
Type
String
例子
console.log(Array2D.version()); //输出 1.8.3 版本升级版本号会增加 最新版可到教学群回复 案例文件
//输出结果
Array2D 1.8.3 作者郑广学 网址vbayyds.com

z克隆(arr) → {Array}

说明:
  • 这个函数用于复制数组
别名:
  • copy
参数列表:
参数名称 参数类型 备注
arr Array 数组
返回值:
复制后数组 再修改复制后的数组不改变原数组
Type
Array
例子
//示例1
var arr = [[1,2,3],[4,5,6],[7,8,9]];
var brr=Array2D.z克隆(arr);
logjson(brr); // 输出复制后的数组
//输出结果
[[1,2,3],
 [4,5,6],
 [7,8,9]]
//示例2
brr[1][0]=999;
logjson(brr,0);  //修改brr后, arr不变
logjson(arr,0);
//输出结果
[[1,2,3],[999,5,6],[7,8,9]]  //brr修改
[[1,2,3],[4,5,6],[7,8,9]]    //arr不变

copy(arr) → {Array}

说明:
  • 这个函数用于复制数组
别名:
  • z克隆
参数列表:
参数名称 参数类型 备注
arr Array 数组
返回值:
复制后数组 再修改复制后的数组不改变原数组
Type
Array
例子
//示例1
var arr = [[1,2,3],[4,5,6],[7,8,9]];
var brr=Array2D.copy(arr);
logjson(brr); // 输出复制后的数组
//输出结果
[[1,2,3],
 [4,5,6],
 [7,8,9]]
//示例2
brr[1][0]=999;
logjson(brr,0);  //修改brr后, arr不变
logjson(arr,0);
//输出结果
[[1,2,3],[999,5,6],[7,8,9]]  //brr修改
[[1,2,3],[4,5,6],[7,8,9]]    //arr不变

z解析函数表达式(函数表达式) → {function}

说明:
  • 这个函数用于解析函数表达式
别名:
  • parseLambda
参数列表:
参数名称 参数类型 备注
函数表达式 function
返回值:
解析后的函数表达式
Type
function
例子
//输出结果

parseLambda(函数表达式) → {function}

说明:
  • 这个函数用于解析函数表达式
别名:
  • z解析函数表达式
参数列表:
参数名称 参数类型 备注
函数表达式 function
返回值:
解析后的函数表达式
Type
function
例子
//输出结果

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

说明:
  • 这个函数用于计算指定列的平均值
别名:
  • average
参数列表:
参数名称 参数类型 备注
arr Array 数组
列选择函数 function 选择要计算平均值的列 或 列回调函数 (row) => 回调函数
返回值:
平均值
Type
Number
例子
//示例1  字符串简写模式
var arr = [[1,2,3],[4,5,6],[7,8,9]];
var average =Array2D.z平均值(arr, 'f1');  //选择实际一维数组的第一个元素(第一列) 
console.log(average); // 输出平均值
//输出结果
4
//示例2  列回调函数
var arr = [[1,2,3],[4,5,6],[7,6,9]];
var average =Array2D.z平均值(arr, r=>r[1]);//实际数组第二列
console.log(average); // 输出平均值
//输出结果
4.333333333333333

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

说明:
  • 这个函数用于计算指定列的平均值
别名:
  • z平均值
参数列表:
参数名称 参数类型 备注
arr Array 数组
列选择函数 function 选择要计算平均值的列 或 列回调函数 (row) => 回调函数
返回值:
平均值
Type
Number
例子
//示例1  字符串简写模式
var arr = [[1,2,3],[4,5,6],[7,8,9]];
var average =Array2D.average(arr, 'f1');  //选择实际一维数组的第一个元素(第一列) 
console.log(average); // 输出平均值
//输出结果
4
//示例2  列回调函数
var arr = [[1,2,3],[4,5,6],[7,6,9]];
var average =Array2D.average(arr, r=>r[1]);//实际数组第二列
console.log(average); // 输出平均值
//输出结果
4.333333333333333

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

说明:
  • 这个函数用于将两个或者多个数组按行连接
别名:
  • concat
参数列表:
参数名称 参数类型 备注
arr Array 第一个数组
brr Array 第二个数组 或者是多个数组 依次传递 嵌套的二维数组用 ...args
返回值:
连接后的数组
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上下连接
参数列表:
参数名称 参数类型 备注
arr Array 第一个数组
brr Array 第二个数组 或者是多个数组 依次传递 嵌套的二维数组用 ...args
返回值:
连接后的数组
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.concat(arr, brr);
logjson(result);
//输出结果
[[1,2,3],
[4,5,6],
[7,8,9],
[11,22,33],
[44,55,66],
[7,8,9]]

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

说明:
  • 这个函数用于将数组复制到指定位置
别名:
  • copyWithin
参数列表:
参数名称 参数类型 备注
arr Array 数组
返回值:
复制后的二维数组
Type
Array
例子
//示例1
var arr = [1, 2, 3, 4, 5];
var result = Array2D.z复制到指定位置(arr);
logjson(result,0); // 输出复制后的数组
//输出结果
[[1],[2],[3],[4],[5]]
//示例2
var arr =  [[1, 2, 3],[4, 5, 6],[7 ,8 , 9]];
var result = Array2D.z复制到指定位置(arr,2,1);
logjson(result,0);// 输出复制后的数组
//输出结果
[[1,2,3],[4,5,6],[4,5,6]]

copyWithin(arr) → {Array}

说明:
  • 这个函数用于将数组复制到指定位置
别名:
  • z复制到指定位置
参数列表:
参数名称 参数类型 备注
arr Array 数组
返回值:
复制后的二维数组
Type
Array
例子
//示例1
var arr = [1, 2, 3, 4, 5];
var result = Array2D.copyWithin(arr);
logjson(result,0); // 输出复制后的数组
//输出结果
[[1],[2],[3],[4],[5]]
//示例2
var arr =  [[1, 2, 3],[4, 5, 6],[7 ,8 , 9]];
var result = Array2D.copyWithin(arr,2,1);
logjson(result,0);// 输出复制后的数组
//输出结果
[[1,2,3],[4,5,6],[4,5,6]]

z数量(arr) → {Number}

说明:
  • 这个函数用于计算数组元素的数量, 如果是二维数组则为行数
别名:
  • count
参数列表:
参数名称 参数类型 备注
arr Array 数组
返回值:
数组元素的数量, 如果是二维数组则为行数
Type
Number
例子
//示例1
var arr = [[1,2],[3,4]];
var result = Array2D.z数量(arr);
console.log(result); // 输出数组行数 2
//输出结果
2
//示例2
var arr = [1, 2, 3, 4, 5];
var result = Array2D.z数量(arr);
console.log(result); // 输出数组元素的数量
//输出结果
5

count(arr) → {Number}

说明:
  • 这个函数用于计算数组元素的数量, 如果是二维数组则为行数
别名:
  • z数量
参数列表:
参数名称 参数类型 备注
arr Array 数组
返回值:
数组元素的数量, 如果是二维数组则为行数
Type
Number
例子
//示例1
var arr = [[1,2],[3,4]];
var result = Array2D.count(arr);
console.log(result); // 输出数组行数 2
//输出结果
2
//示例2
var arr = [1, 2, 3, 4, 5];
var result = Array2D.count(arr);
console.log(result); // 输出数组元素的数量
//输出结果
5

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

说明:
  • 这个函数用于计算两个数组的笛卡尔积
别名:
  • crossjoin
参数列表:
参数名称 参数类型 备注
arr Array 第一个数组
brr Array 第二个数组
返回值:
笛卡尔积二维数组
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笛卡尔积
参数列表:
参数名称 参数类型 备注
arr Array 第一个数组
brr Array 第二个数组
返回值:
笛卡尔积二维数组
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
参数列表:
参数名称 参数类型 备注
arr Array 数组
列号数组 Array 要删除的列号数组 传空字符串则代表删除空行
返回值:
删除指定列后的数组
Type
Array
例子
//示例1
var arr = [[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9],
           ['a','b','c']];
var result = Array2D.z批量删除列(arr, [0, 2]);//删除实际数组的第1列和第3列
logjson(result);
//输出结果
[[2],
 [5],
 [8],
 ["b"]]
//示例2
var result = Array2D.z批量删除列(arr, 'f3');//删除实际数组的第3列 以f数字形式按1数列
logjson(result);
//输出结果
[[1,2],
 [4,5],
 [7,8],
 ["a","b"]]

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

说明:
  • 这个函数用于批量删除指定列
别名:
  • z批量删除列
参数列表:
参数名称 参数类型 备注
arr Array 数组
列号数组 Array 要删除的列号数组 传空字符串则代表删除空行
返回值:
删除指定列后的数组
Type
Array
例子
//示例1
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"]]
//示例2
var result = Array2D.deleteCols(arr, 'f3');//删除实际数组的第3列 以f数字形式按1数列
logjson(result);
//输出结果
[[1,2],
 [4,5],
 [7,8],
 ["a","b"]]

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

说明:
  • 这个函数用于批量删除指定行
别名:
  • deleteRows
参数列表:
参数名称 参数类型 备注
arr Array 数组
行号数组 Array 要删除的行号数组 传空字符串则代表删除空行
返回值:
删除指定行后的数组
Type
Array
例子
//示例1
var arr = [[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9],
           ['a','b','c']];
var 行号数组 = [1, 2];  //实际数组的第2,3行
var result = Array2D.z批量删除行(arr, 行号数组);
logjson(result); // 输出删除指定行后的数组
//输出结果
[[1,2,3],
["a","b","c"]]
//示例2
var result = Array2D.z批量删除行(arr, 'f2-f4');//删除实际数组的第2到第4行 只留下第一行
logjson(result); 
//输出结果
[[1,2,3]]

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

说明:
  • 这个函数用于批量删除指定行
别名:
  • z批量删除行
参数列表:
参数名称 参数类型 备注
arr Array 数组
行号数组 Array 要删除的行号数组
返回值:
删除指定行后的数组
Type
Array
例子
//示例1
var arr = [[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9],
           ['a','b','c']];
var 行号数组 = [1, 2];  //实际数组的第2,3行
var result = Array2D.deleteRows(arr, 行号数组);
logjson(result); // 输出删除指定行后的数组
//输出结果
[[1,2,3],
["a","b","c"]]
//示例2
var result = Array2D.deleteRows(arr, 'f2-f4');//删除实际数组的第2到第4行 只留下第一行
logjson(result); 
//输出结果
[[1,2,3]]

z去重(arr, col, resultSelector) → {Array}

说明:
  • 这个函数用于去除数组中的重复元素
别名:
  • distinct
参数列表:
参数名称 参数类型 备注
arr Array 数组
col any 列选择器 也可以接受map型回调函数 (row) => 回调函数 不指定则按全部列去重
resultSelector any 结果列选择器, 相当于再跟一个selectCols,''代表返回所有列 默认返回按关键字列
返回值:
去重后的数组
Type
Array
例子
//示例1  按全部列去重
var arr =[[1, 2, 3],
          [1, 2, 6],
          [1, 2, 3],
          ['a','b','c']];
var result = Array2D.z去重(arr);   //全部列去重
logjson(result);
//输出结果
[[1,2,3],
 [1,2,6],
 ["a","b","c"]]
//示例2   
var result = Array2D.z去重(arr,'f1,f2');   
     //按列号去重  按实际数组第1,第2列   结果同列选择器：实际数组第1,第2列
logjson(result); // 输出去重后的数组
//输出结果
[[1,2],
 ["a","b"]]
//示例3   
var result = Array2D.z去重(arr,row=>row[0],'');  //回调函数 按实际数组第1列去重  '': 返回所有列
logjson(result); 
//输出结果
[[1,2,3],
 ["a","b","c"]]

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

说明:
  • 这个函数用于去除数组中的重复元素
别名:
  • z去重
参数列表:
参数名称 参数类型 备注
arr Array 数组
col any 列选择器 也可以接受map型回调函数 (row) => 回调函数 不指定则按全部列去重
resultSelector any 结果列选择器 返回那些列 相当于再跟一个selectCols ''代表：返回所有列 默认按列选择器的列
返回值:
去重后的数组
Type
Array
例子
//示例1  按全部列去重
var arr =[[1, 2, 3],
          [1, 2, 6],
          [1, 2, 3],
          ['a','b','c']];
var result = Array2D.distinct(arr);   //全部列去重
logjson(result);
//输出结果
[[1,2,3],
 [1,2,6],
 ["a","b","c"]]
//示例2   
var result = Array2D.distinct(arr,'f1,f2');   
     //按列号去重  按实际数组第1,第2列   结果同列选择器：实际数组第1,第2列
logjson(result); // 输出去重后的数组
//输出结果
[[1,2],
 ["a","b"]]
//示例3   
var result = Array2D.distinct(arr,row=>row[0],'');  //回调函数 按实际数组第1列去重  '': 返回所有列
logjson(result); 
//输出结果
[[1,2,3],
 ["a","b","c"]]

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

说明:
  • 这个函数用于判断数组中的所有元素是否都满足给定的条件
别名:
  • every
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调函数 function 用于判断元素是否满足条件的回调函数 element => 回调
返回值:
是否所有元素都满足条件
Type
Boolean
例子
var arr = [1, 2, 3, 4, 5];
var result = Array2D.z全部满足(arr, element => element > 0); // 判断元素是否大于0
console.log(result); // 输出是否所有元素都满足条件
//输出结果
true

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

说明:
  • 这个函数用于判断数组中的所有元素是否都满足给定的条件
别名:
  • z全部满足
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调函数 function 用于判断元素是否满足条件的回调函数 element => 回调
返回值:
是否所有元素都满足条件
Type
Boolean
例子
var arr = [1, 2, 3, 4, 5];
var conditionCallback = (element) => element > 0; // 判断元素是否大于0
var result = Array2D.every(arr, conditionCallback);
console.log(result); // 输出是否所有元素都满足条件
//输出结果
true

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

说明:
  • 这个函数用于从左表中排除与右表中相同的元素
别名:
  • except
参数列表:
参数名称 参数类型 备注
arr Array 左表数组
brr Array 右表数组
左表列选择器 function 左表比较列 或回调 (row) => 回调函数 默认: 全部列
右表列选择器 function 右表比较列 或回调 (row) => 回调函数 默认: 全部列
返回值:
排除相同后的数组
Type
Array
例子
//示例1   按全部列比较
var arr = [[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9],
           ['a','b','c']];
var brr = [[1, 2, 3],
           [7, 5, 9]];
var result = Array2D.z排除(arr,brr);      //按全部列比较 只有1,2,3这行与arr中相同被排除
logjson(result);
//输出结果
[[4,5,6],
 [7,8,9],
 ["a","b","c"]]
//示例2   按指定列比较
var result = Array2D.z排除(arr,brr,a=>a[2],b=>b[2]);   //按实际数组第3列比较 第1,3行被排除
logjson(result); // 输出排除后的数组
//输出结果
[[4,5,6],
 ["a","b","c"]]

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

说明:
  • 这个函数用于从左表中排除与右表中相同的元素
别名:
  • z排除
参数列表:
参数名称 参数类型 备注
arr Array 左表数组
brr Array 右表数组
左表列选择器 function 左表比较列 或回调 (row) => 回调函数 默认: 全部列
右表列选择器 function 右表比较列 或回调 (row) => 回调函数 默认: 全部列
返回值:
排除相同后的数组
Type
Array
例子
//示例1   按全部列比较
var arr = [[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9],
           ['a','b','c']];
var brr = [[1, 2, 3],
           [7, 5, 9]];
var result = Array2D.except(arr,brr);   //按全部列比较 只有1,2,3这行与arr中相同被排除
logjson(result);
//输出结果
[[4,5,6],
 [7,8,9],
 ["a","b","c"]]
//示例2   按指定列比较
var result = Array2D.except(arr,brr,a=>a[2],b=>b[2]);  //按实际数组第3列比较 第1,3行被排除
logjson(result); // 输出排除后的数组
//输出结果
[[4,5,6],
 ["a","b","c"]]

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

说明:
  • 这个函数用于批量填充数组的所有元素为指定值
别名:
  • fill
参数列表:
参数名称 参数类型 备注
arr Array 数组
值 * 要填充的值
返回值:
填充后的数组
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批量填充
参数列表:
参数名称 参数类型 备注
arr Array 数组
值 * 要填充的值
返回值:
填充后的数组
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}

说明:
  • 这个函数用于数组按方向位置的值补齐空白
别名:
  • fillBlank
参数列表:
参数名称 参数类型 备注
arr Array 数组
方向: string u,d,l,r 上,下,左,右
返回值:
补齐后的数组 注意原数组也一起改动!
Type
Array
例子
var arr = [[4,5,6,7],[1, 2, "",""],[7,8,9,8]];
var brr=Array2D.z补齐空位(arr,"u"); //按上补齐结果
logjson(brr); //输出补齐后的结果  同时 arr也是这个结果
//输出结果
[[4,5,6,7],
 [1,2,6,7],
 [7,8,9,8]]

fillBlank(arr, 方向:) → {Array}

说明:
  • 这个函数用于数组按方向位置的值补齐空白
别名:
  • z补齐空位
参数列表:
参数名称 参数类型 备注
arr Array 数组
方向: string u,d,l,r 上,下,左,右
返回值:
补齐后的数组 注意原数组也一起改动!
Type
Array
例子
var arr = [[4,5,6,7],[1, 2, "",""],[7,8,9,8]];
var brr=Array2D.fillBlank(arr,"u"); //按上补齐结果
logjson(brr); //输出补齐后的结果  同时arr也是这个结果
//输出结果
[[4,5,6,7],
 [1,2,6,7],
 [7,8,9,8]]

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

说明:
  • 这个函数用于根据指定的条件筛选数组的元素
别名:
  • filter
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调 function 用于判断元素是否满足条件的回调函数 (element) => 回调
header Number 忽略表头行数 默认为0
返回值:
筛选后的数组
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, 条件回调函数, header) → {Array}

说明:
  • 这个函数用于根据指定的条件筛选数组的元素
别名:
  • z筛选
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调函数 function 用于判断元素是否满足条件的回调函数 (element) => 回调
header Number 忽略表头行数 默认为0
返回值:
筛选后的数组
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
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调 function 用于判断元素是否满足条件的回调函数 (element) => 回调
返回值:
查找到的单个元素
Type
Object
例子
//示例1
var arr = [1, 2, 3, 4, 5];
var conditionCallback = (element) => element > 2; // 判断元素是否大于2
var result = Array2D.z查找单个(arr, conditionCallback);
logjson(result); // 输出查找到的单个元素
//输出结果
[3]
//示例2
var arr = [[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9],
           ['a','b','c']];  
var result = Array2D.z查找单个(arr, row=>row[0]>2);  //实际数组第1列>2
logjson(result);// 输出查找到的单个元素
//输出结果
[4,5,6]

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

说明:
  • 这个函数用于在数组中查找满足条件的单个元素
别名:
  • z查找单个
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调 function 用于判断元素是否满足条件的回调函数 (element) => 回调
返回值:
查找到的单个元素
Type
Object
例子
//示例1
var arr = [1, 2, 3, 4, 5];
var conditionCallback = (element) => element > 2; // 判断元素是否大于2
var result = Array2D.find(arr, conditionCallback);
logjson(result); // 输出查找到的单个元素
//输出结果
[3]
//示例2
var arr = [[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9],
           ['a','b','c']];  
var result = Array2D.find(arr, row=>row[0]>2);  //实际数组第1列>2
logjson(result);// 输出查找到的单个元素
//输出结果
[4,5,6]

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

说明:
  • 这个函数用于在数组中查找满足条件的所有元素的下标
别名:
  • findAllIndex
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调 function 用于判断元素是否满足条件的回调函数 (element) => 回调
返回值:
查找所有满足条件的元素行列下标数组,每一行是一个数组[行,列] 没找到返回 []
Type
Array
例子
//示例 
var arr = [[1, 2],
		  [4, 5],
		  [7, 8,],
		  ['a','b','c']];
var result = Array2D.z查找所有下标(arr, x=>x>5);  //判断元素是否大于5
logjson(result,0);  // 输出查找到的所有元素的下标
//输出结果
//[[2,0],[2,1]] //返回找到值的行列坐标数组

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

说明:
  • 这个函数用于在数组中查找满足条件的所有元素的下标
别名:
  • z查找所有下标
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调 function 用于判断元素是否满足条件的回调函数 (element) => 回调
返回值:
查找所有满足条件的元素行列下标数组,每一行是一个数组[行,列] 没找到返回 []
Type
Array
例子
//示例 
var arr = [[1, 2],
		  [4, 5],
		  [7, 8,],
		  ['a','b','c']];
var result = Array2D.z查找所有下标(arr, x=>x>5);  //判断元素是否大于5
logjson(result,0);  // 输出查找到的所有元素的下标
//输出结果
//[[2,0],[2,1]] //返回找到值的行列坐标数组

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

说明:
  • 这个函数用于在数组中查找指定列所有符合条件的行下标
别名:
  • findRowsIndex
参数列表:
参数名称 参数类型 备注
arr Array 数组
按行条件回调 function 查找条件 或回调 (row) => 回调函数
返回值:
返回所有符合条件的行下标的一维数组
Type
Array
例子
//示例1:
var arr=[[7,8,9],[0,5,3],[1,2,3],[4,5,6]];
var result=Array2D.z查找所有行下标(arr,x=>x[0]>3 && x[0]<8); //查找数组实际第1列符合条件的行下标
logjson(result); // 输出所有符合条件的行下标的一维数组
//输出结果
[0,3]

findRowsIndex(arr, 按行条件回调) → {Array}

说明:
  • 这个函数用于在数组中查找指定列所有符合条件的行下标
别名:
  • z查找所有行下标
参数列表:
参数名称 参数类型 备注
arr Array 数组
按行条件回调 function 查找条件 或回调 (row) => 回调函数
返回值:
返回所有符合条件的行下标的一维数组
Type
Array
例子
//示例1:
var arr=[[7,8,9],[0,5,3],[1,2,3],[4,5,6]];
var result=Array2D.z查找所有行下标(arr,x=>x[0]>3 && x[0]<8); //查找数组实际第1列符合条件的行下标
logjson(result); // 输出所有符合条件的行下标的一维数组
//输出结果
[0,3]

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

说明:
  • 这个函数用于在数组中查找指定行所有符合条件的列下标
别名:
  • findColsIndex
参数列表:
参数名称 参数类型 备注
arr Array 数组
按列条件回调 function 查找条件 (c) => 回调函数
返回值:
返回所有符合条件的列下标的一维数组
Type
Array
例子
var arr=[[1,"Product1","中国",19,2,2023,10,10],
         [2,"Product2","德国",22,5,2023,4,5],
         ["ID","产品","国家","数量","价格","年","月","日"],
         [3,"Product2","英国",25,5,2022,6,28]];
var result=Array2D.z查找所有列下标(arr,c=>(["产品","国家","年"]).includes(c[2])); //查找数组第3行包含指定内容的列
logjson(result); // 输出所有符合条件的列下标的一维数组
//输出结果
[1,2,5]

findColsIndex(arr, 按列条件回调) → {Array}

说明:
  • 这个函数用于在数组中查找指定行所有符合条件的列下标
别名:
  • z查找所有列下标
参数列表:
参数名称 参数类型 备注
arr Array 数组
按列条件回调 function 查找条件 (c) => 回调函数
返回值:
返回所有符合条件的列下标的一维数组
Type
Array
例子
var arr=[[1,"Product1","中国",19,2,2023,10,10],
         [2,"Product2","德国",22,5,2023,4,5],
         ["ID","产品","国家","数量","价格","年","月","日"],
         [3,"Product2","英国",25,5,2022,6,28]];
var result=Array2D.z查找所有列下标(arr,c=>(["产品","国家","年"]).includes(c[2])); //查找数组第3行包含指定内容的列
logjson(result); // 输出所有符合条件的列下标的一维数组
//输出结果
[1,2,5]

z查找元素下标(arr, 条件回调) → {Number}

说明:
  • 这个函数用于在数组中查找元素的下标
别名:
  • findIndex
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调 function 查找条件 (element) => 回调
返回值:
返回符合条件的下标
Type
Number
例子
var arr=["ID","产品","国家","数量","价格","年","月","日"];
var result=Array2D.z查找元素下标(arr,r=>"年"==r);  
logjson(result);
//输出结果
5

findIndex(arr, 条件回调) → {Number}

说明:
  • 这个函数用于在数组中查找元素的下标
别名:
  • z查找元素下标
参数列表:
参数名称 参数类型 备注
arr Array 数组
条件回调 function 查找条件 (element) => 回调
返回值:
返回符合条件的下标
Type
Number
例子
var arr=["ID","产品","国家","数量","价格","年","月","日"];
var result=Array2D.findIndex(arr,r=>"年"==r);  
logjson(result);
//输出结果
5

z第一个(arr, 条件回调函数, 默认值) → {Array}

说明:
  • 这个函数用于获取二维数组中满足条件的第一个子数组，如果没有满足条件的子数组或空，则返回默认值
别名:
  • first
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 用于判断子数组是否满足条件的回调函数 (row) => 回调函数
默认值 * 默认值第一个数组
返回值:
满足条件的第一个子数组或默认的第一个数组 二维数组
Type
Array
例子
//示例1 默认值 第一个数组
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z第一个(arr);
logjson(result); // 输出满足条件的第一个子数组或默认的第一个数组 二维数组
//输出结果
[[1,2]]
//示例2 条件回调
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);  // 输出满足条件的第一个子数组或默认值  二维数组
//输出结果
[[3,4]]

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

说明:
  • 这个函数用于获取二维数组中满足条件的第一个子数组，如果没有满足条件的子数组或空，则返回默认值
别名:
  • z第一个
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 用于判断子数组是否满足条件的回调函数 (row) => 回调函数
默认值 * 默认值第一个数组
返回值:
满足条件的第一个子数组或默认的第一个数组 二维数组
Type
Array
例子
//示例1 默认值 第一个数组
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.first(arr);
logjson(result); // 输出满足条件的第一个子数组或默认的第一个数组 二维数组
//输出结果
[[1,2]]
//示例2  条件回调
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
深度 number 降维的深度，默认为1
返回值:
重组后的二维数组
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降维
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
深度 number 降维的深度，默认为1
返回值:
重组后的二维数组
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 用于执行每个子数组的回调函数 (row) => 回调函数
返回值:
执行结果组成的数组
Type
Array
例子
//示例1
var brr = [[1, 2], [3, 4], [5, 6]];    
Array2D.z遍历执行(brr, row=>{
     console.log(row[0]*2);         //对每行的第1列*2输出
});
//输出结果
2
6
10
//示例2   for each回调完整形态也可以写回数据
var brr = [[1, 2], [3, 4], [5, 6]];  
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遍历执行
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 用于执行每个子数组的回调函数 (row) => 回调函数
返回值:
执行结果组成的数组
Type
Array
例子
//示例1
var brr = [[1, 2], [3, 4], [5, 6]];    
Array2D.forEach(brr, row=>{
     console.log(row[0]*2);         //对每行的第1列*2输出
});
//输出结果
2
6
10
//示例2   for each回调完整形态也可以写回数据
var brr = [[1, 2], [3, 4], [5, 6]];  
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 每个子数组回调函数 (row) => 回调函数 回调函数中return有结果且是false时中途退出循环
返回值:
返回原数组
Type
Array
例子
//示例1
var brr = [[1, 2], [3, 4], [5, 6]]; 
var crr=[];  
var rs=Array2D.z倒序遍历执行(brr, row=>{
	console.log(row[0]*2);        //对每行的第一列*2输出 注意输出的顺序
	crr.push(row[0]*2); //倒序添加实际数组第1列*2
});  //返回原数组
logjson(crr,0);  //倒序过程中添加的数组
logjson(rs,0);   //返回原数组
//输出结果  中间过程
10
6
2
//输出结果  倒序过程中添加的数组
[10,6,2]
//输出结果  返回原数组
[[1,2],[3,4],[5,6]]
//示例2
var brr = [[1, 2], [5, 6], [3, 4]]; 
var crr=[];
Array2D.z倒序遍历执行(brr,r=>{
	crr.push(r[0]);  //倒序添加实际数组第1列
	return r[0]<5;   //当实际数组第1列>5时, 则退出循环
})
logjson(crr,0);  //倒序添加的数组
//输出结果
[3,5]

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

说明:
  • 这个函数用于倒序遍历执行二维数组的每个子数组，返回原数组
别名:
  • z倒序遍历执行
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 每个子数组回调函数 (row) => 回调函数 回调函数中return有结果且是false时中途退出循环
返回值:
返回原数组
Type
Array
例子
//示例1
var brr = [[1, 2], [3, 4], [5, 6]]; 
var crr=[];  
var rs=Array2D.forEachRev(brr, row=>{
	console.log(row[0]*2);        //对每行的第一列*2输出 注意输出的顺序
	crr.push(row[0]*2); //倒序添加实际数组第1列*2
});  //返回原数组
logjson(crr,0);  //倒序过程中添加的数组
logjson(rs,0);   //返回原数组
//输出结果  中间过程
10
6
2
//输出结果  倒序过程中添加的数组
[10,6,2]
//输出结果  返回原数组
[[1,2],[3,4],[5,6]]
//示例2
var brr = [[1, 2], [5, 6], [3, 4]]; 
var crr=[];
Array2D.forEachRev(brr,r=>{
	crr.push(r[0]);  //倒序添加实际数组第1列
	return r[0]<5;   //当实际数组第1列>5时, 则退出循环
})
logjson(crr,0);  //倒序添加的数组
//输出结果
[3,5]

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

说明:
  • 这个函数用于对两个二维数组进行左右全连接操作，并返回连接后的二维结果数组
别名:
  • fulljoin
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组
左表列选择器 function 左表中要连接列(0下标列或f列模式) 或 回调函数 (row) => 回调函数
右表列选择器 function 右表中要连接列(0下标列或f列模式) 或 回调函数 (row) => 回调函数
结果选择器 function 连接后的结果选择器的回调函数，默认为(a, b) => a.concat(b)
返回值:
左表与右表指定列匹配后连接的二维结果数组
Type
Array
例子
//示例1
var arr = [[1, 'A'],
           [2, 'B'],
           [3, 'C']];
var brr = [[2, 'B'],
           [3, 'Y'], 
           [4, 'Z']];
var result = Array2D.z左右全连接(arr, brr, 'f1', 'f1');  //f列模式
logjson(result,0);
//输出结果  二维数组
[[1,"A","",""],
 [2,"B",2,"B"],
 [3,"C",3,"Y"],
 ["","",4,"Z"]]
//示例2
var result = Array2D.z左右全连接(arr, brr, 0, 0);  //0下标列
输出结果与上面相同
var result = Array2D.z左右全连接(arr, brr, r=>r[0], r=>r[0]); //回调模式
//输出结果与上面相同
//示例3    结果选择集可以用完整箭头函数: (a,b)=>a.concat(b)
var result = Array2D.z左右全连接(arr, brr, 'f2', 'f2','a.f1,b.f2');  //自定义结果选择集
logjson(result,0);
//输出结果   二维数组  自定义结果选择集
[[1,""],
 [2,"B"],
 [3,""],
 ["","Y"],
 ["","Z"]]

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

说明:
  • 这个函数用于对两个二维数组进行左右全连接操作，并返回连接后的二维结果数组
别名:
  • z左右全连接
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组
左表列选择器 function 左表中要连接列(0下标列或f列模式) 或 回调函数 (row) => 回调函数
右表列选择器 function 右表中要连接列(0下标列或f列模式) 或 回调函数 (row) => 回调函数
结果选择器 function 连接后的结果选择器的回调函数，默认为(a, b) => a.concat(b)
返回值:
左表与右表指定列匹配后连接的二维结果数组
Type
Array
例子
//示例1
var arr = [[1, 'A'],
           [2, 'B'],
           [3, 'C']];
var brr = [[2, 'B'],
           [3, 'Y'], 
           [4, 'Z']];
var result = Array2D.fulljoin(arr, brr, 'f1', 'f1');  //f列模式
logjson(result,0);
//输出结果  二维数组
[[1,"A","",""],
 [2,"B",2,"B"],
 [3,"C",3,"Y"],
 ["","",4,"Z"]]
//示例2
var result = Array2D.fulljoin(arr, brr, 0, 0);  //0下标列
输出结果与上面相同
var result = Array2D.fulljoin(arr, brr, r=>r[0], r=>r[0]); //回调模式
//输出结果与上面相同
//示例3    结果选择集可以用完整箭头函数: (a,b)=>a.concat(b)
var result = Array2D.fulljoin(arr, brr, 'f2', 'f2','a.f1,b.f2');  //自定义结果选择集
logjson(result,0);
//输出结果   二维数组  自定义结果选择集
[[1,""],
 [2,"B"],
 [3,""],
 ["","Y"],
 ["","Z"]]

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

说明:
  • 这个函数用于对二维数组进行分组，并返回分组后的结果Map
别名:
  • groupBy
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
关键字选择器 function 用于选择分组的关键字的回调函数
分隔符 string 分组结果中每个键的分隔符，默认为"@^@"
返回值:
分组后的结果Map
Type
Map
例子
var arr = [[1, 'A'],
[2, 'B'],
[3, 'C'], 
[4, 'B'], 
[5, 'A']];
var result = Array2D.z分组(arr, 'f2');//注意结果是一个map
logjson(Array.from(result),false);
//输出结果
[["A",[[1,"A"],
[5,"A"]]],
["B",[[2,"B"],
[4,"B"]]],
["C",[[3,"C"]]]]

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

说明:
  • 这个函数用于对二维数组进行分组，并返回分组后的结果Map
别名:
  • z分组
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
关键字选择器 function 用于选择分组的关键字的回调函数
分隔符 string 分组结果中每个键的分隔符，默认为"@^@"
返回值:
分组后的结果Map
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生成下标数组(数组的开始数字, 数组的结束数字, 间隔数字,) → {Array}

说明:
  • 这个函数用于得到一个指定开始/结束/间隔数字, 默认间隔为1的一维数组
别名:
  • getIndexs
参数列表:
参数名称 参数类型 备注
数组的开始数字 Number
数组的结束数字 Number
间隔数字, Number 默认为1
返回值:
新的一维数组
Type
Array
例子
//示例1
var result = Array2D.z生成下标数组(1,10); //默认间隔为1
logjson(result,0); //后面的参数0为不输出时间标记
//输出结果
[1,2,3,4,5,6,7,8,9,10]  //从1开始,10结束间隔为1的一维数组
//示例2
var result = Array2D.z生成下标数组(5,30,3);
logjson(result,0);
//输出结果
[5,8,11,14,17,20,23,26,29] //从5开始,30结束间隔为3的一维数组

getIndexs(数组的开始数字, 数组的结束数字, 间隔数字,) → {Array}

说明:
  • 这个函数用于得到一个指定开始/结束/间隔数字, 默认间隔为1的一维数组
别名:
  • z生成下标数组
参数列表:
参数名称 参数类型 备注
数组的开始数字 Number
数组的结束数字 Number
间隔数字, Number 默认为1
返回值:
新的一维数组
Type
Array
例子
//示例1
var result = Array2D.getIndexs(1,10); //默认间隔为1
logjson(result,0); //后面的参数0为不输出时间标记
//输出结果
[1,2,3,4,5,6,7,8,9,10]  //从1开始,10结束间隔为1的一维数组
//示例2
var result = Array2D.getIndexs(5,30,3);
logjson(result,0);
//输出结果
[5,8,11,14,17,20,23,26,29] //从5开始,30结束间隔为3的一维数组

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

说明:
  • 这个函数用于对二维数组按指定关键字分组,并按结果要求返回一个新的二维数组
别名:
  • groupInto
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
关键字选择函数 function 要分组的关键字 支持回调模式
结果选择函数 function 分组后要计算的列及计算要求 支持回调模式
分组分隔符, string 默认为 "@^@"
返回值:
分组及计算后的新二维数组
Type
Array
例子
//以下2个示例标题均为  ID,产品,国家,数量,价格,年,月,日
//示例1
var arr=[[1,"Product1","中国",19,2,2023,10,10],
         [2,"Product2","德国",22,5,2023,4,5],
         [3,"Product2","英国",25,5,2022,6,28],
         [5,"Product1","中国",11,1,2023,11,15],
         [6,"Product2","德国",18,5,2024,2,18]];
var rs=Array2D.z分组汇总(arr,//源数组
         x=>[x.f2,x.f3,x.f6],  //产品+国家+年份分组
         g=>[g.count(),   //计数项
         g.sum('f4'), //对数量求和
         g.textjoin("f5","+")//所有单价用+连接
         ]);
logjson(rs,0);
//输出结果
[["Product1","中国","2023",2,30,"2+1"],["Product2","德国","2023",1,22,"5"],
["Product2","英国","2022",1,25,"5"],["Product2","德国","2024",1,18,"5"]]
//示例2
var arr=[[1,"Product1","中国",19,2,2023,10,10],
         [2,"Product2","德国",22,5,2023,4,5],
         [3,"Product2","英国",25,5,2022,6,28],
         [5,"Product1","中国",11,1,2023,11,15],
         [6,"Product2","德国",18,5,2024,2,18]];
var rs=Array2D.z分组汇总(arr,'f2,f3','count(),sum("f4"),average("f5"),textjoin("f4","+")'); 
//对产品和国家分组, 计数,数量求和,价格平均值,连接数量
logjson(rs,0);
//输出结果
[["Product1","中国",2,30,1.5,"19+11"],["Product2","德国",2,40,5,"22+18"],
["Product2","英国",1,25,5,"25"]]

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

说明:
  • 这个函数用于对二维数组按指定关键字分组,并按结果要求返回一个新的二维数组
别名:
  • z分组汇总
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
关键字选择函数 function 要分组的关键字 支持回调模式
结果选择函数 function 分组后要计算的列及计算要求 支持回调模式
分组分隔符, string 默认为 "@^@"
返回值:
分组及计算后的新二维数组
Type
Array
例子
//以下2个示例标题均为  ID,产品,国家,数量,价格,年,月,日
//示例1
var arr=[[1,"Product1","中国",19,2,2023,10,10],
         [2,"Product2","德国",22,5,2023,4,5],
         [3,"Product2","英国",25,5,2022,6,28],
         [5,"Product1","中国",11,1,2023,11,15],
         [6,"Product2","德国",18,5,2024,2,18]];
var rs=Array2D.groupInto(arr,//源数组
         x=>[x.f2,x.f3,x.f6],  //产品+国家+年份分组
         g=>[g.count(),   //计数项
         g.sum('f4'), //对数量求和
         g.textjoin("f5","+")//所有单价用+连接
         ]);
logjson(rs,0);
//输出结果
[["Product1","中国","2023",2,30,"2+1"],["Product2","德国","2023",1,22,"5"],
["Product2","英国","2022",1,25,"5"],["Product2","德国","2024",1,18,"5"]]
//示例2
var arr=[[1,"Product1","中国",19,2,2023,10,10],
         [2,"Product2","德国",22,5,2023,4,5],
         [3,"Product2","英国",25,5,2022,6,28],
         [5,"Product1","中国",11,1,2023,11,15],
         [6,"Product2","德国",18,5,2024,2,18]];
var rs=Array2D.groupInto(arr,'f2,f3','count(),sum("f4"),average("f5"),textjoin("f4","+")'); 
//对产品和国家分组, 计数,数量求和,价格平均值,连接数量
logjson(rs,0);
//输出结果
[["Product1","中国",2,30,1.5,"19+11"],["Product2","德国",2,40,5,"22+18"],
["Product2","英国",1,25,5,"25"]]

z分组汇总到字典(arr, 关键字选择函数, 结果选择函数, 分隔符默认为) → {Map}

说明:
  • 这个函数用于将数组按指定关键字作为键，要求结果列为值放入字典，返回该字典
别名:
  • groupIntoMap
参数列表:
参数名称 参数类型 备注
arr Array 数组
关键字选择函数 function 用于指定作为字典的关键字的列
结果选择函数 function 用于指定作为字典的值的列, 默认值为整行的二维数组, 指定结果列时, 既有整行二维数组还有指定列
分隔符默认为 string "@^@"
返回值:
返回字典
Type
Map
例子
//示例1
var arr=[["印子乐","男",102],
         ["许安莘","男",88],
         ["胡思卓","女",102],
         ["王静轩","女",97],
         ["吴瑾萱","女",93]];
var rs=Array2D.z分组汇总到字典(arr,'f1'); //字典关键字为第1列姓名, 值为各行二维数组
logjson(Array.from(rs),0); //转成数组输出
//输出结果
[["印子乐",[["印子乐","男",102]]],["许安莘",[["许安莘","男",88]]],
["胡思卓",[["胡思卓","女",102]]],["王静轩",[["王静轩","女",97]]],
["吴瑾萱",[["吴瑾萱","女",93]]]]
//示例2
var arr=[["印子乐","男",102],
         ["许安莘","男",88],
         ["胡思卓","女",102],
         ["王静轩","女",97],
         ["吴瑾萱","女",93]];
var rs=Array2D.z分组汇总到字典(arr,'f2','f1,f3'); 
//字典关键字为第2列性别, 值为agg: 第1列姓名,第3列分数值一维数组和 group: 各行二维数组
logjson(Array.from(rs),0);
//输出结果
[["男",{"agg":["印子乐",102],"group":[["印子乐","男",102],
["许安莘","男",88]]}],
["女",{"agg":["胡思卓",102],"group":[["胡思卓","女",102],
["王静轩","女",97],["吴瑾萱","女",93]]}]]

groupIntoMap(arr, 关键字选择函数, 结果选择函数, 分隔符默认为) → {Map}

说明:
  • 这个函数用于将数组按指定关键字作为键，要求结果列为值放入字典，返回该字典
别名:
  • z分组汇总到字典
参数列表:
参数名称 参数类型 备注
arr Array 数组
关键字选择函数 function 用于指定作为字典的关键字的列
结果选择函数 function 用于指定作为字典的值的列, 默认值为整行的二维数组, 指定结果列时, 既有整行二维数组还有指定列
分隔符默认为 string "@^@"
返回值:
返回字典
Type
Map
例子
//示例1
var arr=[["印子乐","男",102],
         ["许安莘","男",88],
         ["胡思卓","女",102],
         ["王静轩","女",97],
         ["吴瑾萱","女",93]];
var rs=Array2D.groupIntoMap(arr,'f1'); //字典关键字为第1列姓名, 值为各行二维数组
logjson(Array.from(rs),0); //转成数组输出
//输出结果
[["印子乐",[["印子乐","男",102]]],["许安莘",[["许安莘","男",88]]],
["胡思卓",[["胡思卓","女",102]]],["王静轩",[["王静轩","女",97]]],
["吴瑾萱",[["吴瑾萱","女",93]]]]
//示例2
var arr=[["印子乐","男",102],
         ["许安莘","男",88],
         ["胡思卓","女",102],
         ["王静轩","女",97],
         ["吴瑾萱","女",93]];
var rs=Array2D.groupIntoMap(arr,'f2','f1,f3'); 
//字典关键字为第2列性别, 值为agg: 第1列姓名,第3列分数值一维数组和 group: 各行二维数组
logjson(Array.from(rs),0);
//输出结果
[["男",{"agg":["印子乐",102],"group":[["印子乐","男",102],
["许安莘","男",88]]}],
["女",{"agg":["胡思卓",102],"group":[["胡思卓","女",102],
["王静轩","女",97],["吴瑾萱","女",93]]}]]

z超级透视(arr, 行字段函数, 列字段函数, 数据字段函数, 标题行, 输出表头, 分隔符默认为) → {Array}

说明:
  • 这个函数用于将二维数组仿透视表生成行列字段, 并进行各种汇总统计的交叉表, 返回二维数组
别名:
  • superPivot
参数列表:
参数名称 参数类型 备注
arr Array 数组
行字段函数 function 用于二维数组的行
列字段函数 function 用于二维数组的列
数据字段函数 function 对指定字段进行汇总统计 支持条件回调
标题行 Number 实际行数, 无：0 默认:1
输出表头 string 1: 输出 0: 不输出 'map': 字典不输出 默认:1
分隔符默认为 string "@^@"
返回值:
返回二维数组
Type
Array
例子
//示例1
var arr=[["销售员","商品ID","数量","数量","价格","年","月","日"],
	    [1,"product3","中国",29,10,2023,5,23],
	    [2,"product2","德国",20,5,2023,4,20],
	    [3,"product1","英国",19,1,2023,5,23],
	    [4,"product3","英国",24,10,2023,6,28],
	    [5,"product2","中国",30,5,2023,4,19]];
var rs=Array2D.z超级透视(arr,['f1+,f2-'],['f5+,f6+'],['count(),sum("f3")']);  
     //行字段:第1列升序,第2列降序  列字段: 第5列升序,第6列升序  //数据字段: 计数,第3列求和
logjson(rs,0);
//输出结果
[["","价格",1,1,5,5,10,10],
["","年",2023,2023,2023,2023,2023,2023],
["销售员","商品ID","计数","求和","计数","求和","计数","求和"],
[1,"product3","","","","",1,0],
[2,"product2","","",1,0,"",""],
[3,"product1",1,0,"","","",""],
[4,"product3","","","","",1,0],
[5,"product2","","",1,0,"",""]]
//示例2
var arr=[["销售员","商品ID","数量","数量","价格","年","月","日"],
	    [1,"product3","中国",29,10,2023,5,23],
	    [2,"product2","德国",20,5,2023,4,20],
	    [3,"product1","英国",19,1,2023,5,23],
	    [4,"product3","英国",24,10,2023,6,28],
	    [5,"product2","中国",30,5,2023,4,19]];
var rs=Array2D.z超级透视(arr,
		['f1,f5,f6','prod,year,month'],
		['f2','country'],
		['count(),sum("f3"),average("f4")','count,sum,avg']);
     //行字段: 第1,第5,第6列, 行标题:"prod,year,month"  列字段: 第2列 列标题: "country"
     //数据字段: 计数,第3列求和,第4列平均, 标题: "count,sum,avg"
logjson(rs,0);
//输出结果
[["","","country","product1","product1","product1",
"product2","product2","product2","product3","product3","product3"],
["prod","year","month","count","sum","avg","count","sum","avg","count","sum","avg"],
[1,10,2023,"","","","","","",1,0,29],
[2,5,2023,"","","",1,0,20,"","",""],
[3,1,2023,1,0,19,"","","","","",""],
[4,10,2023,"","","","","","",1,0,24],
[5,5,2023,"","","",1,0,30,"","",""]]
//示例3
var arr=[["0","1","2","3","4","5","6","7"],
         ["销售员","商品ID","数量","数量","价格","年","月","日"],
         [1,"product3","中国",29,10,2023,5,23],
         [2,"product2","德国",20,5,2023,4,20],
         [3,"product1","英国",19,1,2023,5,23],
         [4,"product3","英国",24,10,2023,6,28],
         [5,"product2","中国",30,5,2023,4,19]];
var rs=Array2D.z超级透视(arr,
     ['f1,f5,f6#','期数,年,月'],  //行: 第1,第5,第6列, 标题: "期数,年,月"
     ['f2#','国家'],	  //列: 第2列  标题: "国家" #代表按数据源顺序排列
     [[g=>g.count(),g=>g.sum("f3"),g=>g.average("f4")],'计数,求和,平均'], 
          //计数,第3列求和,第4列平均,标题:"计数,求和,平均"
     2,'map');       //2: 2行标题  map: 返回一个查询标准字典, 不输出
rs=SuperMap.fromMap(rs); //转成超级字典
logjson(rs,0);
//输出结果
{"map":{},"parent":null,"level":1,"total":0,
"sortkey":{"1@^@10@^@2023@^@product3":"01L0001 1@^@10@^@2023@^@product3",
"2@^@5@^@2023@^@product2":"01L0002 2@^@5@^@2023@^@product2",
"3@^@1@^@2023@^@product1":"01L0003 3@^@1@^@2023@^@product1",
"4@^@10@^@2023@^@product3":"01L0004 4@^@10@^@2023@^@product3",
"5@^@5@^@2023@^@product2":"01L0005 5@^@5@^@2023@^@product2"},
"size":5,"tag":null,"showCount":1024,"arraycount":255,
"all":
{"01L0001 1@^@10@^@2023@^@product3":{"agg":[1,0,29],
     "group":{"00000":[1,"product3","中国",29,10,2023,5,23]}},
"01L0002 2@^@5@^@2023@^@product2":{"agg":[1,0,20],
     "group":{"00000":[2,"product2","德国",20,5,2023,4,20]}},
"01L0003 3@^@1@^@2023@^@product1":{"agg":[1,0,19],
     "group":{"00000":[3,"product1","英国",19,1,2023,5,23]}},
"01L0004 4@^@10@^@2023@^@product3":{"agg":[1,0,24],
     "group":{"00000":[4,"product3","英国",24,10,2023,6,28]}},
"01L0005 5@^@5@^@2023@^@product2":{"agg":[1,0,30],
     "group":{"00000":[5,"product2","中国",30,5,2023,4,19]}}}}

superPivot(arr, 行字段函数, 列字段函数, 数据字段函数, 标题行, 输出表头, 分隔符默认为) → {Array}

说明:
  • 这个函数用于将二维数组仿透视表生成行列字段, 并进行各种汇总统计的交叉表, 返回二维数组
别名:
  • z超级透视
参数列表:
参数名称 参数类型 备注
arr Array 数组
行字段函数 function 用于二维数组的行
列字段函数 function 用于二维数组的列
数据字段函数 function 对指定字段进行汇总统计 支持条件回调
标题行 Number 实际行数, 无：0 默认:1
输出表头 string 1: 输出 0: 不输出 'map': 字典不输出 默认:1
分隔符默认为 string "@^@"
返回值:
返回二维数组
Type
Array
例子
//示例1
var arr=[["销售员","商品ID","数量","数量","价格","年","月","日"],
	    [1,"product3","中国",29,10,2023,5,23],
	    [2,"product2","德国",20,5,2023,4,20],
	    [3,"product1","英国",19,1,2023,5,23],
	    [4,"product3","英国",24,10,2023,6,28],
	    [5,"product2","中国",30,5,2023,4,19]];
var rs=Array2D.superPivot(arr,['f1+,f2-'],['f5+,f6#'],['count(),sum("f3")']);  
     //行字段:第1列升序,第2列降序  列字段: 第5列升序,第6列按原始顺序  //数据字段: 计数,第3列求和
logjson(rs,0);
//输出结果
[["","价格",1,1,5,5,10,10],
["","年",2023,2023,2023,2023,2023,2023],
["销售员","商品ID","计数","求和","计数","求和","计数","求和"],
[1,"product3","","","","",1,0],
[2,"product2","","",1,0,"",""],
[3,"product1",1,0,"","","",""],
[4,"product3","","","","",1,0],
[5,"product2","","",1,0,"",""]]
//示例2
var arr=[["销售员","商品ID","数量","数量","价格","年","月","日"],
	    [1,"product3","中国",29,10,2023,5,23],
	    [2,"product2","德国",20,5,2023,4,20],
	    [3,"product1","英国",19,1,2023,5,23],
	    [4,"product3","英国",24,10,2023,6,28],
	    [5,"product2","中国",30,5,2023,4,19]];
var rs=Array2D.superPivot(arr,
		['f1,f5,f6','prod,year,month'],
		['f2','country'],
		['count(),sum("f3"),average("f4")','count,sum,avg']);
     //行字段: 第1,第5,第6列, 行标题:"prod,year,month"  列字段: 第2列 列标题: "country"
     //数据字段: 计数,第3列求和,第4列平均, 标题: "count,sum,avg"
logjson(rs,0);
//输出结果
[["","","country","product1","product1","product1",
"product2","product2","product2","product3","product3","product3"],
["prod","year","month","count","sum","avg","count","sum","avg","count","sum","avg"],
[1,10,2023,"","","","","","",1,0,29],
[2,5,2023,"","","",1,0,20,"","",""],
[3,1,2023,1,0,19,"","","","","",""],
[4,10,2023,"","","","","","",1,0,24],
[5,5,2023,"","","",1,0,30,"","",""]]
//示例3
var arr=[["0","1","2","3","4","5","6","7"],
         ["销售员","商品ID","数量","数量","价格","年","月","日"],
         [1,"product3","中国",29,10,2023,5,23],
         [2,"product2","德国",20,5,2023,4,20],
         [3,"product1","英国",19,1,2023,5,23],
         [4,"product3","英国",24,10,2023,6,28],
         [5,"product2","中国",30,5,2023,4,19]];
var rs=Array2D.superPivot(arr,
     ['f1,f5,f6','期数,年,月'],  //行: 第1,第5,第6列, 标题: "期数,年,月"
     ['f2','国家'],	  //列: 第2列  标题: "国家"
     [[g=>g.count(),g=>g.sum("f3"),g=>g.average("f4")],'计数,求和,平均'], 
          //计数,第3列求和,第4列平均,标题:"计数,求和,平均"
     2,'map');       //2: 2行标题  map: 返回一个查询标准字典, 不输出
rs=SuperMap.fromMap(rs); //转成超级字典
logjson(rs,0);
//输出结果
{"map":{},"parent":null,"level":1,"total":0,
"sortkey":{"1@^@10@^@2023@^@product3":"01L0001 1@^@10@^@2023@^@product3",
"2@^@5@^@2023@^@product2":"01L0002 2@^@5@^@2023@^@product2",
"3@^@1@^@2023@^@product1":"01L0003 3@^@1@^@2023@^@product1",
"4@^@10@^@2023@^@product3":"01L0004 4@^@10@^@2023@^@product3",
"5@^@5@^@2023@^@product2":"01L0005 5@^@5@^@2023@^@product2"},
"size":5,"tag":null,"showCount":1024,"arraycount":255,
"all":
{"01L0001 1@^@10@^@2023@^@product3":{"agg":[1,0,29],
     "group":{"00000":[1,"product3","中国",29,10,2023,5,23]}},
"01L0002 2@^@5@^@2023@^@product2":{"agg":[1,0,20],
     "group":{"00000":[2,"product2","德国",20,5,2023,4,20]}},
"01L0003 3@^@1@^@2023@^@product1":{"agg":[1,0,19],
     "group":{"00000":[3,"product1","英国",19,1,2023,5,23]}},
"01L0004 4@^@10@^@2023@^@product3":{"agg":[1,0,24],
     "group":{"00000":[4,"product3","英国",24,10,2023,6,28]}},
"01L0005 5@^@5@^@2023@^@product2":{"agg":[1,0,30],
     "group":{"00000":[5,"product2","中国",30,5,2023,4,19]}}}}

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

说明:
  • 这个函数用于判断数组是否包含指定的值
别名:
  • includes
参数列表:
参数名称 参数类型 备注
arr Array 数组 一维二维均可以
值 * 要判断的值
返回值:
数组是否包含指定的值
Type
Boolean
例子
//示例1
var arr = [1, 2, 3, 4, 5];
var value = 3;
var result = Array2D.z是否包含值(arr, value);
console.log(result); // 输出是否包含指定的值
//输出结果
true
//示例2
var arr =  [[1, 'A'],
            [2, 'B'],
            [3, 'C'], 
            [4, 'B'], 
            [5, 'A']];
var result = Array2D.z是否包含值(arr, 1);
console.log(result); // 输出是否包含指定的值
//输出结果
true

includes(arr, 值) → {Boolean}

说明:
  • 这个函数用于判断数组是否包含指定的值
别名:
  • z是否包含值
参数列表:
参数名称 参数类型 备注
arr Array 数组 一维二维均可以
值 * 要判断的值
返回值:
数组是否包含指定的值
Type
Boolean
例子
//示例1
var arr = [1, 2, 3, 4, 5];
var value = 3;
var result = Array2D.includes(arr, value);
console.log(result); // 输出是否包含指定的值
//输出结果
true
//示例2
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
下标的数组 一维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z下标数组(arr);
logjson(result);  // 输出下标的数组
//输出结果
[0,1,2]

indexArray(arr) → {Array}

说明:
  • 这个函数用于获取二维数组的下标的一维数组
别名:
  • z下标数组
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
下标的数组 一维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.indexArray(arr);
logjson(result);  // 输出下标的数组
//输出结果
[0,1,2]

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

说明:
  • 这个函数用于获取值在二维数组中的位置的一维数组
别名:
  • indexOf
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
值 * 要查找的值
返回值:
值的位置的一维数组 [1维下标/行,2维下标/列]
Type
Array
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6]];
var value = 4;
var result = Array2D.z值位置(arr, value);
logjson(result); //输出值的位置的一维数组
//输出结果
[1,1]
//示例2
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z值位置(arr, 3);
logjson(result);//输出值的行列坐标 
//输出结果
[1,0]

indexOf(arr, 值) → {Array}

说明:
  • 这个函数用于获取值在二维数组中的位置的一维数组
别名:
  • z值位置
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
值 * 要查找的值
返回值:
值的位置的一维数组 [1维下标/行,2维下标/列]
Type
Array
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6]];
var value = 4;
var result = Array2D.indexOf(arr, value);
logjson(result); //输出值的位置的一维数组
//输出结果
[1,1]
//示例2
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.indexOf(arr, 3);
logjson(result);//输出值的行列坐标 
//输出结果
[1,0]

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

说明:
  • 这个函数用于批量插入列到二维数组
别名:
  • insertCols
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择器 function 用于选择要插入的列号或使用回调函数 (row) => 回调函数
值 * 列的初始值，默认为空字符串 也可使用回调函数 与map回调一致
数量 number 要插入的列的数量，默认为1
返回值:
插入列后的二维数组
Type
Array
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z批量插入列(arr,1,'',2); //数组实际第2列插入2列空白
logjson(result,0); // 输出插入列后的二维数组
//输出结果
[[1,"","",2],[3,"","",4],[5,"","",6]]
//示例2
var arr =  [[1,2,3,4,5,6,7,8],
		  [1,"Product1","中国",19,1,2023,10,10],
		  ["ID","产品","国家","数量","价格","年","月","日"]];
var rs = Array2D.z批量插入列(arr,x=>'产品'==x[2],"  ",2);  //数组实际第3行中与'产品'匹配的列号插入2列
logjson(rs,0); // 输出值的位置数组
//输出结果
[[1,"  ","  ",2,3,4,5,6,7,8],
 [1,"  ","  ","Product1","中国",19,1,2023,10,10],
 ["ID","  ","  ","产品","国家","数量","价格","年","月","日"]]

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

说明:
  • 这个函数用于批量插入列到二维数组
别名:
  • z批量插入列
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择器 function 用于选择要插入的列号或使用回调函数 (row) => 回调函数
值 * 列的初始值，默认为空字符串 也可使用回调函数 与map回调一致
数量 number 要插入的列的数量，默认为1
返回值:
插入列后的二维数组
Type
Array
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.insertCols(arr,1,'',2); //数组实际第2列插入2列空白
logjson(result,0); // 输出插入列后的二维数组
//输出结果
[[1,"","",2],[3,"","",4],[5,"","",6]]
//示例2
var arr =  [[1,2,3,4,5,6,7,8],
		  [1,"Product1","中国",19,1,2023,10,10],
		  ["ID","产品","国家","数量","价格","年","月","日"]];
var rs = Array2D.insertCols(arr,x=>'产品'==x[2],"  ",2);  //数组实际第3行中与'产品'匹配的列号插入2列
logjson(rs,0); // 输出值的位置数组
//输出结果
[[1,"  ","  ",2,3,4,5,6,7,8],
 [1,"  ","  ","Product1","中国",19,1,2023,10,10],
 ["ID","  ","  ","产品","国家","数量","价格","年","月","日"]]

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

说明:
  • 这个函数用于批量插入行到二维数组
别名:
  • insertRows
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
行号数组 Array 要插入行的行号数组 或 条件回调(按列条件筛选出符合条件的行)
值 * 行的初始值，默认为空字符串
数量 number 要插入行的数量，默认为1
返回值:
插入行后的二维数组
Type
Array
例子
//示例1
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]]
//示例2
var arr = [[1, 2, 3],[6, 3, 1] ,[7, 8, 9], [4, 5, 6]];
var result = Array2D.z批量插入行(arr, x=>x[1]>7, "/", 2);//查找数组实际第2列>7的行插入值为"/"的2行
logjson(result,0);
//输出结果
[[1,2,3],[6,3,1],["/","/","/"],["/","/","/"],[7,8,9],[4,5,6]]

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

说明:
  • 这个函数用于批量插入行到二维数组
别名:
  • z批量插入行
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
行号数组 Array 要插入行的行号数组 或 条件回调(按列条件筛选出符合条件的行)
值 * 行的初始值，默认为空字符串
数量 number 要插入行的数量，默认为1
返回值:
插入行后的二维数组
Type
Array
例子
//示例1
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]]
//示例2
var arr = [[1, 2, 3],[6, 3, 1] ,[7, 8, 9], [4, 5, 6]];
var result = Array2D.insertRows(arr, x=>x[1]>7, "/", 2);//查找数组实际第2列>7的行插入值为"/"的2行
logjson(result,0);
//输出结果
[[1,2,3],[6,3,1],["/","/","/"],["/","/","/"],[7,8,9],[4,5,6]]

z插入行号(arr, 首行开始行号，默认为0) → {Array}

说明:
  • 这个函数用于批量插入行号到二维数组每列的函数
别名:
  • insertRowNum
参数列表:
参数名称 参数类型 备注
arr Array 待插入行号的二维数组
首行开始行号，默认为0 Number
返回值:
带有行号的新二维数组
Type
Array
例子
var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var result = Array2D.z插入行号(arr); //二维数组的每个首列插入行号
logjson(result,0)
//输出结果
[[0,1,2,3],
 [1,4,5,6],
 [2,7,8,9]]

insertRowNum(arr, 首行开始行号，默认为0) → {Array}

说明:
  • 这个函数用于批量插入行号到二维数组每列的函数
别名:
  • z插入行号
参数列表:
参数名称 参数类型 备注
arr Array 待插入行号的二维数组
首行开始行号，默认为0 Number
返回值:
带有行号的新二维数组
Type
Array
例子
var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var result = Array2D.insertRowNum(arr);//二维数组的每个首列插入行号
logjson(result,0)
//输出结果
[[0,1,2,3],
 [1,4,5,6],
 [2,7,8,9]]

z取交集(arr, brr, 列选择器1, 列选择器2) → {Array}

说明:
  • 这个函数用于获取两个二维数组的交集
别名:
  • intersect
参数列表:
参数名称 参数类型 备注
arr Array 第一个二维数组
brr Array 第二个二维数组
列选择器1 String 列选择器 第一个二维数组 默认为全部匹配
列选择器2 String 列选择器 第二个二维数组 默认为全部匹配
返回值:
返回交集的二维数组
Type
Array
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6],[3, 4],[7, 9]];
var brr = [[3, 4], [5, 6], [7, 8]];
var result = Array2D.z取交集(arr, brr);//完全一样的行
logjson(result,0); // 输出交集数组
输出结果
[[3,4],[5,6],[3,4]]
//示例2
logjson(Array2D.z取交集(arr, brr,'f1','f1'),0);  //按照实际数组第1列取交集
//输出结果
[[3,4],[5,6],[3,4],[7,9]]

intersect(arr, brr, 列选择器1, 列选择器2) → {Array}

说明:
  • 这个函数用于获取两个二维数组的交集
别名:
  • z取交集
参数列表:
参数名称 参数类型 备注
arr Array 第一个二维数组
brr Array 第二个二维数组
列选择器1 String 第一个二维数组 默认为全部匹配
列选择器2 String 第二个二维数组 默认为全部匹配
返回值:
返回交集的二维数组
Type
Array
例子
//示例1
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]]
//示例2
logjson(Array2D.intersect(arr, brr,'f1','f1'));  //按照实际数组第1列取交集
//输出结果
[[3,4],[5,6],[3,4],[7,9]]

z空结果(arr) → {boolean}

说明:
  • 这个函数用于判断数组是否为空
别名:
  • isEmpty
参数列表:
参数名称 参数类型 备注
arr Array 数组
返回值:
如果为空返回true，否则返回false
Type
boolean
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z空结果(arr);
console.log(result); // 输出false
//输出结果
false
//示例2
console.log(Array2D.z空结果([])); //输出true
//输出结果
true

isEmpty(arr) → {boolean}

说明:
  • 这个函数用于判断数组是否为空
别名:
  • z空结果
参数列表:
参数名称 参数类型 备注
arr Array 数组
返回值:
如果为空返回true，否则返回false
Type
boolean
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.isEmpty(arr);
console.log(result); // 输出false
//输出结果
false
//示例2
console.log(Array2D.isEmpty([])); // 输出true
//输出结果
true

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

说明:
  • 二维表先行后列连接字符串
别名:
  • join
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列分隔符 string 默认为","
行分隔符 string 默认为","
返回值:
连接后的文本
Type
string
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var separator = "-";
var result = Array2D.z文本连接(arr, separator);
logjson(result); // 输出连接后的文本
//输出结果
"1-2,3-4,5-6"

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

说明:
  • 二维表先行后列连接字符串
别名:
  • z文本连接
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列分隔符 string 默认为","
行分隔符 string 默认为","
返回值:
连接后的文本
Type
string
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var separator = "-";
var result = Array2D.join(arr, separator);
logjson(result); // 输出连接后的文本
//输出结果
"1-2,3-4,5-6"

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

说明:
  • 这个函数用于返回二维数组满足条件的最后一个子数组(一维数组)或默认值
别名:
  • last
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 用于判断子数组是否满足条件的回调函数 (row) => 回调函数
没找到返回默认值 * 没有找到满足条件的子数组时返回的默认值，默认为undefined
返回值:
满足条件的最后一个子数组(一维数组)或默认值
Type
Object
例子
//示例1
var arr = [[5, 6], [3, 4], [1, 2]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组第一个元素是否大于2的最后一组子数组
var defaultValue = [];
var result = Array2D.z最后一个(arr, conditionCallback, defaultValue);
logjson(result,0); // 输出满足条件的最后一个子数组或默认值
//输出结果
[3,4]
//示例2
var arr = [[5, 6], [3, 4], [1, 2]];
logjson(Array2D.z最后一个(arr,x=>x[0]>7,[8,9]));  //判断子数组的第一个元素是否大于7的最后一组子数组, 如果没找到返回[8,9]
//输出结果
[8,9]

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

说明:
  • 这个函数用于返回二维数组满足条件的最后一个子数组(一维数组)或默认值
别名:
  • z最后一个
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 用于判断子数组是否满足条件的回调函数 (row) => 回调函数
没找到返回默认值 * 没有找到满足条件的子数组时返回的默认值，默认为undefined
返回值:
满足条件的最后一个子数组(一维数组)或默认值
Type
Object
例子
//示例1
var arr = [[5, 6], [3, 4], [1, 2]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组第一个元素是否大于2的最后一组子数组
var defaultValue = [];
var result = Array2D.last(arr, conditionCallback, defaultValue);
logjson(result,0); // 输出满足条件的最后一个子数组或默认值
//输出结果
[3,4]
//示例2
var arr = [[5, 6], [3, 4], [1, 2]];
logjson(Array2D.last(arr,x=>x[0]>7,[8,9]));  //判断子数组的第一个元素是否大于7的最后一组子数组, 如果没找到返回[8,9]
//输出结果
[8,9]

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

说明:
  • 这个函数用于返回对二维数组按指定值从后往前匹配值的位置的一维数组
别名:
  • lastIndexOf
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
值 * 指定的值 默认为undefined
返回值:
正数的数组位置的一维数组[行,列], 没找到返回 [-1,-1]
Type
number
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z从后往前值位置(arr);  //默认为undefined的查找, 返回 [-1,-1]
logjson(result,0); 
//输出结果
[-1,-1]
//示例2
var arr = [[4, 3], [9, 11], [7, 8], [4, 3], [5, 6]];
var value = 4;
var result = Array2D.z从后往前值位置(arr, value);  //从后往前匹配, 返回位置还是正数的实际数组的第4行,第1列
logjson(result,0); 
//输出结果
[3,0]

lastIndexOf(arr, 值) → {number}

说明:
  • 这个函数用于返回对二维数组按指定值从后往前匹配值的位置的一维数组
别名:
  • z从后往前值位置
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
值 * 指定的值 默认为undefined
返回值:
正数的数组位置的一维数组[行,列], 没找到返回 [-1,-1]
Type
number
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.lastIndexOf(arr);  //默认为undefined的查找, 返回 [-1,-1]
logjson(result,0); 
//输出结果
[-1,-1]
//示例2
var arr = [[4, 3], [9, 11], [7, 8], [4, 3], [5, 6]];
var value = 4;
var result = Array2D.lastIndexOf(arr, value);  //从后往前匹配, 返回位置还是正数的实际数组的第4行,第1列
logjson(result,0); 
//输出结果
[3,0]

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

说明:
  • 这个函数用于对两个二维数组进行一对多连接操作，并返回连接后的结果数组 二维数组
别名:
  • leftFulljoin
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组
左表列选择器 function 左表指定匹配列 或 列条件回调函数 (row) => 回调函数 默认为全部列
右表列选择器 function 右表指定匹配列 或 列条件回调函数 (row) => 回调函数 默认为全部列
结果选择器 function 连接后的结果选择器的回调函数，默认为(a, b) => a.concat(a, b)
返回值:
连接后的结果数组 二维数组
Type
Array
例子
//示例1
var arr = [[1, 'A'],
		 [2, 'B'], 
		 [3, 'C']];
var brr = [[2, 'X','C1'],
		 [1, 'A','C2'],
		 [1, 'A','C3'],
		 [3, 'C'],               //整列命中才连接
		 [3, 'C', 'c4']];
var result = Array2D.z一对多连接(arr, brr);   //比较二个数组, 以整列命中为准, 命中的有值, 没有命中会空
logjson(result,0);
//输出结果
[[1,"A","","",""],[2,"B","","",""],[3,"C",3,"C"]]
//示例2
var result = Array2D.z一对多连接(arr, brr,'f1','f1');
logjson(result,0);
//输出结果
[[1,"A",1,"A","C2"],[1,"A",1,"A","C3"],
 [2,"B",2,"X","C1"],[3,"C",3,"C"],[3,"C",3,"C","c4"]]
//示例3    lamda函数写法完全体
var result = Array2D.z一对多连接(
arr,
brr,
a=>a[0],
b=>b[0],
(a,b)=>[a[0]+'-'+b[0],b[1],b[2],a[0]]  //结果选择回调形式
);
logjson(result,0);
//输出结果
[["1-1","A","C2",1],["1-1","A","C3",1],
 ["2-2","X","C1",2],["3-3","C",null,3],["3-3","C","c4",3]]

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

说明:
  • 这个函数用于对两个二维数组进行一对多连接操作，并返回连接后的结果数组 二维数组
别名:
  • z一对多连接
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组
左表列选择器 function 左表指定匹配列 或 列条件回调函数 (row) => 回调函数 默认为全部列
右表列选择器 function 右表指定匹配列 或 列条件回调函数 (row) => 回调函数 默认为全部列
结果选择器 function 连接后的结果选择器的回调函数，默认为(a, b) => a.concat(a, b)
返回值:
连接后的结果数组 二维数组
Type
Array
例子
//示例1
var arr = [[1, 'A'],
		 [2, 'B'], 
		 [3, 'C']];
var brr = [[2, 'X','C1'],
		 [1, 'A','C2'],
		 [1, 'A','C3'],
		 [3, 'C'],               //整列命中才连接
		 [3, 'C', 'c4']];
var result = Array2D.leftFulljoin(arr, brr);   //比较二个数组, 以整列命中为准, 命中的有值, 没有命中会空
logjson(result,0);
//输出结果
[[1,"A","","",""],[2,"B","","",""],[3,"C",3,"C"]]
//示例2
var result = Array2D.leftFulljoin(arr, brr,'f1','f1');
logjson(result,0);
//输出结果
[[1,"A",1,"A","C2"],[1,"A",1,"A","C3"],
 [2,"B",2,"X","C1"],[3,"C",3,"C"],[3,"C",3,"C","c4"]]
//示例3    lamda函数写法完全体
var result = Array2D.leftFulljoin(
arr,
brr,
a=>a[0],
b=>b[0],
(a,b)=>[a[0]+'-'+b[0],b[1],b[2],a[0]]  //结果选择回调形式
);
logjson(result,0);
//输出结果
[["1-1","A","C2",1],["1-1","A","C3",1],
 ["2-2","X","C1",2],["3-3","C",null,3],["3-3","C","c4",3]]

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

说明:
  • 对两个二维数组进行左外连接操作(以左面行数为准)，并返回连接后的结果二维数组
别名:
  • leftjoin
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组
左表列选择器 function 左表指定匹配列 或 列条件回调函数 (row) => 回调函数 默认为全部列
右表列选择器 function 右表指定匹配列 或 列条件回调函数 (row) => 回调函数 默认为全部列
结果选择器 function 连接后的结果选择器的回调函数，默认为(a, b) => a.concat(a, b)
返回值:
连接后的结果数组 二维数组
Type
Array
例子
//示例1
var arr = [[1, 'A'],
           [2, 'B'], 
           [3, 'C']];
var brr = [ [2, 'X','C1'],
            [1, 'A','C2'],
            [1, 'A','C3'],   //2个1只会连接第一个
            [2, 'B'],
            [4, 'Z','C4']];	
var result = Array2D.z左连接(arr, brr);//整行比较, 完全命中写入, 只要没完全命中则右侧为空
logjson(result,0); //以主侧为主, 主侧总行数不变
//输出结果
[[1,"A","","",""],[2,"B",2,"B"],[3,"C","","",""]]
//示例2
var result = Array2D.z左连接(arr, brr,'f1','f1'); 
     //比较左右实际数组第1列 左侧行数不变, 右侧只放入第一次相符的, 第二次相符的不写入,如果没有则右侧为空
logjson(result,0);  
//输出结果
[[1,"A",1,"A","C2"],[2,"B",2,"X","C1"],[3,"C","","",""]]
//示例3
var result = Array2D.z左连接(
arr,
brr,
a=>a[0],
b=>b[0],
(a,b)=>[a[0]+'-'+b[0],b[1],b[2],a[0]]
);
logjson(result,0); //左侧行数不变, 右侧只放入第一次相符的, 第二次相符的不写入, 如果没有则b的位置为空
//输出结果
[["1-1","A","C2",1],["2-2","X","C1",2],["3-","","",3]]

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

说明:
  • 对两个二维数组进行左外连接操作(以左面行数为准)，并返回连接后的结果二维数组
别名:
  • z左连接
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组
左表列选择器 function 左表指定匹配列 或 列条件回调函数 (row) => 回调函数 默认为全部列
右表列选择器 function 右表指定匹配列 或 列条件回调函数 (row) => 回调函数 默认为全部列
结果选择器 function 连接后的结果选择器的回调函数，默认为(a, b) => a.concat(a, b)
返回值:
连接后的结果数组 二维数组
Type
Array
例子
//示例1
var arr = [[1, 'A'],
		 [2, 'B'], 
		 [3, 'C']];
var brr = [ [2, 'X','C1'],
            [1, 'A','C2'],
            [1, 'A','C3'],   //2个1只会连接第一个
            [2, 'B'],
            [4, 'Z','C4']];	
var result = Array2D.leftjoin(arr, brr);//整行比较, 完全命中写入, 只要没完全命中则右侧为空
logjson(result,0); //以主侧为主, 主侧总行数不变
//输出结果
[[1,"A","","",""],[2,"B",2,"B"],[3,"C","","",""]]
//示例2
var result = Array2D.leftjoin(arr, brr,'f1','f1'); 
     //比较左右实际数组第1列 左侧行数不变, 右侧只放入第一次相符的, 第二次相符的不写入,如果没有则右侧为空
logjson(result,0);  
//输出结果
[[1,"A",1,"A","C2"],[2,"B",2,"X","C1"],[3,"C","","",""]]
//示例3
var result = Array2D.leftjoin(
arr,
brr,
a=>a[0],
b=>b[0],
(a,b)=>[a[0]+'-'+b[0],b[1],b[2],a[0]]
);
logjson(result,0); //左侧行数不变, 右侧只放入第一次相符的, 第二次相符的不写入, 如果没有则b的位置为空
//输出结果
[["1-1","A","C2",1],["2-2","X","C1",2],["3-","","",3]]

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

说明:
  • 这个函数用于根据条件回调函数对二维数组进行映射生成新的二维数组
别名:
  • map
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 指定每个一维数组的元素(指定列)进行映射的回调函数 (row) => 回调函数
返回值:
映射生成的新二维数组
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映射生成
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 指定每个一维数组的元素(指定列)进行映射的回调函数 (row) => 回调函数
返回值:
映射生成的新的二维数组
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 选择要比较列 或 比较列回调函数 (row) => 回调函数
返回值:
最大值
Type
Number
例子
//示例1
var arr = [[1, 2], [5, 6], [3, 4]];
var result = Array2D.z最大值(arr, "f1"); //实际对每个一维数组第1个元素(实际数组第1列)进行比较
console.log(result); // 输出最大值
//输出结果
5
//示例2
var arr = [[1, 2], [5, 6], [3, 4]];
var columnSelector = (row) => row[1]; //实际对每个一维数组第2个元素(实际数组第2列)进行比较
var result = Array2D.z最大值(arr, columnSelector);
console.log(result); // 输出最大值
//输出结果
6

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

说明:
  • 这个函数用于计算二维数组中指定列的最大值
别名:
  • z最大值
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 选择要比较列 或 比较列回调函数 (row) => 回调函数
返回值:
最大值
Type
Number
例子
//示例1
var arr = [[1, 2], [5, 6], [3, 4]];
var result = Array2D.max(arr, "f1"); //实际对每个一维数组第1个元素(实际数组第1列)进行比较
console.log(result); // 输出最大值
//输出结果
5
//示例2
var arr = [[1, 2], [5, 6], [3, 4]];
var columnSelector = (row) => row[1]; // 实际对每个一维数组第2个元素(实际数组第2列)进行比较
var result = Array2D.max(arr, columnSelector);
console.log(result); // 输出最大值
//输出结果
6

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

说明:
  • 这个函数用于计算二维数组中指定列的中位数
别名:
  • median
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 选择要比较列 或 比较列回调函数 (row) => 回调函数
返回值:
中位数
Type
Number
例子
//示例1
var arr = [[1, 2], [5, 6], [3, 4]];
var result = Array2D.z中位数(arr, "f1"); //实际对每个一维数组的第1个元素(实际数组第1列)进行比较
console.log(result); // 输出中间值
//输出结果
3
//示例2
var arr = [[1, 2], [5, 6], [3, 4]];
var columnSelector = (row) => row[1]; //实际数组第2列进行比较
var result = Array2D.z中位数(arr, columnSelector);
console.log(result); // 输出中间值
//输出结果
4

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

说明:
  • 这个函数用于计算二维数组中指定列的中位数
别名:
  • z中位数
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 选择要比较列 或 比较列回调函数 (row) => 回调函数
返回值:
中位数
Type
Number
例子
//示例1
var arr = [[1, 2], [5, 6], [3, 4]];
var result = Array2D.median(arr, "f1"); //实际对每个一维数组的第1个元素(实际数组第1列)进行比较
console.log(result); // 输出中间值
//输出结果
3
//示例2
var arr = [[1, 2], [5, 6], [3, 4]];
var columnSelector = (row) => row[1]; //实际数组第2列进行比较
var result = Array2D.median(arr, columnSelector);
console.log(result); // 输出中间值
//输出结果
4

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

说明:
  • 这个函数用于计算二维数组中指定列的最小值
别名:
  • min
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 选择要比较列 或 比较列的回调函数 (row) => 回调函数
返回值:
最小值
Type
Number
例子
//示例1
var arr = [[5, 6], [1, 2], [3, 4]];
var columnSelector = (row) => row[1]; 	//实际数组第二列进行比较
var result = Array2D.z最小值(arr, columnSelector);
console.log(result); 	//输出最小值
//输出结果
2
//示例2
var result = Array2D.z最小值(arr, "f1"); 	//实际数组第一列进行比较
console.log(result); 
//输出结果
1

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

说明:
  • 这个函数用于计算二维数组中指定列的最小值
别名:
  • z最小值
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 选择要比较列 或 比较列的回调函数 (row) => 回调函数
返回值:
最小值
Type
Number
例子
//示例1
var arr = [[5, 6], [1, 2], [3, 4]];
var columnSelector = (row) => row[1]; 	//实际数组第二列进行比较
var result = Array2D.min(arr, columnSelector);
console.log(result); 	//输出最小值
//输出结果
2
//示例2
var result = Array2D.min(arr, "f1"); 	//实际数组第一列进行比较
console.log(result); 
//输出结果
1

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

说明:
  • 这个函数用于按指定间隔取二维数组的数据(保留实际数组第一组即表头)，并返回取到的二维数组
别名:
  • nth
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
间隔 number 除实际数组第一组数组(即表头)后每间隔多少个一维数组取一次
偏移 number 偏移值，往右偏移几个一维数组，不支持负数, 默认为 0 不偏移
返回值:
取到的二维数组
Type
Array
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 7]];
var interval = 3;  //实际数组第1个保留不计算, 后面每3个一维数组取出
var offset = 0;    //不支持负数, 向右偏移几个  //第三个为0 可以不写是默认参数
var result = Array2D.z间隔取数(arr, interval, offset);
logjson(result,0);  
//输出结果
[[1,2],[7,8]]
//示例2
logjson(Array2D.z间隔取数(arr, 3, 2),0);  //取数后向右偏移2组
//输出结果
[[5,6],[11,7]]

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

说明:
  • 这个函数用于按指定间隔取二维数组的数据(保留实际数组第一组即表头)，并返回取到的二维数组
别名:
  • z间隔取数
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
间隔 number 除实际数组第一组数组(即表头)后每间隔多少个一维数组取一次
偏移 number 偏移值，往右偏移几个一维数组，不支持负数, 默认为 0 不偏移
返回值:
取到的二维数组
Type
Array
例子
//示例1
var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 7]];
var interval = 3;  //实际数组第1个保留不计算, 后面每3个一维数组取出
var offset = 0;    //不支持负数, 向右偏移几个  //第三个为0 可以不写是默认参数
var result = Array2D.nth(arr, interval, offset);
logjson(result,0);  
//输出结果
[[1,2],[7,8]]
//示例2
logjson(Array2D.nth(arr, 3, 2),0);  //取数后向右偏移2组
//输出结果
[[5,6],[11,7]]

z补齐数组(arr, 列数, 行数, 补齐值) → {Array}

说明:
  • 这个函数用于补齐二维数组的大小，并返回补齐后的新二维数组
别名:
  • pad
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列数 number 要补齐的列数
行数 number 要补齐的行数
补齐值 any 默认为 ''
返回值:
补齐后的新二维数组
Type
Array
例子
//示例1
var arr = [ [1, 'A'],
[2, 'B', 'bx'], 
[3, 'C'] ];
logjson(Array2D.z补齐数组(arr,4,5),0);  //扩充数组arr, 4列5行, 填充默认值 ''
//输出结果
[[1,"A","",""],[2,"B","bx",""],
 [3,"C","",""],["","","",""],
 ["","","",""]]
//示例2
logjson(Array2D.z补齐数组(arr,3,4,"补"),0);    //扩充数组arr, 3列4行, 填充 '补'
//输出结果
[[1,"A","补"],[2,"B","bx"],
 [3,"C","补"],["补","补","补"]]

pad(arr, 列数, 行数, 补齐值) → {Array}

说明:
  • 这个函数用于补齐二维数组的大小，并返回补齐后的新二维数组
别名:
  • z补齐数组
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列数 number 要补齐的列数
行数 number 要补齐的行数
补齐值 any 默认为 ''
返回值:
补齐后的新二维数组
Type
Array
例子
//示例1
var arr = [ [1, 'A'],
[2, 'B', 'bx'], 
[3, 'C'] ];
logjson(Array2D.pad(arr,4,5),0);  //扩充数组arr, 4列5行, 填充默认值 ''
//输出结果
[[1,"A","",""],[2,"B","bx",""],
 [3,"C","",""],["","","",""],
 ["","","",""]]
//示例2
logjson(Array2D.pad(arr,3,4,"补"),0);    //扩充数组arr, 3列4行, 填充 '补'
//输出结果
[[1,"A","补"],[2,"B","bx"],
 [3,"C","补"],["补","补","补"]]

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

说明:
  • 这个函数用于按照总页数对二维数组进行分页，并返回分页后的新数组
别名:
  • pageByCount
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
总页数 number 表示将二维数组分成多少页
返回值:
分页后的新多维数组
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],     //第1页
//  [3,4]],
// [[5,6],     //第2页
//  [7,8]],
// [[9,10]]]   //第3页

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

说明:
  • 这个函数用于按照总页数对二维数组进行分页，并返回分页后的新数组
别名:
  • z按页数分页
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
总页数 number 表示将二维数组分成多少页
返回值:
分页后的新多维数组
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],     //第1页
//  [3,4]],
// [[5,6],     //第2页
//  [7,8]],
// [[9,10]]]   //第3页

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

说明:
  • 这个函数用于按照每页数量(行数的数量)对二维数组进行分页，并返回分页后的新数组
别名:
  • pageByRows
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
每页数量 number 即内部的每个新二维数组的行数
返回值:
分页后的新多维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var pageSize = 2;  //每个二维数组2行
var result = Array2D.z按行数分页(arr, pageSize);
logjson(result); // 输出分页后的新数组
//输出结果
//[[[1,2],      //第1页   1行 列数按原来
//  [3,4]],               2行
// [[5,6],      //第2页   1行 列数按原来
//  [7,8]],               2行
// [[9,10]]]    //第3页   1行 列数按原来

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

说明:
  • 这个函数用于按照每页数量(行数的数量)对二维数组进行分页，并返回分页后的新数组
别名:
  • z按行数分页
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
每页数量 number 即内部的每个新二维数组的行数
返回值:
分页后的新多维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var pageSize = 2;  //每个二维数组2行
var result = Array2D.pageByRows(arr, pageSize);
logjson(result); // 输出分页后的新数组
//输出结果
//[[[1,2],      //第1页   1行  列数按原来
//  [3,4]],               2行
// [[5,6],      //第2页   1行  列数按原来
//  [7,8]],               2行
// [[9,10]]]    //第3页   1行  列数按原来

z按下标分页(arr, 下标数组) → {Array}

说明:
  • 这个函数用于按照下标数组对二维数组进行分页，返回分页后的新数组,结果为多组二维数组
别名:
  • pageByIndexs
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
下标数组 Array 每页第一个元素的下标数组 或 回调函数
返回值:
分页后的新多组二维(多维)数组
Type
Array
例子
//示例1
var arr=[0,1,2,3,4,5,6,7,8,9,10,11,12];
var rs=Array2D.z按下标分页(arr,[4,9]); //按下标分组
     //第4个,第9个分组  下标是0开始  第1组:0,1,2,3  第2组:4,5,6,7,8  第3组: 9,10,11,12
logjson(rs,0);
//输出结果
[[0,1,2,3],[4,5,6,7,8],[9,10,11,12]]
//示例2   回调函数
var arr=[["ID","产品","国家","数量","价格","年","月","日"],
		 [1,"Product1","中国",19,1,2023,10,10],
		 [2,"Product2","德国",19,5,2023,4,5],
		 ["ID","产品","国家","数量","价格","年","月","日"],
		 [6,"Product2","德国",18,5,2023,2,18],
		 [7,"Product2","英国",11,5,2023,6,16],
		 [8,"Product2","美国",11,5,2023,6,21],
		 ["ID","产品","国家","数量","价格","年","月","日"],
		 [10,"Product1","德国",18,1,2021,11,13],
		 [11,"Product2","英国",11,5,2022,10,14]];
var rs=Array2D.z按下标分页(arr,'f1=="ID"');
logjson(rs);
//输出结果
[[["ID","产品","国家","数量","价格","年","月","日"],
   [1,"Product1","中国",19,1,2023,10,10],
   [2,"Product2","德国",19,5,2023,4,5]],
 [["ID","产品","国家","数量","价格","年","月","日"],
  [6,"Product2","德国",18,5,2023,2,18],
  [7,"Product2","英国",11,5,2023,6,16],
  [8,"Product2","美国",11,5,2023,6,21]],
 [["ID","产品","国家","数量","价格","年","月","日"],
  [10,"Product1","德国",18,1,2021,11,13],
  [11,"Product2","英国",11,5,2022,10,14]]]

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

说明:
  • 这个函数用于按照下标数组对二维数组进行分页，返回分页后的新数组,结果为多组二维数组
别名:
  • z按下标分页
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
下标数组 Array 每页第一个元素的下标数组 或 回调函数
返回值:
分页后的新多组二维(多维)数组
Type
Array
例子
//示例1
var arr=[0,1,2,3,4,5,6,7,8,9,10,11,12];
var rs=Array2D.pageByIndexs(arr,[4,9]); //按下标分组
     //第4个,第9个分组  下标是0开始  第1组:0,1,2,3  第2组:4,5,6,7,8  第3组: 9,10,11,12
logjson(rs,0);
//输出结果
[[0,1,2,3],[4,5,6,7,8],[9,10,11,12]]
//示例2   回调函数
var arr=[["ID","产品","国家","数量","价格","年","月","日"],
		 [1,"Product1","中国",19,1,2023,10,10],
		 [2,"Product2","德国",19,5,2023,4,5],
		 ["ID","产品","国家","数量","价格","年","月","日"],
		 [6,"Product2","德国",18,5,2023,2,18],
		 [7,"Product2","英国",11,5,2023,6,16],
		 [8,"Product2","美国",11,5,2023,6,21],
		 ["ID","产品","国家","数量","价格","年","月","日"],
		 [10,"Product1","德国",18,1,2021,11,13],
		 [11,"Product2","英国",11,5,2022,10,14]];
var rs=Array2D.pageByIndexs(arr,'f1=="ID"');
logjson(rs);
//输出结果
[[["ID","产品","国家","数量","价格","年","月","日"],
   [1,"Product1","中国",19,1,2023,10,10],
   [2,"Product2","德国",19,5,2023,4,5]],
 [["ID","产品","国家","数量","价格","年","月","日"],
  [6,"Product2","德国",18,5,2023,2,18],
  [7,"Product2","英国",11,5,2023,6,16],
  [8,"Product2","美国",11,5,2023,6,21]],
 [["ID","产品","国家","数量","价格","年","月","日"],
  [10,"Product1","德国",18,1,2021,11,13],
  [11,"Product2","英国",11,5,2022,10,14]]]

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

说明:
  • 这个函数用于取二维数组最后一组的一维数组，并返回这组取出的一维数组
别名:
  • pop
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
最后一组的一维数组 没有为空
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z尾部弹出一项(arr);
logjson(result);  // 输出弹出的项
//输出结果
[5,6]

pop(arr) → {Array}

说明:
  • 这个函数用于取二维数组最后一组的一维数组，并返回这组取出的一维数组
别名:
  • z尾部弹出一项
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
最后一组的一维数组 没有为空
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.pop(arr);
logjson(result);  // 输出弹出的项
//输出结果
[5,6]

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

说明:
  • 这个函数用于在二维数组的末尾追加一项，并返回追加后的二维数组
别名:
  • push
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
单行数组 Array 要追加的单行数组(一维数组)
返回值:
追加后的二维数组
Type
Array
例子
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, 单行数组) → {Array}

说明:
  • 这个函数用于在二维数组的末尾追加一项，并返回追加后的二维数组
别名:
  • z追加一项
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
单行数组 Array 要追加的单行数组(一维数组)
返回值:
追加后的二维数组
Type
Array
例子
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
返回新二维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z随机一项(arr);
logjson(result);   // 输出选择的项
//输出结果
[[5,6]]

random(arr) → {Array}

说明:
  • 从二维数组中随机选择一组一维数组，并返回选择的项
别名:
  • z随机一项
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
返回新二维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.random(arr);
logjson(result);   // 输出选择的项
//输出结果
[[1, 2]]

z排名(arr, 参考列, 中式美式) → {Array}

说明:
  • 对二维数组排名 返回排名结果单列二维数组
别名:
  • rank
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
参考列 String 列号+- f1+代表第一列升序
中式美式 String "cn|usa|+" cn中国 usa美式 +顺序递增
返回值:
返回排名结果 单列二维数组
Type
Array
例子
function rank排名_test(){
	 var arr=[[1,90,'女'],
           [2,80,'女'],
           [3,90,'男'],
           [4,76,'女'],
           [5,88,'男'],
           [6,100,'女'],
           [7,80,'男'],
           [8,100,'男'],
           [9,80,'女'],
           [10,90,'男']
          ]
      var rs=[];
      var 中式排名降序=$$.z排名(arr,'f2-','cn');
      var 美式排名降序=$$.z排名(arr,'f2-','usa');
      var 加号顺序编号=$$.z排名(arr,'f2-','+');
     //2列排名结果 依次放到原数组右侧
      rs=$$.zip(arr,中式排名降序)
	  rs=$$.zip(rs,美式排名降序)
	  rs=$$.zip(rs,加号顺序编号)
      logjson(Array2D.sortByCols(rs,'f2-'));
}  
 // 输出结果
[[6,100,"女",1,1,1],
 [8,100,"男",1,1,2],
 [1,90,"女",2,3,3],
 [3,90,"男",2,3,4],
 [10,90,"男",2,3,5],
 [5,88,"男",3,6,6],
 [2,80,"女",4,7,7],
 [7,80,"男",4,7,8],
 [9,80,"女",4,7,9],
 [4,76,"女",5,10,10]]

rank(arr, 参考列, 中式美式) → {Array}

说明:
  • 对二维数组排名 返回排名结果单列二维数组
别名:
  • z排名
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
参考列 String 列号+- f1+代表第一列升序
中式美式 String "cn|usa|+" cn中国 usa美式 +顺序递增
返回值:
返回排名结果 单列二维数组
Type
Array
例子
function rank排名_test(){
	 var arr=[[1,90,'女'],
           [2,80,'女'],
           [3,90,'男'],
           [4,76,'女'],
           [5,88,'男'],
           [6,100,'女'],
           [7,80,'男'],
           [8,100,'男'],
           [9,80,'女'],
           [10,90,'男']
          ]
      var rs=[];
      var 中式排名降序=$$.rank(arr,'f2-','cn');
      var 美式排名降序=$$.rank(arr,'f2-','usa');
      var 加号顺序编号=$$.rank(arr,'f2-','+');
     //2列排名结果 依次放到原数组右侧
      rs=$$.zip(arr,中式排名降序)
	  rs=$$.zip(rs,美式排名降序)
	  rs=$$.zip(rs,加号顺序编号)
      logjson(Array2D.sortByCols(rs,'f2-'));
}  
 // 输出结果
[[6,100,"女",1,1,1],
 [8,100,"男",1,1,2],
 [1,90,"女",2,3,3],
 [3,90,"男",2,3,4],
 [10,90,"男",2,3,5],
 [5,88,"男",3,6,6],
 [2,80,"女",4,7,7],
 [7,80,"男",4,7,8],
 [9,80,"女",4,7,9],
 [4,76,"女",5,10,10]]

z分组排名(arr, 参考列, 分组列, 中式美式) → {Array}

说明:
  • 对二维数组排名 返回排名结果单列二维数组
别名:
  • rankGroup
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
参考列 String 列号+- f1+代表第一列升序 可使用列选择器
分组列 String 列号+- f1+代表第一列升序 可使用列选择器
中式美式 String "cn|usa|+" cn中国 usa美式 +顺序编号
返回值:
返回排名结果 单列二维数组
Type
Array
例子
function 分组排名_test(){
	 var arr=[[1,90,'女'],
           [2,80,'女'],
           [3,90,'男'],
           [4,76,'女'],
           [5,88,'男'],
           [6,100,'女'],
           [7,80,'男'],
           [8,100,'男'],
           [9,80,'女'],
           [10,90,'男']
          ]
      var rs=[];
      var 分组中式排名降序=$$.rankGroup(arr,'f2-',"f3",'cn',false);
      var 分组美式排名降序=$$.rankGroup(arr,'f2-',"f3",'usa',false);
      var 分组加号顺序编号=$$.rankGroup(arr,'f2-',"f3",'+',false);
     //3列排名结果 依次放到原数组右侧
      rs=$$.zip(arr,分组中式排名降序)
	  rs=$$.zip(rs,分组美式排名降序)
	  rs=$$.zip(rs,分组加号顺序编号)
      logjson(Array2D.sortByCols(rs,'f3+,f2-'));
}
     //输出结果
     [[8,100,"男",1,1,1],
 [3,90,"男",2,2,2],
 [10,90,"男",2,2,3],
 [5,88,"男",3,4,4],
 [7,80,"男",4,5,5],
 [6,100,"女",1,1,1],
 [1,90,"女",2,2,2],
 [2,80,"女",3,3,3],
 [9,80,"女",3,3,4],
 [4,76,"女",4,5,5]]

rankGroup(arr, 参考列, 分组列, 中式美式) → {Array}

说明:
  • 对二维数组排名 返回排名结果单列二维数组
别名:
  • z分组排名
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
参考列 String 列号+- f1+代表第一列升序 可使用列选择器
分组列 String 列号+- f1+代表第一列升序 可使用列选择器
中式美式 String "cn|usa|+" cn中国 usa美式 +顺序编号
返回值:
返回排名结果 单列二维数组
Type
Array
例子
function 分组排名_test(){
	 var arr=[[1,90,'女'],
           [2,80,'女'],
           [3,90,'男'],
           [4,76,'女'],
           [5,88,'男'],
           [6,100,'女'],
           [7,80,'男'],
           [8,100,'男'],
           [9,80,'女'],
           [10,90,'男']
          ]
      var rs=[];
      var 分组中式排名降序=$$.rankGroup(arr,'f2-',"f3",'cn',false);
      var 分组美式排名降序=$$.rankGroup(arr,'f2-',"f3",'usa',false);
      var 分组加号顺序编号=$$.rankGroup(arr,'f2-',"f3",'+',false);
     //3列排名结果 依次放到原数组右侧
      rs=$$.zip(arr,分组中式排名降序)
	  rs=$$.zip(rs,分组美式排名降序)
	  rs=$$.zip(rs,分组加号顺序编号)
      logjson(Array2D.sortByCols(rs,'f3+,f2-'));
}
     //输出结果
     [[8,100,"男",1,1,1],
 [3,90,"男",2,2,2],
 [10,90,"男",2,2,3],
 [5,88,"男",3,4,4],
 [7,80,"男",4,5,5],
 [6,100,"女",1,1,1],
 [1,90,"女",2,2,2],
 [2,80,"女",3,3,3],
 [9,80,"女",3,3,4],
 [4,76,"女",4,5,5]]

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

说明:
  • 这个函数用于按范围遍历二维数组，并返回原数组
别名:
  • rangeForEach
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
address Array 地址 或 范围 [行起, 列起, 行数, 列数] = [0, 0, Infinity, Infinity]
回调函数 function (当前元素,行号,列号,原数组) => 回调函数
返回值:
原数组
Type
Array
例子
//示例1
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], //(数组从0下标开始)行起,列起,行数,列数 相当于 [行起,列起].Resize(行数,列数) = A1:B2这个区域 
     (item,i,j,arr)=>{           //当前元素,行号,列号,原数组
          console.log([item,i,j,arr[i][j+1]].toString())
     }
);
//输出结果
A1,0,0,B1
B1,0,1,C1
A2,1,0,B2
B2,1,1,C2
//示例2
var rs=[];
Array2D.z按范围遍历(                           
     arr,
     'c4:e5',  //相当于[3,2,2,3]  行起,列起,行数,列数
     (item,i,j)=>{            //当前元素,行号,列号
          rs.push([item,i,j]);  //添加到结果数组
     }
);
logjson(rs,0);
//输出结果
[["C4",3,2],["D4",3,3],["E4",3,4],
 ["C5",4,2],["D5",4,3],["E5",4,4]]
//示例3   也可以使用原数组参数来直接对原数组进行修改:
Array2D.z按范围遍历(
     arr,
     [0, 0, 2, 2],                   //(数组从0下标开始)行起,列起,行数,列数 代表 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, address, 回调函数) → {Array}

说明:
  • 这个函数用于按范围遍历二维数组，并返回原数组
别名:
  • z按范围遍历
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
address Array 地址 或 范围 [行起, 列起, 行数, 列数] = [0, 0, Infinity, Infinity]
回调函数 function (当前元素,行号,列号,原数组) => 回调函数
返回值:
原数组
Type
Array
例子
//示例1
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], //(数组从0下标开始)行起,列起,行数,列数 相当于 [行起,列起].Resize(行数,列数) = A1:B2这个区域 
     (item,i,j,arr)=>{           //当前元素,行号,列号,原数组
          console.log([item,i,j,arr[i][j+1]].toString())
     }
);
//输出结果
A1,0,0,B1
B1,0,1,C1
A2,1,0,B2
B2,1,1,C2
//示例2
var rs=[];
Array2D.rangeForEach(                           
     arr,
     'c4:e5',  //相当于[3,2,2,3]  行起,列起,行数,列数
     (item,i,j)=>{            //当前元素,行号,列号
          rs.push([item,i,j]);  //添加到结果数组
     }
);
logjson(rs,0);
//输出结果
[["C4",3,2],["D4",3,3],["E4",3,4],
 ["C5",4,2],["D5",4,3],["E5",4,4]]
//示例3   也可以使用原数组参数来直接对原数组进行修改:
Array2D.rangeForEach(
     arr,
     [0, 0, 2, 2],                   //(数组从0下标开始)行起,列起,行数,列数 代表 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, address, 条件回调函数) → {Array}

说明:
  • 这个函数用于对二维数组的指定范围进行局部映射，并返回映射后的二维数组
别名:
  • rangeMap
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
address Array 地址 或 范围 [行起, 列起, 行数, 列数] = [0, 0, Infinity, Infinity]
条件回调函数 function (当前元素,行号,列号,原数组) => 回调函数
返回值:
映射后的二维数组
Type
Array
例子
//示例1   3行2列 + 这个区域加**后缀
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"]];
var result = Array2D.z局部映射(arr, [0, 0, 3, 2], x=>x+'**'); //[行起, 列起, 行数, 列数]  相当于'a1:b3'
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"]]
//示例2
var rs=Array2D.z局部映射(arr, 'a1:b3',  //相当于 [0,0,3,2]
	(x,i,j,brr)=>`${x}-${i}-${j}-${arr[i][j+2]}`);  // (当前元素,行号,列号,原数组) => 回调函数 
logjson(rs);
//输出结果
[["A1-0-0-C1","B1-0-1-D1","C1","D1","E1","F1"],
 ["A2-1-0-C2","B2-1-1-D2","C2","D2","E2","F2"],
 ["A3-2-0-C3","B3-2-1-D3","C3","D3","E3","F3"],
 ["A4","B4","C4","D4","E4","F4"],
 ["A5","B5","C5","D5","E5","F5"]]

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

说明:
  • 这个函数用于对二维数组的指定范围进行局部映射，并返回映射后的二维数组
别名:
  • z局部映射
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
address Array 地址 或 范围 [行起, 列起, 行数, 列数] = [0, 0, Infinity, Infinity]
条件回调函数 function (当前元素,行号,列号,原数组) => 回调函数
返回值:
映射后的二维数组
Type
Array
例子
//示例1   3行2列 + 这个区域加**后缀
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"]];
var result = Array2D.rangeMap(arr, [0, 0, 3, 2], x=>x+'**'); //[行起, 列起, 行数, 列数]  相当于'a1:b3'
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"]]
//示例2
var rs=Array2D.rangeMap(arr, 'a1:b3',  //相当于 [0,0,3,2]
	(x,i,j,brr)=>`${x}-${i}-${j}-${arr[i][j+2]}`);  // (当前元素,行号,列号,原数组) => 回调函数 
logjson(rs);
//输出结果
[["A1-0-0-C1","B1-0-1-D1","C1","D1","E1","F1"],
 ["A2-1-0-C2","B2-1-1-D2","C2","D2","E2","F2"],
 ["A3-2-0-C3","B3-2-1-D3","C3","D3","E3","F3"],
 ["A4","B4","C4","D4","E4","F4"],
 ["A5","B5","C5","D5","E5","F5"]]

z矩阵运算(arr, address, brr, 条件回调) → {Array}

说明:
  • 这个函数用于对二个二维数组按指定地址指定条件进行操作，并返回操作后的二维数组
别名:
  • rangeMatrix
参数列表:
参数名称 参数类型 备注
arr Array 主二维数组
address Array 地址范围 []: 完整数组行列
brr Array 进行操作的二维数组
条件回调 function (a,b) => 回调函数
返回值:
操作后的二维数组
Type
Array
例子
//示例1   2个一样大小的数组 元素相加得到一个结果数组
var arr = [[1, 2, 3], 
		 [4, 5, 6],
		 [7, 8, 9]];
var brr = [[1, 2, 3],
		 [4, 5, 6], 
		 [7, 8, 9]];
var result = Array2D.z矩阵运算(arr, [], brr, (a,b)=>a+b);  //arr, []代表全部区域  与brr数组累加
logjson(result);
//输出结果
[[2,4,6],
 [8,10,12],
 [14,16,18]]
//示例2     地址形式
//A数组中选取一个区域 与B数组运算 一般B数组传入一个和A数组选中的区域一样大小的区域    
//B数组的第2列与A数组的第2列进行计算
var rs = Array2D.z矩阵运算(arr, 
                          'b1:b3',    //只能使用这个地址形式
                          Array2D.selectCols(brr,'f2'), 
                          (a,b)=>a+b);
logjson(rs);
//输出结果
[[1,4,3],
 [4,10,6],
 [7,16,9]]

rangeMatrix(arr, address, brr, 条件回调) → {Array}

说明:
  • 这个函数用于对二个二维数组按指定地址指定条件进行操作，并返回操作后的二维数组
别名:
  • z矩阵运算
参数列表:
参数名称 参数类型 备注
arr Array 主二维数组
address Array 地址范围 []: 完整数组行列
brr Array 进行操作的二维数组
条件回调 function (a,b) => 回调函数
返回值:
操作后的二维数组
Type
Array
例子
//示例1   2个一样大小的数组 元素相加得到一个结果数组
var arr = [[1, 2, 3], 
		 [4, 5, 6],
		 [7, 8, 9]];
var brr = [[1, 2, 3],
		 [4, 5, 6], 
		 [7, 8, 9]];
var result = Array2D.rangeMatrix(arr, [], brr, (a,b)=>a+b);  //arr, []代表全部区域  与brr数组累加
logjson(result);
//输出结果
[[2,4,6],
 [8,10,12],
 [14,16,18]]
//示例2       地址形式
//A数组中选取一个区域 与B数组运算 一般B数组传入一个和A数组选中的区域一样大小的区域    
//B数组的第2列与A数组的第2列进行计算
var rs = Array2D.rangeMatrix(arr, 
                          'b1:b3',          //只能使用这个地址形式
                          Array2D.selectCols(brr,'f2'), 
                          (a,b)=>a+b);
logjson(rs);
//输出结果
[[1,4,3],
 [4,10,6],
 [7,16,9]]

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

说明:
  • 这个函数用于按范围选择二维数组的部分元素，并返回选择后的二维数组
别名:
  • rangeSelect
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
address Array 地址 或 范围 [行起, 列起, 行数, 列数] = [0, 0, Infinity, Infinity]
返回值:
选择后的二维数组
Type
Array
例子
//示例1
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]]
//示例2
logjson(Array2D.z按范围选择(arr, 'a1:b2'));  //相当于  [0, 0, 2, 2]
//输出结果
[[1,2],
 [4,5]]

rangeSelect(arr, address) → {Array}

说明:
  • 这个函数用于按范围选择二维数组的部分元素，并返回选择后的二维数组
别名:
  • z按范围选择
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
address Array 地址 或 范围 [行起, 列起, 行数, 列数] = [0, 0, Infinity, Infinity]
返回值:
选择后的二维数组
Type
Array
例子
//示例1
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]]
//示例2
logjson(Array2D.rangeSelect(arr, 'a1:b2'));  //相当于  [0, 0, 2, 2]
//输出结果
[[1,2],
 [4,5]]

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

说明:
  • 这个函数用于对二维数组进行聚合操作，并返回聚合结果对象
别名:
  • reduce
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
聚合回调函数 function 用于执行聚合操作的回调函数
种子初始值 * 聚合操作的种子初始值，默认为undefined
返回值:
聚合结果
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聚合
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
聚合回调函数 function 用于执行聚合操作的回调函数
种子初始值 * 聚合操作的种子初始值，默认为undefined
返回值:
聚合结果对象
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
聚合回调函数 function 用于执行聚合操作的回调函数
种子初始值 * 聚合操作的种子初始值，默认为undefined
返回值:
聚合结果对象
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倒序聚合
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
聚合回调函数 function 用于执行聚合操作的回调函数
种子初始值 * 聚合操作的种子初始值，默认为undefined
返回值:
聚合结果对象
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
个数 number 重复的次数
返回值:
重复后的结果二维数组
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次
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
个数 number 重复的次数
返回值:
重复后的结果二维数组
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
结果部分的二维数组
Type
Array
例子
//示例1
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var result = Array2D.z结果(arr);
logjson(result); // 输出结果部分的数组
//输出结果
[[1,"A"],
 [2,"B"],
 [3,"C"]]
//示例2
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var result = asArray2D(arr).filter('f1>1').map('f1**2').z结果();
logjson(result);  // 输出结果部分的数组
//输出结果
[[4],
 [9]]

res(arr) → {Array}

说明:
  • 这个函数用于获取二维数组通过前面代码得到的结果部分
别名:
  • z结果
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
结果部分的数组
Type
Array
例子
//示例1
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var result = Array2D.res(arr);
logjson(result); // 输出结果部分的数组
//输出结果
[[1,"A"],
 [2,"B"],
 [3,"C"]]
//示例2
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
反转后的结果数组
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反转
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
反转后的结果数组
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列号数组 Array 要选择列的索引数组
表头数组 Array 要指定的表头 默认原表头
返回值:
返回选择后的结果二维数组
Type
Array
例子
//示例1	
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]]
//示例2    //下面是按表头
var arr=[['a','b','c'],
         [1,2,3],
         [4,5,6],
         [7,8,9]];
logjson($$.z选择列(arr,['c','b','a']));  //按首行表头 错位选择
//输出结果
[["c","b","a"],
 [3,2,1],
 [6,5,4],
 [9,8,7]]
//示例3    按自定义表头 第2个数组为每列依次指定新的表头
logjson($$.z选择列(arr,['x','z'],['x','y','z']));
//输出结果
[["x","z"],
 [1,3],
 [4,6],
 [7,9]]

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

说明:
  • 这个函数用于选择二维数组中指定的列(列号数组可以是表头数组)，并返回选择后的结果二维数组
别名:
  • z选择列
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列号数组 Array 要选择列的索引数组
表头数组 Array 要指定的表头 默认原表头
返回值:
返回选择后的结果二维数组
Type
Array
例子
//示例1	
var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var columnIndexes = [0, 2]; // 选择第一列和第三列
var result = Array2D.selectCols(arr, columnIndexes);
logjson(result);  // 输出选择后的结果数组
//输出结果
[[1,3],
 [4,6],
 [7,9]]
//示例2    //下面是按表头
var arr=[['a','b','c'],
         [1,2,3],
         [4,5,6],
         [7,8,9]];
logjson($$.selectCols(arr,['c','b','a']));  //按首行表头 错位选择
//输出结果
[["c","b","a"],
 [3,2,1],
 [6,5,4],
 [9,8,7]]
//示例3    按自定义表头 第2个数组为每列依次指定新的表头
logjson($$.selectCols(arr,['x','z'],['x','y','z']));
//输出结果
[["x","z"],
 [1,3],
 [4,6],
 [7,9]]

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

说明:
  • 这个函数用于选择二维数组中指定的行，并返回选择后的结果二维数组
别名:
  • selectRows
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
行号数组 Array 要选择的行的索引数组
返回值:
选择后的结果二维数组
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选择行
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
行号数组 Array 要选择的行的索引数组
返回值:
选择后的结果二维数组
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, 个数) → {Array}

说明:
  • 删除二维数组中的前N个元素，并返回被删除的二维数组, 原数组为删除后的二维数组
别名:
  • shift
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
个数 number 要删除的元素个数，默认为1
返回值:
被删除的二维数组
Type
Array
例子
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]]
logjson(arr);
//输出结果  删除后的原数组 --- 原数组改变
[[7,8,9]]

shift(arr, 个数) → {Array}

说明:
  • 删除二维数组中的前N个元素，并返回被删除的二维数组, 原数组为删除后的二维数组
别名:
  • z删除第一个
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
个数 number 要删除的元素个数，默认为1
返回值:
被删除的二维数组
Type
Array
例子
var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
var count = 2; // 删除前二个元素
var result = Array2D.shift(arr, count);
logjson(result);
//输出结果   被删除的二个元素 
[[1,2,3],
 [4,5,6]]
logjson(arr);
//输出结果  删除后的原数组 --- 原数组改变
[[7,8,9]]

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

说明:
  • 这个函数用于随机打乱二维数组中的元素顺序，并返回打乱后的结果二维数组
别名:
  • shuffle
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
打乱后的结果二维数组
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随机打乱
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
打乱后的结果二维数组
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
个数 number 要跳过的元素个数
返回值:
跳过后的结果二维数组
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个
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
个数 number 要跳过的元素个数
返回值:
跳过后的结果二维数组
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}

说明:
  • 这个函数用于跳过二维数组中前面连续满足条件的元素，并返回跳过后的结果二维数组
别名:
  • skipWhile
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 用于判断元素是否满足条件的回调函数 (row) => 回调函数
返回值:
跳过后的结果二维数组
Type
Array
例子
var arr = [[3, 2], [4, 4], [5, 6],[1, 2],[4, 2]];
var conditionCallback = (subArray) => subArray[0] > 2; // 判断子数组的第一个元素是否大于2
var result = Array2D.z跳过前面连续满足(arr, conditionCallback);
logjson(result);  // 输出跳过后的结果数组
//输出结果
[[1,2],
 [4,2]]

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

说明:
  • 这个函数用于跳过二维数组中前面连续满足条件的元素，并返回跳过后的结果二维数组
别名:
  • z跳过前面连续满足
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 用于判断元素是否满足条件的回调函数 (row) => 回调函数
返回值:
跳过后的结果二维数组
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
开始位置 number 切片的起始位置 (从0开始计算)
结束位置 number 不包含
返回值:
切片后的结果二维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];

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

slice(arr, 开始位置, 结束位置) → {Array}

说明:
  • 这个函数用于对二维数组进行行切片操作，并返回切片后的结果二维数组
别名:
  • z行切片
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
开始位置 number 切片的起始位置 (从0开始计算)
结束位置 number 不包含
返回值:
切片后的结果二维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];
var result = Array2D.slice(arr, 1, 3);
logjson(result); 
//输出结果  
[[3,4],
 [5,6]]

z满足条件(arr, 列选择函数) → {Boolean}

说明:
  • 这个函数用于判断二维数组中是否存在至少一个满足条件的元素
别名:
  • some
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 条件回调: (子数组/一维数组) => 回调函数判断元素是否满足条件的
返回值:
是否存在至少一个满足条件的元素
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满足条件
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 条件回调: (子数组/一维数组) => 回调函数判断元素是否满足条件的
返回值:
是否存在至少一个满足条件的元素
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
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
排序后的结果二维数组
Type
Array
例子
var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.z升序排序(arr);  //按数组首列升序
logjson(result);  
//输出结果
[[1,"A"],
 [2,"B"],
 [3,"C"]]

sort(arr) → {Array}

说明:
  • 这个函数用于对二维数组首列进行升序排序，并返回排序后的结果二维数组
别名:
  • z升序排序
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
排序后的结果二维数组
Type
Array
例子
var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.sort(arr);  //按数组首列升序
logjson(result);  
//输出结果
[[1,"A"],
 [2,"B"],
 [3,"C"]]

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

说明:
  • 这个函数用于对二维数组进行按规则升序排序，并返回排序后的结果二维数组
别名:
  • sortBy
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择器 function 选择排序列 或 (row) => 回调函数;
返回值:
排序后的结果二维数组
Type
Array
例子
//示例1
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"]]
//示例2
var arr=[[2,"Product2","德国",19,5,2023,4,5,"德国",19],
		 [11,"Product2","英国",11,5,2022,10,7,"英国",11],
		 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
		 [1,"Product1","中国",19,1,2023,10,10,"中国",19],
		 [3,"Product2","英国",19,5,2022,6,28,"英国",19]];
var rs=$$.z按规则升序(arr,'f1');  //按实际数组第1列升序排序
logjson(rs);
//输出结果
[[1,"Product1","中国",19,1,2023,10,10,"中国",19],
 [2,"Product2","德国",19,5,2023,4,5,"德国",19],
 [3,"Product2","英国",19,5,2022,6,28,"英国",19],
 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
 [11,"Product2","英国",11,5,2022,10,7,"英国",11]]

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

说明:
  • 这个函数用于对二维数组进行按规则升序排序，并返回排序后的结果二维数组
别名:
  • z按规则升序
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择器 function 选择排序列 或 (row) => 回调函数;
返回值:
排序后的结果二维数组
Type
Array
例子
//示例1
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"]]
//示例2
var arr=[[2,"Product2","德国",19,5,2023,4,5,"德国",19],
		 [11,"Product2","英国",11,5,2022,10,7,"英国",11],
		 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
		 [1,"Product1","中国",19,1,2023,10,10,"中国",19],
		 [3,"Product2","英国",19,5,2022,6,28,"英国",19]];
var rs=$$.sortBy(arr,'f1');  //按实际数组第1列升序排序
logjson(rs);
//输出结果
[[1,"Product1","中国",19,1,2023,10,10,"中国",19],
 [2,"Product2","德国",19,5,2023,4,5,"德国",19],
 [3,"Product2","英国",19,5,2022,6,28,"英国",19],
 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
 [11,"Product2","英国",11,5,2022,10,7,"英国",11]]

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

说明:
  • 这个函数用于对二维数组进行按规则降序排序，并返回排序后的结果二维数组
别名:
  • sortByDesc
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择器 function 选择排序列 或 (row) => 回调函数;
返回值:
排序后的结果二维数组
Type
Array
例子
//示例1
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"]]
//示例2
var arr=[[2,"Product2","德国",19,5,2023,4,5,"德国",19],
		 [11,"Product2","英国",11,5,2022,10,7,"英国",11],
		 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
		 [1,"Product1","中国",19,1,2023,10,10,"中国",19],
		 [3,"Product2","英国",19,5,2022,6,28,"英国",19]];
var rs=$$.z按规则降序(arr,'f1');
logjson(rs);
//输出结果
[[11,"Product2","英国",11,5,2022,10,7,"英国",11],
 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
 [3,"Product2","英国",19,5,2022,6,28,"英国",19],
 [2,"Product2","德国",19,5,2023,4,5,"德国",19],
 [1,"Product1","中国",19,1,2023,10,10,"中国",19]]

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

说明:
  • 这个函数用于对二维数组进行按规则降序排序，并返回排序后的结果二维数组
别名:
  • z按规则降序
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择器 function 选择排序列 或 (row) => 回调函数;
返回值:
排序后的结果二维数组
Type
Array
例子
//示例1
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"]]
//示例2
var arr=[[2,"Product2","德国",19,5,2023,4,5,"德国",19],
		 [11,"Product2","英国",11,5,2022,10,7,"英国",11],
		 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
		 [1,"Product1","中国",19,1,2023,10,10,"中国",19],
		 [3,"Product2","英国",19,5,2022,6,28,"英国",19]];
var rs=$$.sortByDesc(arr,'f1');
logjson(rs);
//输出结果
[[11,"Product2","英国",11,5,2022,10,7,"英国",11],
 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
 [3,"Product2","英国",19,5,2022,6,28,"英国",19],
 [2,"Product2","德国",19,5,2023,4,5,"德国",19],
 [1,"Product1","中国",19,1,2023,10,10,"中国",19]]

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

说明:
  • 这个函数用于对二维数组首列进行降序排序，并返回排序后的结果二维数组
别名:
  • sortDesc
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
排序后的结果二维数组
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降序排序
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
排序后的结果二维数组
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, header) → {Array}

说明:
  • 这个函数用于对二维数组选择指定列按自定义序列(可选择表头行数)进行排序, 并返回结果二维数组
别名:
  • sortByList
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择器 function 选择指定列 (列号, f模式) 或 (row) => 回调函数模式
list Array 排序列表, 数字必须用数组形式, 非数字可以直接使用字符串形式用逗号分隔
header Number 表头行数 默认为0
返回值:
排序后的二维数组
Type
Array
例子
//示例1  直接写列号
var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.z自定义排序(arr,0,[2,3,1]);  //实际数组第1列, 按2,3,1顺序排序, 数字必须用数组形式
logjson(result);
//输出结果
[[2,"B"],
 [3,"C"],
 [1,"A"]]
//示例2   列回调模式   r => 回调条件
logjson(Array2D.z自定义排序(arr,r=>r[0],[2,3,1]));
//输出结果
[[2,"B"],
 [3,"C"],
 [1,"A"]]  
//示例3   f模式
var arr = [["ID","产品","国家","数量","价格","年","月","日","国家","数量"],
		   [13,"Product1","中国",11,1,2022,9,2,"中国",11],
		   [8,"Product2","美国",11,5,2023,6,21,"美国",11],
	       [10,"Product1","德国",18,1,2021,11,13,"德国",18],
		   [7,"Product2","英国",11,5,2023,6,16,"英国",11]];
var result = Array2D.z自定义排序(arr,"f3",'中国,英国,美国,德国',1); 
	//实际数组第3列, 按'中国,英国,美国,德国'顺序排序,非数字可以使用字符串形式 第1行标题行
logjson(result); 
//输出结果
[["ID","产品","国家","数量","价格","年","月","日","国家","数量"],
 [13,"Product1","中国",11,1,2022,9,2,"中国",11],
 [7,"Product2","英国",11,5,2023,6,16,"英国",11],
 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
 [10,"Product1","德国",18,1,2021,11,13,"德国",18]]

sortByList(arr, 列选择器, list, header) → {Array}

说明:
  • 这个函数用于对二维数组选择指定列按自定义序列(可选择表头行数)进行排序, 并返回结果二维数组
别名:
  • z自定义排序
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择器 function 选择指定列 (列号, f模式) 或 (row) => 回调函数模式
list Array 排序列表, 数字必须用数组形式, 非数字可以直接使用字符串形式用逗号分隔
header Number 表头行数 默认为0
返回值:
排序后的二维数组
Type
Array
例子
//示例1  直接写列号
var arr = [[3, 'C'], [1, 'A'], [2, 'B']];
var result = Array2D.sortByList(arr,0,[2,3,1]);  //实际数组第1列, 按2,3,1顺序排序, 数字必须用数组形式
logjson(result);
//输出结果
[[2,"B"],
 [3,"C"],
 [1,"A"]]
//示例2   列回调模式   r => 回调条件
logjson(Array2D.sortByList(arr,r=>r[0],[2,3,1]));
//输出结果
[[2,"B"],
 [3,"C"],
 [1,"A"]]  
//示例3   f模式
var arr = [["ID","产品","国家","数量","价格","年","月","日","国家","数量"],
		   [13,"Product1","中国",11,1,2022,9,2,"中国",11],
		   [8,"Product2","美国",11,5,2023,6,21,"美国",11],
	       [10,"Product1","德国",18,1,2021,11,13,"德国",18],
		   [7,"Product2","英国",11,5,2023,6,16,"英国",11]];
var result = Array2D.sortByList(arr,"f3",'中国,英国,美国,德国',1); 
	//实际数组第3列, 按'中国,英国,美国,德国'顺序排序,非数字可以使用字符串形式 第1行标题行
logjson(result); 
//输出结果
[["ID","产品","国家","数量","价格","年","月","日","国家","数量"],
 [13,"Product1","中国",11,1,2022,9,2,"中国",11],
 [7,"Product2","英国",11,5,2023,6,16,"英国",11],
 [8,"Product2","美国",11,5,2023,6,21,"美国",11],
 [10,"Product1","德国",18,1,2021,11,13,"德国",18]]

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

说明:
  • 这个函数用于对二维数组按指定列(可选表头行数, 可选升序或降序)进行排序, 并返回排序后结果二维数组
别名:
  • sortByCols
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
cols String 排序列 f1+ 加表示升序 f2- 减表示降序 也可使用 0+ 1- 模式
header Number 表头行数, 默认为0
返回值:
排序后的结果二维数组
Type
Array
例子
//示例1  直接写列号
var arr = [[3, 'C'], [2, 'C'], [1, 'A'], [3, 'D'], [2, 'B']];
var result = Array2D.z多列排序(arr,'0+,1-');  //实际数组第1列升序, 第2列降序排序
logjson(result);
//输出结果
[[1,"A"],
 [2,"C"],
 [2,"B"],
 [3,"D"],
 [3,"C"]]
//示例2   f模式
var arr = [["ID","产品","国家","数量","价格","年","月","日","国家","数量"],
		   [13,"Product1","中国",11,1,2022,9,2,"中国",11],
		   [8,"Product2","中国",11,5,2023,6,21,"中国",11],
	       [10,"Product1","中国",18,1,2021,11,13,"中国",18],
		   [7,"Product2","中国",11,5,2022,6,16,"中国",11]];
var result = Array2D.z多列排序(arr,"f2+,f6-", 1);  //实际数组第2列升序, 第6列降序排序   1行表头
logjson(result); 
//输出结果
[["ID","产品","国家","数量","价格","年","月","日","国家","数量"],
 [13,"Product1","中国",11,1,2022,9,2,"中国",11],
 [10,"Product1","中国",18,1,2021,11,13,"中国",18],
 [8,"Product2","中国",11,5,2023,6,21,"中国",11],
 [7,"Product2","中国",11,5,2022,6,16,"中国",11]]

sortByCols(arr, cols, header) → {Array}

说明:
  • 这个函数用于对二维数组按指定列(可选表头行数, 可选升序或降序)进行排序, 并返回排序后结果二维数组
别名:
  • z多列排序
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
cols String 排序列 f1+ 加表示升序 f2- 减表示降序 也可使用 0+ 1- 模式
header Number 表头行数, 默认为0
返回值:
排序后的结果二维数组
Type
Array
例子
//示例1  直接写列号
var arr = [[3, 'C'], [2, 'C'], [1, 'A'], [3, 'D'], [2, 'B']];
var result = Array2D.sortByCols(arr,'0+,1-');  //实际数组第1列升序, 第2列降序排序
logjson(result);
//输出结果
[[1,"A"],
 [2,"C"],
 [2,"B"],
 [3,"D"],
 [3,"C"]]
//示例2   f模式
var arr = [["ID","产品","国家","数量","价格","年","月","日","国家","数量"],
		   [13,"Product1","中国",11,1,2022,9,2,"中国",11],
		   [8,"Product2","中国",11,5,2023,6,21,"中国",11],
	       [10,"Product1","中国",18,1,2021,11,13,"中国",18],
		   [7,"Product2","中国",11,5,2022,6,16,"中国",11]];
var result = Array2D.sortByCols(arr,"f2+,f6-", 1);  //实际数组第2列升序, 第6列降序排序   1行表头
logjson(result); 
//输出结果
[["ID","产品","国家","数量","价格","年","月","日","国家","数量"],
 [13,"Product1","中国",11,1,2022,9,2,"中国",11],
 [10,"Product1","中国",18,1,2021,11,13,"中国",18],
 [8,"Product2","中国",11,5,2023,6,21,"中国",11],
 [7,"Product2","中国",11,5,2022,6,16,"中国",11]]

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

说明:
  • 这个函数用于删除二维数组中指定位置的行，并返回被删除的二维数组, 原数组修改成删除行并用替换值替换
别名:
  • splice
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
开始位置 number 要删除的开始行的位置 按0下标计算
删除行数 number 要删除行的数量
替换值 * 要替换删除行的值
返回值:
被删除的二维数组
Type
Array
例子
var arr = [[1, 'A'], 
		 [2, 'B'],
		 [3, 'C'],
		 [4, 'D'],
		 [6, 'F']];
var 开始行 = 1;  //实际数组第2行
var 行数 = 3;  //行数
var 原位替换值 = [5, 'E'];
var result = Array2D.z行切片删除行(arr, 开始行, 行数, 原位替换值);
logjson(result);  //返回被删除的行
//输出结果
[[2,"B"],
 [3,"C"],
 [4,"D"]]
//修改原数组删除并替换后的结果
logjson(arr);
//输出结果
[[1,"A"],
 [5,"E"],
 [6,"F"]]

splice(arr, 开始位置, 删除行数, 替换值) → {Array}

说明:
  • 这个函数用于删除二维数组中指定位置的行，并返回被删除的二维数组, 原数组修改成删除行并用替换值替换
别名:
  • z行切片删除行
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
开始位置 number 要删除的开始行的位置 按0下标计算
删除行数 number 要删除行的数量
替换值 * 要替换删除行的值
返回值:
被删除的二维数组
Type
Array
例子
var arr = [[1, 'A'], 
		 [2, 'B'],
		 [3, 'C'],
		 [4, 'D'],
		 [6, 'F']];
var 开始行 = 1;  //实际数组第2行
var 行数 = 3;  //行数
var 原位替换值 = [5, 'E'];
var result = Array2D.splice(arr, 开始行, 行数, 原位替换值);
logjson(result);  //返回被删除的行
//输出结果
[[2,"B"],
 [3,"C"],
 [4,"D"]]
//修改原数组删除并替换后的结果
logjson(arr);
//输出结果
[[1,"A"],
 [5,"E"],
 [6,"F"]]

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

说明:
  • 这个函数用于对二维数组中的指定列进行求和，并返回求和结果
别名:
  • sum
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 选择列(直接列0下标,f列模式) 或 (row) => 回调条件列模式
返回值:
求和结果
Type
number
例子
//示例1   直接写列  按0下标
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z求和(arr, 1);  //实际数组第2列求和
console.log(result); // 输出求和结果
//输出结果
12
//示例2   f列模式
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z求和(arr, 'f2');  //实际数组第2列求和
console.log(result); // 输出求和结果
//输出结果
12
//示例3    (row) => 回调条件列模式
var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1];   //实际数组第2列求和
var result = Array2D.z求和(arr, columnSelector);
console.log(result); // 输出求和结果
//输出结果
12

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

说明:
  • 这个函数用于对二维数组中的指定列进行求和，并返回求和结果
别名:
  • z求和
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
列选择函数 function 选择列(直接列0下标,f列模式) 或 (row) => 回调条件列模式
返回值:
求和结果
Type
number
例子
//示例1   直接写列  按0下标
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.sum(arr, 1);  //实际数组第2列求和
console.log(result); // 输出求和结果
//输出结果
12
//示例2   f列模式
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.sum(arr, 'f2');  //实际数组第2列求和
console.log(result); // 输出求和结果
//输出结果
12
//示例3    (row) => 回调条件列模式
var arr = [[1, 2], [3, 4], [5, 6]];
var columnSelector = (row) => row[1];   //实际数组第2列求和
var result = Array2D.sum(arr, columnSelector);
console.log(result); // 输出求和结果
//输出结果
12

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

说明:
  • 这个函数用于对两个二维数组进行超级查找操作，并返回查找结果二维数组
别名:
  • superLookup
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组
左表列选择器 function 左表中查找列(0下标列或f列模式) 或 回调函数: (row) => 回调:左表列
右表列选择器 function 右表中比对列(0下标列或f列模式) 或 回调函数: (row) => 回调:右表列
双表结果选择器 function 查找结果的回调函数，默认为 (a, b) => a.concat(b)
返回值:
查找结果二维数组
Type
Array
例子
//示例1   回调模式
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var brr = [[2, 'X'], [3, 'Y'], [4, 'Z']];
var leftKeySelector = (row) => row[0];  // 选择左表的实际第一列作为查找列
var rightKeySelector = (row) => row[0]; // 选择右表的实际第一列作为比对列
var resultSelector = (a, b) => a.concat(b); // 查找结果的选择器
var result = Array2D.z超级查找(arr, brr, leftKeySelector, rightKeySelector, resultSelector); //以左表为主
logjson(result);  
//输出结果
[[1,"A","",""],
 [2,"B",2,"X"],
 [3,"C",3,"Y"]]
//示例2   f列模式
logjson(Array2D.z超级查找(arr, brr, 'f1', 'f1')); //以左表为主
//输出结果
[[1,"A","",""],
 [2,"B",2,"X"],
 [3,"C",3,"Y"]]
//示例3   直接列模式   0下标
logjson(Array2D.z超级查找(arr, brr, 0, 0, (a,b)=>a.concat(b))); //以左表为主
//输出结果
[[1,"A","",""],
 [2,"B",2,"X"],
 [3,"C",3,"Y"]]

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

说明:
  • 这个函数用于对两个二维数组进行超级查找操作，并返回查找结果二维数组
别名:
  • z超级查找
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组
左表列选择器 function 左表中查找列(0下标列或f列模式) 或 回调函数: (row) => 回调左表列
右表列选择器 function 右表中比对列(0下标列或f列模式) 或 回调函数: (row) => 回调右表列
双表结果选择器 function 查找结果的回调函数，默认为 (a, b) => a.concat(b)
返回值:
查找结果二维数组
Type
Array
例子
//示例1   回调模式
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var brr = [[2, 'X'], [3, 'Y'], [4, 'Z']];
var leftKeySelector = (row) => row[0];  // 选择左表的实际第一列作为查找列
var rightKeySelector = (row) => row[0]; // 选择右表的实际第一列作为比对列
var resultSelector = (a, b) => a.concat(b); // 查找结果的选择器
var result = Array2D.superLookup(arr, brr, leftKeySelector, rightKeySelector, resultSelector); //以左表为主
logjson(result);  
//输出结果
[[1,"A","",""],
 [2,"B",2,"X"],
 [3,"C",3,"Y"]]
//示例2   f列模式
logjson(Array2D.superLookup(arr, brr, 'f1', 'f1')); //以左表为主
//输出结果
[[1,"A","",""],
 [2,"B",2,"X"],
 [3,"C",3,"Y"]]
//示例3   直接列模式   0下标
logjson(Array2D.superLookup(arr, brr, 0, 0, (a,b)=>a.concat(b))); //以左表为主
//输出结果
[[1,"A","",""],
 [2,"B",2,"X"],
 [3,"C",3,"Y"]]

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

说明:
  • 这个函数用于从二维数组中取前N个元素，并返回取到的结果二维数组
别名:
  • take
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
个数 number 要取子元素(行)个数
返回值:
取到的结果二维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6], [7, 8]];
var count = 2;  //取前二行
var result = Array2D.z取前N个(arr, count);
logjson(result);  // 输出取到的结果数组
//输出结果
[[1,2],
 [3,4]]

take(arr, 个数) → {Array}

说明:
  • 这个函数用于从二维数组中取前N个元素，并返回取到的结果二维数组
别名:
  • z取前N个
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
个数 number 要取子元素(行)个数
返回值:
取到的结果二维数组
Type
Array
例子
var arr = [[1, 2], [3, 4], [5, 6], [7, 8]];
var count = 2;  //取前二行
var result = Array2D.take(arr, count);
logjson(result);  
//输出结果
[[1,2],
 [3,4]]

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

说明:
  • 这个函数用于从二维数组中取前面连续满足条件的元素，并返回取到的结果二维数组
别名:
  • takeWhile
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 判断子元素是否满足条件的回调函数 (row) => 回调函数
返回值:
取到的结果二维数组
Type
Array
例子
var arr = [[5, 6], [7, 8], [1, 2], [4, 3]];  
var conditionCallback = (element) => element[0] > 3; // 子元素的实际数组第一个值是否大于3
var result = Array2D.z取前面连续满足(arr, conditionCallback);  //最后元素: [4, 3] 因为前面元素已经不满足,所以不取
logjson(result); 
//输出结果
[[5,6],
 [7,8]]

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

说明:
  • 这个函数用于从二维数组中取前面连续满足条件的元素，并返回取到的结果二维数组
别名:
  • z取前面连续满足
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
条件回调函数 function 判断子元素是否满足条件的回调函数 (row) => 回调函数
返回值:
取到的结果二维数组
Type
Array
例子
var arr = [[5, 6], [7, 8], [1, 2], [4, 3]];  
var conditionCallback = (element) => element[0] > 3; // 子元素的实际数组第一个值是否大于3
var result = Array2D.takeWhile(arr, conditionCallback);  //最后元素: [4, 3] 因为前面元素已经不满足,所以不取
logjson(result); 
//输出结果
[[5,6],
 [7,8]]

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

说明:
  • 这个函数用于将二维数组转换为字符串，并返回转换后的结果
别名:
  • toString
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
转换后的结果字符串
Type
String
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.z转字符串(arr);
console.log(result); // 输出转换后的结果字符串
//输出结果
1,2,3,4,5,6

toString(arr) → {String}

说明:
  • 这个函数用于将二维数组转换为字符串，并返回转换后的结果
别名:
  • z转字符串
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
转换后的结果字符串
Type
String
例子
var arr = [[1, 2], [3, 4], [5, 6]];
var result = Array2D.toString(arr);
console.log(result); // 输出转换后的结果字符串
//输出结果
1,2,3,4,5,6

z去重并集(arr, brr, 指定条件回调函数) → {Array}

说明:
  • 这个函数用于对两个二维数组进行去重并集操作，并返回操作后的结果二维数组
别名:
  • union
参数列表:
参数名称 参数类型 备注
arr Array 第一个二维数组
brr Array 第二个二维数组
指定条件回调函数 function (row) => 回调函数
返回值:
去重并集操作后的结果二维数组
Type
Array
例子
//示例1
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]]
//示例2   按首列去重
var result = Array2D.z去重并集(arr, brr, x=>x[0]);
logjson(result);
//输出结果
[[1,2],
 [3,4],
 [5,6],
 [9,10]]

union(arr, brr, 指定条件回调函数) → {Array}

说明:
  • 这个函数用于对两个二维数组进行去重并集操作，并返回操作后的结果二维数组
别名:
  • z去重并集
参数列表:
参数名称 参数类型 备注
arr Array 第一个二维数组
brr Array 第二个二维数组
指定条件回调函数 function (row) => 回调函数
返回值:
去重并集操作后的结果二维数组
Type
Array
例子
//示例1
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]]
//示例2   按首列去重
var result = Array2D.union(arr, brr, x=>x[0]);
logjson(result);
//输出结果
[[1,2],
 [3,4],
 [5,6],
 [9,10]]

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

说明:
  • 这个函数用于对两个二维数组进行左右连接操作，并返回操作后的结果二维数组
别名:
  • zip
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组 可接受多个数组依次书写 zip(a,b,c,d..)
返回值:
左右连接操作后的结果二维数组
Type
Array
例子
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var brr = [[2, 'X'], [3, 'Y'], [4, 'Z']];
var result = Array2D.z左右连接(arr, brr);
logjson(result);  // 输出左右连接操作后的结果数组
//输出结果
[[1,"A",2,"X"],
 [2,"B",3,"Y"],
 [3,"C",4,"Z"]]

zip(arr, brr) → {Array}

说明:
  • 这个函数用于对两个二维数组进行左右连接操作，并返回操作后的结果二维数组
别名:
  • z左右连接
参数列表:
参数名称 参数类型 备注
arr Array 左表二维数组
brr Array 右表二维数组 可接受多个数组依次书写 zip(a,b,c,d..)
返回值:
左右连接操作后的结果二维数组
Type
Array
例子
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var brr = [[2, 'X'], [3, 'Y'], [4, 'Z']];
var result = Array2D.zip(arr, brr);
logjson(result);  // 输出左右连接操作后的结果数组
//输出结果
[[1,"A",2,"X"],
 [2,"B",3,"Y"],
 [3,"C",4,"Z"]]

z转置(arr) → {Array}

说明:
  • 这个函数用于对二维数组进行(行列)转置, 并返回转置后的结果二维数组
别名:
  • transpose
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
转置后的结果二维数组
Type
Array
例子
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var result = Array2D.z转置(arr);  
logjson(result);  
//输出结果
[[1,2,3],
 ["A","B","C"]]

transpose(arr) → {Array}

说明:
  • 这个函数用于对二维数组进行(行列)转置, 并返回转置后的结果二维数组
别名:
  • transpose
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
返回值:
转置后的结果二维数组
Type
Array
例子
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var result = Array2D.transpose(arr);  
logjson(result);  
//输出结果
[[1,2,3],
 ["A","B","C"]]

z写入单元格(arr, 写入的单元格) → {ActiveCell}

说明:
  • 这个函数用于将二维数组写入指定单元格
别名:
  • toRange
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
写入的单元格 rng 单元格地址 或 直接range写法
返回值:
写入的单元格 range类型
Type
ActiveCell
例子
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
Array2D.z写入单元格(arr, "Sheet1!a1");
Array2D.z写入单元格(arr, "e1");
var rs=Array2D.z写入单元格(arr, Range("i1"));  //返回写入的单元格
console.log(rs.Address());  //输出地址
//输出结果
$I$1:$J$3

toRange(arr, 写入的单元格) → {ActiveCell}

说明:
  • 这个函数用于将二维数组写入指定单元格
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
写入的单元格 rng 单元格地址 或 直接range写法
返回值:
写入的单元格 range类型
Type
ActiveCell
例子
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
Array2D.toRange(arr, "Sheet1!a1");
Array2D.toRange(arr, "e1");
var rs=Array2D.toRange(arr, Range("i1"));  //返回写入的单元格
console.log(rs.Address());  //输出地址
//输出结果
$I$1:$J$3

z错误值(v) → {Boolean}

说明:
  • 判断目标是否错误值
别名:
  • isError
参数列表:
参数名称 参数类型 备注
v any
返回值:
Type
Boolean

isError(v) → {Boolean}

说明:
  • 判断目标是否错误值
别名:
  • z错误值
参数列表:
参数名称 参数类型 备注
v any
返回值:
Type
Boolean
例子
isError(1/0)

z矩阵排版(arr, 源数据单组行数, 结果列数, 排版参数) → {Array}

说明:
  • 这个函数用于对二维数组按指定行列数, 排版版式进行重新排版, 返回排版后的结果二维数组
别名:
  • toMatrix
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
源数据单组行数 Number
结果列数 Number
排版参数 function '方向|[方向,结果单组行数,结果单组列数,[[表头]]]'
返回值:
排版后的结果二维数组
Type
Array
例子
//示例1	
var arr = [[1,"A1",124,11],
           [2,"A2",171,16],
		 [3,"A3",135,12],
		 [4,"A4",156,14],
		 [5,"A5",127,11],
		 [6,"A6",126,13],
		 [7,"A7",128,15]];
var rs=Array2D.z矩阵排版(arr,1,3,['r',2,3]);  
	//每组1行,总共3列  r: 先行后列  组2行-1行数组=空1行
logjson(rs);
//输出结果
[[1,"A1",124,2,"A2",171,3,"A3",135],
 ["","","","","","","","",""],
 [4,"A4",156,5,"A5",127,6,"A6",126],
 ["","","","","","","","",""],
 [7,"A7",128,"","","","","",""],
 ["","","","","","","","",""]]
//示例2
var rs=Array2D.z矩阵排版(arr,1,3,['c',3,6,[["序号","ID","单价","数量"]]]); 
	//每组1行,总共3列  c: 先列后行 组3行-1行标题-1行数组=1行空行  组6列-4列=空2列  表头
logjson(rs);
//输出结果
[["序号","ID","单价","数量","","","序号","ID","单价","数量","","","序号","ID","单价","数量","",""],
 [1,"A1",124,11,"","",4,"A4",156,14,"","",7,"A7",128,15,"",""],
 ["","","","","","","","","","","","","","","","","",""],
 ["序号","ID","单价","数量","","","序号","ID","单价","数量","","","","","","","",""],
 [2,"A2",171,16,"","",5,"A5",127,11,"","","","","","","",""],
 ["","","","","","","","","","","","","","","","","",""],
 ["序号","ID","单价","数量","","","序号","ID","单价","数量","","","","","","","",""],
 [3,"A3",135,12,"","",6,"A6",126,13,"","","","","","","",""],
 ["","","","","","","","","","","","","","","","","",""]]

toMatrix(arr, 源数据单组行数, 结果列数, 排版参数) → {Array}

说明:
  • 这个函数用于对二维数组按指定行列数, 排版版式进行重新排版, 返回排版后的结果二维数组
别名:
  • z矩阵排版
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
源数据单组行数 Number
结果列数 Number
排版参数 function '方向|[方向,结果单组行数,结果单组列数,[[表头]]]'
返回值:
排版后的结果二维数组
Type
Array
例子
//示例1	
var arr = [[1,"A1",124,11],
           [2,"A2",171,16],
		 [3,"A3",135,12],
		 [4,"A4",156,14],
		 [5,"A5",127,11],
		 [6,"A6",126,13],
		 [7,"A7",128,15]];
var rs=Array2D.toMatrix(arr,1,3,['r',2,3]);  
	//每组1行,总共3列  r: 先行后列  组2行-1行数组=空1行
logjson(rs);
//输出结果
[[1,"A1",124,2,"A2",171,3,"A3",135],
 ["","","","","","","","",""],
 [4,"A4",156,5,"A5",127,6,"A6",126],
 ["","","","","","","","",""],
 [7,"A7",128,"","","","","",""],
 ["","","","","","","","",""]]
//示例2
var rs=Array2D.toMatrix(arr,1,3,['c',3,6,[["序号","ID","单价","数量"]]]); 
	//每组1行,总共3列  c: 先列后行 组3行-1行标题-1行数组=1行空行  组6列-4列=空2列  表头
logjson(rs);
//输出结果
[["序号","ID","单价","数量","","","序号","ID","单价","数量","","","序号","ID","单价","数量","",""],
 [1,"A1",124,11,"","",4,"A4",156,14,"","",7,"A7",128,15,"",""],
 ["","","","","","","","","","","","","","","","","",""],
 ["序号","ID","单价","数量","","","序号","ID","单价","数量","","","","","","","",""],
 [2,"A2",171,16,"","",5,"A5",127,11,"","","","","","","",""],
 ["","","","","","","","","","","","","","","","","",""],
 ["序号","ID","单价","数量","","","序号","ID","单价","数量","","","","","","","",""],
 [3,"A3",135,12,"","",6,"A6",126,13,"","","","","","","",""],
 ["","","","","","","","","","","","","","","","","",""]]

z矩阵分布(总行数, 规定列数, 方向) → {Array}

说明:
  • 这个函数用于将总行数按规定列数和方向排版, 返回排版后的数字序列(从0开始到总行数-1)的二维数组
别名:
  • getMatrix
参数列表:
参数名称 参数类型 备注
总行数 Number
规定列数 Number
方向 string 'r': 先行后列 'c': 先列后行
返回值:
排版后的数字序列(从0开始到总行数-1)的二维数组
Type
Array
例子
//示例1	
var arr = [[1,"A1",124,11],
           [2,"A2",171,16],
		 [3,"A3",135,12],
		 [4,"A4",156,14],
		 [5,"A5",127,11],
		 [6,"A6",126,13],
		 [7,"A7",128,15]];
var rs=Array2D.z矩阵分布(arr.length,4,'r'); //4列, 先行后列
logjson(rs);
//输出结果
[[0,1,2,3],
 [4,5,6]]
//示例2
var rs=Array2D.z矩阵分布(arr.length,4,'c'); //4列, 先列后行
logjson(rs);
//输出结果
[[0,2,4,6],
 [1,3,5]]

getMatrix(总行数, 规定列数, 方向) → {Array}

说明:
  • 这个函数用于将总行数按规定列数和方向排版, 返回排版后的数字序列(从0开始到总行数-1)的二维数组
别名:
  • z矩阵分布
参数列表:
参数名称 参数类型 备注
总行数 Number
规定列数 Number
方向 string 'r': 先行后列 'c': 先列后行
返回值:
排版后的数字序列(从0开始到总行数-1)的二维数组
Type
Array
例子
//示例1	
var arr = [[1,"A1",124,11],
           [2,"A2",171,16],
		 [3,"A3",135,12],
		 [4,"A4",156,14],
		 [5,"A5",127,11],
		 [6,"A6",126,13],
		 [7,"A7",128,15]];
var rs=Array2D.getMatrix(arr.length,4,'r'); //4列, 先行后列
logjson(rs);
//输出结果
[[0,1,2,3],
 [4,5,6]]
//示例2
var rs=Array2D.getMatrix(arr.length,4,'c'); //4列, 先列后行
logjson(rs);
//输出结果
[[0,2,4,6],
 [1,3,5]]

z重设大小(arr, 行数, 列数) → {Array}

说明:
  • 这个函数用于将二维数组按照指定行数,列数进行扩展, 原数组不变, 返回扩展后的结果二维数组
别名:
  • resize
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
行数 Number 要扩展的行数
列数 Number 要扩展的列数
返回值:
扩展后的结果二维数组
Type
Array
例子
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
     var brr=Array2D.resize(arr,4,3);
     logjson(brr,0);
     //输出结果
     [[1,"A",""],[2,"B",""],[3,"C",""],["","",""]]

resize(arr, 行数, 列数) → {Array}

说明:
  • 这个函数用于将二维数组按照指定行数,列数进行扩展, 原数组不变, 返回扩展后的结果二维数组
别名:
  • z重设大小
参数列表:
参数名称 参数类型 备注
arr Array 二维数组
行数 Number 要扩展的行数
列数 Number 要扩展的列数
返回值:
扩展后的结果二维数组
Type
Array
例子
var arr = [[1, 'A'], [2, 'B'], [3, 'C']];
var brr=Array2D.resize(arr,4,3);
logjson(brr,0);
//输出结果
[[1,"A",""],[2,"B",""],[3,"C",""],["","",""]]

z处理空值(arr)

说明:
  • 把数组中null和undefined替换为空字符串 方便后续处理
别名:
  • noNull
参数列表:
参数名称 参数类型 备注
arr Array 二维数
例子
var arr = [[1, null], [2, undefined], [3, 'C']];
     var brr=Array2D.z处理空值(arr);
     logjson(brr,0);
     //输出结果
     [[1, ""], [2, ""], [3, 'C']];

noNull(arr)

说明:
  • 把数组中null和undefined替换为空字符串 方便后续处理
别名:
  • z处理空值
参数列表:
参数名称 参数类型 备注
arr Array 二维数
例子
var arr = [[1, null], [2, undefined], [3, 'C']];
     var brr=Array2D.z处理空值(arr);
     logjson(brr,0);
     //输出结果
     [[1, ""], [2, ""], [3, 'C']];