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