création d'un objet en javascript avec une méthode 'init' avec des paires nom/valeur optionnelles

Question

J'ai vu beaucoup d'objets javascript qui ont une méthode 'init' à laquelle vous passez des valeurs pour configurer l'objet.

Comment font-ils gérer en interne les initialisations de leurs variables privées lorsqu'il est passé dans un tableau de paires nom/valeur comme:

myObject.init ( {prop1: "bla", prop2: "asdf",. .., propn: "n"} ); Plus précisément, certaines de ces valeurs peuvent être facultatives. Par conséquent, comment définiriez-vous les valeurs par défaut, puis remplacez-les si la paire nom/valeur a été transmise pendant l'initialisation.

Answer 1

var myObject = { 
    init: function(options) { 
    this.foo = options.foo || 'some default'; 
    this.bar = options.requiredArg; 

    if (!this.bar) raiseSomeError(); 
    } 
} 

Answer 2

Vous pouvez utiliser un opérateur ternaire pour vérifier si un élément du tableau d'initialisation est défini et l'utiliser si c'est le cas, ou utiliser une valeur par défaut sinon. Par exemple, en supposant que les données d'initialisation est passé comme un objet appelé init ....

var myObject = { 
    init: function(opts) { 
    this.foo=(typeof(opts.foo)!="undefined")?opts.foo:'default value'; 
    } 
} 

Sinon, vous pouvez simplement copier tableau d'initialisation remplaçant les valeurs précédemment définies

var myObject = { 
    init: function(opts) { 
     this.foo='default value'; 

     for (name in opts) 
     { 
     this[name]=opts[name]; 
     } 
    } 

Notez qu'un idiome comme

this.foo = opts.foo || 'some default'; 

Échec si opts.foo est défini sur une valeur évaluée à false, par exemple 0

Answer 3

permet oh voir

modifier: mise à jour, cela fonctionne en fait

function myObject(){} 

myObject.prototype.init = function (argObj) 
{ 
    if (!argObj) 
    { 
     argObj = new Object(); 
    } 

    var abc = (argObj['abc'] != undefined) ? argObj['abc'] : "default value 1"; 
    var defg = (argObj['defg'] != undefined) ? argObj['defg'] : "default value 2"; 
} 

Answer 4

La façon la plus propre que je peux penser serait d'utiliser un objet par défaut qui contient toutes les propriétés par défaut comme suit:

function init(args) { 
    this.value = 'value' in args ? args.value : defaults.value; 
} 

Vous pouvez même itérer sur l'objet par défaut en utilisant une boucle for Vous n'avez pas besoin de garder trace des propriétés que vous voulez que l'objet contienne.

Vous devez utiliser l'opérateur "in" car il est possible de définir la valeur d'une propriété sur non définie. Il est valide de définir une propriété sur undefined et, dans ce cas, elle est considérée comme définie, le seul moyen de s'assurer qu'une valeur n'a pas été définie est de vérifier qu'elle n'est pas du tout dans l'objet.

Answer 5

Cela teste ok sur FF5, IE8, Chrome 12, Opera v11.5. Peu importe les valeurs par défaut, elles seront écrasées si leur clé est dans la liste des appels, sinon elles resteront seules.

var myObject = { 
    prop1: 'default1', 
    prop2: 'default2', 
    prop3: 'default3', 
    prop4: 'default4', 
    prop5: 'default5', 
    prop6: 'default6', 
    init: function(options) { 
     for(key in options) { 
     if(this.hasOwnProperty(key)) { 
      this[key] = options[key] 
     } 
     } 
    } 
} 

myObject.init({prop1: "blah", prop2: "asdf", prop5: "n"}) 

Answer 6

Mieux encore, récupérez la méthode init de l'objet pour pouvoir utiliser init pour d'autres objets.

Cela teste ok sur FF5, IE8, Chrome 12, Opera v11.5. Peu importe les valeurs par défaut, elles seront écrasées si leur clé est dans la liste des appels, sinon elles resteront seules.

var myGlobal = { 
    init: function(obj, options) { 
     for(key in options) { 
     if(obj.hasOwnProperty(key)) { 
      obj[key] = options[key] 
     } 
     } 
    } 
} 

var myObject = { 
    prop1: 'default1', 
    prop2: 'default2', 
    prop3: 'default3', 
    prop4: 'default4', 
    prop5: 'default5', 
    prop6: 'default6' 
} 

myGlobal.init(myObject, {prop1: "blah", prop2: "asdf", prop5: "n"})