ES6 —— 递归

---

一、什么是递归？

1. 如果一个函数在内部可以调用其本身，那么这个函数就是递归函数。
2. 简单理解：函数内部自己调用自己，这个函数就是递归函数。

	let num = 1
    function fn(){
    
    
        console.log('打印六次')
        if(num == 6){
    
    
            return //递归里面必须加退出条件
        }
        num++
        fn()
    }
    fn()

二、利用递归求数学题

1. 求 1 * 2 * 3 * … * n 阶乘。

	function fn(n){
    
    
        if(n == 1){
    
    
            return 1
        }
        return n * fn(n-1)
    }
    console.log(fn(3)) //6

2. 求斐波那契数列（兔子序列）：前两项相加的和是第三项。

1、1、2、3、5、8、13、21…

	// 用户输入数字n 就可以求出这个数字对应的序列值
    // 我们只需要知道用户输入的n 的前面两项(n-1 n-2)就可以计算出n 对应的序列值
    function fn(n){
    
    
        if(n == 1||n == 2){
    
    
            return 1
        }
        return fn(n-1) + fn(n-2)
    }
    console.log(fn(1)) //1
    console.log(fn(2)) //1
    console.log(fn(3)) //2
    console.log(fn(4)) //3

三、利用递归遍历数据

1. 输入id号，就可以返回数据对象。

	let data = [{
    
    
        id: 1,
        name: '家电',
        goods:[{
    
    
            id: 11,
            gname: '冰箱',
            goods: [{
    
    
                id: 111,
                gname: '海尔'
            },{
    
    
                id: 112,
                gname: '美的'
            }]
        },{
    
    
            id: 12,
            gname: '洗衣机'
        }]
    },{
    
    
        id: 2,
        name: '服饰'
    }]
    // 我们想要做输入id号 就可以返回的数据对象
    // 1. 使用 forEach 去遍历里面的每一个对象
    function getID(json, id){
    
    
        let o = {
    
    }
        json.forEach(function(item) {
    
    
            // console.log(item) //两个数组元素
            if(item.id == id){
    
    
                // console.log(item)
                o = item
                // 2.得到里层的数据11 12 可以使用递归函数
                // 里面应该有goods数组 并且长度不为零
            }else if(item.goods && item.goods.length > 0){
    
    
                o = getID(item.goods, id)
            }
        })
        return o
    }
    console.log(getID(data, 1))
    console.log(getID(data, 2))
    console.log(getID(data, 11))
    console.log(getID(data, 12))
    console.log(getID(data, 111))
    console.log(getID(data, 112))

四、浅拷贝和深拷贝

1. 浅拷贝：只拷贝一层，更深层次对象级别的只拷贝引用。（指向同一个地址）

	let obj = {
    
    
        id: 1,
        name: 'andy',
        msg:{
    
    
            age: 18
        }
    }
    let o = {
    
    }
    for(let k in obj){
    
    
        o[k] = obj[k] 
    }
    console.log(o) 
    o.msg.age = 20
    console.log(o)

2. ES6新增浅拷贝：Object.assign(target, ...sources) （指向同一个地址）

	let obj = {
    
    
    id: 1,
    name: 'andy',
    msg:{
    
    
            age: 18
        }
    }
    let o = {
    
    }
    Object.assign(o, obj)
    console.log(o) 
    o.msg.age = 20
    console.log(o)

3. 深拷贝：拷贝多层，每一级别的数据都会拷贝。（指向两个不同的地址）

	let obj = {
    
    
        id: 1,
        name: 'andy',
        msg:{
    
    
            age: 18
        },
        color: ['pink', 'red']
    }
    let o = {
    
    }
    // 封装函数
    function deepCopy(newobj, oldobj){
    
    
        for(let k in oldobj){
    
    
            // 判断我们的属性值属于哪种数据类型
            // 1.获取属性值 oldobj[k]
            let item = oldobj[k]
            // 2.判断这个值是否是数组
            if(item instanceof Array){
    
    
                newobj[k] = []
                deepCopy(newobj[k], item)
            // 3.判断这个值是否是对象
            }else if(item instanceof Object){
    
    
                newobj[k] = {
    
    }
                deepCopy(newobj[k], item)
            // 4.属于简单数据类型
            }else{
    
    
                newobj[k] = item
            }  
        }
    }
    deepCopy(o, obj)
    console.log(o)

    o.msg.age = 20
    console.log(obj)