复习笔记之函数进阶(2)

递归

如果一个函数在内部可以调用其本身，那么这个函数就是递归函数

简单理解：函数内部自己调用自己就是递归函数(递归函数的作用和循环效果一样)

由于递归很容易发生“栈溢出”错误(stack overflow),所以必须加退出条件return

// 递归函数：函数内部自己调用自己，这个函数就是递归函数
let num = 1;
function fn() {
    console.log(`打印${num}句话`);
    if(num == 6) {
        return; // 递归里面必须加退出条件
    }
    num++;
    fn();
}
fn();

// 利用递归函数求1~n的阶乘
function fn(n) {
    if(n == 1) {
        return 1;
    }
    return n * fn(n - 1);
}
console.log(fn(6));

// 利用递归函数求斐波那契数列(兔子序列) 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(7));

深拷贝和浅拷贝的区别

浅拷贝只是拷贝一层，更深层次对象级别的只拷贝引用地址

let obj = {
    id: 1,
    name: 'andy',
    msg: {
        age: 18
    }
};
let o = {};
for(let k in obj) {
    // k是属性名  obj[k]是属性值
    o[k] = obj[k];
}
console.log(o);
o.msg.age = 20;
console.log(obj); // 数据做了修改，被拷贝的对象的属性值也会跟着改变

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(obj); // 数据做了修改，被拷贝的对象的属性值也会跟着改变

深拷贝拷贝多层，每一级别的数据都会拷贝

let obj = {
    id: 1,
    name: 'andy',
    msg: {
        age: 18
    }
};
let o = {};

// 封装函数
function deepCopy(newObj, oldObj) {
    for (let k in oldObj) {
        // 判断属性值属于哪种数据类型
        // 获取属性值 oldObj[k]
        let item = oldObj[k];
        // 判断这个值是否是数组/对象，如果不是则属于简单数据类型
        // 注意此处一定要先判断是否属于数组，然后再判断是否属于Object
        if (item instanceof Array) {
            newObj[k] = [];
            deepCopy(newObj[k], item);
        } else if (item instanceof Object) {
            newObj[k] = {};
            deepCopy(newObj[k], item);
        } else {
            newObj[k] = item;
        }
    }
}
deepCopy(o, obj);
console.log(o);
o.msg.age = 20;
console.log(obj);