递归以及递归的简单应用 JavaScript

递归以及递归的简单应用

执行上下文[代码的执行环境]

全局执行上下文

函数执行上下文

eval执行上下文（已经很少使用了，不推荐使用）

执行上下文调用栈[先进后出]

全局上下文入栈
函数上下文入栈
函数上下文出栈
全局上下文出栈

递归

当不满足条件时，函数调用自身，满足条件时，递归返回。

*递归实现阶乘

function play(num) {
            // 2.此时num=3，判断num不等于1，跳过if
            // 4.此时num=2，判断num不等于1，跳过if
            // 6.此时num=1,return 1，此时play(1)的结果为1
            if (num == 1) {
                return 1;
            }
            // 3.进入play(2)函数
            // 5.进入play(1)函数
            // 7. 执行play(1)的结果和2相乘  1*2==2
            // 8.执行play(2)的结果和3相乘  2*3==6
            // 9.返回结果为6
            return ((play(num - 1) * num))
        }
        // 1.首先执行log，然后进入play函数
        // 10.打印结果
        console.log(play(3))

快速排序【快排】

在数据集之中，选择一个元素作为”基准”
所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。

对”基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

//声明一个数组，存放需要排序的数
var arr = [5, 3, 8, 44, 2, 1, 12, 15, 21, 35]

    function quick(list) {
        //左边的数组
        let left_arr = [];
        //右边的数组
        let right_arr = [];
        //用来存放基数
        let basic = list[0];
        //如果数组长度小于等于1，则返回数组
        if (list.length <= 1) {
            return list;
        }
        // 循环每个数，如果小于基数则放左数组，如果大于基数则放右数组
        for (let i = 1; i < list.length; i++) {
            if (list[i] < basic) {
                left_arr.push(list[i]);
            } else {
                right_arr.push(list[i]);
            }
        }
        //返回一个数组，将左边数组，基数，和右边数组拼接起来
        return [].concat(quick(left_arr), basic, quick(right_arr));
    }
    console.log(quick(arr));//[1, 2, 3, 5, 8, 12, 15, 21, 35, 44]

浅拷贝

复制出来的对象在修改时对原来的对象造成了影响

3种浅拷贝：

复制了引用的地址
复制了对象但没有完全复制，对象中的对象类型值复制了地址

使用Object.assign()将y的内容全部复制到x中。

// 浅拷贝

    var obj = {
            name: 'jack',
            age: 20,
            work: ['写代码', '打麻将', '接外包']
        }
    // 1.复制了引用的地址
    var a = obj;
    a.name = 'rose'
    console.log(a);
    console.log(obj)
    // 2.虽然创建了对象，但是并没有完全创建对象
    var b = {
...obj
    };
    b.work[1] = '修电脑'
    console.log(b);
    console.log(a);
    // 3.将y的内容全部复制到x中
    var x = {
};
    var y = {
        name: 'jack',
        list: [1, 2, 3]
    }
    var result = Object.assign(x, y);

深拷贝

复制出来的对象在修改时不会对原来的对象造成影响。

2种深拷贝：

使用JSON转换。(函数无法拷贝、undefined的值无法拷贝)
使用递归

//深拷贝
//1.使用JSON进行深拷贝(函数无法拷贝、undefined的值无法拷贝)
```
    var str = JSON.stringify(phone);
    phone2 = JSON.parse(str);
```

//2.使用递归进行深拷贝
        var girl = {
            name: 'kk',
            age: '18',
            hobby: ['sing', 'swim', 'run'],
            pet: {
                dog: 'bt',
                cat: 'tt'
            }
        }
        var girl2 = {
    };
        function deepCopy(target, source) {
            //循环source中的每一项
            for (let i in source) {
                // 如果这一项的类型为object型
                if (typeof(source[i]) == 'object') {
                    // 如果存在长度，则为数组
                    if (source[i].length) {
                        p = []
                            // 否则为对象
                    } else {
                        p = {
    }
                    }
                    // 目标对象的这一项递归调用此函数，将此项复制
                    target[i] = deepCopy(p, source[i]);
                } else {
                    // 如果不为object类型，则为普通数据类型，直接赋值
                    target[i] = source[i]
                }
            }
            return target;
        }
        console.log(deepCopy(girl2, girl));
        girl2.pet = {
            dog: 'hh',
            pet: 'bb'
        }
        console.log(girl2)
        console.log(girl)