Devrais-je utiliser des littéraux d'objet ou des fonctions de constructeur?

Question

Je ne sais plus trop comment créer un objet en javascript. Il semble y avoir au moins deux manières. L'une consiste à utiliser la notation littérale d'objet, tandis que l'autre utilise des fonctions de construction. Y a-t-il un avantage de l'un sur l'autre?

Merci

Answer 1

Si vous n'avez pas le comportement associé à un objet (par exemple, si l'objet est un conteneur de données/de l'état), je voudrais utiliser un objet littéral.

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

Appliquer le principe de BAISER. Si vous n'avez pas besoin de quelque chose au-delà d'un simple conteneur de données, aller avec un simple littérale.

Si vous souhaitez ajouter un comportement à votre objet, vous pouvez aller avec un constructeur et d'ajouter des méthodes à l'objet lors de la construction ou de donner à votre classe un prototype.

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;
};

Une classe comme cela agit également comme un schéma pour votre objet de données: Vous disposez maintenant d'une sorte de contrat (par le constructeur) quelles sont les propriétés de l'objet initialise/contient. Gratuitement un littéral est juste un machin amorphe de données.

Vous pourriez aussi bien avoir un externe verify fonction qui agit sur un simple vieux données de l'objet:

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

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

Cependant, ce n'est pas favorable en ce qui concerne l'encapsulation: Idéalement, toutes les données de comportement associés à une entité doit vivre ensemble.

Answer 2

Cela revient essentiellement à savoir si vous avez besoin de plusieurs instances de votre objet ou non; L'objet défini avec un constructeur vous permet d'avoir plusieurs instances de cet objet. Les littéraux d'objet sont fondamentalement des singletons avec des variables / méthodes qui sont tous publics.

 // 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
 

Answer 3

Une autre façon de créer des objets de manière uniforme consiste à utiliser une fonction qui retourne un objet:

 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!
 

Puisque les fonctions en JavaScript sont des fermetures, nous pouvons utiliser des méthodes et des variables privées et éviter les new .

De http://javascript.crockford.com/private.html sur les variables privées en JavaScript.

Answer 4

Cela dépend de ce que vous voulez faire. Si vous souhaitez utiliser (semi-)privée des variables ou des fonctions en vous un objet, un constructeur de la fonction est le moyen de le faire. Si votre objet ne contient que des propriétés et méthodes d'un objet littéral est fine.

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

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

Maintenant, la méthode de multiply5 en myObj et SomeLiteral faire exactement la même chose. La seule différence est que myObj utilise une variable privée. Celui-ci peut être utile dans certains cas. La plupart du temps un Objet littéral est suffisante et une belle et propre façon de créer un JS-objet.

Answer 5

Aller avec le littéral d'objet, c'est plus consise et se développe mieux avec l'introduction des valeurs initiales.