JSON串选择器方式解析

以选择器方式选择想要获取的值，并存入数组中。

    /**
     * [simpleJson description]
     * @param  [Object-json]  obj   [被解析的json串]
     * @param  [String]       str   [选择器 以空格隔开父节点与子元素]
     * @param  [Boolean]      flag  [标志是否寻找到父元素节点]
     * 使用前必须创建数组arr  所有子元素的值存储在数组结构中
     */
    function simpleJson(obj,str,flag){
        var parentNode = str.split(' ')[0];
        var childNode = str.split(' ')[1];
        if (obj && obj.constructor === Array) {
            obj.forEach(function(value) {
                simpleJson(value, str,0);
            });
            return;
        } else if (obj && obj.constructor === Object) {
            for (var k in obj) {
                if(!flag){ 
                    if (k == parentNode) {
                        for(var j in obj[k]){
                            if(j == childNode){
                                arr.push(obj[k][j]);
                            }
                            if (obj[k][j] && obj[k][j].constructor === Array){
                                obj[k][j].forEach(function(value) {
                                    simpleJson(value, str,1);
                                });
                            }
                            if (obj && obj.constructor === Object){
                                simpleJson(obj[k][j], str ,1);
                            }
                        }
                    }
                    simpleJson(obj[k], str ,0);
                }else{
                    if(k == childNode){
                        arr.push(obj[k]);
                        return false;
                    }else{
                        for(var l in obj[k]){
                            if (obj[k][l] && obj[k][l].constructor === Array){
                                obj[k][l].forEach(function(value) {
                                    simpleJson(value, str,1);
                                });
                            }
                            if (obj && obj.constructor === Object){
                                simpleJson(obj[k][l], str ,1);
                            }
                        }
                    }
                }
            }
        }
    }

项目中，有的时候后台传递过来两个同样的datas，但是纵深又特别深。例如：

var htmlJson = 
{
    'head':{...},
    'body':{
        'data':{
            'title':{
                'datas':[{
                    'style': '...',
                    'cols':[{
                        'showName':''
                    },{
                        'showName':''
                    },{
                        'showName':''
                    },{
                        'showName':''
                    }]
                }]
            },
            'content':[{
                'datas':[{
                    'style': '...',
                    'cols':[{
                        'showName':''
                    },{
                        'showName':''
                    },{
                        'showName':''
                    },{
                        'showName':''
                    }]
                    }，
                    {
                    'style': '...',
                    'cols':[{
                        'showName':''
                    },{
                        'showName':''
                    },{
                        'showName':''
                    },{
                        'showName':''
                    }]}}]
                }]
            }]
        }
    }
}

实际情况层级比这还多，则取到所有content下的showName放入数组,不需要title中的showName。
常规做法是一层一层剥开他的心，直到取到自己想要的东西，那么就有可能是这样的，
showNameArray.push(htmlJson.body.data.content.datas[i].cols[j].showName)
这样链式存取真的是太痛苦了，但是又不能直接遍历showName,不排除其他地方存在相同的字段，因此，需要对范围进行界定，在某一个范围内的showName一定是排他的，只有同类的showName,而没有其他乱入的showName