展平对象的对象答案

【问题标题】：Flatten object of objects展平对象的对象
【发布时间】：2014-01-05 03:16:04
【问题描述】：

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

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 }
      }
    }
  }

【问题讨论】：

如果{ foo: { bar: 'baz' } } 怎么办？ { bar: 'baz' }?
只有一个对象是递归的，检查我的编辑。
谢谢你们的回答。我接受了一个。

标签： javascript object flatten

【解决方案1】：

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;
}

【讨论】：

我必须添加hasOwnProperty检查。

【解决方案2】：

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

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

【讨论】：

【解决方案3】：

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

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 }
//}

【讨论】：

【解决方案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 || {};
};

【讨论】：