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

递归以及递归的简单应用

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

全局执行上下文

函数执行上下文

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

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

1. 全局上下文入栈
2. 函数上下文入栈
3. 函数上下文出栈
4. 全局上下文出栈

递归

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

*递归实现阶乘

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))

快速排序【快排】

1. 在数据集之中，选择一个元素作为"基准"

2. 所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素，都移到"基准"的右边。

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种浅拷贝：

1. 复制了引用的地址
2. 复制了对象但没有完全复制，对象中的对象类型值复制了地址
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种深拷贝：

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

//深拷贝
 //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)