import { isNaN, isEqual, findIndex, chunk, drop, camelCase, endsWith, pick, words, compact, concat, difference, differenceBy, differenceWith, dropRight, dropRightWhile, dropWhile, fill, findLastIndex, head, flatten, flattenDeep, flattenDepth, fromPairs, indexOf, initial, intersection, intersectionBy, intersectionWith, join, last, lastIndexOf, nth, pull, pullAll, pullAllBy, pullAllWith, remove, reverse, slice, sortedIndex, sortedIndexBy, sortedIndexOf, sortedLastIndex, sortedLastIndexBy, sortedLastIndexOf, sortedUniq, sortedUniqBy, tail, take, takeRight, takeRightWhile, takeWhile, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, without, xor, xorBy, xorWith, zip, zipObject, zipObjectDeep, zipWith, countBy, forEach, forEachRight, every, } from 'lodash'; import moment from 'moment'; import { openToast } from '../location/Notification'; import { showToast } from '../location/Toast'; // 图片引入 import Compatibility from '../assets/Compatibility.png'; import Compatibility2 from '../assets/Compatibility2.png'; import Dimensions from '../assets/Dimensions.png'; import Dimensions2 from '../assets/Dimensions2.png'; import Database from '../assets/Database.png'; import Database2 from '../assets/Database2.png'; import DateImg from '../assets/Date.png'; import DateImg2 from '../assets/Date2.png'; import Finance from '../assets/Finance.png'; import Finance2 from '../assets/Finance2.png'; import MessageImg from '../assets/Message.png'; import MessageImg2 from '../assets/Message2.png'; import Logic from '../assets/Logic.png'; import Logic2 from '../assets/Logic2.png'; import Find from '../assets/Find.png'; import Find2 from '../assets/Find2.png'; import MathImg from '../assets/Math.png'; import MathImg2 from '../assets/Math2.png'; import Statistics from '../assets/Statistics.png'; import Statistics2 from '../assets/Statistics2.png'; import TextImg from '../assets/Text.png'; import TextImg2 from '../assets/Text2.png'; import Project from '../assets/Project.png'; import Project2 from '../assets/Project2.png'; import Column from '../assets/Column.png'; import Column2 from '../assets/Column2.png'; import PieImg from '../assets/Pie.png'; import PieImg2 from '../assets/Pie2.png'; import Radar from '../assets/Radar.png'; import Radar2 from '../assets/Radar2.png'; import Bubble from '../assets/Bubble.png'; import Bubble2 from '../assets/Bubble2.png'; import Splashes from '../assets/Splashes.png'; import Splashes2 from '../assets/Splashes2.png'; import Dendrogram from '../assets/Dendrogram.png'; import Dendrogram2 from '../assets/Dendrogram2.png'; import Box from '../assets/Box.png'; import Box2 from '../assets/Box2.png'; import Rising from '../assets/Rising.png'; import Rising2 from '../assets/Rising2.png'; import Line from '../assets/Line.png'; import Line2 from '../assets/Line2.png'; import Straight from '../assets/Straight.png'; import Straight2 from '../assets/Straight2.png'; import ArrayPng from '../assets/Array.png'; import Array2Png from '../assets/Array2.png'; import NumberPng from '../assets/Number.png'; import Number2Png from '../assets/Number2.png'; import ObjectPng from '../assets/Object.png'; import Object2Png from '../assets/Object2.png'; import StringPng from '../assets/String.png'; import String2Png from '../assets/String2.png'; let isArray = Array.isArray /** * 函数集 */ const List = [ { name: '数组操作函数', images: ArrayPng, pitchImages: Array2Png, children:[ { name:'数组合并数组', // 函数代表名 funcName: '将传入2个数组进行合并,返回一个合并后数组', // 函数名字 function: MERGEARRAY, // 当前函数 callKey: 'MERGEARRAY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入合并数组', // 第一个参数代表含义 }, { text:'传入合并数组', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78],// 传入函数中的值 text:'[23,98,78]', // 展示页面所用值 }, { value:[32,51,79],// 传入函数中的值 text:'[32,51,79]', // 展示页面所用值 }, ], }, { name: '筛选非假值数组',// 函数代表名 funcName: '创建一个新数组,包含原数组中所有的非假值元素。例如false, null, 0, "", undefined, 和 NaN 都是被认为是“假值”。',// 函数名字 function: ArrayScreenFalse, // 当前函数 callKey: 'ArrayScreenFalse', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要筛选数组', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78,false,''],// 传入函数中的值 text:'[23,98,78,false,""]', // 展示页面所用值 } ], }, { name: '数组链接数组或值',// 函数代表名 funcName: '创建一个新数组,将array与任何数组 或 值连接在一起。',// 函数名字 function: ArrayConcatData, // 当前函数 callKey: 'ArrayConcatData', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要连接数组', // 第一个参数代表含义 }, { text: '传入需要连接的数组或值' } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78],// 传入函数中的值 text:'[23,98,78]', // 展示页面所用值 }, { value:'8',// 传入函数中的值 text:'8', // 展示页面所用值 } ], }, { name: '排除数组指定值',// 函数代表名 funcName: '创建一个新数组,这个数组中的值,为第一个数字(array 参数)排除了给定数组中的值。',// 函数名字 function: ArrayDifference, // 当前函数 callKey: 'ArrayDifference', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要检查的数组。', // 第一个参数代表含义 }, { text: '排除的值。' } ], demo: [ // 展示给用户看的案例传入值 { value:[3, 2, 1],// 传入函数中的值 text:'[3, 2, 1]', // 展示页面所用值 }, { value:[4, 2],// 传入函数中的值 text:'[4, 2]', // 展示页面所用值 } ], }, { name: '排除数组指定值(指定规则)',// 函数代表名 funcName: '它接受一个 iteratee (注:迭代器), 调用array 和 values 中的每个元素以产生比较的标准。 结果值是从第一数组中选择。',// 函数名字 function: ArrayDifferenceBy, // 当前函数 callKey: 'ArrayDifferenceBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要检查的数组。', // 第一个参数代表含义 }, { text: '排除的值。' }, { text: 'iteratee 调用每个元素。' } ], demo: [ // 展示给用户看的案例传入值 { value:[{ x: 2 }, { x: 1 }],// 传入函数中的值 text:'[{ x: 2 }, { x: 1 }]', // 展示页面所用值 }, { value:[{ x: 1 }],// 传入函数中的值 text:'[{ x: 1 }]', // 展示页面所用值 }, { value:'x', text:'x', // 展示页面所用值 } ], }, { name: '筛选数组中不相同的值',// 函数代表名 funcName: '比较array,values中的元素。 结果值是从第一数组中选择。',// 函数名字 function: ArrayDifferenceWith, // 当前函数 callKey: 'ArrayDifferenceWith', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要检查的数组。', // 第一个参数代表含义 }, { text: '排除的值。' }, ], demo: [ // 展示给用户看的案例传入值 { value:[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],// 传入函数中的值 text:"[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]", // 展示页面所用值 }, { value:[{ 'x': 1, 'y': 2 }],// 传入函数中的值 text:"[{ 'x': 1, 'y': 2 }]", // 展示页面所用值 }, ], }, { name:'数组指定切片', // 函数代表名 funcName: '将传入数组按照传入长度进行切片,返回一个切片后数组', // 函数名字 function: REMOVEARRAYDROP, // 当前函数 callKey: 'REMOVEARRAYDROP', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要切片数组', // 第一个参数代表含义 }, { text:'传入切片长度', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78,65,32,11,12],// 传入函数中的值 text:'[23,98,78,65,32,11,12]', // 展示页面所用值 }, { value:2,// 传入函数中的值 text:'2', // 展示页面所用值 }, ], }, { name:'数组从尾部指定切片', // 函数代表名 funcName: '创建一个切片数组,去除array尾部的n个元素。(n默认值为1。)', // 函数名字 function: ArrayDropRight, // 当前函数 callKey: 'ArrayDropRight', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要查询的数组。', // 第一个参数代表含义 }, { text:'要去除的元素个数。', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 3],// 传入函数中的值 text:'[1, 2, 3]', // 展示页面所用值 }, { value:2,// 传入函数中的值 text:'2', // 展示页面所用值 }, ], }, { name:'数组从尾部指定规则切片', // 函数代表名 funcName: '创建一个切片数组,从尾部去除array中从 predicate 返回假值开始到尾部的部分。', // 函数名字 function: ArrayDropRightWhile, // 当前函数 callKey: 'ArrayDropRightWhile', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要查询的数组。', // 第一个参数代表含义 }, { text:'筛选规则,这个函数会在每一次迭代调用。', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[ { 'user': 'barney', 'active': false }, { 'user': 'fred', 'active': true }, { 'user': 'pebbles', 'active': false } ],// 传入函数中的值 text:`[ { 'user': 'barney', 'active': true }, { 'user': 'fred', 'active': false }, { 'user': 'pebbles', 'active': false } ]`, // 展示页面所用值 }, { value:function(o) { return !o.active; },// 传入函数中的值 text:`function(o) { return !o.active; }`, // 展示页面所用值 }, ], }, { name:'数组指定规则切片', // 函数代表名 funcName: '创建一个切片数组,去除array中从 predicate 返回假值开始到尾部的部分。', // 函数名字 function: ArrayDropWhile, // 当前函数 callKey: 'ArrayDropWhile', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要查询的数组。', // 第一个参数代表含义 }, { text:'筛选规则,这个函数会在每一次迭代调用。', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[ { 'user': 'barney', 'active': false }, { 'user': 'fred', 'active': true }, { 'user': 'pebbles', 'active': false } ],// 传入函数中的值 text:`[ { 'user': 'barney', 'active': true }, { 'user': 'fred', 'active': false }, { 'user': 'pebbles', 'active': false } ]`, // 展示页面所用值 }, { value:function(o) { return !o.active; },// 传入函数中的值 text:`function(o) { return !o.active; }`, // 展示页面所用值 }, ], }, { name:'填充数组', // 函数代表名 funcName: '使用 value 值来填充(替换) array,从start位置开始, 到end位置结束(但不包含end位置)。', // 函数名字 function: ArrayFill, // 当前函数 callKey: 'ArrayFill', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要填充改变的数组。', // 第一个参数代表含义 }, { text:'填充(替换)给 array 的值。', // 第二个参数代表含义 }, { text:'开始位置(默认0) 可不传', }, { text: '结束位置(默认全部) 可不传', } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 3],// 传入函数中的值 text:`[1, 2, 3]`, // 展示页面所用值 }, { value:'a',// 传入函数中的值 text:'a', // 展示页面所用值 }, ], }, { name:'数组指定查找,返回下标', // 函数代表名 funcName: '该方法返回第一个通过 predicate 判断为真值的元素的索引值(index),而不是元素本身。', // 函数名字 function: ArrayFindIndex, // 当前函数 callKey: 'ArrayFindIndex', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要搜索的数组。', // 第一个参数代表含义 }, { text:'这个函数会在每一次迭代调用。', // 第二个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value:[ { 'user': 'fred', 'active': false }, { 'user': 'barney', 'active': false }, { 'user': 'pebbles', 'active': true } ],// 传入函数中的值 text:`[ { 'user': 'fred', 'active': false }, { 'user': 'barney', 'active': false }, { 'user': 'pebbles', 'active': true } ]`, // 展示页面所用值 }, { value:function(o) { return o.user == 'barney'; },// 传入函数中的值 text:"function(o) { return o.user == 'barney'; }", // 展示页面所用值 }, ], }, { name:'数组从末尾指定查找,返回下标', // 函数代表名 funcName: '该方法从末尾查询返回第一个通过 predicate 判断为真值的元素的索引值(index),而不是元素本身。', // 函数名字 function: ArrayFindLastIndex, // 当前函数 callKey: 'ArrayFindLastIndex', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要搜索的数组。', // 第一个参数代表含义 }, { text:'这个函数会在每一次迭代调用。', // 第二个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value:[ { 'user': 'barney', 'active': true }, { 'user': 'fred', 'active': false }, { 'user': 'pebbles', 'active': false } ],// 传入函数中的值 text:`[ { 'user': 'barney', 'active': true }, { 'user': 'fred', 'active': false }, { 'user': 'pebbles', 'active': false } ]`, // 展示页面所用值 }, { value:function(o) { return o.user == 'pebbles'},// 传入函数中的值 text:"function(o) { return o.user == 'pebbles'}", // 展示页面所用值 }, ], }, { name:'数组首数据获取,返回下标', // 函数代表名 funcName: '获取数组 array 的第一个元素。', // 函数名字 function: ArrayHead, // 当前函数 callKey: 'ArrayHead', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要查询的数组。', // 第一个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 3],// 传入函数中的值 text:`[1, 2, 3]`, // 展示页面所用值 }, ], }, { name:'数组嵌套深度减少一级', // 函数代表名 funcName: '减少一级array嵌套深度。', // 函数名字 function: ArrayFlatten, // 当前函数 callKey: 'ArrayFlatten', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 需要减少嵌套层级的数组。', // 第一个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, [[3],[4],[5]]],// 传入函数中的值 text:`[1, 2, [[3],[4],[5]]]`, // 展示页面所用值 }, ], }, { name:'数组嵌套深度指定减少', // 函数代表名 funcName: '减少指定层级array嵌套深度。', // 函数名字 function: ArrayFlattenDepth, // 当前函数 callKey: 'ArrayFlattenDepth', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 需要减少嵌套层级的数组。', // 第一个参数代表含义 }, { text: '2' } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, [[3],[4],[5]]],// 传入函数中的值 text:`[1, 2, [[3],[4],[5]]]`, // 展示页面所用值 }, { value: 2, text: 2, } ], }, { name:'数组清除嵌套深度', // 函数代表名 funcName: '将array递归为一维数组。', // 函数名字 function: ArrayFlattenDeep, // 当前函数 callKey: 'ArrayFlattenDeep', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 需要处理嵌套的数组。', // 第一个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value:[[1], [2], [[3,6],[4],[5]]],// 传入函数中的值 text:`[[1], [2], [[3,6],[4],[5]]]`, // 展示页面所用值 }, ], }, { name:'数组pairs格式化为对象', // 函数代表名 funcName: '将数组pairs格式化为对象', // 函数名字 function: ArrayFromPairs, // 当前函数 callKey: 'ArrayFromPairs', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 键值对pairs。', // 第一个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value:[['fred', 30], ['barney', 40]],// 传入函数中的值 text:`[['fred', 30], ['barney', 40]]`, // 展示页面所用值 }, ], }, { name:'数组查找', // 函数代表名 funcName: '返回首次 value 在数组array中被找到的 索引值, 如果 fromIndex 为负值,将从数组array尾端索引进行匹配。', // 函数名字 function: ArrayIndexOf, // 当前函数 callKey: 'ArrayIndexOf', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 需要查找的数组。', // 第一个参数代表含义 }, { text: '需要查找的值。', }, { text: '开始查询的位置。 可不传' } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 1, 2],// 传入函数中的值 text:`[1, 2, 1, 2]`, // 展示页面所用值 }, { value:2, text:2, } ], }, { name:'数组删除最后一个元素', // 函数代表名 funcName: '获取数组array中除了最后一个元素之外的所有元素(注:去除数组array中的最后一个元素)。', // 函数名字 function: ArrayInitial, // 当前函数 callKey: 'ArrayInitial', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 需要查找的数组。', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 1, 2],// 传入函数中的值 text:`[1, 2, 1, 2]`, // 展示页面所用值 } ], }, { name:'数组相同对比', // 函数代表名 funcName: '创建唯一值的数组,这个数组包含所有给定数组都包含的元素,', // 函数名字 function: ArrayIntersection, // 当前函数 callKey: 'ArrayIntersection', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 待检查的数组', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[[2, 1], [4, 2], [1, 2]],// 传入函数中的值 text:`[[2, 1], [4, 2], [1, 2]]`, // 展示页面所用值 } ], }, { name:'数组指定规则做相同对比', // 函数代表名 funcName: '它接受一个 iteratee 调用每一个arrays的每个值以产生一个值,通过产生的值进行了比较。结果值是从第一数组中选择。', // 函数名字 function: ArrayIntersectionBy, // 当前函数 callKey: 'ArrayIntersectionBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 待检查的数组', // 第一个参数代表含义 }, { text: 'iteratee(迭代器)调用每个元素。' } ], demo: [ // 展示给用户看的案例传入值 { value:[[{ x: 1 }], [{ x: 2 }, { x: 1 }]],// 传入函数中的值 text:`[[{ x: 1 }], [{ x: 2 }, { x: 1 }]]`, // 展示页面所用值 }, { value:'x', text:'x' } ], }, { name:'数组按照指定格式转换字符串', // 函数代表名 funcName: '将 array 中的所有元素转换为由 separator 分隔的字符串。', // 函数名字 function: ArrayJoin, // 当前函数 callKey: 'ArrayJoin', params: [ // 函数所需要传入值内容 为空为不传值 { text:'待转换的数组', // 第一个参数代表含义 }, { text: '分隔元素' }, ], demo: [ // 展示给用户看的案例传入值 { value:['a', 'b', 'c'],// 传入函数中的值 text:`['a', 'b', 'c']`, // 展示页面所用值 }, { value: '~', text: '~' } ], }, { name:'数组获取最后一个参数', // 函数代表名 funcName: '获取array中的最后一个元素。', // 函数名字 function: ArrayLast, // 当前函数 callKey: 'ArrayLast', params: [ // 函数所需要传入值内容 为空为不传值 { text:'待检索的数组', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:['a', 'b', 'c'],// 传入函数中的值 text:`['a', 'b', 'c']`, // 展示页面所用值 } ], }, { name:'数组反向查找', // 函数代表名 funcName: '它是从右到左遍历array的元素。返回查找到的元素', // 函数名字 function: ArrayLastIndexOf, // 当前函数 callKey: 'ArrayLastIndexOf', params: [ // 函数所需要传入值内容 为空为不传值 { text:'待检索的数组', // 第一个参数代表含义 }, { text: '要搜索的值。', }, { text: '开始搜索的索引值。(默认最后位) 可不传' } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 1, 2],// 传入函数中的值 text:`[1, 2, 1, 2]`, // 展示页面所用值 }, { value:1, text:1 } ], }, { name:'数组获取指定参数', // 函数代表名 funcName: '获取array数组的第n个元素。如果n为负数,则返回从数组结尾开始的第n个元素。', // 函数名字 function: ArrayNth, // 当前函数 callKey: 'ArrayNth', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要查询的数组。', // 第一个参数代表含义 }, { text: '要返回元素的索引值。', } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 3, 1, 2],// 传入函数中的值 text:`[1, 3, 1, 2]`, // 展示页面所用值 }, { value:1, text:1 } ], }, { name:'数组删除指定元素', // 函数代表名 funcName: '移除数组array中所有和给定值相等的元素,使用 SameValueZero 进行全等比较。 会修改传入数组', // 函数名字 function: ArrayPull, // 当前函数 callKey: 'ArrayPull', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要修改的数组。', // 第一个参数代表含义 }, { text: '需要删除的值 可多个', } ], demo: [ // 展示给用户看的案例传入值 { value:[3, 53, 87, 2],// 传入函数中的值 text:`[3, 53, 87, 2]`, // 展示页面所用值 }, { value:2, text:2 } ], }, { name: '数组删除指定元素(删除值为数组包裹)', funcName: '移除数组array中所有和给定值相等的元素,使用 SameValueZero 进行全等比较。区别是这个方法接收一个要移除值的数组。 会修改传入数组', // 函数名字 function: ArrayPullAll, // 当前函数 callKey: 'ArrayPullAll', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要修改的数组。', // 第一个参数代表含义 }, { text: '需要删除的值数组', } ], demo: [ // 展示给用户看的案例传入值 { value:[3, 53, 87, 2],// 传入函数中的值 text:`[3, 53, 87, 2]`, // 展示页面所用值 }, { value:[2,53], text:'[2,53]' } ], }, { name:'数组删除指定元素(支持对象)', // 函数代表名 funcName: '这个方法接受一个 iteratee(迭代函数) 调用 array 和 values的每个值以产生一个值,通过产生的值进行了比较。 会修改传入数组', // 函数名字 function: ArrayPullAllBy, // 当前函数 callKey: 'ArrayPullAllBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要修改的数组。', // 第一个参数代表含义 }, { text: '要移除值的数组。', }, { text: 'iteratee(迭代器)调用每个元素。' } ], demo: [ // 展示给用户看的案例传入值 { value:[{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'y': 1 }],// 传入函数中的值 text:`[{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'y': 1 }];`, // 展示页面所用值 }, { value:[{'x':3},{'y':1}], text:`[{'x':3},{'y':1}]` }, { value: 'x', text: 'x' } ], }, { name:'数组删除指定元素(支持对象,且不需要迭代器)', // 函数代表名 funcName: '调用 array 和 values的每个值以产生一个值,通过产生的值进行了比较。 会修改传入数组', // 函数名字 function: ArrayPullAllWith, // 当前函数 callKey: 'ArrayPullAllWith', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要修改的数组。', // 第一个参数代表含义 }, { text: '要移除值的数组。', } ], demo: [ // 展示给用户看的案例传入值 { value:[{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'y': 1 }],// 传入函数中的值 text:`[{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'y': 1 }];`, // 展示页面所用值 }, { value:[{'x':3},{'y':1}], text:`[{'x':3},{'y':1}]` } ], }, { name:'数组移除指定下标数据', // 函数代表名 funcName: '根据索引 indexes,移除array中对应的元素,并返回被移除元素的数组。', // 函数名字 function: ArrayPullAt, // 当前函数 callKey: 'ArrayPullAt', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要修改的数组。', // 第一个参数代表含义 }, { text: '要移除元素的索引。', } ], demo: [ // 展示给用户看的案例传入值 { value:[5, 10, 15, 20],// 传入函数中的值 text:`[5, 10, 15, 20]`, // 展示页面所用值 }, { value:1, text:1 } ], }, { name:'数组指定规则删除元素', // 函数代表名 funcName: '移除数组中predicate(断言)返回为真值的所有元素,并返回移除元素组成的数组。', // 函数名字 function: ArrayRemove, // 当前函数 callKey: 'ArrayRemove', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要修改的数组。', // 第一个参数代表含义 }, { text: ' 每次迭代调用的函数。', } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 3, 4,5,6],// 传入函数中的值 text:`[1, 2, 3, 4,5,6]`, // 展示页面所用值 }, { value:function(n) { return n % 2 == 0; }, text:`function(n) { return n % 2 == 0; }` } ], }, { name:'数组反转', // 函数代表名 funcName: '反转array,使得第一个元素变为最后一个元素,第二个元素变为倒数第二个元素,依次类推。返回新数组', // 函数名字 function: ArrayReverse, // 当前函数 callKey: 'ArrayReverse', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要修改的数组。', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 3, 4],// 传入函数中的值 text:`[1, 2, 3, 4]`, // 展示页面所用值 } ], }, { name:'数组指定裁剪', // 函数代表名 funcName: '裁剪数组array,从 start 位置开始到end结束,但不包括 end 本身的位置。', // 函数名字 function: ArraySlice, // 当前函数 callKey: 'ArraySlice', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要裁剪数组。', // 第一个参数代表含义 }, { text: '开始位置。(默认为0)' }, { text: '结束位置。(默认为最后)' } ], demo: [ // 展示给用户看的案例传入值 { value:[1, 2, 3, 4],// 传入函数中的值 text:`[1, 2, 3, 4]`, // 展示页面所用值 }, { value:0, text:0 }, { value:2, text:2 } ], }, { name:'数组插入值判定', // 函数代表名 funcName: '使用二进制的方式检索来决定 value值 应该插入到数组中 尽可能小的索引位置,以保证array的排序。', // 函数名字 function: ArraySortedIndex, // 当前函数 callKey: 'ArraySortedIndex', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的排序数组。', // 第一个参数代表含义 }, { text: '要评估的值' } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 20, 30, 40],// 传入函数中的值 text:`[10, 20, 30, 40]`, // 展示页面所用值 }, { value:22, text:22 } ], }, { name:'数组指定迭代器插入值判断', // 函数代表名 funcName: '它接受一个 iteratee (迭代函数),调用每一个数组(array)元素,返回结果和value 值比较来计算排序', // 函数名字 function: ArraySortedIndexBy, // 当前函数 callKey: 'ArraySortedIndexBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要检查的排序数组。', // 第一个参数代表含义 }, { text: '要评估的值。' }, { text: '迭代函数,调用每个元素。' } ], demo: [ // 展示给用户看的案例传入值 { value:[{ 'x': 4 }, { 'x': 6 }],// 传入函数中的值 text:`[{ 'x': 4 }, { 'x': 6 }]`, // 展示页面所用值 }, { value:{ 'x': 5 }, text:`{ 'x': 5 }` }, { value:function(o) { return o.x; }, text:`function(o) { return o.x; }` } ], }, { name:'排序数组二进制查找', // 函数代表名 funcName: '这个方法类似 indexOf,除了它是在已经排序的数组array上执行二进制检索。不存在返回-1', // 函数名字 function: ArraySortedIndexOf, // 当前函数 callKey: 'ArraySortedIndexOf', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要搜索的数组。', // 第一个参数代表含义 }, { text: '搜索的值。' } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 20, 30, 40],// 传入函数中的值 text:`[10, 20, 30, 40]`, // 展示页面所用值 }, { value:20, text:20 } ], }, { name:'排序数组查找最后一次出现索引', funcName: '它返回 value值 在 array 中尽可能大的索引位置(index)。不存在返回-1', // 函数名字 function: ArraySortedLastIndex, // 当前函数 callKey: 'ArraySortedLastIndex', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要搜索的数组。', // 第一个参数代表含义 }, { text: '搜索的值。' } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 20, 20, 30, 40],// 传入函数中的值 text:`[10, 20, 20, 30, 40]`, // 展示页面所用值 }, { value:20, text:20 } ], }, { name:'排序数组反向指定规则插入', funcName: '它接受一个 iteratee (迭代函数),调用每一个数组(array)元素,返回结果和value 值比较来计算排序。返回因插入的下标', // 函数名字 function: ArraySortedLastIndexBy, // 当前函数 callKey: 'ArraySortedLastIndexBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的排序数组。', // 第一个参数代表含义 }, { text: '要评估的值。' }, { text: '迭代函数,调用每个元素' } ], demo: [ // 展示给用户看的案例传入值 { value:[{ 'x': 4 }, { 'x': 5 }],// 传入函数中的值 text:`[{ 'x': 4 }, { 'x': 5 }]`, // 展示页面所用值 }, { value:{ 'x': 4.5 }, text:`{ 'x': 4.5 }` }, { value:function(o) { return o.x; }, text:`function(o) { return o.x; }` } ], }, { name:'排序数组反向二进制查找', funcName: '它是在已经排序的数组array上执行反向二进制检索。不存在返回-1', // 函数名字 function: ArraySortedLastIndexOf, // 当前函数 callKey: 'ArraySortedLastIndexOf', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要搜索的数组。', // 第一个参数代表含义 }, { text: '搜索的值。' } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 20, 20, 30, 40],// 传入函数中的值 text:`[10, 20, 20, 30, 40]`, // 展示页面所用值 }, { value:20, text:20 } ], }, { name:'数组去重', funcName: '它会优化排序数组,返回一个不重复数组', // 函数名字 function: ArraySortedUniq, // 当前函数 callKey: 'ArraySortedUniq', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要搜索的数组。', // 第一个参数代表含义 }, { text: '搜索的值。' } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 10, 20, 20, 30, 30, 40, 40],// 传入函数中的值 text:`[10, 10, 20, 20, 30, 30, 40, 40]`, // 展示页面所用值 } ], }, { name:'数组去重(指定规则)', funcName: '它会根据指定规则优化排序数组。,返回一个不重复数组', // 函数名字 function: ArraySortedUniqBy, // 当前函数 callKey: 'ArraySortedUniqBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要检查的数组。', // 第一个参数代表含义 }, { text: '迭代函数,调用每个元素。' } ], demo: [ // 展示给用户看的案例传入值 { value:[1.1, 1.2, 2.3, 2.4],// 传入函数中的值 text:`[1.1, 1.2, 2.3, 2.4]`, // 展示页面所用值 }, { value: Math.floor, text:'Math.floor' } ], }, { name:'数组(除第一个数据)数据获取', funcName: '获取除了array数组第一个元素以外的全部元素。', // 函数名字 function: ArrayTail, // 当前函数 callKey: 'ArrayTail', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的数组。', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 10, 20, 20, 30, 30, 40, 40],// 传入函数中的值 text:`[10, 10, 20, 20, 30, 30, 40, 40]`, // 展示页面所用值 } ], }, { name:'数组指定数量元素提取', funcName: '创建一个数组切片,从array数组的起始元素开始提取n个元素。', // 函数名字 function: ArrayTake, // 当前函数 callKey: 'ArrayTake', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检索的数组', // 第一个参数代表含义 }, { text: '要提取的元素个数。' } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 10, 20, 20, 30, 30, 40, 40],// 传入函数中的值 text:`[10, 10, 20, 20, 30, 30, 40, 40]`, // 展示页面所用值 }, { value:5, text:5 } ], }, { name:'数组(从最后开始)指定数量元素提取', funcName: '创建一个数组切片,从array数组的最后一个元素开始提取n个元素。', // 函数名字 function: ArrayTakeRight, // 当前函数 callKey: 'ArrayTakeRight', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的数组。', // 第一个参数代表含义 }, { text: '要提取的元素个数。' } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 10, 20, 20, 30, 30, 40, 40],// 传入函数中的值 text:`[10, 10, 20, 20, 30, 30, 40, 40]`, // 展示页面所用值 }, { value:5, text:5 } ], }, { name:'数组指定规则元素提取', funcName: '从array数组的起始元素开始提取元素,直到 规则 返回假值。', // 函数名字 function: ArrayTakeWhile, // 当前函数 callKey: 'ArrayTakeWhile', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检索的数组。', // 第一个参数代表含义 }, { text: '每次迭代调用的函数。' } ], demo: [ // 展示给用户看的案例传入值 { value:[ { 'user': 'barney', 'active': true }, { 'user': 'fred', 'active': false }, { 'user': 'pebbles', 'active': false } ],// 传入函数中的值 text:`[ { 'user': 'barney', 'active': true }, { 'user': 'fred', 'active': false }, { 'user': 'pebbles', 'active': false } ]`, // 展示页面所用值 }, { value:function(o) { return o.active; }, text:`function(o) { return o.active; }` } ], }, { name:'数组(从最后开始)指定规则元素提取', funcName: '从array数组的最后一个元素开始提取元素,直到规则返回假值。', // 函数名字 function: ArrayTakeRightWhile, // 当前函数 callKey: 'ArrayTakeRightWhile', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检索的数组。', // 第一个参数代表含义 }, { text: '每次迭代调用的函数。' } ], demo: [ // 展示给用户看的案例传入值 { value:[ { 'user': 'barney', 'active': true }, { 'user': 'fred', 'active': false }, { 'user': 'pebbles', 'active': false } ],// 传入函数中的值 text:`[ { 'user': 'barney', 'active': true }, { 'user': 'fred', 'active': false }, { 'user': 'pebbles', 'active': false } ]`, // 展示页面所用值 }, { value:function(o) { return !o.active; }, text:`function(o) { return !o.active; }` } ], }, { name:'多个数组去重合并', funcName: '创建一个按顺序排列的唯一值的数组。所有给定数组的元素值做等值比较。', // 函数名字 function: ArrayUnion, // 当前函数 callKey: 'ArrayUnion', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的数组。可传多个', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[10, 10, 20, 20, 30, 30, 40, 40],// 传入函数中的值 text:`[10, 10, 20, 20, 30, 30, 40, 40]`, // 展示页面所用值 }, { value:[10,25,30,35,40,45], text:`[10,25,30,35,40,45]` }, { value:[10,25,30,35,40,45], text:`[10,25,30,35,40,45]` }, ], }, { name:'多个数组按照规则去重合并(支持对象)', funcName: '它接受一个 iteratee (迭代函数),调用每一个数组(array)的每个元素以产生唯一性计算的标准。', // 函数名字 function: ArrayUnionBy, // 当前函数 callKey: 'ArrayUnionBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 需要合并的数组组,', // 第一个参数代表含义 }, { text:'迭代函数,调用每个元素。' } ], demo: [ // 展示给用户看的案例传入值 { value:[[{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }]],// 传入函数中的值 text:`[[{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }]]`, // 展示页面所用值 }, { value:'x', text:`x` }, ], }, { name:'多个数组去重合并(支持对象)', funcName: '它接受一个 comparator 调用比较arrays数组的每一个元素。 ', // 函数名字 function: ArrayUnionWith, // 当前函数 callKey: 'ArrayUnionWith', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 需要合并的数组,', // 第一个参数代表含义 }, { text:' 需要合并的数组,', // 第一个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value:[{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 1 }],// 传入函数中的值 text:`[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]`, // 展示页面所用值 }, { value:[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], text:`[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]` }, ], }, { name:'数组去重(简版)', funcName: '创建一个去重后的array数组副本。只有第一次出现的元素才会被保留。', // 函数名字 function: ArrayUniq, // 当前函数 callKey: 'ArrayUniq', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的数组。,', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[2, 1, 2],// 传入函数中的值 text:`[2, 1, 2]`, // 展示页面所用值 } ], }, { name:'数组对象自动去重', funcName: '它接受一个 comparator 调用比较arrays数组的每一个元素', // 函数名字 function: ArrayUniqWith, // 当前函数 callKey: 'ArrayUniqWith', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的数组。', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }],// 传入函数中的值 text:`[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]`, // 展示页面所用值 } ], }, { name:'数组重组', funcName: '它接收分组元素的数组,并且创建一个数组,分组元素到打包前的结构。返回数组的第一个元素包含所有的输入数组的第一元素,第一个元素包含了所有的输入数组的第二元素,依此类推。)', // 函数名字 function: ArrayUnzip, // 当前函数 callKey: 'ArrayUnzip', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要重组的数组。', // 第一个参数代表含义 }, { text:' 要重组的数组。', // 第一个参数代表含义 }, { text:' 要重组的数组。', // 第一个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value:['fred', 'barney'],// 传入函数中的值 text:`['fred', 'barney']`, // 展示页面所用值 }, { value:[30, 40], text: `[30, 40]` }, { value:[true, false], text:`[true, false]` } ], }, { name:'数组指定规则重组', funcName: '它接受一个iteratee指定重组值应该如何被组合。', // 函数名字 function: ArrayUnzipWidth, // 当前函数 callKey: 'ArrayUnzipWidth', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要处理的分组元素数组。', // 第一个参数代表含义 }, { text:'这个函数用来组合重组的值。' } ], demo: [ // 展示给用户看的案例传入值 { value:[[1, 10, 100], [2, 20, 200]],// 传入函数中的值 text:`[[1, 10, 100], [2, 20, 200]]`, // 展示页面所用值 }, { value:function(num,num1) { return num+num1 }, text:`function(num,num1) { return num+num1 }` } ], }, { name:'数组剔除指定参数', funcName: '创建一个剔除所有给定值的新数组', // 函数名字 function: ArrayWithout, // 当前函数 callKey: 'ArrayWithout', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的数组。', // 第一个参数代表含义 }, { text: '要剔除的值。 可多个' }, ], demo: [ // 展示给用户看的案例传入值 { value:[2, 1, 2, 3],// 传入函数中的值 text:`[2, 1, 2, 3]`, // 展示页面所用值 }, { value:1, text:1 }, { value:2, text:2, } ], }, { name:'数组过滤', funcName: '创建一个给定数组唯一值的数组,返回值的顺序取决于他们数组的出现顺序,返回过滤后的新数组', // 函数名字 function: ArrayXor, // 当前函数 callKey: 'ArrayXor', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要过滤的数组。', // 第一个参数代表含义 }, { text:'要过滤的数组。' } ], demo: [ // 展示给用户看的案例传入值 { value:[2, 1],// 传入函数中的值 text:`[2, 1]`, // 展示页面所用值 }, { value: [2, 3], text: `[2, 3]` }, { value: [3, 4], text: `[3, 4]` } ], }, { name:'数组指定规则过滤', funcName: '它接受 迭代器,这个迭代器 调用每一个 arrays(数组)的每一个值,以生成比较的新值。', // 函数名字 function: ArrayXorBy, // 当前函数 callKey: 'ArrayXorBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的数组组。', // 第一个参数代表含义 }, { text:' 调用每一个元素的迭代函数。' } ], demo: [ // 展示给用户看的案例传入值 { value:[[{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }]],// 传入函数中的值 text:`[[{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }]]`, // 展示页面所用值 }, { value: 'x', text: `x` } ], }, { name:'数组过滤(支持对象)', funcName: '接收对象进行相同筛选,以调用比较数组的元素。', // 函数名字 function: ArrayXorBy, // 当前函数 callKey: 'ArrayXorBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:' 要检查的数组组。', // 第一个参数代表含义 }, { text:' 调用每一个元素的迭代函数。' } ], demo: [ // 展示给用户看的案例传入值 { value:[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }],// 传入函数中的值 text:`[{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]`, // 展示页面所用值 }, { value: 'x', text: `x` } ], }, { name:'多数组合并', funcName: '创建一个分组元素的数组,数组的第一个元素包含所有给定数组的第一个元素,数组的第二个元素包含所有给定数组的第二个元', // 函数名字 function: ArrayZip, // 当前函数 callKey: 'ArrayZip', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要处理的数组。传多个', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:['fred', 'barney'],// 传入函数中的值 text:`['fred', 'barney']`, // 展示页面所用值 }, { value: [30, 40], text: `[30, 40]` }, { value: [true, false], text: `[true, false]` } ], }, { name:'数组合并为对象', funcName: '它接受2个数组,第一个数组中的值作为属性标识符(属性名),第二个数组中的值作为相应的属性值。', // 函数名字 function: ArrayZipObject, // 当前函数 callKey: 'ArrayZipObject', params: [ // 函数所需要传入值内容 为空为不传值 { text:'作为对象标识符数组', // 第一个参数代表含义 }, { text:'作为属性值数组' } ], demo: [ // 展示给用户看的案例传入值 { value:['name', 'age', 'year'],// 传入函数中的值 text:`['name', 'age', 'year']`, // 展示页面所用值 }, { value: ['张三', 18, 2018], text: `['张三', 18, 2018]` } ], }, { name:'数组合并为指定路径对象', funcName: '它支持属性路径接受2个数组,第一个数组中的值作为属性标识符(属性名),第二个数组中的值作为相应的属性值。', // 函数名字 function: ArrayZipObjectDeep, // 当前函数 callKey: 'ArrayZipObjectDeep', params: [ // 函数所需要传入值内容 为空为不传值 { text:'作为对象标识符数组', // 第一个参数代表含义 }, { text:'作为属性值数组' } ], demo: [ // 展示给用户看的案例传入值 { value:['a.b[0].c', 'a.b[1].d'],// 传入函数中的值 text:`['a.b[0].c', 'a.b[1].d']`, // 展示页面所用值 }, { value: [1, 2], text: `[1, 2]` } ], }, { name:'数组指定规则合成', funcName: '它接受一个 iteratee(迭代函数),来 指定分组的值应该如何被组合。 该iteratee调用每个组的元素', // 函数名字 function: ArrayZipWith, // 当前函数 callKey: 'ArrayZipWith', params: [ // 函数所需要传入值内容 为空为不传值 { text:'要处理的数组组。', // 第一个参数代表含义 }, { text:'函数用来组合分组的值。' } ], demo: [ // 展示给用户看的案例传入值 { value:[[1, 2], [10, 20], [100, 200],[40,60]],// 传入函数中的值 text:`[[1, 2], [10, 20], [100, 200],[40,60]]`, // 展示页面所用值 }, { value: function(...ary) { let num = 0 ary.map(item=>{ console.log(item) num+=item }) return num }, text: `function(...ary) { let num = 0 ary.map(item=>{ num+=item }) return num }` } ], }, ], }, { name: '对象操作函数', images: ObjectPng, pitchImages: Object2Png, children:[ { name:'数组指定规则生成对象', // 函数代表名 funcName: '创建一个组成对象,key(键)是经过 iteratee(迭代函数) 执行处理collection中每个元素后返回的结果,每个key(键)对应的值是 iteratee(迭代函数)返回该key(键)的次数', // 函数名字 function: ObjectCountBy, // 当前函数 callKey: 'ObjectCountBy', params: [ // 函数所需要传入值内容 为空为不传值 { text:'一个用来迭代的数组。', // 第一个参数代表含义 }, { text:'一个迭代函数', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:['one', 'two', 'three'],// 传入函数中的值 text:`['one', 'two', 'three']`, // 展示页面所用值 }, { value:'length',// 传入函数中的值 text:'length', // 展示页面所用值 }, ], }, { name:'对象制定规则遍历', // 函数代表名 funcName: '调用 iteratee 遍历 collection(集合) 中的每个元素,如果迭代函数(iteratee)显式的返回 false ,迭代会提前退出。', // 函数名字 function: ObjectForEach, // 当前函数 callKey: 'ObjectForEach', params: [ // 函数所需要传入值内容 为空为不传值 { text:'一个用来迭代的集合。', // 第一个参数代表含义 }, { text:'函数用来组合分组的值。', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:{ 'a': 1, 'b': 2 },// 传入函数中的值 text:`{ 'a': 1, 'b': 2 }`, // 展示页面所用值 }, { value:function(value, key) { console.log(value,key); },// 传入函数中的值 text:`function(value, key) { console.log(value,key); }`, // 展示页面所用值 }, ], }, { name:'对象制定规则反向遍历', // 函数代表名 funcName: '调用 iteratee 反方向遍历 collection(集合) 中的每个元素,如果迭代函数(iteratee)显式的返回 false ,迭代会提前退出。', // 函数名字 function: ObjectForEachRight, // 当前函数 callKey: 'ObjectForEachRight', params: [ // 函数所需要传入值内容 为空为不传值 { text:'一个用来迭代的集合。', // 第一个参数代表含义 }, { text:'函数用来组合分组的值。', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:{ 'a': 1, 'b': 2 },// 传入函数中的值 text:`{ 'a': 1, 'b': 2 }`, // 展示页面所用值 }, { value:function(value, key) { console.log(value,key); },// 传入函数中的值 text:`function(value, key) { console.log(value,key); }`, // 展示页面所用值 }, ], }, { name:'对象制定规则断言', // 函数代表名 funcName: '通过 predicate(断言函数) 检查 collection(集合)中的 所有 元素是否都返回真值。一旦 predicate(断言函数) 返回假值,迭代就马上停止。', // 函数名字 function: ObjectEvery, // 当前函数 callKey: 'ObjectEvery', params: [ // 函数所需要传入值内容 为空为不传值 { text:'一个用来迭代的集合。', // 第一个参数代表含义 }, { text:'函数用来组合分组的值。', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[ { 'user': 'barney', 'age': 36, 'active': false }, { 'user': 'fred', 'age': 40, 'active': false } ],// 传入函数中的值 text:`[ { 'user': 'barney', 'age': 36, 'active': false }, { 'user': 'fred', 'age': 40, 'active': false } ]`, // 展示页面所用值 }, { value:{ 'user': 'barney', 'active': false },// 传入函数中的值 text:`{ 'user': 'barney', 'active': false }`, // 展示页面所用值 }, ], } ], }, { name: '数字操作函数', images: NumberPng, pitchImages: Number2Png, children:[ { name:'兼容合并数组', // 函数代表名 funcName: '将传入2个数组进行合并,返回一个合并后数组', // 函数名字 function: MERGEARRAY, // 当前函数 callKey: 'MERGEARRAY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入合并数组', // 第一个参数代表含义 }, { text:'传入合并数组', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78],// 传入函数中的值 text:'[23,98,78]', // 展示页面所用值 }, { value:[32,51,79],// 传入函数中的值 text:'[32,51,79]', // 展示页面所用值 }, ], }, ], }, { name: '字符串操作函数', images: StringPng, pitchImages: String2Png, children:[ { name:'兼容合并数组', // 函数代表名 funcName: '将传入2个数组进行合并,返回一个合并后数组', // 函数名字 function: MERGEARRAY, // 当前函数 callKey: 'MERGEARRAY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入合并数组', // 第一个参数代表含义 }, { text:'传入合并数组', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78],// 传入函数中的值 text:'[23,98,78]', // 展示页面所用值 }, { value:[32,51,79],// 传入函数中的值 text:'[32,51,79]', // 展示页面所用值 }, ], }, ], }, { name:'兼容性函数', // 系列函数名称 images: Compatibility, pitchImages: Compatibility2, children:[ { name:'兼容合并数组', // 函数代表名 funcName: '将传入2个数组进行合并,返回一个合并后数组', // 函数名字 function: MERGEARRAY, // 当前函数 callKey: 'MERGEARRAY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入合并数组', // 第一个参数代表含义 }, { text:'传入合并数组', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78],// 传入函数中的值 text:'[23,98,78]', // 展示页面所用值 }, { value:[32,51,79],// 传入函数中的值 text:'[32,51,79]', // 展示页面所用值 }, ], }, { name:'兼容拆分数组', // 函数代表名 funcName: '将传入数组按照传入长度进行拆分,返回一个拆分后多维数组', // 函数名字 function: SPLITARRAY, // 当前函数 callKey: 'SPLITARRAY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要拆分数组', // 第一个参数代表含义 }, { text:'传入拆分长度', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78,65,32,11,12],// 传入函数中的值 text:'[23,98,78,65,32,11,12]', // 展示页面所用值 }, { value:2,// 传入函数中的值 text:'2', // 展示页面所用值 }, ], }, { name:'兼容切片数组', // 函数代表名 funcName: '将传入数组按照传入长度进行切片,返回一个切片后数组', // 函数名字 function: REMOVEARRAYDROP, // 当前函数 callKey: 'REMOVEARRAYDROP', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要切片数组', // 第一个参数代表含义 }, { text:'传入切片长度', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[23,98,78,65,32,11,12],// 传入函数中的值 text:'[23,98,78,65,32,11,12]', // 展示页面所用值 }, { value:2,// 传入函数中的值 text:'2', // 展示页面所用值 }, ], }, ] }, { name:'多维数据集函数', // 系列函数名称 images: Dimensions, pitchImages: Dimensions2, children:[ { name:'多维数据数组对象从大到小排序', // 函数代表名 funcName: '检查传入数组中对象,并根据指定数字属性进行从大到小排序', // 函数名字 function: ARRAYSORTONJECT, // 当前函数 callKey: 'ARRAYSORTONJECT', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要排序的数组', // 第一个参数代表含义 }, { text:'需要排序的对象指定值', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[{name:'xx',age:19},{name:'ss',age:16},{name:'ww',age:12} ,{name:'ee',age:17},{name:'qq',age:14},{name:'uu',age:22}],// 传入函数中的值 text:`[{name:'xx',age:19},{name:'ss',age:16},{name:'ww',age:12} ,{name:'ee',age:17},{name:'qq',age:14},{name:'uu',age:22}]`, // 展示页面所用值 }, { value:'age',// 传入函数中的值 text:'age', // 展示页面所用值 }, ], }, { name:'多维数据数组对象从小到大排序', // 函数代表名 funcName: '检查传入数组中对象,并根据指定数字属性进行从小到大排序', // 函数名字 function: ARRAYSORTONJECTTWO, // 当前函数 callKey: 'ARRAYSORTONJECTTWO', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要排序的数组', // 第一个参数代表含义 }, { text:'需要排序的对象指定值', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[{name:'qq',age:19},{name:'ss',age:56},{name:'ww',age:12} ,{name:'ii',age:17},{name:'qq',age:34},{name:'uu',age:22}],// 传入函数中的值 text:`[{name:'qq',age:19},{name:'ss',age:56},{name:'ww',age:12} ,{name:'ii',age:17},{name:'qq',age:34},{name:'uu',age:22}]`, // 展示页面所用值 }, { value:'age',// 传入函数中的值 text:'age', // 展示页面所用值 }, ], }, { name:'多维数据对象转为数组', // 函数代表名 funcName: '检查传入对象,并进行转换为数组', // 函数名字 function: OBJECTTOARRY, // 当前函数 callKey: 'OBJECTTOARRY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的对象', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:{name:'xx',age:12,address:'china'},// 传入函数中的值 text:"{name:'xx',age:12,address:'china'}", // 展示页面所用值 } ], }, { name:'多维数据获取对象指定值', // 函数代表名 funcName: '检查传入对象,获取需要的指定key值', // 函数名字 function: OBJECTGETKEY, // 当前函数 callKey: 'OBJECTGETKEY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要操作的对象', // 第一个参数代表含义 }, { text:'获取数组中指定的key值' } ], demo: [ // 展示给用户看的案例传入值 { value:{name:'xx',age:12,address:'china',time:'2019-10-10'},// 传入函数中的值 text:"{name:'xx',age:12,address:'china',time:'2019-10-10'}", // 展示页面所用值 }, { value:['name','address'], text: "['name','address']" } ], }, { name:'多维数据子数组排序', // 函数代表名 funcName: '传入多维数组,并对子数组中数值排序进行,非子数组则会跳过', // 函数名字 function: ARRAYMANYSORT, // 当前函数 callKey: 'ARRAYMANYSORT', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要排序的多维数组', // 第一个参数代表含义 }, { text:'是否从大到小排序,默认从大到小' } ], demo: [ // 展示给用户看的案例传入值 { value:[[43,12,56,26,47],[21,76,74,23,63],'我不是数组',[85,74,12,53,23]], text: "[[43,12,56,26,47],[21,76,74,23,63],'我不是数组',[85,74,12,53,23]]" }, { value:false, text:'false' } ], }, { name:'多维数据子数组中对象拆分为数组', // 函数代表名 funcName: '传入多维数组,并对子数组中对象进行拆分成数组,非子数组则会跳过', // 函数名字 function: ARRAYSPLITOBJECT, // 当前函数 callKey: 'ARRAYSPLITOBJECT', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要拆分的多维数组', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[[{age:21,name:'sx',address:'chind'},{post:'职位',title:'标题'}],[{name1:'as',age1:43,address:'china'},{post:'职位',title:'标题'}]], text: "[[{age:21,name:'sx',address:'chind'},{post:'职位',title:'标题'}],[{name1:'as',age1:43,address:'china'},{post:'职位',title:'标题'}]]" } ], }, ] }, { name:'数据库函数', // 系列函数名称 images: Database, pitchImages: Database2, children:[ { name:'数据库函数子函数', // 函数代表名 funcName: 'sql', // 函数名字 function: sql, // 当前函数 callKey: 'sql', params: [ // 函数所需要传入值内容 为空为不传值 { } ], demo: [ // 展示给用户看的案例传入值 { value:'', // 传入函数中的值 text: '', // 展示页面所用值 } ] } ] }, { name:'日期和时间函数', // 系列函数名称 images: DateImg, pitchImages: DateImg2, children:[ { name:'日期差值计算', // 函数代表名 funcName: '将传入2个时间戳进行计算,返回2者时间戳差值', // 函数名字 function: CONTRASTTIME, // 当前函数 callKey: 'CONTRASTTIME', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入计算时间戳', // 第一个参数代表含义 }, { text:'传入计算时间戳', // 第二个参数代表含义 }, { text:'是否需要将时间差值进行转换(true或false)', } ], demo: [ // 展示给用户看的案例传入值 { value:1576122231269,// 传入函数中的值 text:'1576122231269', // 展示页面所用值 }, { value:1576111231269,// 传入函数中的值 text:'1576121231269', // 展示页面所用值 }, { value:true, text:'true' } ], }, { name:'日期年月日格式化', // 函数代表名 funcName: '将传入的时间戳格式化为年月日', // 函数名字 function: DATEGETYEAR, // 当前函数 callKey: 'DATEGETYEAR', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要格式化时间戳', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:1576122231269,// 传入函数中的值 text:'1576122231269', // 展示页面所用值 } ], }, { name:'日期月日格式化', // 函数代表名 funcName: '将传入的时间戳格式化为月日', // 函数名字 function: DATAGETMONTH, // 当前函数 callKey: 'DATAGETMONTH', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要格式化时间戳', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:1576122231269,// 传入函数中的值 text:'1576122231269', // 展示页面所用值 } ], }, { name:'日期日格式化', // 函数代表名 funcName: '将传入的时间戳格式化为日', // 函数名字 function: DATAGETDAY, // 当前函数 callKey: 'DATAGETDAY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要格式化时间戳', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:1576122231269,// 传入函数中的值 text:'1576122231269', // 展示页面所用值 } ], }, { name:'日期时间格式化', // 函数代表名 funcName: '将传入的时间戳格式化为时间', // 函数名字 function: DATAGETTIME, // 当前函数 callKey: 'DATAGETTIME', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要格式化时间戳', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:1576122231269,// 传入函数中的值 text:'1576122231269', // 展示页面所用值 } ], }, { name:'日期自定义格式化', // 函数代表名 funcName: '将传入的时间戳按照自定义格式化为时间格式', // 函数名字 function: DATAGETCUSTOM, // 当前函数 callKey: 'DATAGETCUSTOM', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要格式化时间戳', // 第一个参数代表含义 }, { text:'传入的时间格式化格式' } ], demo: [ // 展示给用户看的案例传入值 { value:1576122231269,// 传入函数中的值 text:'1576122231269', // 展示页面所用值 }, { value:'YYYY-MM-DD hh:mm:ss', text:'YYYY-MM-DD hh:mm:ss', } ], }, ] }, { name:'财务函数', // 系列函数名称 images: Finance, pitchImages: Finance2, children:[ { name:'财务自动求和', // 函数代表名 funcName: '将传入2个数值进行相加,返回相加后总数', // 函数名字 function: AUTOSUMMATION, // 当前函数 callKey: 'AUTOSUMMATION', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入被加值', // 第一个参数代表含义 }, { text:'传入累加值', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:23,// 传入函数中的值 text:'23', // 展示页面所用值 }, { value:85,// 传入函数中的值 text:'85', // 展示页面所用值 }, ], }, { name:'财务自动求平均值', // 函数代表名 funcName: '将传入的数字数组集合累加并进行平均值求值', // 函数名字 function: AUTOMEAN, // 当前函数 callKey: 'AUTOMEAN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求平均值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, { name:'财务自动获取最大值', // 函数代表名 funcName: '将传入的数字数组集合获取最大值', // 函数名字 function: AUTOMAX, // 当前函数 callKey: 'AUTOMAX', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求获取最大值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, { name:'财务自动获取最小值', // 函数代表名 funcName: '将传入的数字数组集合获取最小值', // 函数名字 function: AUTOMIN, // 当前函数 callKey: 'AUTOMIN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求获取最小值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, ] }, { name:'信息函数', // 系列函数名称 images: MessageImg, pitchImages: MessageImg2, children:[ { name:'信息类型判断', // 函数代表名 funcName: '将传入的数据判断类型并返回', // 函数名字 function: TYPEOFDATA, // 当前函数 callKey: 'TYPEOFDATA', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入一个数据,对传入数据进行判断', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:['测试'], // 传入函数中的值 text: '["测试"]', // 展示页面所用值 } ] }, { name:'信息提示', // 函数代表名 funcName: '将传入的提示内容添加到提示框展示', // 函数名字 function: TOASTMESSAGE, // 当前函数 callKey: 'TOASTMESSAGE', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要提示用户的信息', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:'测试信息', // 传入函数中的值 text: '测试信息', // 展示页面所用值 } ] }, { name:'信息NaN判断', // 函数代表名 funcName: '将传入的数据是否是NaN', // 函数名字 function: TYPEOFNAN, // 当前函数 callKey: 'TYPEOFNAN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入的需要判断数据', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:NaN, // 传入函数中的值 text: 'NaN', // 展示页面所用值 } ] }, ] }, { name:'逻辑函数', // 系列函数名称 images: Logic, pitchImages: Logic2, children:[ { name:'逻辑判断数组是否存在空数值', // 函数代表名 funcName: '检查传入数组所有值是否存在值,存在控制返回true', // 函数名字 function: LOGICARRAY, // 当前函数 callKey: 'LOGICARRAY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要检查的数组', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[56,'23','236',undefined,null], // 传入函数中的值 text: "[56,'23','236',undefined,null]", // 展示页面所用值 } ] }, { name:'逻辑判断文本内容对比', // 函数代表名 funcName: '对比传入的2个字符串是否相同', // 函数名字 function: STRINGISSAME, // 当前函数 callKey: 'STRINGISSAME', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要对比的字符串', // 第一个参数代表含义 }, { text:'需要对比的字符串', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: '你好,world', // 传入函数中的值 text: '你好,world', // 展示页面所用值 }, { value: '你好世界', // 传入函数中的值 text: '你好世界', // 展示页面所用值 } ] }, { name:'逻辑判断文本对比查询', // 函数代表名 funcName: '对比传入的2个字符串对比,查询后面传入值是否存在于第一个参数中', // 函数名字 function: STRINGISHAVE, // 当前函数 callKey: 'STRINGISHAVE', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要对比的字符串', // 第一个参数代表含义 }, { text:'需要对比的字符串', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: '你好,world', // 传入函数中的值 text: '你好,world', // 展示页面所用值 }, { value: '好', // 传入函数中的值 text: '好', // 展示页面所用值 } ] }, { name:'逻辑筛选数组指定值', // 函数代表名 funcName: '检查数值是否存在指定值,存在则返回', // 函数名字 function: LOGICARRAYFILTER, // 当前函数 callKey: 'LOGICARRAYFILTER', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要检查的数组', // 第一个参数代表含义 }, { text:'指定值', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: ['你好','世界','嗯'], // 传入函数中的值 text: "['你好','世界','嗯']", // 展示页面所用值 }, { value: '世界', // 传入函数中的值 text: '世界', // 展示页面所用值 } ] }, ] }, { name:'查找和引用函数', // 系列函数名称 images: Find, pitchImages: Find2, children:[ { name:'查找并替换字段', // 函数代表名 funcName: '修改字符串中匹配的第一个字段', // 函数名字 function: FINDSTRRPLACE, // 当前函数 callKey: 'FINDSTRRPLACE', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要查询的字符串', // 第一个参数代表含义 }, { text: '传入需要查询的字段', }, { text: '传入需要更换查询的字段', } ], demo: [ // 展示给用户看的案例传入值 { value:'你好,世界', // 传入函数中的值 text: '你好,世界', // 展示页面所用值 }, { value:'世界', text:'世界', }, { value:'美丽世界', text:'美丽世界' } ] }, { name:'查找数组内容', // 函数代表名 funcName: '查找出数组中匹配的第一个数值', // 函数名字 function: FINDARRAYNUM, // 当前函数 callKey: 'FINDARRAYNUM', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要查询的数组', // 第一个参数代表含义 }, { text: '传入需要查询的内容', }, ], demo: [ // 展示给用户看的案例传入值 { value:[2,3,5,2,21], // 传入函数中的值 text: '[2,3,5,2,21]', // 展示页面所用值 }, { value:21, text:'21', } ] }, ] }, { name:'数学和三角函数', // 系列函数名称 images: MathImg, pitchImages: MathImg2, children:[ { name:'数学自动求和', // 函数代表名 funcName: '将传入2个数值进行相加,返回相加后总数', // 函数名字 function: AUTOSUMMATION, // 当前函数 callKey: 'AUTOSUMMATION', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入被加值', // 第一个参数代表含义 }, { text:'传入累加值', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:23,// 传入函数中的值 text:'23', // 展示页面所用值 }, { value:85,// 传入函数中的值 text:'85', // 展示页面所用值 }, ], }, { name:'数学自动求平均值', // 函数代表名 funcName: '将传入的数字数组集合累加并进行平均值求值', // 函数名字 function: AUTOMEAN, // 当前函数 callKey: 'AUTOMEAN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求平均值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, { name:'数学自动获取最大值', // 函数代表名 funcName: '将传入的数字数组集合获取最大值', // 函数名字 function: AUTOMAX, // 当前函数 callKey: 'AUTOMAX', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求获取最大值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, { name:'数学自动获取最小值', // 函数代表名 funcName: '将传入的数字数组集合获取最小值', // 函数名字 function: AUTOMIN, // 当前函数 callKey: 'AUTOMIN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求获取最小值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, ] }, { name:'统计函数', // 系列函数名称 images: Statistics, pitchImages: Statistics2, children:[ { name:'统计数组总值', // 函数代表名 funcName: '将传入的数组值,进行累加返回累加总数,如果存在非数字会跳过计算', // 函数名字 function: ARRAYADDNUM, // 当前函数 callKey: 'ARRAYADDNUM', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要进行累积的数组', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,'测试',16], // 传入函数中的值 text: '[8,9,6,8,7,"测试",16]', // 展示页面所用值 } ] }, { name:'统计数组中对象某一值总数', // 函数代表名 funcName: '将传入的数组值,进行累加返回累加总数,如果存在非数字会跳过计算', // 函数名字 function: ARRAYOBJECTADD, // 当前函数 callKey: 'ARRAYOBJECTADD', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入需要进行累积的数组', // 第一个参数代表含义 }, { text: '指定需要累积的对象key值' } ], demo: [ // 展示给用户看的案例传入值 { value:[{num:3},{num:33},{num:63},{num:43},{num:23},{num:"98w"},{num:13}], // 传入函数中的值 text: '[{num:3},{num:33},{num:63},{num:43},{num:23},{num:"98w"},{num:13}]', // 展示页面所用值 }, { value:'num', text:'num', } ] }, { name:'统计用户输入长度', // 函数代表名 funcName: '统计用户总共输入的长度并返回', // 函数名字 function: STRINGLEHGTH, // 当前函数 callKey: 'STRINGLEHGTH', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要统计的内容长度', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:'我是被测试内容', // 传入函数中的值 text: '我是被测试内容', // 展示页面所用值 } ] }, { name:'统计自动求和', // 函数代表名 funcName: '将传入2个数值进行相加,返回相加后总数', // 函数名字 function: AUTOSUMMATION, // 当前函数 callKey: 'AUTOSUMMATION', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入被加值', // 第一个参数代表含义 }, { text:'传入累加值', // 第二个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:23,// 传入函数中的值 text:'23', // 展示页面所用值 }, { value:85,// 传入函数中的值 text:'85', // 展示页面所用值 }, ], }, { name:'统计自动求平均值', // 函数代表名 funcName: '将传入的数字数组集合累加并进行平均值求值', // 函数名字 function: AUTOMEAN, // 当前函数 callKey: 'AUTOMEAN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求平均值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, { name:'统计自动获取最大值', // 函数代表名 funcName: '将传入的数字数组集合获取最大值', // 函数名字 function: AUTOMAX, // 当前函数 callKey: 'AUTOMAX', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求获取最大值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, { name:'统计自动获取最小值', // 函数代表名 funcName: '将传入的数字数组集合获取最小值', // 函数名字 function: AUTOMIN, // 当前函数 callKey: 'AUTOMIN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'传入所有需要求获取最小值的数组集合', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:[8,9,6,8,7,16], // 传入函数中的值 text: '[8,9,6,8,7,16]', // 展示页面所用值 } ] }, ] }, { name:'文本函数', // 系列函数名称 images: TextImg, pitchImages: TextImg2, children:[ { name:'文本HTML标签转译', // 函数代表名 funcName: '将文本域输入的HTML标签转移', // 函数名字 function: TRANSLATIONSTRING, // 当前函数 callKey: 'TRANSLATIONSTRING', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要进行转移的文本输入', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:'<script>alert("233")</script>', // 传入函数中的值 text: '<script>alert("233")</script>', // 展示页面所用值 } ] }, { name:'文本HTML标签反向转译', // 函数代表名 funcName: '将文本域输入的已转译HTML标签反向转译', // 函数名字 function: TRANSLATIONSTRINGTWO, // 当前函数 callKey: 'TRANSLATIONSTRINGTWO', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要进行反向转译的文本输入', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:'<script>alert(&quto;233&quto;)</script>', // 传入函数中的值 text: '<script>alert(&quto;233&quto;)</script>', // 展示页面所用值 } ] }, { name:'文本数组内容拼接', // 函数代表名 funcName: '将数组内容进行拼接,会跳过拼接对象', // 函数名字 function: TEXTCONCAT, // 当前函数 callKey: 'TEXTCONCAT', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要拼接的数组内容', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value:['你好',{num:1},'世界'], // 传入函数中的值 text: "['你好',{num:1},'世界']", // 展示页面所用值 } ] }, { name:'文本内容对比', // 函数代表名 funcName: '对比传入的2个字符串是否相同', // 函数名字 function: STRINGISSAME, // 当前函数 callKey: 'STRINGISSAME', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要对比的字符串', // 第一个参数代表含义 }, { text:'需要对比的字符串', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: '你好,世界', // 传入函数中的值 text: '你好,世界', // 展示页面所用值 }, { value: '你好世界', // 传入函数中的值 text: '你好世界', // 展示页面所用值 } ] }, { name:'文本对比查询', // 函数代表名 funcName: '对比传入的2个字符串对比,查询后面传入值是否存在于第一个参数中', // 函数名字 function: STRINGISHAVE, // 当前函数 callKey: 'STRINGISHAVE', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要对比的字符串', // 第一个参数代表含义 }, { text:'需要对比的字符串', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: '你好,世界', // 传入函数中的值 text: '你好,世界', // 展示页面所用值 }, { value: '好', // 传入函数中的值 text: '好', // 展示页面所用值 } ] }, { name:'文本转换为驼峰写法', // 函数代表名 funcName: '将文本英文转为驼峰写法', // 函数名字 function: STRINGCAMELCASE, // 当前函数 callKey: 'STRINGCAMELCASE', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的字符串', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: '你好,hello world,世界', // 传入函数中的值 text: '你好,hello world,世界', // 展示页面所用值 } ] }, { name:'文本校验', // 函数代表名 funcName: '校验传入文本是否按照规定字符结尾', // 函数名字 function: STRINGVERIFY, // 当前函数 callKey: 'STRINGVERIFY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要校验的字符串', // 第一个参数代表含义 }, { text:'需要校验的字符规则', // 第一个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value: '你好,hello world,世界', // 传入函数中的值 text: '你好,hello world,世界', // 展示页面所用值 }, { value: '世界', // 传入函数中的值 text: '世界', // 展示页面所用值 }, ] }, { name: '文本拆分为集合', // 函数代表名 funcName: '拆分字符串内容成数组', // 函数名字 function: STRINGVERIFY, // 当前函数 callKey: 'STRINGVERIFY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要拆分的字段', // 第一个参数代表含义 }, ], demo: [ // 展示给用户看的案例传入值 { value: '你好,hello world,世界', // 传入函数中的值 text: '你好,hello world,世界', // 展示页面所用值 } ] }, ] }, { name:'工程函数', // 系列函数名称 images: Project, pitchImages: Project2, children:[ { name:'工程十进制转八进制', // 函数代表名 funcName: '获得十进制参数并转换为八进制返回', // 函数名字 function: TENSCALETOEIGHT, // 当前函数 callKey: 'TENSCALETOEIGHT', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 580, // 传入函数中的值 text: '580', // 展示页面所用值 }, ] }, { name:'工程十进制转十六进制', // 函数代表名 funcName: '获得十进制参数并转换为十六进制返回', // 函数名字 function: TENSCALETOSIXTEEN, // 当前函数 callKey: 'TENSCALETOSIXTEEN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 580, // 传入函数中的值 text: '580', // 展示页面所用值 }, ] }, { name:'工程十进制转二进制', // 函数代表名 funcName: '获得十进制参数并转换为二进制返回', // 函数名字 function: TENSCALETOTWO, // 当前函数 callKey: 'TENSCALETOTWO', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 580, // 传入函数中的值 text: '580', // 展示页面所用值 }, ] }, { name:'工程十进制自定义转化', // 函数代表名 funcName: '获得十进制参数并转换为自定义转化返回', // 函数名字 function: TENSCALETOMANY, // 当前函数 callKey: 'TENSCALETOMANY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 }, { text:'自定义的进制转换' } ], demo: [ // 展示给用户看的案例传入值 { value: 580, // 传入函数中的值 text: '580', // 展示页面所用值 }, { value: 8, text:'8' } ] }, { name:'工程八进制到十进制转换', // 函数代表名 funcName: '获得八进制参数并转换为十进制返回', // 函数名字 function: EIGHTSCALETOTEN, // 当前函数 callKey: 'EIGHTSCALETOTEN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 1104, // 传入函数中的值 text: '1104', // 展示页面所用值 } ] }, { name:'工程八进制到十六进制转换', // 函数代表名 funcName: '获得八进制参数并转换为十六进制返回', // 函数名字 function: EIGHTSCALETOSIXTEEN, // 当前函数 callKey: 'EIGHTSCALETOSIXTEEN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 1104, // 传入函数中的值 text: '1104', // 展示页面所用值 } ] }, { name:'工程八进制到二进制转换', // 函数代表名 funcName: '获得八进制参数并转换为二进制返回', // 函数名字 function: EIGHTSCALETOTWO, // 当前函数 callKey: 'EIGHTSCALETOTWO', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 1104, // 传入函数中的值 text: '1104', // 展示页面所用值 } ] }, { name:'工程八进制到自定义进制转换', // 函数代表名 funcName: '获得八进制参数并转换为自定义返回', // 函数名字 function: EIGHTSCALETOMANY, // 当前函数 callKey: 'EIGHTSCALETOMANY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 }, { text:'自定义的进制转换' } ], demo: [ // 展示给用户看的案例传入值 { value: 1104, // 传入函数中的值 text: '1104', // 展示页面所用值 }, { value:10, text:'10' } ] }, { name:'工程十六进制到十进制转换', // 函数代表名 funcName: '获得十六进制参数并转换为十进制返回', // 函数名字 function: SIXTEENSCALETOTEN, // 当前函数 callKey: 'SIXTEENSCALETOTEN', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 244, // 传入函数中的值 text: '244', // 展示页面所用值 } ] }, { name:'工程十六进制到二进制转换', // 函数代表名 funcName: '获得十六进制参数并转换为二进制返回', // 函数名字 function: SIXTEENSCALETOTWO, // 当前函数 callKey: 'SIXTEENSCALETOTWO', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 244, // 传入函数中的值 text: '244', // 展示页面所用值 } ] }, { name:'工程十六进制到八进制转换', // 函数代表名 funcName: '获得十六进制参数并转换为八进制返回', // 函数名字 function: SIXTEENSCALETOEIGHT, // 当前函数 callKey: 'SIXTEENSCALETOEIGHT', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 } ], demo: [ // 展示给用户看的案例传入值 { value: 244, // 传入函数中的值 text: '244', // 展示页面所用值 } ] }, { name:'工程十六进制到自定义进制转换', // 函数代表名 funcName: '获得十六进制参数并转换为自定义返回', // 函数名字 function: SIXTEENSCALETOMANY, // 当前函数 callKey: 'SIXTEENSCALETOMANY', params: [ // 函数所需要传入值内容 为空为不传值 { text:'需要转换的数字', // 第一个参数代表含义 }, { text:'自定义的进制转换' } ], demo: [ // 展示给用户看的案例传入值 { value: 244, // 传入函数中的值 text: '244', // 展示页面所用值 }, { value:10, text:'10' } ] }, ] }, ] /** * 公式选择数组 */ const tabList = [ // { // name:'柱形图', // key:'1', // images: Column, // pitchImages: Column2, // children:[ // // 格式参考 // // { // // name: '', // 函数名字 // // funcName: '', // 函数介绍 // // function: ''. // 函数 // // } // ], // isPitch:false, // 是否选中 // isShowList: false, // 是否自动展开子表单 // }, // { // name:'饼图', // key:'2', // images:PieImg, // pitchImages: PieImg2, // children:[], // isPitch:false, // isShowList: false, // }, // { // name: '雷达图', // key:'3', // images: Radar, // pitchImages: Radar2, // children:[], // isPitch:false, // isShowList: false, // }, // { // name: '气泡图', // key:'4', // images: Bubble, // pitchImages: Bubble2, // children:[], // isPitch:false, // isShowList: false, // }, // { // name: '散点图', // key:'5', // images: Splashes, // pitchImages: Splashes2, // children:[], // isPitch:false, // isShowList: false, // }, // { // name: '树状图', // key: '6', // images: Dendrogram, // pitchImages: Dendrogram2, // children:[], // isPitch:false, // isShowList: false, // }, // { // name: '箱型图', // key: '7', // images: Box, // pitchImages: Box2, // children:[], // isPitch:false, // isShowList: false, // }, // { // name: '旭日图', // key: '8', // images: Rising, // pitchImages: Rising2, // children:[], // isPitch:false, // isShowList: false, // }, // { // name: '折线图', // key: '9', // images: Line, // pitchImages: Line2, // children:[], // isPitch:false, // isShowList: false, // }, // { // name: '直方图', // key:'10', // images: Straight, // pitchImages: Straight2, // children:[], // isPitch:false, // isShowList: false, // } ] /** * List 在此做格式化操作并添加入tabList导出, * 属于List数组中函数新增应新增到List中,此处会自动添加进去 * 属于tabList数组函数新增应新增到tabList中 */ List.map( (item,index) => { tabList.push({ name:item.name, key:item.name+index, images: item.images, pitchImages: item.pitchImages, isPitch:false, isShowList: false, children:item.children.map((arr,i) => { return { name: arr.name, funcName: arr.funcName, function: arr.function, callKey: arr.callKey } }) }) }) export const formulaList = tabList /** * 数据库函数系列 * @param {*} params */ export function sql() { } /** * 基础计算函数 * 自动求和 * @param {传入被加值} num * @param {传入累加值} num1 */ export function AUTOSUMMATION(num,num1) { num=+num num1=+num1 return num+num1 } /** * 基础计算函数 * 自动求平均值 * @param {传入需要累加的数组,里面为数字} List */ export function AUTOMEAN(List) { let num = 0; // 初始值 let mean = 0; // 平均值 if(isArray(List)){ List.map(item => { if(typeof item == 'number'||typeof item == 'string'){ num +=item } else { console.log('这不是一个数字') return } }) if(isNaN(num)){ console.log('传入值错误,请检查') } else { mean = num/List.length return mean } } else { console.log('这不是数组') return } } /** * 基础计算函数 * 获取最大值 * @param {传入需要累加的数组,获取数组最大值} List */ export function AUTOMAX(List) { return Math.max.apply(null,List); } /** * 基础计算函数 * 获取最大值 * @param {传入需要累加的数组,获取数组最小值} List */ export function AUTOMIN(List) { return Math.min.apply(null,List); } /** * 查找引用函数 * 修改字符串中匹配的第一个字段 * @param {传入需要查询的字符串} str * @param {传入需要查询的字段} str2 * @param {传入需要更换的字段} str32 */ export function FINDSTRRPLACE(str,str2,str3) { if(typeof str == 'string'&&typeof str2 == 'string'&&typeof str3 == 'string'){ str=str.replace(str2,str3) return str } else { console.log('这不是个字符串') } } /** * 查找引用函数 * 查找出数组中匹配的第一个数值 * @param {传入需要查询的数组} arr * @param {传入需要查询的内容} data */ export function FINDARRAYNUM(arr,data) { if(isArray(arr)){ if(typeof arr[0] == 'object'){ let index = arr.findIndex(arr,data) if(index == -1){ return '数组不存在查询值' }else{ return arr[index] } } let index = arr.indexOf(data) if(index == -1){ return '数组不存在查询值' }else{ return arr[index] } }else{ return '传入值不是数组' } } /** * 兼容性函数 * 合并2个传入的数组集合 * @param {传入需要合并的数组} arr * @param {传入需要合并的数组} arr1 */ export function MERGEARRAY(arr,arr1) { if(isArray(arr)&&isArray(arr1)){ const list = [...arr,...arr1] return list }else{ return '传入值不是数组' } } /** * 兼容性函数 * 根据传入数组进行拆分成多维数组 * @param {传入需要拆分的数组} arr * @param {传入需要拆分成长度的数值} num */ export function SPLITARRAY(arr,num) { if(isArray(arr)){ let list = chunk(arr,num) return list }else { return '传入值不是数组' } } /** * 兼容性函数 * 根据传入数组和切片长度,去除对应长度的数组 * @param {传入需要拆分的数组} arr * @param {传入需要拆分成长度的数值} num */ export function REMOVEARRAYDROP(arr,num) { if(isArray(arr)){ let list = drop(arr,num) return list }else { return '传入值不是数组' } } /** * 日期和时间函数 * 根据传入的2个时间戳进行对比,返回时间差值 * @param {传入需要对比的时间戳} time * @param {传入需要对比的时间戳} time1 * @param {是否需要将时间差值进行转换} isFormat */ export function CONTRASTTIME(time,time1,isFormat) { if(typeof time1 == 'number'&&typeof time=='number'){ if(time1>time){ let data = time1-time if(isFormat){ return getTimeMonth(data) }else{ return data } } else if(time1<time){ let data = time-time1 if(isFormat){ return getTimeMonth(data) }else{ return data } } } else { return '传入值不正确' } } /** * 时间戳格式化函数 */ export function getTimeMonth(time) { if(time<=60000){ // 低于1分钟 return '低于一分钟' } else if( 60000<=time&&time<3600000) { // 低于1小时 统计分钟数 return moment(time).format('mm')+'分钟' } else if( 3600000<=time&&time<86400000 ){ // 高于一小时,低于一天 return moment(time).format('hh:mm:ss') } else if(86400000<=time&&time<2592000000){ // 大于一天小于一个月 return moment(time).format('DD天hh:mm:ss') }else if(2592000000<time){ // 大于一个月 return moment(time).format('MM月DD天 hh:mm:ss') } } /** * 日期和时间函数 * 将传入的时间戳格式化为年月日 * @param {传入的时间戳} time */ export function DATEGETYEAR(time) { let data = moment(time).format('YYYY-MM-DD') return data } /** * 日期和时间函数 * 将传入的时间戳格式化为月日 * @param {传入的时间戳} time */ export function DATAGETMONTH(time) { let data = moment(time).format('MM-DD') return data } /** * 日期和时间函数 * 将传入的时间戳格式化为日 * @param {传入的时间戳} time */ export function DATAGETDAY(time) { let data = moment(time).format('DD') return data } /** * 日期和时间函数 * 将传入的时间戳格式化为时间格式 * @param {传入的时间戳} time */ export function DATAGETTIME(time) { let data = moment(time).format('hh:mm:ss') return data } /** * 日期和时间函数 * 将传入的时间戳按照自定义格式化为时间格式 * @param {传入的时间戳} time * @param {传入的时间格式化格式} str */ export function DATAGETCUSTOM(time,str) { let data = moment(time).format(str) return data } /** * 信息函数 * 判断传入值的类型并返回 * @param {需要判断类型的数据} data */ export function TYPEOFDATA(data) { if(typeof data == 'object'){ if(isArray(data)){ return 'array' } else { return 'object' } } else { return typeof data } } /** * 信息函数 * 发起弹框提示用户信息 * @param {需要提示用户的信息} str */ export function TOASTMESSAGE(str) { let width = document.documentElement.clientWidth || document.body.clientWidth; if(width<1200){ showToast(str) } else { openToast('info','提示',str) } return '' } /** * 信息函数 * 判断传入值是否为NAN * @param {传入的需要判断数据} str */ export function TYPEOFNAN(str) { if (typeof str == 'string') { try { JSON.parse(str); if(typeof JSON.parse(str) === 'number'){ return false; } return true; } catch (e) { return false; } } } /** * 统计函数 * 将传入的数组值,进行累加返回累加总数,如果存在非数字会跳过计算 * @param {传入的需要累加的数组} ary */ export function ARRAYADDNUM(ary) { if(isArray(ary)){ let sum = 0; ary.map(item => { if(isNaN(+item)){ return } sum+=item }) return sum }else { return '传入值非数组' } } /** * 统计函数 * 将传入的为对象型数组进行指定属性统一累积 * @param {传入的需要累加的数组} ary * @param {指定需要累积的对象key值} str */ export function ARRAYOBJECTADD(ary,str) { if(isArray(ary)){ let sum = 0; ary.map(item => { if(isNaN(+item[str])){ return } sum+=item[str] }) return sum }else { return '传入值非数组' } } /** * 统计函数 * 统计传入的字符串总共输入的长度 * @param {需要统计的字符串长度} str */ export function STRINGLEHGTH(str) { return str.length } /** * 文本函数 * 将文本域输入的HTML标签转译 * @param {需要进行转移的文本输入} str */ export function TRANSLATIONSTRING(str) { str = str.replace(/&/g, '&') str = str.replace(/</g, '<') str = str.replace(/>/g, '>') str = str.replace(/"/g, '&quto;') str = str.replace(/'/g, ''') str = str.replace(/`/g, '`') str = str.replace(/\//g, '/') str = str.replace(/ /g, " "); return str } /** * 文本函数 * 将文本域输入的已转译HTML标签反向转译 * @param {需要进行反向转译的文本输入} str */ export function TRANSLATIONSTRINGTWO(str) { str = str.replace(/&/g, '&') str = str.replace(/</g, '<') str = str.replace(/>/g, '>') str = str.replace(/&quto;/g, '"') str = str.replace(/'/g, "'") str = str.replace(/`/g, '`') str = str.replace(///g, '\/') str = str.replace(/ /g, " "); return str } /** * 文本函数 * 拆分字符串内容成数组 * @param {需要拆分的字段} str */ export function STRINGWORDS(str) { if(typeof str == 'string'){ return words(str) } else { return '传入值应该为字符串' } } /** * 文本函数 * 将数组中内容进行拼接返回一个完整字符串,无法拼接则会跳过 * @param {需要拼接的数组内容} ary */ export function TEXTCONCAT(ary) { if(isArray(ary)){ let str = '' ary.map(item => { if(typeof item == 'object'){ return }else{ str = `${str}`+`${item}` } }) return str }else { return '传入值非数组' } } /** * 文本函数 * 对比传入的2个字符串是否相同 * @param {需要对比的字符串} str * @param {需要对比的字符串} str1 */ export function STRINGISSAME(str,str1) { return str === str1 } /** * 文本函数 * 对比传入的2个字符串对比,查询后面传入值是否存在于第一个参数中 * @param {需要对比的字符串} str * @param {需要对比的字符串} str1 */ export function STRINGISHAVE(str,str1) { let res = str.indexOf(str1) if(res == -1){ return false }else { return true } } /** * 文本函数 * 将文本英文转为驼峰写法 * @param {需要转换的字符串} str */ export function STRINGCAMELCASE(str) { if(typeof str == 'string'){ return camelCase(str) } else { return '这不是个字符串' } } /** * 文本函数 * 校验传入文本是否按照规定字符结尾 * @param {需要校验的字符串} str * @param {需要校验的字符规则} str1 */ export function STRINGVERIFY(str,str1) { if(typeof str == 'string'&&typeof str1 == 'string'){ return endsWith(str,str1) }else { return '传入值不是字符串' } } /** * 工程函数 * 十进制转换8进制 * @param { 需要转换的十进制} num */ export function TENSCALETOEIGHT(num) { if(typeof num == 'number'){ return parseInt(num).toString(8) }else{ return '传入值不是数字' } } /** * 工程函数 * 十进制转换16进制 * @param { 需要转换的十进制} num */ export function TENSCALETOSIXTEEN(num) { if(typeof num == 'number'){ return parseInt(num).toString(16) }else{ return '传入值不是数字' } } /** * 工程函数 * 十进制转换2进制 * @param { 需要转换的十进制} num */ export function TENSCALETOTWO(num) { if(typeof num == 'number'){ return parseInt(num).toString(2) }else{ return '传入值不是数字' } } /** * 工程函数 * 自定义十进制转换 * @param {需要转换的十进制} num * @param {自定义的进制转换} num1 */ export function TENSCALETOMANY(num,num1) { if(typeof num == 'number'&&typeof num1 == 'number'){ return parseInt(num).toString(num1) }else{ return '传入值不是数字' } } /** * 工程函数 * 八进制到十进制转换 * @param {需要转换的八进制} num */ export function EIGHTSCALETOTEN(num) { if(typeof num == 'number'){ return parseInt(num,8) }else{ return '传入值不是数字' } } /** * 工程函数 * 八进制到十六进制转换 * @param {需要转换的八进制} num */ export function EIGHTSCALETOSIXTEEN(num) { if(typeof num == 'number'){ return parseInt(num,8).toString(16) }else{ return '传入值不是数字' } } /** * 工程函数 * 八进制到二进制转换 * @param {需要转换的八进制} num */ export function EIGHTSCALETOTWO(num) { if(typeof num == 'number'){ return parseInt(num,8).toString(2) }else{ return '传入值不是数字' } } /** * 工程函数 * 八进制到自定义机制转换 * @param {需要转换的八进制} num * @param {自定义的进制转换} num1 */ export function EIGHTSCALETOMANY(num,num1) { if(typeof num == 'number'&&typeof num1 == 'number'){ return parseInt(num,8).toString(num1) }else{ return '传入值不是数字' } } /** * 工程函数 * 十六进制转二进制 * @param {需要转换的十六进制} num */ export function SIXTEENSCALETOTWO(num) { if(typeof num == 'number'){ return parseInt(num,16).toString(2) }else{ return '传入值不是数字' } } /** * 工程函数 * 十六进制转八进制 * @param {需要转换的十六进制} num */ export function SIXTEENSCALETOEIGHT(num) { if(typeof num == 'number'){ return parseInt(num,16).toString(8) }else{ return '传入值不是数字' } } /** * 工程函数 * 十六进制转十进制 * @param {需要转换的十六进制} num */ export function SIXTEENSCALETOTEN(num) { if(typeof num == 'number'){ return parseInt(num,16) }else{ return '传入值不是数字' } } /** * 工程函数 * 十六进制转自定义进制 * @param {需要转换的十六进制} num * @param {自定义的进制转换} num1 */ export function SIXTEENSCALETOMANY(num,num1) { if(typeof num == 'number'&&typeof num1 == 'number'){ return parseInt(num,16).toString(num1) }else{ return '传入值不是数字' } } /** * 逻辑函数 * 检查传入数组所有值是否存在值,存在控制返回true * @param {需要检查的数组} ary */ export function LOGICARRAY(ary) { if(isArray(ary)){ let isHave = true ary.map(item => { if(!!item == false){ isHave = false } }) return isHave }else { return '传入值不是数组' } } /** * 逻辑函数 * 检查数值是否存在指定值,存在则返回 * @param {需要检查的数组} ary * @param {需要检查的指定值} res */ export function LOGICARRAYFILTER(ary,res) { if(isArray(ary)){ let data; data = ary.filter(item => item==res) if(data.length>0){ return data }else { return '不存在指定值' } }else { return '传入值不是数组' } } /** * 多维数据集函数 * 检查传入数组中对象,并根据指定数字属性进行从大到小排序 * @param {需要排序的数组} ary * @param {需要排序的对象指定值} name */ export function ARRAYSORTONJECT(ary,name) { function sortList(obj1,obj2){ var a=obj1[name]; var b=obj2[name]; if(a>b){ return -1 }else if(a<b){ return 1 }else{ return 0 } }; if(isArray(ary)){ return ary.sort(sortList) }else { return '传入值不是数组' } } /** * 多维数据集函数 * 检查传入数组中对象,并根据指定数字属性进行从小到大排序 * @param {需要排序的数组} ary * @param {需要排序的对象指定值} name */ export function ARRAYSORTONJECTTWO(ary,name) { function sortList(obj1,obj2){ var a=obj1[name]; var b=obj2[name]; if(a<b){ return -1 }else if(a>b){ return 1 }else{ return 0 } }; if(isArray(ary)){ return ary.sort(sortList) }else { return '传入值不是数组' } } /** * 多维数据集函数 * 检查传入对象,并进行转换为数组 * @param {需要转换的对象} obj */ export function OBJECTTOARRY(obj) { let arr = []; for (let i in obj) { let o = {}; o[i] = obj[i]; arr.push(o) } return arr } /** * 多维数据集函数 * 检查传入对象,获取需要的指定key值 * @param {需要操作的对象} obj * @param {获取数组中指定的key值} ary */ export function OBJECTGETKEY(obj,ary) { if(isArray(ary)){ return pick(obj,ary) }else{ return '获取key值需传入数组' } } /** * 多维数据集函数 * 传入多维数组,并对子数组中数值排序进行,非子数组则会跳过 * @param {需要排序的多维数组} ary * @param {是否从大到小排序} isSort */ export function ARRAYMANYSORT(ary,isSort = true) { function sortList(a,b){ if(isSort){ if(a>b){ return -1 }else if(a<b){ return 1 }else{ return 0 } } else { if(a<b){ return -1 }else if(a>b){ return 1 }else{ return 0 } } }; if(isArray(ary)){ ary.map(item => { if(isArray(item)){ return item.sort(sortList) } else { return } }) return ary }else{ return '传入值应为数组' } } /** * 多维数据集函数 * 传入多维数组,并对子数组中对象进行拆分成数组,非子数组则会跳过 * @param {需要拆分的多维数组} ary */ export function ARRAYSPLITOBJECT(ary) { if(isArray(ary)){ let data = ary.map(item => { if(isArray(item)){ let newAry = item.map(res => { if(Object.prototype.toString.call(res) == '[object Object]'){ let arr = []; for (let i in res) { let o = {}; o[i] = res[i]; arr.push(o) } return arr } return res }) return newAry } else { return item } }) return data } else { return '应传入一个数组' } } /** * 数组操作函数 * 创建一个新数组,包含原数组中所有的非假值元素。例如false, null, 0, "", undefined, 和 NaN 都是被认为是“假值”。 * @param {Array} ary 筛选数组 */ export function ArrayScreenFalse(ary) { if(isArray(ary)){ return compact(ary) } else { console.log('传入值非数组') } } /** * 数组操作函数 * 创建一个新数组,将array与任何数组 或 值连接在一起。 * @param { Array } ary 连接数组 * @param { any } data 连接入数组的值 */ export function ArrayConcatData(ary,data) { if(isArray(ary)){ return concat(ary,data) } else { console.log('连接值必须为数组') } } /** * 数组操作函数 * 创建一个新数组,这个数组中的值,为第一个数字(array 参数)排除了给定数组中的值。 * @param { Array } ary 需要被筛选的数组 * @param { Array } ary2 被筛选除外的值 */ export function ArrayDifference(ary,ary2) { if(isArray(ary)&&isArray(ary2)){ return difference(ary,ary2) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个 iteratee (注:迭代器), 调用array 和 values 中的每个元素以产生比较的标准。 结果值是从第一数组中选择。 * @param { Array } ary 需要被筛选的数组 * @param { Array } ary2 排除的值。 * @param { Array|Function|Object|string } data 调用每个元素。 * @returns { Array } 返回筛选后的数组 */ export function ArrayDifferenceBy(ary,ary2,data) { if(isArray(ary)&&isArray(ary2)){ return differenceBy(ary,ary2,data) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 比较array,values中的元素。 结果值是从第一数组中选择。 * @param { Array } ary 要检查的数组 * @param { Array } ary2 要排除的值 * @returns { Array } 返回一个新数组 */ export function ArrayDifferenceWith(ary,ary2) { if(isArray(ary)&&isArray(ary2)){ return differenceWith(ary,ary2,isEqual) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个切片数组,去除array尾部的n个元素。(n默认值为1。) * @param { Array } ary 要查询的数组。 * @param { number } num 要去除的元素个数。 * @returns { Array } 返回一个新数组 */ export function ArrayDropRight(ary,num){ if(isArray(ary)){ return dropRight(ary,num) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个切片数组,去除array中从 predicate 返回假值开始到尾部的部分。 * @param { Array } ary 要查询的数组。 * @param { function } func 查询规则 * @returns { Array } 返回一个新数组 */ export function ArrayDropRightWhile(ary,func) { if(isArray(ary)){ return dropRightWhile(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个切片数组,去除array中从 predicate 返回假值开始到尾部的部分。 * @param { Array } ary 要查询的数组。 * @param { function } func 查询规则 * @returns { Array } 返回一个新数组 */ export function ArrayDropWhile(ary,func) { if(isArray(ary)){ return dropWhile(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 使用 value 值来填充(替换) array,从start位置开始, 到end位置结束(但不包含end位置)。 * @param { Array } ary 要查询的数组. * @param { * } data 填充给 array 的值。 * @param { number } start 开始位置(默认0)。 * @param { number } end 结束位置 * @returns { Array } 返回一个新数组 */ export function ArrayFill(ary,data,start=0,end) { if(isArray(ary)){ return fill(ary,data,start) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 该方法返回第一个通过 predicate 判断为真值的元素的索引值(index),而不是元素本身。 * @param { Array } ary 要查询的数组. * @param { function } func 查询规则 * @returns { Array } 返回一个新数组 */ export function ArrayFindIndex(ary,func) { if(isArray(ary)){ return findIndex(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 该方法从末尾查询返回第一个通过 predicate 判断为真值的元素的索引值(index),而不是元素本身。 * @param { Array } ary 要查询的数组. * @param { function } func 查询规则 * @returns { Array } 返回一个新数组 */ export function ArrayFindLastIndex(ary,func) { if(isArray(ary)){ return findLastIndex(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 获取数组第一个元素 * @param {Array} ary 要查询的数组 * @returns {*} 返回数组 array的第一个元素。 */ export function ArrayHead(ary) { if(isArray(ary)){ return head(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 减少一级array嵌套深度。 * @param {Array} ary 要减少嵌套深度的数组 */ export function ArrayFlatten(ary) { if(isArray(ary)){ return flatten(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 将array递归为一维数组。 * @param {Array} ary 要清除嵌套深度的数组 * @returns { Array } 一维数组 */ export function ArrayFlattenDeep(ary) { if(isArray(ary)){ return flattenDeep(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 减少指定层级array嵌套深度。 * @param { Array } ary 减少指定层级array嵌套深度。 * @param { number } num 最多减少的嵌套层级数。 * @returns { Array } 返回减少嵌套层级后的新数组。 */ export function ArrayFlattenDepth(ary,num) { if(isArray(ary)){ return flattenDepth(ary,num) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 将数组pairs格式化为对象 * @param { Array } ary 键值对pairs。 * @returns { object } 返回一个新对象。 */ export function ArrayFromPairs(ary) { if(isArray(ary)){ return fromPairs(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 返回首次 value 在数组array中被找到的 索引值, 如果 fromIndex 为负值,将从数组array尾端索引进行匹配。 * @param { Array } ary 需要查找的数组。 * @param { * } data 需要查找的值 * @param { numbre } num 开始查询的位置。 * @returns 返回 值value在数组中的索引位置, 没有找到为返回-1。 */ export function ArrayIndexOf(ary,data,num=0) { if(isArray(ary)){ return indexOf(ary,data,num) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 获取数组array中除了最后一个元素之外的所有元素(注:去除数组array中的最后一个元素)。 * @param { Array } ary 需要查找的数组。 * @returns 返回截取后的数组array。 */ export function ArrayInitial(ary) { if(isArray(ary)){ return initial(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建唯一值的数组,这个数组包含所有给定数组都包含的元素, * @param { Array } ary 待检查的数组 * @returns 返回一个包含所有传入数组交集元素的新数组。 */ export function ArrayIntersection(ary) { if(isArray(ary)){ return intersection(...ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个 iteratee 调用每一个arrays的每个值以产生一个值,通过产生的值进行了比较。结果值是从第一数组中选择。 * @param { Array } ary 待检查的数组 * @param { function } func 查询规则 * @returns 返回一个包含所有传入数组交集元素的新数组。 */ export function ArrayIntersectionBy(ary,func) { if(isArray(ary)){ return intersectionBy(...ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个 comparator 调用比较arrays中的元素。结果值是从第一数组中选择。 * @param { Array } ary 待检查的数组 * @returns 返回一个包含所有传入数组交集元素的新数组。 */ export function ArrayIntersectionWith(ary) { if(isArray(ary)){ return intersectionBy(...ary,isEqual) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 将 array 中的所有元素转换为由 separator 分隔的字符串。 * @param { Array } ary 待转换的数组 * @param { string } str 分割元素 * @returns 返回连接字符串。 */ export function ArrayJoin(ary,str=',') { if(isArray(ary)){ return join(ary,str) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 获取array中的最后一个元素。 * @param { Array } ary 要检索的数组 */ export function ArrayLast(ary) { if(isArray(ary)){ return last(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它是从右到左遍历array的元素。返回查找到的元素 * @param { Array } ary 待查找数组 * @param {*} value 要搜索的值 * @param {number} startIndex 开始搜索的下标值 默认 最后位 * @returns 返回匹配值的索引值,否则返回 -1。 */ export function ArrayLastIndexOf(ary,value,startIndex) { if(isArray(ary)){ if(startIndex){ return lastIndexOf(ary,value,startIndex) } return lastIndexOf(ary,value) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 获取array数组的第n个元素。如果n为负数,则返回从数组结尾开始的第n个元素。 * @param { Array } ary 要查询的数组。 * @param { number } num 要返回元素的索引值。 * @returns { * } 获取array数组的第n个元素。 */ export function ArrayNth(ary,num) { if(isArray(ary)){ return nth(ary,num) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 移除数组array中所有和给定值相等的元素,使用 SameValueZero 进行全等比较。 会修改传入数组 * @param { Array } ary 要修改的数组。 * @param { value } value 需要删除的值 可多个 * @returns { Array } 返回 array. */ export function ArrayPull(ary,...value) { if(isArray(ary)){ return pull(ary,...value) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 移除数组array中所有和给定值相等的元素,使用 SameValueZero 进行全等比较。区别是这个方法接收一个要移除值的数组。 会修改传入数组 * @param { Array } ary 要修改的数组。 * @param { Array } ary2 要移除值的数组。 * @returns { Array } 返回 array. */ export function ArrayPullAll(ary,ary2) { if(isArray(ary)&&isArray(ary2)){ return pullAll(ary,ary2) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 这个方法接受一个 iteratee(迭代函数) 调用 array 和 values的每个值以产生一个值,通过产生的值进行了比较。 会修改传入数组 * @param { Array } ary 要修改的数组。 * @param { Array } ary2 要移除值的数组。 * @param { Array|Function|Object|string } value(迭代器)调用每个元素。 * @returns { Array } 返回 array. */ export function ArrayPullAllBy(ary,ary2,value) { if(isArray(ary)&&isArray(ary2)){ if(value){ return pullAllBy(ary,ary2,value) } return pullAllBy(ary,ary2) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 这个方法接受 comparator 调用array中的元素和values比较。 * @param { Array } ary 要修改的数组。 * @param { Array } ary2 要移除值的数组。 * @returns { Array } 返回 array. */ export function ArrayPullAllWith(ary,ary2) { if(isArray(ary)&&isArray(ary2)){ return pullAllWith(ary,ary2,isEqual) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 根据索引 indexes,移除array中对应的元素,并返回被移除元素的数组。 会修改传入数组 * @param { Array } ary 要修改的数组。 * @param { number } value 要移除元素的索引。 */ export function ArrayPullAt(ary,value) { if(isArray(ary)){ let newAry = [] ary.map((item,index) => { if(index === value){ return item } newAry.push(item) return item }) return newAry } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 移除数组中predicate(断言)返回为真值的所有元素,并返回移除元素组成的数组。 * @param { Array } ary 要修改的数组。 * @param { Array|Function|Object|string } func 每次迭代调用的函数。 * @returns { Array } 返回移除元素组成的新数组。 */ export function ArrayRemove(ary,func) { if(isArray(ary)){ remove(ary,func) return ary } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 反转array,使得第一个元素变为最后一个元素,第二个元素变为倒数第二个元素,依次类推。 * @param { Array } ary 要反转的数组 * @returns { Array } 返回反转组成的新数组。 */ export function ArrayReverse(ary) { if(isArray(ary)){ let nAry = [...ary] reverse(nAry) return nAry } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 裁剪数组array,从 start 位置开始到end结束,但不包括 end 本身的位置 * @param { Array } ary 要裁剪的数组 * @param { number } start 开始的位置 * @param { number } end 结束的位置 * @returns 返回 数组array 裁剪部分的新数组。 */ export function ArraySlice(ary,start=0,end) { if(isArray(ary)){ if(end){ return slice(ary,start,end) } else { return slice(ary,start) } }else{ console.log('传入值必须为数组') } } /** * 数组操作函数 * 使用二进制的方式检索来决定 value值 应该插入到数组中 尽可能小的索引位置,以保证array的排序。 * @param { Array } ary 要检查的排序数组。 * @param { * } value 要评估的值 * @returns 返回 value值 应该在数组array中插入的索引位置 index。 */ export function ArraySortedIndex(ary,value) { if(isArray(ary)){ return sortedIndex(ary,value) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个 iteratee (迭代函数),调用每一个数组(array)元素,返回结果和value 值比较来计算排序 * @param { Array } ary 要检查的排序数组 * @param { * } value 要评估的值。 * @param { Array|Function|Object|string } func 每次迭代调用的函数。 * @returns 返回 value值 应该在数组array中插入的索引位置 index。 */ export function ArraySortedIndexBy(ary,value,func) { if(isArray(ary)){ return sortedIndexBy(ary,value,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 这个方法类似 _.indexOf,除了它是在已经排序的数组array上执行二进制检索。 * @param { Array } ary 要检查的排序数组 * @param { * } value 要检查的值 * @returns 返回匹配值的索引位置,否则返回 -1。 */ export function ArraySortedIndexOf(ary,value) { if(isArray(ary)){ return sortedIndexOf(ary,value) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它返回 value值 在 array 中尽可能大的索引位置(index)。 * @param { Array } ary 要检查的排序数组 * @param { * } value 要检查的值 * @returns 返回匹配值的索引位置,否则返回 -1。 */ export function ArraySortedLastIndex(ary,value) { if(isArray(ary)){ return sortedLastIndex(ary,value) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个 iteratee (迭代函数),调用每一个数组(array)元素,返回结果和value 值比较来计算排序。 * @param { Array } ary 要检查的排序数组 * @param { * } value 要评估检查的值 * @param { Array|Function|Object|string } func 每次迭代调用的函数。 * @returns 返回 value值 应该在数组array中插入的索引位置 index。 */ export function ArraySortedLastIndexBy(ary,value,func) { if(isArray(ary)){ return sortedLastIndexBy(ary,value,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它是在已经排序的数组array上执行反向二进制检索。 * @param { Array } ary 要检查的排序数组 * @param { * } value 要检查的值 * @returns 返回匹配值的索引位置,否则返回 -1。 */ export function ArraySortedLastIndexOf(ary,value) { if(isArray(ary)){ return sortedLastIndexOf(ary,value) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它会优化排序数组,返回一个不重复数组 * @param { Array } ary 要检查的排序数组 * @returns 返回一个新的不重复的数组。 */ export function ArraySortedUniq(ary) { if(isArray(ary)){ return sortedUniq(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它会根据指定规则优化排序数组。,返回一个不重复数组 * @param { Array } ary 要检查的数组。 * @param { Array|Function|Object|string } func 每次迭代调用的函数。 * @returns 迭代函数,调用每个元素。 */ export function ArraySortedUniqBy(ary,func) { if(isArray(ary)){ return sortedUniqBy(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 获取除了array数组第一个元素以外的全部元素。 * @param { Array } ary 要检查的数组。 * @returns 返回 array 数组的切片(除了array数组第一个元素以外的全部元素)。 */ export function ArrayTail(ary) { if(isArray(ary)){ return tail(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个数组切片,从array数组的起始元素开始提取n个元素。 * @param { Array } ary 要检索的数组 * @param { number } num 要提取的元素个数。 * @returns 返回 array 数组的切片(从起始元素开始n个元素)。 */ export function ArrayTake(ary,num) { if(isArray(ary)){ return take(ary,num) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个数组切片,从array数组的最后一个元素开始提取n个元素。 * @param { Array } ary 要检索的数组 * @param { number } num 要提取的元素个数 * @returns 返回 array 数组的切片(从最后元素开始n个元素)。 */ export function ArrayTakeRight(ary,num) { if(isArray(ary)){ return takeRight(ary,num) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 从array数组的最后一个元素开始提取元素,直到规则返回假值。 * @param { Array } ary 要检索的数组 * @param { Array|Function|Object|string } func 每次迭代调用的函数。 * @returns 返回 array 数组的切片。 */ export function ArrayTakeRightWhile(ary,func) { if(isArray(ary)){ return takeRightWhile(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 从array数组的起始元素开始提取元素,,直到 规则 返回假值。 * @param { Array } ary 要检索的数组 * @param { Array|Function|Object|string } func 每次迭代调用的函数。 * @returns 返回 array 数组的切片。 */ export function ArrayTakeWhile(ary,func) { if(isArray(ary)){ return takeWhile(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个按顺序排列的唯一值的数组。所有给定数组的元素值做等值比较。 * @param { Array } ary 要检查的数组 * @returns 返回一个新的联合数组。 */ export function ArrayUnion(...ary) { return union(...ary) } /** * 数组操作函数 * 它接受一个 iteratee (迭代函数),调用每一个数组(array)的每个元素以产生唯一性计算的标准。 * @param { Array } ary 要检查的数组。 * @param { Array|Function|Object|string } func 迭代函数,调用每个元素。 * @returns 返回一个新的联合数组。 */ export function ArrayUnionBy(ary,func) { if(isArray(ary)){ return unionBy(ary,func) } else { console.log('传入值必须为数组') } } /*** * 数组操作函数 * 它接受一个 comparator 调用比较arrays数组的每一个元素。 * @param { Array } ary 要检查的多个数组 * @returns 返回一个新的联合数组。 */ export function ArrayUnionWith(...ary) { if(isArray(ary)){ return unionWith(...ary,isEqual) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个去重后的array数组副本。只有第一次出现的元素才会被保留。 * @param { Array } ary 要检查的数组。 * @returns 返回新的去重后的数组。 */ export function ArrayUniq(ary) { if(isArray(ary)){ return uniq(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个 iteratee (迭代函数),调用每一个数组(array)的每个元素以产生唯一性计算的标准。 * @param { Array } ary 要检查的数组。 * @param { Array|Function|Object|string } func 迭代函数,调用每个元素。 * @returns 返回新的去重后的数组。 */ export function ArrayUniqBy(ary,func) { if(isArray(ary)){ return uniqBy(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个 comparator 调用比较arrays数组的每一个元素 * @param { Array } ary 要检查的数组。 * @returns 返回新的去重后的数组。 */ export function ArrayUniqWith(ary) { if(isArray(ary)){ return uniqWith(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接收分组元素的数组,并且创建一个数组,分组元素到打包前的结构。 * @param { Array } ary 要处理的分组元素数组。 * @returns 返回重组元素的新数组。 */ export function ArrayUnzip(...ary) { if(isArray(ary)){ return unzip(ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个iteratee指定重组值应该如何被组合。 * @param { Array } ary 要处理的分组元素数组。 * @param { Array|Function|Object|string } func 迭代函数,调用每个元素。 * @returns 这个函数用来组合重组的值。 */ export function ArrayUnzipWidth(ary,func) { if(isArray(ary)){ return unzipWith(ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个剔除所有给定值的新数组, * @param { Array } ary 要处理的分组元素数组。 * @param { any } value 要剔除的值。 * @returns 返回过滤值后的新数组。 */ export function ArrayWithout(ary,...value) { if(isArray(ary)){ return without(ary,...value) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个给定数组唯一值的数组,返回值的顺序取决于他们数组的出现顺序,返回过滤后的新数组 * @param { Array } ary 要检查的数组。 * @returns 返回过滤值后的新数组。 */ export function ArrayXor(...ary) { if(isArray(ary)){ return xor(...ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受 迭代器,这个迭代器 调用每一个 arrays(数组)的每一个值,以生成比较的新值。 * @param { Array } ary 要检查的数组组。 * @param { Array|Function|Object|string } func 迭代函数,调用每个元素。 * @returns 返回过滤值后的新数组。 */ export function ArrayXorBy(ary,func) { if(isArray(ary)){ return xorBy(...ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 接收对象进行相同筛选,以调用比较数组的元素。 * @param { Array } ary 要检查的数组组。 * @param { Array|Function|Object|string } func 迭代函数,调用每个元素。 * @returns 返回过滤值后的新数组。 */ export function ArrayXorWith(ary,func) { if(isArray(ary)){ return xorWith(...ary,func) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 创建一个分组元素的数组,数组的第一个元素包含所有给定数组的第一个元素,数组的第二个元素包含所有给定数组的第二个元 * @param { Array } ary 要合并分组的数组组 * @returns 返回分组元素的新数组。 */ export function ArrayZip(...ary) { if(isArray(ary)){ return zip(...ary) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受2个数组,第一个数组中的值作为属性标识符(属性名),第二个数组中的值作为相应的属性值。 * @param { Array } ary 作为对象标识符数组 * @param { Array } ary2 作为属性值数组 * @returns 返回新对象 */ export function ArrayZipObject(ary,ary2) { if(isArray(ary)&&isArray(ary2)){ return zipObject(ary,ary2) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它支持属性路径接受2个数组,第一个数组中的值作为属性标识符(属性名),第二个数组中的值作为相应的属性值。 * @param { Array } ary 作为对象标识符(属性名)数组 * @param { Array } ary2 作为属性值数组 * @returns 返回新对象 */ export function ArrayZipObjectDeep(ary, ary2) { if(isArray(ary)&&isArray(ary2)){ return zipObjectDeep(ary,ary2) } else { console.log('传入值必须为数组') } } /** * 数组操作函数 * 它接受一个 iteratee(迭代函数),来 指定分组的值应该如何被组合。 该iteratee调用每个组的元素 * @param { Array } ary 要处理的数组组。 * @param { Function } func 函数用来组合分组的值。 * @returns 返回分组元素的新数组。 */ export function ArrayZipWith(ary,func) { if(isArray(ary)){ return zipWith(...ary,func) } else { console.log('传入值必须为数组') } } /** * 对象操作函数 * 创建一个组成对象,key(键)是经过 iteratee(迭代函数) 执行处理collection中每个元素后返回的结果,每个key(键)对应的值是 iteratee(迭代函数)返回该key(键)的次数 * @param { Array } ary 一个用来迭代的集合。 * @param { Array|Function|Object|string } func 一个迭代函数,用来转换key(键) * @returns { Object } 返回一个组成集合对象。 */ export function ObjectCountBy(ary,func) { if(isArray(ary)){ return countBy(ary,func) } else { console.log('传入值必须为数组') } } /** * 对象操作函数 * 调用 iteratee 遍历 collection(集合) 中的每个元素,如果迭代函数(iteratee)显式的返回 false ,迭代会提前退出。 * @param { Array|Object } ary 一个用来迭代的集合。 * @param { Function } func 函数用来组合分组的值。 * @returns 返回集合 collection。 */ export function ObjectForEach(ary,func) { return forEach(ary,func) } /** * 对象操作函数 * 调用 iteratee 反方向遍历 collection(集合) 中的每个元素,如果迭代函数(iteratee)显式的返回 false ,迭代会提前退出。 * @param { Array|Object } ary 一个用来迭代的集合。 * @param { Function } func 函数用来组合分组的值。 * @returns 返回集合 collection。 */ export function ObjectForEachRight(ary,func) { return forEachRight(ary,func) } /** * 对象操作函数 * 通过 predicate(断言函数) 检查 collection(集合)中的 所有 元素是否都返回真值。一旦 predicate(断言函数) 返回假值,迭代就马上停止。 * @param { Array|Object } ary 一个用来迭代的集合。 * @param { Array|Function|Object|string } func 每次迭代调用的函数。 * @returns 如果所有元素经 predicate(断言函数) 检查后都都返回真值,那么就返回true,否则返回 false 。 */ export function ObjectEvery(ary, func) { return every(ary,func) } export default List