Dovrei usare letterali oggetto o funzioni di costruzione?

Mi sto confondendo su come dovrei creare un oggetto in javascript. Sembra che ci siano almeno due modi. Uno consiste nell'usare la notazione letterale dell'oggetto mentre l'altro utilizza le funzioni di costruzione. C'è un vantaggio dell'uno sull'altro?

Se non hai un comportamento associato a un oggetto (cioè se l'oggetto è solo un contenitore per dati / stato), userei un oggetto letterale.

var data = {
    foo: 42,
    bar: 43
};

Applica il principio KISS . Se non hai bisogno di nient'altro che un semplice contenitore di dati, vai con un semplice letterale.

Se vuoi aggiungere un comportamento al tuo oggetto, puoi andare con un costruttore e aggiungere metodi all'oggetto durante la costruzione o dare alla tua classe un prototipo.

function MyData(foo, bar) {
    this.foo = foo;
    this.bar = bar;

    this.verify = function () {
        return this.foo === this.bar;
    };
}

// or:
MyData.prototype.verify = function () {
    return this.foo === this.bar;
};

Una classe come questa agisce anche come uno schema per il tuo oggetto dati: ora hai una sorta di contratto (tramite il costruttore) sulle proprietà che l'oggetto inizializza / contiene. Un letterale libero è solo un ammasso di dati amorfo.

Potresti anche avere una verifyfunzione esterna che agisce su un semplice vecchio oggetto dati:

var data = {
    foo: 42,
    bar: 43
};

function verify(data) {
    return data.foo === data.bar;
}

Tuttavia, questo non è favorevole per quanto riguarda l'incapsulamento: idealmente, tutti i dati + il comportamento associati a un'entità dovrebbero convivere.

Essenzialmente si riduce a se hai bisogno di più istanze del tuo oggetto o meno; oggetto definito con un costruttore consente di avere più istanze di quell'oggetto. I letterali oggetto sono fondamentalmente singoli con variabili / metodi che sono tutti pubblici.

// define the objects:
var objLit = {
  x: 0,
  y: 0,
  z: 0,
  add: function () {
    return this.x + this.y + this.z;
  }
};

var ObjCon = function(_x, _y, _z) {
  var x = _x; // private
  var y = _y; // private
  this.z = _z; // public
  this.add = function () {
    return x + y + this.z; // note x, y doesn't need this.
  };
};

// use the objects:
objLit.x = 3; 
objLit.y = 2; 
objLit.z = 1; 
console.log(objLit.add());    

var objConIntance = new ObjCon(5,4,3); // instantiate an objCon
console.log(objConIntance.add());
console.log((new ObjCon(7,8,9)).add()); // another instance of objCon
console.log(objConIntance.add()); // same result, not affected by previous line

Un altro modo per creare oggetti in modo uniforme è usare una funzione che restituisce un oggetto:

function makeObject() {
    var that = {
        thisIsPublic: "a public variable"
        thisIsAlsoPublic: function () {
            alert(that.thisIsPublic);
        }
    };

    var secret = "this is a private variable"

    function secretFunction() { // private method
        secret += "!"; // can manipulate private variables
        that.thisIsPublic = "foo";     
    }

    that.publicMethod = function () {
        secret += "?"; // this method can also mess with private variables
    }

    that.anotherPublicVariable = "baz";

    return that; // this is the object we've constructed
}

makeObject.static = "This can be used to add a static varaible/method";

var bar = makeObject();
bar.publicMethod(); // ok
alert(bar.thisIsPublic); // ok
bar.secretFunction(); // error!
bar.secret // error!

Poiché le funzioni in JavaScript sono chiusure, possiamo usare variabili e metodi privati ​​ed evitare new.

Da http://javascript.crockford.com/private.html sulle variabili private in JavaScript.

Il codice seguente mostra tre metodi per creare un oggetto, la sintassi Object Literal, un costruttore di funzioni e Object.create(). La sintassi letterale dell'oggetto crea semplicemente un oggetto al volo e come tale __prototype__è l' Objectoggetto e avrà accesso a tutte le proprietà e metodi di Object. Strettamente dal punto di vista del modello di progettazione, è necessario utilizzare un semplice valore letterale Object per archiviare una singola istanza di dati.

Il costruttore di funzioni ha una proprietà speciale denominata .prototype. Questa proprietà diventerà l'elemento __prototype__di tutti gli oggetti creati dal costruttore della funzione. Tutte le proprietà e i metodi aggiunti alla .prototypeproprietà di un costruttore di funzioni saranno disponibili per tutti gli oggetti che crea. È necessario utilizzare un costruttore se sono necessarie più istanze dei dati o se si richiede un comportamento dall'oggetto. Si noti che il costruttore di funzioni è anche meglio utilizzato quando si desidera simulare un modello di sviluppo privato / pubblico. Ricordarsi di mettere tutti i metodi condivisi su in .prototypemodo che non vengano creati in ogni istanza di oggetto.

La creazione di oggetti con Object.create()utilizza un oggetto letterale come __prototype__per gli oggetti creati con questo metodo. Tutte le proprietà e i metodi aggiunti all'oggetto letterale saranno disponibili per tutti gli oggetti creati da esso tramite una vera eredità prototipale. Questo è il mio metodo preferito.

//Object Example

//Simple Object Literal
var mySimpleObj = {
    prop1 : "value",
    prop2 : "value"
}

// Function Constructor
function PersonObjConstr()  {
    var privateProp = "this is private";
    this.firstname = "John";
    this.lastname = "Doe";
}
PersonObjConstr.prototype.greetFullName = function()    {
    return "PersonObjConstr says: Hello " + this.firstname + 
    " " + this.lastname;
};

// Object Literal
var personObjLit = {
    firstname : "John",
    lastname: "Doe",
    greetFullName : function() {
        return "personObjLit says: Hello " + this.firstname +
        ", " + this.lastname;
    }
} 

var newVar = mySimpleObj.prop1;
var newName = new PersonObjConstr();
var newName2 = Object.create(personObjLit);

Dipende da quello che vuoi fare. Se si desidera utilizzare variabili o funzioni (semi) private nel proprio oggetto, una funzione di costruzione è il modo per farlo. Se il tuo oggetto contiene solo proprietà e metodi, un oggetto letterale va bene.

function SomeConstructor(){
    var x = 5;
    this.multiply5 = function(i){
        return x*i;
    }
}
var myObj = new SomeConstructor;

var SomeLiteral = {
    multiply5: function(i){ return i*5; }
}

Ora il metodo multiply5in myObje SomeLiteralfare esattamente la stessa cosa. L'unica differenza è che myObj utilizza una variabile privata. Quest'ultimo può essere utile in alcuni casi. La maggior parte delle volte un valore letterale Object è sufficiente ed è un modo carino e pulito per creare un oggetto JS.

Vuoi una singola istanza dell'oggetto per la pagina - Letterale.

Vuoi solo trasferire dati come oggetti DTO semplici GET SET: - Letterale

Vuoi creare oggetti reali con comportamenti di metodo, istanze multiple - Funzione Costruttore, Segui principi OOP, ereditarietà: - Funzioni Costruttore.

Di seguito è riportato il video di YouTube che spiega in dettaglio cosa è letterale, cosa sono le funzioni del costruttore e come differiscono tra loro.

https://www.youtube.com/watch?v=dVoAq2D3n44

Vai con l'oggetto letterale, è più coerente e si espande meglio con l'introduzione dei valori iniziali.

Come menzionato in https://www.w3schools.com/js/js_object_definition.asp

L'utilizzo di un letterale oggetto, sia di definire e creare , un oggetto in una dichiarazione.

Anche

Il valore letterale dell'oggetto crea solo un singolo oggetto. A volte ci piace avere un tipo di oggetto che può essere utilizzato per creare molti oggetti di un tipo.

La funzione di costruzione Object () è un po 'più lenta e più dettagliata. Pertanto, il modo consigliato per creare nuovi oggetti in JavaScript è usare la notazione letterale

JavaScript orientato agli oggetti di Udacity

In realtà, penso, possiamo avere metodi privati ​​in letterali oggetto. Considera il codice seguente:

var myObject = {

   publicMethod: function () {
      privateMethod1();
      privateMethod2(); 
      function privateMethod1(){
          console.log('i am privateMethod1');
      } 
      function privateMethod2(){
          console.log('i am privateMethod2');
      } 
   }

}

Questione di gusti, ma preferisco usare oggetti letterali dove è possibile.

// Object Literal e Object costruttore

function MyData(foo, bar) {
        this.foo = foo;
        this.bar = bar;

    }
MyData.prototype.verify = function () {
        return this.foo === this.bar;
    };

//add property using prototype

var MD  = new MyData;//true.
var MD = new MyData();//true.
MD.verify// return only the function structure.
MD.verify(); //return the verify value and in this case return true coz both value is null. 
var MD1  = new MyData(1,2); // intialized the value at the starting. 
MD1.verify// return only the function structure.
MD1.verify(); // return false coz both value are not same.
MD1.verify(3,3);// return false coz this will not check this value intialized at the top 
MyData.prototype.verify = function (foo,bar) {
    return this.foo === this.bar;
};
var MD1  = new MyData(1,2);
MD1.verify();
MD1.verify(3,3);// return false coz this keyword used with foo and bar that will check parent data