最简单的递归

//var d={success:false,data:{}}
                var firstName= function(array,d){
                    for(var k in array){
                        var v=array[k];
                        if(d.success==false && v.showName){
                            d.success=true;
                            d.data=v;
                            return;
                        }else{
                            if(v.children){
                                for(var kc in v.children){
                                    firstName(v.children,d);
                                }
                            }
                        }
                    }
                }
                var d={success:false,data:null};
                firstName(data,d);

           /**
         * TODO
         * 对象的递归
         * 此递归方法不包含数组对象
         * */
        var obj = {
            a: 1,
            arr: [2, 3]
        };
        var shallowObj = shallowCopy(obj);

        function shallowCopy(src) {
            //console.log("src",src)
            //1、浅拷贝传入拷贝对象
            var newobj = {};
            //定义一个对象
            for(var prop in src) {
                //console.log("prop",prop)
                //循环src传入对象的key  prop就是src对象的每个key
                if(src.hasOwnProperty(prop)) {
                    //console.log("prop2",prop)
                    //obj.hasOwnProperty(prop),prop就是拿出来的每一个key
                    //console.log("原始的newobj",newobj)
                    newobj[prop] = src[prop];
                    //console.log("newobj[prop]",newobj[prop])
                    //新对象newobj是一个新的{}，它的每一个key的val == 传进来的obj，也就是src的每一个key的val
                }
            }
            //循环完成之后，再return 出来把得到的结果 返回给新创建的  newobj对象
            return newobj;
        }
        //console.log("shallowObj",shallowObj)

        /**
         * 递归遍历对象
         * 只获取vlaue
         * */

        var obj = {
            a: {
                name: "maoguotao",
                age: 18,
                sex: 'M',
            },
            b: {
                name: "maoshuqin",
                age: 18,
                sex: 'M',
            },
            c: {
                name: "MGT360124",
                age: 18,
                sex: 'M',
                title: {
                    job: "班长"
                }
            }
        };
        var arr = [];

        function f(obj) {
            for(var i in obj) {
                if(typeof obj[i] === "object") {
                    f(obj[i]);
                } else {
                    arr.push(obj[i]);
                }
            }
        }
        f(obj);
        //console.log(arr);

        /**
         * TODO
         * 递归对象的属性
         * hasOwnProperty 遍历一个对象的所有自身属性
         * */
        var obj = {
            name: "maoguotao",
            age: 18,
            sex: 'M'
        }
        for(var i in obj) {
            if(obj.hasOwnProperty(i)) {
                console.log(i + ":" + obj[i]);
            }
        }

        /**
         * TODO
         * hasOwnProperty 遍历一个对象的所有自身属性
         * JavaScript 并没有保护 hasOwnProperty 属性名，
         * 因此， 可能存在于一个包含此属性名的对象， 有必要使用一个可扩展的hasOwnProperty方法来获取正确的结果：
         * */

        var foo = {
            hasOwnProperty: function() {
                return false;
            },
            bar: 'Here be dragons'
        };

        foo.hasOwnProperty('bar'); // 始终返回 false

        // 如果担心这种情况，可以直接使用原型链上真正的 hasOwnProperty 方法
        // 使用另一个对象的`hasOwnProperty` 并且call
        ({}).hasOwnProperty.call(foo, 'bar'); // true

        // 也可以使用 Object 原型上的 hasOwnProperty 属性
        Object.prototype.hasOwnProperty.call(foo, 'bar'); // true

        /**
         * TODO
         * 数组的递归
         * */
        var arrs = [2, [6, 7, 12, 34, 3],
            [5, 23, [1], 9]
        ];
        var arr = [];

        function recursive(arrs) {
            for(var i in arrs) {
                if(typeof arrs[i] === "number") {
                    arr.push(arrs[i]);
                } else {
                    recursive(arrs[i]);
                }
            }
        }
        //recursive(arrs);
        //console.log(arr);