Question

我试过这样，它适用于具有一个属性的对象：

var foo = { foo: { foo: { foo: function(){ return x }}}};

function flattenObj(obj) {
  var res;
  for (var k in obj) {
    res = obj[k];
    while (k in res) {
      res = res[k];
    }
  }
  return res;
}

console.log(flattenObj(foo)); // function(){ return x }

如何使其与此对象一起使用？

{ baz: 'baz', foo: { baz: 'baz', foo: function(){ return x }}};

所以它返回：

{ baz: 'baz', foo: function(){ return x }}

修改

  var obj = {
    a: 1,
    b: 2,
    obj: {
      a: 1,
      b: 2,
      obj: {
        a: 1,
        b: 2,
        obj: function(){ return x }
      }
    }
  }

Answer 1

假设你知道属性名称，你可以得到最后一次出现的函数：

while (typeof obj.obj !== 'function') {
    obj = obj.obj;
}

Answer 2

只是做一个简单的递归函数似乎可以完成这项工作：

http://jsbin.com/AhAlEHOf/1/edit?js,console

function addOwnProperties (source, target) {
    var properties = Object.keys(source);
  for ( var p in properties ) {
      var key = properties[p];
      var thisObject = source[key];
    if (typeof thisObject != 'object' || Object.keys(thisObject).length == 0) {
        target[key] = thisObject;     
    } else {
      addOwnProperties(thisObject, target) ;
    }
  }
}

测试：

var tst ={ baz: 'baz', foo: { baz: 'baz', foo: function(){ return x }}};

var res = {};

addOwnProperties(tst, res) ;

console.log(res);
// output :
// [object Object] {
//  baz: "baz",
//  foo: function (){ return x }
// }

var tst2 = {
    a: 1,
    b: 2,
    obj: {
      a: 3,
      b: 4,
      obj: {
        a: 5,
        b: 6,
        obj: function(){ return x }
      }
    }
  }

var res2 = {};

addOwnProperties(tst2, res2) ;

console.log(res2);
// output :
// [object Object] {
//  a: 5,
//  b: 6,
//  obj: function (){ return x }
//}

Answer 3

的 The demo. 的

function flattenObj(obj) { var tmp, k, res = {}; for (k in obj) { tmp = obj[k]; while (typeof tmp == 'object' && k in tmp) { tmp = tmp[k]; } res[k] = tmp; } return res; }

Answer 4

以为我会分享我对这个问题的看法。

递归，允许父键的前缀。

var tst2 = {
    a: 1,
    b: 2,
    obj: {
      a: 3,
      b: 4,
      obj: {
        a: 5,
        b: 6,
        obj: function(){ return x }
      }
    }
  };

Object.prototype.flatten = function (separator, prefix) {
    var obj, prefix;
    if (typeof this != 'undefined') {
        separator = separator || '-';
        prefix = arguments.length > 1 ? ((arguments[1].length > 0) ? (arguments[1] + separator) : '') : '';
        obj = arguments.length > 2 ? arguments[2] : {};
        for (var prop in this) {
            if (this.hasOwnProperty(prop)) {
                var path = prefix + prop;
                if (typeof this[prop] == 'object') {
                    if (Object.prototype.toString.call(this[prop]) == '[object Object]') {
                        var flattened = this[prop].flatten(separator, path, obj);
                        for (var flat in flattened) {
                            if (flattened.hasOwnProperty(flat)) {
                                obj[flat] = flattened[flat];
                            }
                        }
                    } else if (typeof this[prop] != 'undefined') {
                        obj[path] = this[prop];
                    }
                } else if (typeof this[prop] != 'undefined') {
                    obj[path] = this[prop];
                }
            }
        }
    }
    return obj || {};
};

展平对象的对象

4 个答案: