Qual è lo scopo di `Object (target)` nel polyfill `Object.assign()`

Question

Nello MDN page forObject.assign() l'esempio polyfill esegue il wrapping di tutte le origini e dei parametri di destinazione in Object() prima di iterare sulle proprietà. (ad esempio Object(target), Object(source1), Object(source2) ...).

Il testo indica anche che le proprietà aggiuntive vengono aggiunte direttamente al target prima di restituire il target. Tuttavia, il wrapping del target in Object() ha come risultato un oggetto diverso dalle semplici proprietà di conversione. (ad esempio Object(target).newProp !== target.newProp).

Tutti gli esempi forniti hanno oggetti come parametri su Object.assign(). Il caso d'uso per i parametri di origine o di destinazione non oggetto non è quindi chiaro.

A) Qual è lo scopo del wrapping dei parametri in Object()? (Ho l'impressione che lo Object.keys(x) sia lo stesso di Object.keys(Object(x))).

B) Quali sono i possibili casi di utilizzo per l'utilizzo di Object.assign() con non oggetti, c'è? (Per esempio qualcosa come: Object.assign(1, 'b', [3], true, function(){}))

Answer 1

Diamo scomposizione:

Verifica se l'oggetto esiste, se non ce la fa:

if (!Object.assign) { 

rendere il metodo tramite Object.defineProperty e aggiungilo a Object

Object.defineProperty(Object, 'assign', { 
    enumerable: false, 
    configurable: true, 
    writable: true, 

Qui viene impostata la funzione effettiva. Uno ha bisogno di fornire un obiettivo e un minimo di fonte.

value: function(target, firstSource) { 
     'use strict'; 

Se il bersaglio non è definita genera un errore.

 if (target === undefined || target === null) { 
     throw new TypeError('Cannot convert first argument to object'); 
     } 

Cast l'obiettivo di oggetto formato. (Es String 1234 a [object String]{0: "1", 1: "2", 2: "3", 3: "4", length: 4}.

 var to = Object(target); 

Ora ciclo attraverso tutte le fonti utilizzando l'oggetto argomenti della funzione. Inizia con 1, poiché 0 è la porta.

 for (var i = 1; i < arguments.length; i++) { 
     var nextSource = arguments[i]; //store the argument in a variable. 
     if (nextSource === undefined || nextSource === null) { 
      continue; //if the source is undefined continue. 
     } 

Quindi abbiamo bisogno di tutte (non solo quelle esposte) le proprietà enumerabili dall'oggetto sorgente, utilizzare Object.keys in combinazione con Object(source).

 var keysArray = Object.keys(Object(nextSource)); 

scandire le chiavi:

 for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) { 
      var nextKey = keysArray[nextIndex]; //select the key from the index. 

getOwnPropertyDescriptor ci dà informazioni sulla proprietà sotto forma di un oggetto.

  var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey); 

Se la proprietà non è definito ed è enumerabile quindi impostare questa proprietà come una proprietà da to.

  if (desc !== undefined && desc.enumerable) { 
      to[nextKey] = nextSource[nextKey]; 
      } 
     } 
     } 
     return to; 
    } 
    }); 
} 

ritorno Infine to con i (clonati) Proprietà appena aggiunti.