var a = {
  aa: {
    aaa: 1,
    bbb: {
      aaaa: 9,
      dsfs: null,
      da: ['e9875t987']
    },
    ccc: {
      aaaa: {
        aaaaa: 9090,
        bbbbb: 90909
      }
    }
  }
}

function longTree (obj) {
  let walk = []
  ;(function walkTree (obj, deeppath) {
    if (Object.prototype.toString.call(obj) !== '[object Object]') {
      return walk.push(deeppath)
    }
    for (var i in obj) {
      walkTree(obj[i], deeppath + '.' + i)
    }
  })(obj, '')
  return Math.max.apply(null, walk.map(function (n) {
    return n.split('.').length
  }))
}

console.log(longTree(a))
// output
5

没有考虑数组里的object的深度

求a的深度？是不是想访问对象里面的值呢？如果是使用.符号，比如访问bbbbb的值：console.log(a.aa.ccc.aaaa.bbbbb);

没想到好方法, 简单一点就是不断遍历对象的属性,如果属性值是对象的话在遍历这个对象,知道所有的都不是对象

var count = 0;
function deep(obj){
    for(key in obj){
        if(obj[key].constructor == Object){
            count++;
            deep(obj[key]);
        }
    }
}

deep(a);

console.log(count);

function(object) {
    var level = 1;
    var key;
    for (key in object) {
        if (!object.hasOwnProperty(key)) continue;

        if (typeof object[key] == 'object') {
            var depth = utils.depthOf(object[key]) + 1;
            level = Math.max(depth, level);
        }
    }
    return level;
}

前提是你的object里面没有循环应用，否则这程序就死循环了。如果要防止这个，你就要记录下每个引用来比较了

//尽量用较少的代码来写，用了递归；
var depth = 1;
function getDepth(){return function(a){for(var i in a){var temp = typeof(a[i]);if (temp == 'object') {arguments.callee(a[i]);depth++;}}}}
getDepth()(a);
console.log(depth);