Javascript: quali sono alcune linee guida su come definire nuovi tipi di dati?

Question

Supponi di creare il tipo di dati e di esporne il comportamento.

Può darci qualche esempio di quando si usa:

• una funzione & nuova:

  // define new data type 
  var CustomDataType= function(){ 
           this.a='whatever'; 
           this.doX= function(){/*some code*/}; 
          } 
  
  // create a new instance of our custom data type 
  var obj= new customDataType(); 
  

• un oggetto letterale & Object.create:

  // define new data type 
  var customDataType = { 
           a: 'whatever', 
           doX: function(){/*some code*/} 
          } 
  
  // create a new instance of our custom data type 
  var obj= Object.create(customDataType); 
  

• una funzione che ti costruisce r oggetto:

  function customDataTypeFactory(options){ 
      return { 
        a: 'whatever', 
        doX: function(){/*some code*/} 
       } 
  }; 
  
  // create a new instance of our custom data type 
  var obj= customDataTypeFactory(options); 
  

sento che questo potrebbe essere etichettato duplicato per: new vs Object.create ma il mio interesse principale non è in discussione che uno è meglio, ma piuttosto di sapere se ci sono casi di utilizzo specifici in cui si dovrebbe essere preferito agli altri.

Ho letto molti post su domande correlate e il libro di Crockford: Javascript: le parti buone. Finora ho concluso che è una questione di preferenza, il consiglio di Crockford risuona molto con me per me: "cerca di evitare le caratteristiche che sono pericolose e non necessarie" ... Sto parlando di new.

Answer 1

Comincerò con il mio modo di solito definisco classi:

function CustomDataType(a) 
{ 
    this.a = a; 
    this.b = 2; 
} 
CustomDataType.prototype = { 
    doX : function() {} 
}; 
var obj = new CustomDataType(1); 

assegno variabili nel costruttore perché F.prototype = { a : [1,2,3]; } è problematico, l'array sarà condiviso tra le istanze meno che la proprietà viene reinizializzata nel costruttore (problematico per tutti i tipi non primitivi). Ed è anche necessario quando la proprietà dipende in qualche modo dagli argomenti del costruttore. Dichiaro i metodi nel prototipo in modo che siano condivisi tra tutte le istanze, se si utilizza l'ereditarietà significa che è possibile avere chiamate super, ma anche un minore utilizzo della memoria poiché il metodo deve essere assegnato una sola volta (anche se probabilmente non lo è) t un grosso problema).

Non ho mai usato Object.create, non vedo alcun motivo per farlo, a meno che non ci si trovi in ​​qualche folle incitamento dinamico.

Io uso i letterali oggetto ogni volta che non è necessario creare una classe separata per gli oggetti, ad esempio se si tratta di argomenti su un metodo (quindi i chiamanti non devono istanziare esplicitamente qualcosa), o se sono alcuni valori interni che non dovrebbero accesso a chiunque altro

La vostra fabbrica è essenzialmente la stessa dell'oggetto letterale. Suppongo che possa essere utile se è necessario creare una struttura jsonesque e impostare alcuni valori predefiniti.

Non vedo perché new sarebbe pericoloso o non necessario, in che contesto ha detto questo?

Ma penso che molte cose si riducano al gusto. Sii coerente e non complicare le cose.