数据拦截器：递归遍历对象/数组，回调提供对属性，值的修改接口

/**
 * 数据拦截器：
 * 
 *     对复杂类型数据做深度递归，提供修改拦截属性，回调中可对属性，值等做处理
 *
 * @param {*} data  object/array  需要拦截的目标(数组或对象)
 * @param {*} callback1 function  回调函数 在内部对最内层(value为基础类型，再无嵌套)的value做一些事情，回调参数为一个obj
 * @param {*} callback2 function  同上，区别在于value为复杂类型，有嵌套
 * 回调参数说明：
 *      {
            type: ‘Object‘,// ‘Object‘|‘Array‘ 父节点的类型
            obj: data,      //  父节点对象(引用)
            key: key,       //  当前的key(ps:type为‘Array‘即为当前索引)
            value: value    //  当前的value
        }
 *  应用场景1：
        当你的项目中需要对特殊数据做处理的时候，比如测试说页面不能出现null！
        此时你可以在数据渲染之前调用此函数，在callback1中对value做一些处理

    应用场景2(最初写此函数的目的)：
        对echarts的options进行个性化设置，data支持多种配置方式，不同的方式
        做不同的处理，用此函数在callback2中对data做一些处理后再setOption
 */
function dataInterceptor(data, callback1, callback2) {

    again(data)

    function again(data) {

        if (type(data) === ‘Object‘) {

            for (var key in data) {
                // console.log(‘key------‘,key)   ----所有的key都经过这里
                if (typeof data[key] === "object") {
                    // 父节点是对象，值为复杂类型
                    if (callback2) callback2({
                        type: ‘Object‘,
                        obj: data,
                        key: key,
                        value: data[key]
                    })
                    again(data[key])
                } else {
                    // console.log(data[key])
                    //  父节点是对象，值为基础类型
                    if (callback1) callback1({
                        type: ‘Object‘,
                        obj: data,
                        key: key,
                        value: data[key]
                    })
                }
            }

        } else if (type(data) === ‘Array‘) {
            data.forEach(function (item, index) {
                if (typeof item === "object") {
                    // 父节点是数组 ，值为复杂类型
                    if (callback2) callback2({
                        type: ‘Array‘,
                        obj: data,
                        key: index,
                        value: item
                    })
                    again(item)
                } else {
                    //  父节点是数组，值为基础类型--->数组的每一项
                    // console.log(item)
                    if (callback1) callback1({
                        type: ‘Array‘,
                        obj: data,
                        key: index,
                        value: item
                    })
                }
            })
        }
    }

    function type(data) {
        return Object.prototype.toString.call(data).slice(8, -1)
    }
}