递归扩展Jquery对象

Question

I'm trying to extend a javascript object in a repeatable fashion without having to iterate through my element too much. This is a very simple example to illustrate the question:

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/

The way it works now the comment item will only apply to the first element in test1. I am wondering if there is a nifty way to do this such that it applies to all without having to do forEach. Obviously in this small case forEach will be fine, but in my real example I have a very deep object with several lists which I want to merge with static data for each of the items. Are there any cool tools out there which make this easy?

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

Like so? http://jsfiddle.net/76bBR/5/

console.log(test1.concat(test2))

Maybe you'll find something usable here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array

Answer 2

I tried playing around with a recursive algorithm, see this 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;
    }
};

This algorithm makes the assumption that your src and dest have the same structure (regardless of what it is) until the deepest level, where dest will then consist of an array of objects analogous to src 's single object.

It also stops after it finds the first non-array/non-object key.

It's not fully tested, so throw a lot of random test cases at it! You'll want to add protections against src and dest being different structures (I always assume there will be corresponding pairs of src[i] , dest[i] or src[key] , dest[key] ).

Hopefully this points you in the right direction =)