拼合对象

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

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 2

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

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

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

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