Existe-t-il une meilleure façon d'utiliser Ext.apply pour combiner des enfants/sous-objets dans un autre objet?

Question

J'essaie d'appliquer les propriétés d'objet de objA à objB mais j'ai réalisé Ext.apply est imparfait (ou béni?) D'une manière où il s'applique uniquement les objets de premier niveau ensemble.

Exemple:

var objA = { 
    name: 'objA', 
    baseParams: { 
     cols: [1,2,3,4,5] 
    } 
}; 

//used in subclass 
var objB = { 
    name: 'objB', 
    baseParams: { 
     limit: 50, 
     sort: 'name' 
    } 
}; 

//used in baseclass 
var objC = { 
    name: 'objC', 
    baseParams: { 
     as_hash: true, 
     limit: 20 
    } 
}; 

Ext.apply(objB,objA); //used in subclass 
Ext.apply(objC,objB); //used in baseclass 

Exemple de sortie sera:

obj = { 
    name: 'objA', 
    baseParams: { 
     cols: [1,2,3,4,5] 
    } 
}; 

Je voudrais cette sortie à la place (sortie attendue):

obj = { 
    name: 'objA', 
    baseParams: { 
     cols: [1,2,3,4,5], 
     as_hash: true, 
     limit: 50, 
     sort: 'name' 
    } 
}; 

Comment puis-je parvenir sans faire ce?

// subclass: 
var bpTemp = {}; 
bpTemp.baseParams = Ext.apply(objB.baseParams, objA.baseParams); 
Ext.apply(objB,objA); 
Ext.apply(objB,bpTemp); 

// base class: 
var bpTemp = {}; 
bpTemp.baseParams = Ext.apply(objC.baseParams, objB.baseParams); 
Ext.apply(objC,objB); 
Ext.apply(objC,bpTemp); 

Answer 1

Vous pouvez changer la voie Ext.apply() fonctionne de telle sorte qu'un 4ème argument peut être booléen impliquant « profond » apply - cela fonctionnera avec votre exemple (par défaut profondes à true): question intéressante

Ext.apply = function(o, c, defaults, deep){ 
    deep = deep!==false; 
    // no "this" reference for friendly out of scope calls 
    if(defaults){ 
     Ext.apply(o, defaults); 
    } 
    if(o && c && typeof c == 'object'){ 
     for(var p in c){ 
      o[p] = (deep && Ext.isObject(o[p]) && Ext.isObject(c[p])) ? Ext.apply(o[p], c[p]) : c[p]; 
     } 
    } 
    return o; 
}; 

Answer 2

Vous pouvez essayer une solution récursive, avec quelques cas particuliers, comme ci-dessous:

function deepApply(receiver, config, defaults) { 
    if (defaults) { 
     deepApply(receiver, defaults); 
    } 
    if (receiver && config && typeof config == 'object') { 
     for (var p in config) { 
      if (typeof config[p] != 'object' || Ext.isArray(config[p])) { 
       receiver[p] = config[p]; 
      } else { 
       if (typeof receiver[p] != 'object') { 
        receiver[p] = {}; 
       } 
       deepApply(receiver[p], config[p]); 
      } 
     } 
    } 
    return receiver; 
}