『 tydumpling博客 』

Appearance

作者:Yuan Tang
更新于:5 个月前
字数统计:1.5k 字
阅读时长:6 分钟

|关于数字

1.进制转换 ​

将十进制数字转换成其他N进制的数字，可以使用toString(n)

const toDecimal = (num, n = 10) => num.(n) 
// 假设数字10要转换成2进制
toDecimal(10, 2) // '1010'

将n进制数组转换成十进制，可以使用parseInt(num, n)

// 10的2进制为1010
const toDecimalism = (num, n = 10) => parseInt(num, n)
toDecimalism(1010, 2)

2.四舍五入 ​

当你需要将小数点后的某些数字截断，并取四舍五入

const toFixed = (n, fixed) => `${n}`.match(new RegExp(`^-?\d+(?:.\d{0,${fixed}})?`))[0]
toFixed(10.255, 2) // 10.25

3.补零 ​

当你需要在一个数字num不足len位数的时候前面补零操作

const replenishZero = (num, len, zero = 0) => num.().padStart(len, zero)
replenishZero(8, 2) // 08

4.数字正则 ​

手机号格式化 ​

当你需要将手机号码格式化成xxx-xxxx-xxxx的形式

const formatPhone = (str, sign = '-') => str.replace(/(\W|\s)/g, "").split(/^(\d{3})(\d{4})(\d{4})$/).filter(item => item).join(sign)

formatPhone('13123456789') // '131-2345-6789'
formatPhone('13 1234 56 789', ' ') // '131 2345 6789'

去除多余空格 ​

当你需要将一段文本中的多个空格合并成一个空格

const setTrimOut = str => str.replace(/\s\s+/g, ' ')
const str = setTrimOut('hello,   jack') //

|关于数组

1.生成数组

当你需要要生成一个0-99的数组

方案1

const createArr = (n) => Array.from(new Array(n), (v, i) => i)
const arr = createArr(100) // 0 - 99 数组

方案2

const createArr = (n) => new Array(n).fill(0).map((v, i) => i)
createArr(100) // 0 - 99数组

1.new Array(n) 创建一个长度为n的数组。 2. .fill(0) 将数组中的所有元素都填充为0。 3. .map((v, i) => i) 对数组中的每个元素都执行一次回调函数，将每个元素映射为它的下标i。 4. => 是箭头函数的写法，用来定义回调函数的参数和返回值。 5. 最终得到的是一个长度为n的数组，数组中的每个元素都是它的下标。

2.打乱数组 ​

当你有一个数组，你需要打乱这个数组的排序

const randomSort = list => list.sort(() => Math.random() - 0.5)
randomSort([0,1,2,3,4,5,6,7,8,9]) // 随机排列结果

3.数组去重 ​

当你需要将数组中的所有重复的元素只保留一个

const removeDuplicates = list => [...new Set(list)]
removeDuplicates([0, 0, 2, 4, 5]) // [0,2,4,5]

4.多数组取交集 ​

当你需要取多个数组中的交集

const intersection = (a, ...arr) => [...new Set(a)].filter((v) => arr.every((b) => b.includes(v)))

intersection([1, 2, 3, 4], [2, 3, 4, 7, 8], [1, 3, 4, 9])
// [3, 4]

5.查找最大值索引 ​

但你需要找到一个数组中的最大值的索引

const indexOfMax = (arr) => arr.reduce((prev, curr, i, a) => (curr > a[prev] ? i : prev), 0);
indexOfMax([1, 3, 9, 7, 5]); // 2

6.查找最小值索引 ​

当你需要找到一个数组中的最小值的索引

const indexOfMin = (arr) => arr.reduce((prev, curr, i, a) => (curr < a[prev] ? i : prev), 0)
indexOfMin([2, 5, 3, 4, 1, 0, 9]) // 5

7.找到最接近的数值 ​

当你需要在一个数组中找到一个最接近的值

const closest = (arr, n) => arr.reduce((prev, curr) => (Math.abs(curr - n) < Math.abs(prev - n) ? curr : prev))
closest([29, 87, 8, 78, 97, 20, 75, 33, 24, 17], 50) // 33

8.压缩多个数组 ​

当你需要将多个数组压缩成一个数组

const zip = (...arr) => Array.from({ length: Math.max(...arr.map((a) => a.length)) }, (_, i) => arr.map((a) => a[i]))
zip([1,2,3,4], ['a', 'b', 'c', 'd'], ['A', 'B', 'C', 'D'])
// [[1, 'a', 'A'], [2, 'b', 'B'], [3, 'c', 'C'], [4, 'd', 'D']]

9.矩阵交换行和列 ​

当你需要将一个矩阵的行和列进行互相交换

const transpose = (matrix) => matrix[0].map((col, i) => matrix.map((row) => row[i]));
transpose(
    [              // [
        [1, 2, 3], //      [1, 4, 7],
        [4, 5, 6], //      [2, 5, 8],
        [7, 8, 9], //      [3, 6, 9],
     ]             //  ]
 );

数组塌陷 ​

|什么是数组塌陷？

当数组执行删除单元操作时,被删除单元,之后的单元,会前移,进而顶替被删除单元,出现在被删除单元的位置上,造成数组长度减少的情况,这样的现象称为数组的坍塌

// 需求: 要求删除掉数组中的所有元素,但是要一个一个的删除
// 定义一个数组
var arr = [3, 4, 44, 65, 56]
console.log('原始数组 : ', arr);
// 遍历循环数组
for (var i = 0; i < arr.length; i++) {
    arr.splice(i, 1)
}
console.log('删除后的数组 : ', arr);
/* 
    分析:
    
    代码开始执行这个时候
    i===0  arr = [3, 4, 44, 65, 56]
    arr.length = 5  结果是true
    arr.splice(0,1)
    i===1 arr = [4, 44, 65, 56]
    arr.length = 4  结果是true
    arr.splice(1,1)
    i===2 arr = [4, 65, 56]
    arr.length = 3  结果是true
    arr.splice(2,1)
    i===3 arr = [4, 65]
    arr.length = 2  结果是falses
    循环结束
*/

解决方案一: 我们循环的时候倒着循环

// 解决方案 方案一
var arr = [3, 4, 44, 65, 56]
console.log('原始数组 : ', arr);
// 遍历循环数组
for (var i = arr.length - 1; i >= 0; i--) {
    arr.splice(i, 1)
}
console.log('删除后的数组 : ', arr);
/*
    分析:
    代码开始执行;
    i === 4  arr = [3, 4, 44, 65, 56]
    这个时候4是大于0的  条件成立
    arr.splice(4,1)
    i === 3  arr = [3, 4, 44, 65]
    这个时候3也是大于0 的  条件成立
    arr.splice(3,1)
    i === 2  arr = [3, 4, 44]
    这个时候也是大于0 的  条件成立
    arr.splice(2,1)
    i === 1  arr = [3, 4]
    这个时候1也是大于0 的  条件成立
    arr.splice(1,1)
    i === 0  arr = [3]
    这个时候0是等于0 的  条件成立
    arr.splice(0,1)
    i === -1  arr = []
    这个时候-1不大于等于0 的  条件不成立
    循环结束
*/

解决方法二 就是每执行一次删除就执行一次 i-- 操作

// 解决方案  方案二
var arr = [3, 4, 44, 65, 56]
console.log('原始数组 : ', arr);
// 遍历循环数组
for (var i = 0; i < arr.length; i++) {
    arr.splice(i, 1)
    i--
}
console.log('删除后的数组 : ', arr);
/*
    分析:
    代码开始执行
    i === 0  arr = [3, 4, 44, 65, 56]
    arr.length = 5  条件成立
    arr.splice(0, 1)
    这个时候执行了 i--
    i === 0  arr = [4, 44, 65, 56]
    arr.length = 4  条件成立
    arr.splice(0, 1)
    i === 0  arr = [ 44, 65, 56]
    arr.length = 3  条件成立
    arr.splice(0, 1)
    i === 0  arr = [ 65, 56]
    arr.length = 2  条件成立
    arr.splice(0, 1)
    i === 0  arr = [ 56]
    arr.length = 1  条件成立
    arr.splice(0, 1)
    i === 0  arr = []
    arr.length = 0  条件不成立
    循环结束
*/

Contributors ​

Yuan Tang

Copyright © 2023-present tydumpling