javaScript常用函数

1. 匹配正整数

// 匹配正整数
let isPositiveNum = val => {return /^[1-9]d*$/.test(val);
};
console.log(isPositiveNum(9)) //true
console.log(isPositiveNum(2.2)) //false

2. 匹配负整数

// 匹配负整数
 let isNegativeNum = val => {return /^-[1-9]d*$/.test(val);
 };
 console.log(isNegativeNum(-9)) //true
 console.log(isNegativeNum(2.2)) //false

3. 匹配整数

// 匹配整数
let isInteger = val => {return /^(-|\+)?\d+$/.test(val);
};
console.log(isInteger(-9)) //true
console.log(isInteger(2.2)) //false

4. 匹配非负浮点数

// 匹配非负浮点数
let isNotNegativeFloatNum = val => {return /^\d+(\.\d+)?$/.test(val);
};
console.log(isNotNegativeFloatNum(-9)) //false
console.log(isNotNegativeFloatNum(2.2)) //true

5. 匹配由 26 个英文字母组成的字符串

// 匹配由 26 个英文字母组成的字符串
let isAZaz = val => {return /^[A-Za-z]+$/.test(val);
};
console.log(isAZaz('122a')) //false
console.log(isAZaz('abc')) //true

6. 匹配由 26 个英文字母的 大写 组成的字符串

// 匹配由 26 个英文字母的大写组成的字符串
let isAZ = val => {return /^[A-Z]+$/.test(val);
};
console.log(isAZ('Acs')) //false
console.log(isAZ('ABC')) //true

7. 匹配由 26 个英文字母的 小写 组成的字符串

// 匹配由 26 个英文字母的小写组成的字符串
let isaz = val => {return /^[a-z]+$/.test(val);
};
console.log(isaz('Acs')) //false
console.log(isaz('abc')) //true

8. 匹配电子邮件地址

// 匹配电子邮件地址
let isEmailAddress = val => {return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(val) || /w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*/.test(val);
};
console.log(isEmailAddress('Acs')) //false
console.log(isEmailAddress('133@qq.com')) //true

9.arrayMax: 返回数组中的 最大 值

// arrayMax: 返回数组中的最大值
// 将 Math.max()与扩展运算符 (...) 结合使用以获取数组中的最大值。let arrayMax = arr => Math.max(...arr);
let arr = [1,2,3,5];
console.log(arrayMax(arr)) //5

10.arrayMin: 返回数组中的 最小 值

// arrayMin: 返回数组中的最小值
// 将 Math.min()与扩展运算符 (...) 结合使用以获取数组中的最小值。let arrayMin = arr => Math.min(...arr);
let arr = [1, 2, 3, 5];
console.log(arrayMin(arr)) //1

11. 将数组块划分为指定大小的较小数组

// chunk: 将数组块划分为指定大小的较小数组。// 使用 Array.from()创建新的数组, 这符合将生成的区块数。使用 Array.slice()将新数组的每个元素映射到 size 长度的区块。如果原始数组不能均匀拆分, 则最终的块将包含剩余的元素。let chunk = (arr, size) => Array.from({length: Math.ceil(arr.length / size)
}, (v, i) => arr.slice(i * size, i * size + size));
let arr = [1, 2, 3, 5];
console.log(chunk(arr,2)) //0: Array [1, 2],1: Array [3, 5],

12. 从数组中移除 falsey 值

// compact: 从数组中移除 falsey 值。// 使用 Array.filter()筛选出 falsey 值 (false、null、0、""、undefined 和 NaN).
let compact = arr => arr.filter(Boolean);
let arr = [false,null,0,"",undefined,NaN,1]
console.log(compact(arr)) //[1]

13. 计算数组中值的出现次数

// countOccurrences: 计算数组中值的出现次数
// 使用 Array.reduce()在每次遇到数组中的特定值时递增计数器。let countOccurrences = (arr, value) => arr.reduce((a, v) => v === value ? a + 1 : a + 0, 0);
let arr = [1,2,1,2,3,3,3,3];
console.log(countOccurrences(arr,3))//4

14. 深拼合数组

// deepFlatten: 深拼合数组
// 使用递归。使用 Array.concat()与空数组 ([]) 和跨页运算符 (...) 来拼合数组。递归拼合作为数组的每个元素。let deepFlatten= arr => [].concat(...arr.map(v => Array.isArray(v) ? deepFlatten(v) : v));
let arr = [1, 2, [1, 2, [1, 2, [2, 3]]]];
console.log(deepFlatten(arr)) // [1, 2, 1, 2, 1, 2, 2, 3]

15. 返回两个数组之间的差异

// difference: 返回两个数组之间的差异
// 从 b 创建 Set, 然后使用 Array.filter() on 只保留 a b 中不包含的值.
let difference = (a, b) => {const s = new Set(b);
    return a.filter(x => !s.has(x));
};
let arr = [1,2,3];
let arr2 = [2,3,4];
console.log(difference(arr,arr2))//[1]
console.log(difference(arr2,arr))//[4]

16. 返回数组的所有不同值

// distinctValuesOfArray: 返回数组的所有不同值
// 使用 ES6 Set 和...rest 运算符放弃所有重复的值。let distinctValuesOfArray = arr => [...new Set(arr)];
let arr = [1, 2, 3, 1, 2];
console.log(distinctValuesOfArray(arr)) // [1, 2, 3]

17. 返回数组中的每个第 n 个元素

// everyNth: 返回数组中的每个第 n 个元素
// 使用 Array.filter()创建一个包含给定数组的每个第 n 个元素的新数组。let everyNth = (arr, nth) => arr.filter((e, i) => i % nth === 0);

18. 筛选出数组中的非唯一值

// filterNonUnique：筛选出数组中的非唯一值
// 对于只包含唯一值的数组, 请使用 Array.filter()。let filterNonUnique = arr => arr.filter(i => arr.indexOf(i) === arr.lastIndexOf(i));

19. 拼合数组

// flatten: 拼合数组
// 使用 Array.reduce()获取数组中的所有元素和 concat()以拼合它们
let flatten = arr => arr.reduce((a, v) => a.concat(v), []);

20. 将数组向上拼合到指定深度

// falttenDepth: 将数组向上拼合到指定深度
// 使用递归, 递减 depth, 每层深度为 1。使用 Array.reduce()和 Array.concat()来合并元素或数组。基本情况下, 对于等于 1 的 depth 停止递归。省略第二个元素,depth 仅拼合到 1 的深度 (单个拼合)。// falttenDepth: (arr, depth = 1) => depth != 1 ? arr.reduce((a, v) => a.concat(Array.isArray(v) ? flattenDepth(v, depth - 1) : v), []) : arr.reduce((a, v) => a.concat(v), []),

21. 将数组向上拼合到指定深度

// falttenDepth: 将数组向上拼合到指定深度
// 使用递归, 递减 depth, 每层深度为 1。使用 Array.reduce()和 Array.concat()来合并元素或数组。基本情况下, 对于等于 1 的 depth 停止递归。省略第二个元素,depth 仅拼合到 1 的深度 (单个拼合)。// falttenDepth: (arr, depth = 1) => depth != 1 ? arr.reduce((a, v) => a.concat(Array.isArray(v) ? flattenDepth(v, depth - 1) : v), []) : arr.reduce((a, v) => a.concat(v), []),

22. 根据给定函数对数组元素进行分组

// groupby: 根据给定函数对数组元素进行分组
// 使用 Array.map()将数组的值映射到函数或属性名。使用 Array.reduce()创建一个对象, 其中的键是从映射的结果生成的。// groupBy: (arr, func) => arr.map(typeof func === 'function' ? func : val => val[func]).reduce((acc, val, i) => {acc[val] = (acc[val] || []).concat(arr[i]); return acc; }, {}),

23. 返回列表的头

// head: 返回列表的头
// 使用 arr[0]可返回传递的数组的第一个元素。let head = arr => arr[0];