jQuery深度继承非递归函数

var aaa= function() {
    var options, name, src, copy, copyIsArray, clone,
        target = arguments[ 0 ]  {},
        i = 1,
        length = arguments.length,
        deep = false;

    // Handle a deep copy situation
    if ( typeof target === "boolean" ) {
        deep = target;

        // Skip the boolean and the target
        target = arguments[ i ]  {};
        i++;
    }

    // Handle case when target is a string or something (possible in deep copy)
    if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
        target = {};
    }

    // Extend jQuery itself if only one argument is passed
    if ( i === length ) {
        target = this;
        i--;
    }

    for ( ; i < length; i++ ) {

        // Only deal with non-null/undefined values
        if ( ( options = arguments[ i ] ) != null ) {

            // Extend the base object
            for ( name in options ) {

                src = target[ name ];
                copy = options[ name ];

                // Prevent never-ending loop
                if ( target === copy ) {

                    continue;
                }

                // Recurse if we're merging plain objects or arrays
              if ( deep && copy && ( jQuery.isPlainObject( copy ) 
                    ( copyIsArray = jQuery.isArray( copy ) ) ) ) {

                    if ( copyIsArray ) {
                        copyIsArray = false;
                        clone = src && jQuery.isArray( src ) ? src : [];

                    } else {
                        clone = src && jQuery.isPlainObject( src ) ? src : {};
                    }                  
                   var ary=[];
                   var mem={};
                   mem['.'+name]=jQuery.isPlainObject( copy )?{}:(jQuery.isArray( copy ) ? [] : '');      
                   for(var j in copy){
                       ary.push({name:'.'+name+'.'+j,value:copy[j]});
                       mem['.'+name+'.'+j]=jQuery.isPlainObject( copy[j] )?{}:(jQuery.isArray( copy[j] ) ? [] : '');
                   }

                   while(ary.length>0){
                        var temb=ary.shift();

                    if( jQuery.isPlainObject( temb.value ) ( copyIsArray = jQuery.isArray( temb.value ))){
                    mem[temb.name]=jQuery.isPlainObject( temb.value )?{}:(jQuery.isArray( temb.value ) ? [] : '');            
                         for(var k in temb.value){          
                           ary.push({name:temb.name+'.'+k,value:temb.value[k]});
                           mem[temb.name+'.'+k]=jQuery.isPlainObject( temb.value[k] )?{}:(jQuery.isArray( temb.value[k] ) ? [] : '');            
                         }                        
                      }else{
                      var aryA=temb.name.split(".");
                      var tembName='';

                      for(var n=1,len=aryA.length;n<len;n++){
                       if(n!=(len-1)){                        
                         eval('target'+tembName)[aryA[n]]=eval('target'+tembName)[aryA[n]]mem[tembName+'.'+aryA[n]];                       
                        }else{                          
                           eval('target'+tembName)[aryA[n]]=temb.value;                     
                        }
                          tembName=tembName+'.'+aryA[n];                          
                      }
                     }
                   }
                // Don't bring in undefined values
                } else if ( copy !== undefined ) {

                    target[ name ] = copy;
                }
            }
        }
    }
    // Return the modified object
        console.log(target)
    return target;
};
var a={a:{a:1,b:2},b:3,c:{e:44,ff:[1,4,5]}};    
var b={};
    aaa(true,b,a);
    alert(b.c.ff[2])