Question

我正在尝试以可重复的方式扩展javascript对象，而不必过多地遍历我的元素。这是一个非常简单的例子来说明这个问题：

var test1 = [
            {
              tests: [
                {
                  label: "this is a test"
                },
                {
                  label: "this is a test"
                },
                {
                  label: "this is a test"
                }
              ]}];

var test2 = [
            {
              tests: [
                  {comments: 'this is a comment'}
              ]}];

console.log($.extend(true, test1, test2))

http://jsfiddle.net/76bBR/3/

现在它的工作方式注释项只适用于test1中的第一个元素。我想知道是否有一种漂亮的方式来做到这一点，它适用于所有人，而不必为每个做。显然，在这个小案例中，每个都很好，但在我的实例中，我有一个非常深的对象，有几个列表，我想与每个项目的静态数据合并。有没有很酷的工具让这很容易？

var idealResult = [
            {
              tests: [
                {
                  label: "this is a test",
                  comments: 'this is a comment'
                },
                {
                  label: "this is a test",
                  comments: 'this is a comment'
                },
                {
                  label: "this is a test",
                  comments: 'this is a comment'
                }
              ]}];

Answer 1

像这样？ http://jsfiddle.net/76bBR/5/

console.log(test1.concat(test2))

也许您会在这里找到可用的内容：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array

Answer 2

我尝试使用递归算法，请参阅此jsFiddle。

function recursiveAppend(src, dest) {
    // If it's an array, loop through elements
    if ($.isArray(src)) {
        for (var i = 0; i < src.length; i++) {
            // If function returns true, then it found the 'deepest' level...
            if ( recursiveAppend(src[i], dest[i]) ) {
                // ...so extend all objects in the destination...
                for (var j = 0; j < dest.length; j++) {
                    $.extend(true, dest[j], src[i]);
                }
                // ...and stop looping
                break;
            }
        }
    }
    // If it's an object, loop through keys
    else if ($.isPlainObject(src)) {
        for (var key in src) {
            if (src.hasOwnProperty(key)) {
                // Check if the destination has the key
                if (dest.hasOwnProperty(key)) {
                    return recursiveAppend(src[key], dest[key])
                }
                // If it doesn't, then we found the 'deepest' level
                else {
                    //debugger;
                    return true;
                }
            }
        }
    }
    else {
        //debugger;
        return true;
    }
};

此算法假设您的src和dest具有相同的结构（无论它是什么），直到最深层次，其中dest将包含一个数组对象类似于src的单个对象。

它在找到第一个非数组/非对象键后也会停止。

它没有经过全面测试，所以扔了很多随机测试用例！您希望添加针对src和dest不同结构的保护（我始终假设会有相应的src[i]，dest[i]或{{1}对}，src[key]）。

希望这能指出你正确的方向=）

递归扩展Jquery对象

2 个答案: