数组扩展

数组扩展

function *g () {
    console.log(1)
    yield 'one'
    console.log(2)
    yield 'two'
}

const gg = g()
gg.next()

setTimeout(function(){
    gg.next()
},1000)

在第一次使用gg.next()时运行，知道第二个gg.next()出现在运行第二段

let set = new Set([1,2,5,3,4]) // 返回一个数组
console.log(set) 
let arr = [...set] // 展开为数组

Set 里的元素不可以重复，所以可以用它来去重！！！

Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。

const set1 = new Set([1, 2, 3, 4, 5]);

console.log(set1.has(1));
// expected output: true

console.log(set1.has(5));
// expected output: true

console.log(set1.has(6));
// expected output: false

new Set([iterable]);

参数
iterable
如果传递一个可迭代对象，它的所有元素将不重复地被添加到新的 Set中。如果不指定此参数或其值为null，则新的 Set为空。
返回值
一个新的Set对象。

习题

扩展运算符，可以将一个数组转为用逗号分隔的参数序列。由此我们来完成，随机产生十个整数，放入数组中，对这个数组进行降序排序，并将这个数组的最大值和最小值。

效果如下图所示（效果图中的整数是随机产生的）：

任务提示

第一步：创建一个空数组，用来接收后面的十个整数

第二步：在0~100之间的随机整数中，获取十个整数，放入创建的数组中

Tips：利用循环，获取10个整数

第三步：对数组进行降序排序

第四步：按照效果图所示，使用扩展运算符结合Math.min()与Math.max()获取到这个数组的最大值和最小值

注：扩展运算符，可以将一个数组转为用逗号分隔的参数序列

function getRandomInt(max) {
            return Math.floor(Math.random()* Math.floor(max));
        }
        let numberArr = []
        for(let i=0;i<=9;i++) {
            numberArr.push(getRandomInt(100))
        }
        // console.log(numberArr)

        function newSort(...arr) {
            let temArr = []
            let temMax = 0
            let argument = [...arguments[0]]
            console.log(argument)
            let length = argument.length
            for(let i=0;i<length;i++) {
                for(let j=0;j<length-i-1;j++) {
                   temMax = Math.max(argument[j],argument[j+1])
                }
                temArr.push(temMax)
            }
            console.log(temArr)
            numberArr.length = 0
            numberArr = [...temArr]
        }
        console.log(numberArr)
        newSort(numberArr)
        console.log(numberArr)

新的方法

Array.from(obj)

将ArrayLike对象或者Iterable对象转换为一个Array

const obj = {
    0: 1,
    1: 'kangkang',
    2: false,
    length:2
}
// 属性名必须是数字或者字符形式的数字
console.log(Array.from(obj))

//（2) [1, "kangkang"]0: 11: "kangkang"length: 2__proto__: Array(0)
设置的长度是2，所以第三个属性没有显示出来！

console.log(Array.from(obj,item => item*2))

//接受第二个参数对对象里每个值进行运算！

Array.of()

将传入的参数合并为数组

let arr = Array.of("1",2,"adf",false)
// (4) ["1", 2, "adf", false]

fill()

填充数组

let arr = new Array(10).fill(0)
// [0,0,0.....]
console.log([1,2,3].fill(0)) // 会覆盖掉原先的数据
let arr = new Array(10).fill(0,0,5)// 指定开始位置和结束位置（不包括5）

Array.includes()

找到返回true

let arr = [1,2,3,234,32,42]
console.log(arr.includes(234))/true

keys

let arr = [1,23,34]
let keys = arr.keys()
for (let i of keys) {
    console.log(i)
} // 0    1   2

values

let arr = [1,23,34]
let values = arr.values()
for (let i of values) {
    console.log(i)
} // 1  23  34

entries

let arr = [1,23,34]
let entries = arr.entries()
for (let i of entries) {
    console.log(i)
} 
// [0, 1]
// [1, 23]
// [2, 34]

for (let [j,v] of arr.entries()) {
    console.log(j,v)
} 
// 0 1
// 1 23
// 2 34

注意解构赋值的快速取值和序列方法！！

find

参数是接收一个函数作为参数

按顺序遍历数组，当回调返回true时，就返回当前遍历到的值！

const res = [1,2,3,23,34,45].find((value,index,arr)=> {
    return value % 3 ===0
})
console.log(res) // 3

findIndex

参数是接收一个函数作为参数

按顺序遍历数组，当回调返回true时，就返回当前遍历到的值的下标！

const res = [1,2,3,23,34,45].findIndex((value,index,arr)=> {
    return value % 3 ===0
})
console.log(res) // 2

arr.indexOf(NaN) 无法判断 ，但是

const res = [1,2,3,23,34,45,NaN].findIndex((value,index,arr)=> Number.isNaN(value))
console.log(res) // 6

转载于:https://www.cnblogs.com/daixixi/p/11057245.html