la création d'un objet en javascript qui a un 'init' méthode avec, en option, des paires nom/valeur

J'ai vu beaucoup de javascript les objets qui ont un "init" de la méthode que vous passez en valeurs dans le but de configuration de l'objet.

Comment font-ils pour 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 en option, alors comment voulez-vous la configuration par défaut et ensuite de les remplacer si la paire nom/valeur a été adoptée lors de l'init.

OriginalL'auteur Blankman | 2009-02-04

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

    if (!this.bar) raiseSomeError();
  }
}
```
cette échoue également si les options.toto est fausse (false)
Je suppose que si vous avez vraiment besoin de soutien que de cas: cette.foo = options.foo == null ? 'par défaut' : options.foo;
Est init la seule fonction qui peut utiliser cette syntaxe? ou pourrait-on définir une autre fonction à l'aide de nomfonction: function(passedParam){}?
Il n'y a rien de spécial au sujet d'une fonction nommée init. Toute fonction peut utiliser ce modèle.

OriginalL'auteur Alex Wayne
4

La façon la plus propre je pense, serait d'utiliser les valeurs par défaut de l'objet 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 effectuer une itération sur l'objet par défaut à l'aide d'une boucle for, de sorte que vous n'avez pas à garder une trace des propriétés de l'objet à contenir.

Vous devez utiliser l'opérateur "in" depuis qu'il est réellement possible de définir la valeur d'une propriété non définie. Il est valable pour définir une propriété non définie et dans ce cas, il est effectivement considéré défini, la seule façon de s'assurer que la valeur n'a pas été fixée est de vérifier qu'il n'est pas dans l'objet.

OriginalL'auteur Michael Roberts

Ce tests ok sur FF5, IE8, Chrome 12, Opera v11.5. Il n'a pas d'importance ce que les valeurs par défaut sont, ils seront écrasés si leur clé est dans la liste d'appel, si ce n'est qu'ils seront laissés seuls.

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"} )

OriginalL'auteur Anon

Mieux encore, obtenir la méthode init de l'objet de sorte que vous pouvez utiliser init pour d'autres objets.

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"} )

OriginalL'auteur Anon

1

oh permet de voir

edit: mise à jour, cela fonctionne
```
 
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";
}
```
échoue si args['abc'] est fausse (false)
droit, fixe, merci 🙂
toujours en panne, ce que si je passe {abc:0}? J'obtiens la valeur par défaut à la place.
heh, bonne prise Paul, je me demande combien d'occurrences de ce que j'ai dans le vieux code! De toute façon, je l'ai corrigé, ce n'est pas assez, mais il fonctionne.
Utilisation de l'identité de comparaison !== pour la comparaison avec les undefined.

OriginalL'auteur Allen Rice
0

Vous pouvez utiliser un opérateur ternaire pour vérifier si un élément de l'initialisation de la matrice est définie, et l'utiliser si elle est, ou utiliser une valeur par défaut si pas. 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';
  }
}
```
Alternativement, vous pouvez simplement copier init tableau substituant les valeurs définies précédemment
```
var myObject = {
  init: function(opts) {
      this.foo='default value';

      for (name in opts)
      {
         this[name]=opts[name];
      }
  }
```
Noter qu'un idiome comme
```
this.foo = opts.foo || 'some default';
```
Échoue si opte.toto est réglé à une valeur qui correspond à la valeur false, par exemple 0

OriginalL'auteur Paul Dixon

Vous devez vous connecter pour publier un commentaire.