JS方法整理

Array:数组方法

sort()：对数组的成员进行排序，默认是按照字典顺序排序，会改变原数组

        [10111, 1101, 111].sort(function (a, b) {
            return a - b;
        })
        // [111, 1101, 10111]

isArray()：返回一个布尔值，判断一个参数是否为数组

        var arr = [1, 2, 3];
        typeof arr // "object"
        Array.isArray(arr) // true

toString()：将数组中每个元素转为字符串类型

        var arr = [1, 2, 3, [4, 5, 6]];
        arr.toString() // "1,2,3,4,5,6"

push()：在数组的末端添加一个或多个元素，返回添加完成后的数组长度，会改变原数组

        var arr = [];
        arr.push(1) // 1

pop()：在数组的末端删除一个元素，并返回这个删除的元素，会改变原数组

        var arr = ['a', 'b', 'c'];
        arr.pop() // 'c'

shift()：在数组的最前端删除一个元素，并返回这个元素，会改变原数组

        var a = ['a', 'b', 'c'];
        a.shift() // 'a'

unshift()：在数组的最前端添加一个元素，并返回添加完成后的数组长度，会改变原数组

        var a = ['a', 'b', 'c'];
        a.unshift('x'); // 4

join()：指定一个参数作为分隔符，将数组的所有成员连接成一个字符串返回，默认使用逗号隔开

        var a = [1, 2, 3, 4];
        a.join(' ') // '1 2 3 4'

concat()：合并多个数组，将新数组成员添加到原数组的后部，返回一个新数组，原数组不变

        ['hello'].concat(['world'])
        // ["hello", "world"]

reverse()：返回颠倒排列后的数组，会改变原数组

        var a = ['a', 'b', 'c'];
        a.reverse() // ["c", "b", "a"]

slice()：提取数组的某个部分，返回提取出的新数组，原数组不变，第一个参数为起始位置，第二个位置为终止位置，提取时不包括第一个参数

        var a = ['a', 'b', 'c'];
        a.slice(1) // ["b", "c"]
        a.slice(1, 2) // ["b"]

splice()：删除数组的某个部分，并可以在删除的位置添加新的成员，返回被删除的元素，会改变原数组

        var a = ['a', 'b', 'c', 'd', 'e', 'f'];
        a.splice(4, 2) // ["e", "f"]
        a // ["a", "b", "c", "d"]

map()：将数组的成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回。

        var numbers = [1, 2, 3];
        numbers.map(function (n) {
            return n + 1;
        });
        // [2, 3, 4]

forEach()：和map()使用方法一样，区别是forEach()不返回值，对return无效

        function log (element, index, array) {
            console.log('[' + index + '] = ' + element);
        }
        [2, 5, 9].forEach(log);
        // [0] = 2
        // [1] = 5
        // [2] = 9

filter()：过滤数组的成员，满足条件的组成新的数组返回

        [1, 2, 3, 4, 5].filter(function (elem) {
            return (elem > 3);
        })
        // [4, 5]

some()：返回一个布尔值，表示数组成员是否满足某个条件，成员中只需有一个符合条件即返回true

        var arr = [1, 2, 3, 4, 5];
        arr.some(function (elem, index, arr) {
            return elem >= 3;
        });
        // true

every()：返回一个布尔值，表示数组成员是否满足某个条件，成员中必须所有全部符合条件才会返回true

        var arr = [1, 2, 3, 4, 5];
        arr.every(function (elem, index, arr) {
            return elem >= 3;
        });
        // false

reduce()：依次处理数组成员，从左向右处理

reduceRight()：依次处理数组成员，从右向左处理

语法：reduce(function(初始值,当前元素的值,当前元素的下标,当前元素的数组对象){},初始值)；

        [1, 2, 3, 4, 5].reduce(function (a, b) {
            console.log(a, b);
            return a + b;
        })
        // 1 2
        // 3 3
        // 6 4
        // 10 5
        //最后结果：15

indexOf()：返回元素在数组中第一次出现的位置，没有则返回-1，还可以接收第二个参数，表示搜索的起始位置

        var a = ['a', 'b', 'c'];
        a.indexOf('b') // 1
        a.indexOf('y') // -1

lastIndexOf()：返回元素在数组中最后一次出现的位置，没有则返回-1

        var a = [2, 5, 9, 2];
        a.lastIndexOf(2) // 3
        a.lastIndexOf(7) // -1

form()：用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象

        let arrayLike = {
            '0': 'a',
            '1': 'b',
            '2': 'c',
            length: 3
        };
        let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

of()：将一组值转为数组

        Array.of(3, 11, 8) // [3,11,8]
        Array.of(3) // [3]
        Array.of(3).length // 1

copyWithin()：在数组内部指定成员进行替换，然后返回当前数组，会改变原数组。

它有三个参数

target（必需）：从该位置开始替换数据。如果为负值，表示倒数。

start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。

end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示从末尾开始计算。

        [1, 2, 3, 4, 5].copyWithin(0, 3)
        // [4, 5, 3, 4, 5]

find()：返回第一个符合条件的成员

        [1, 4, -5, 10].find((n) => n < 0)
        // -5

findIndex()：返回第一个符合条件成员的位置，都不符合返回-1

        [1, 5, 10, 15].findIndex(function (value, index, arr) {
            return value > 9;
        }) // 2

findLast()：返回第一个符合条件的成员，从最后面开始

findLastIndex()：返回第一个符合条件成员的位置，从最后面开始，都不符合返回-1

        const array = [
            { value: 1 },
            { value: 2 },
            { value: 3 },
            { value: 4 }
        ];
        array.findLast(n => n.value % 2 === 1); // { value: 3 }
        array.findLastIndex(n => n.value % 2 === 1); // 2

fill()：使用给定的值，填充一个数组，还可以接收第二个第三个参数，表示填充的起始位置和结束位置

        ['a', 'b', 'c'].fill(7)
        // [7, 7, 7]
        new Array(3).fill(7)
        // [7, 7, 7]

entries()

keys()

values()

可以用for...of循环进行遍历，这三者都用于遍历数组，区别是entries()是遍历值对，keys()遍历是键名，value()是遍历键值

        for (let index of ['a', 'b'].keys()) {
            console.log(index);
        }
        // 0
        // 1
        for (let elem of ['a', 'b'].values()) {
            console.log(elem);
        }
        // 'a'
        // 'b'
        for (let [index, elem] of ['a', 'b'].entries()) {
            console.log(index, elem);
        }
        // 0 "a"
        // 1 "b"

includes()：返回一个布尔值，表示是否包含某个给定的值，如果不包含则返回-1

        [1, 2, 3].includes(2)     // true
        [1, 2, 3].includes(4)     // false
        [1, 2, NaN].includes(NaN) // true

flat()：用于将嵌套的数组拉平，变成一个数组，会返回一个新的数组，对原数组不影响，默认只会拉平一层，可在参数中赋予拉平的层数

        [1, 2, [3, 4]].flat()
        // [1, 2, 3, 4]

flatMap()：对原数组的每个成员执行一个函数Map()，然后对返回值组成的数组执行flat()方法。该方法返回一个新数组，不改变原数组。

        // 相当于 [[2, 4], [3, 6], [4, 8]].flat()
        [2, 3, 4].flatMap((x) => [x, x * 2])
        // [2, 4, 3, 6, 4, 8]

at()：接收一个整数作为参数，返回数组中对应位置的成员，并且支持负索引

        const arr = [5, 12, 8, 130, 44];
        arr.at(2) // 8
        arr.at(-2) // 130

group()

groupToMap()

它们可以根据分组函数的运行结果，将数组成员分组。参数是一个分组函数，原数组的每个成员都会依次执行这个函数，确定自己是哪一个组。

        const array = [1, 2, 3, 4, 5];
        array.group((num, index, array) => {
            return num % 2 === 0 ? 'even' : 'odd';
        });
        // { odd: [1, 3, 5], even: [2, 4] }

Object：对象方法

……

常见问题

 解决计算误差

        parseFloat((0.1 + 0.2).toFixed(2)) = 0.3

慢慢更新中.....