Constructeurs JavaScript utilisant la notation littérale d'objet JavaScript

Quelle est la meilleure façon de construire des constructeurs en JavaScript à l'aide de l'objet de la notation littérale?

var myObject = {
 funca : function() {
  //...
 },

 funcb : function() {
  //...
 }
};

Je veux être en mesure d'appeler

var myVar = new myObject(...);

Et de passer des arguments à une fonction constructeur à l'intérieur de myObject.

source d'informationauteur mrwooster

  1. 46

    C'est pas "la notation JSON", c'est le JavaScript objet littéral notation. JSON est un sous-ensemble de JS objet littéral de la notation, mais en dehors de la recherche semblables, ils n'ont rien en commun. JSON est utilisé comme l'échange de données format, comme XML.

    Il n'est pas possible ce que vous voulez faire.

    var myObject = {};

    crée déjà un objet. Il n'y a rien que vous pouvez instancier.

    Vous pouvez toutefois créer une fonction constructeur et ajouter les méthodes de son prototype:

    function MyObject(arg1, arg2) {
    //this refers to the new instance
    this.arg1 = arg1;
    this.arg2 = arg2;

    //you can also call methods
    this.funca(arg1);
}

MyObject.prototype = {
 funca : function() {
  //can access `this.arg1`, `this.arg2`
 },

 funcb : function() {
  //can access `this.arg1`, `this.arg2`
 }
};

    Chaque objet que vous instancier avec new MyObject() héritent des propriétés du prototype (en fait, les instances juste obtenir une référence à l'objet prototype).

    Plus à propos de JavaScript objets et à l'héritage:

    Update2:

    Si vous avez d'instancier plusieurs objets de même nature, puis utiliser une fonction constructeur + prototype. Si vous avez seulement besoin un objet (comme un singleton), alors il n'est pas nécessaire d'utiliser une fonction constructeur (la plupart du temps). Vous pouvez directement utiliser l'objet littéral de notation pour créer cet objet.

  2. 7

    Faire l'objet d'une fonction, comme ceci:

    var myObject = function(arg1){
  this.funca = function(){
    //...
  };
  this.funcb = function(){
    //...
  };
  this.constructor = function(obj){
    alert('constructor! I can now use the arg: ' + obj.name);
  };
  this.constructor(arg1);
};

//Use the object, passing in an initializer:
var myVar = new myObject({ name: 'Doug'});
  3. 3

    Désolé d'être en retard à la fête, mais... je pense que dire que cette n'est pas possible est un peu restrictif, selon la façon dont vous interprétez les OP de la question et les commentaires ultérieurs.

    En supposant que l'OP voulait le namespacing avantages que l'objet de la notation littérale peut apporter à une bibliothèque, mais également voulu avoir certaines "classes" à utiliser au sein de cette structure. Ne pourriez-vous pas utiliser quelque chose de cette forme de combiner constructeur modèles à un objet littéral notation préfixée structure de la bibliothèque?

    var myNamespace = {
    aProperty: "A value",

    aMethod: function () { return "A method result"; },

    onePlusOneEquals: function () {
        return new myNamespace.classes.NumberStuff(1, 1).added;
    },

    classes: {
        ClassA: function () {
            this.propertyOne = null;
            this.methodOne = function (param) {
                return "The method was passed " + param;
            }
        },

        NumberStuff: function (argOne, argTwo) {
            this.added      = argOne + argTwo;
            this.subtracted = argOne - argTwo;
        }
    }
};

myNamespace.classes.ClassA.prototype.methodTwo = function () { return "At least this one's not bloating our memory footprint with every ClassA created..."; };

...

var anObj = new myNamespace.classes.ClassA();
alert(anObj.methodOne("the parcel")); //"The method was passed the parcel"
alert(myNamespace.onePlusOneEquals()); //2

    Ils sont stupides exemples, mais il n'existe aucune raison de ne pas le faire, ou pourquoi ce n'est pas valable? Il se débarrasse de la global des problèmes de surpopulation que les gens en général, l'utilisation de l'objet littéral de notation pour les bibliothèques.

  4. 3
    var myObject = function(arg){
    return{
        constructor: function(arg){
            //...
            return this;
        },

        funca: function(){
            //...
        },

        funcb: function(){
            //...
        }
    }.constructor(arg);
};

//...

var myVar = new myObject("...");
  5. 2

    La façon la plus simple que je sais c'est:

    function test(arg1, arg2) {
  var1 = arg1;
  var2 = arg2;
  return {
    var3 : var1, //json can access var1
    var4 : var2 //json can access var2
  };
}

arg1 = 'test';
arg2 = function() {
  window.alert('test')
};
var5 = new test(arg1, arg2);
var5.var4();
  6. 2
    var myObject = {
 funca : function() {
  //...
 },

 funcb : function() {
  //...
 }
};

    vous ne pouvez pas créer un nouvel objet de la précédente de cette façon

    var myVar = new myObject(...);

    mais vous pouvez obtenir la même chose avec en dessous de construire,

    var myVar = Object.create(myObject );