Un javascript modèle de conception pour les options avec les valeurs par défaut?

Il utilise jQuery.étendre mais pourrait être échangé avec un objet de la fusion à partir de votre bibliothèque de choix ou de l'Objet.attribuer dans l'ES6.

function Module(options){
    var defaults = {
        color: 'red',
    };
    var actual = $.extend({}, defaults, options || {});
    console.info( actual.color );
}

var a = new Module();
//Red
var b = new Module( { color: 'blue' } );
//Blue

---

Modifier: Maintenant aussi dans soulignement ou lodash!

function Module(options){
    var actual = _.defaults(options || {}, {
         color: 'red',
    });
    console.info( actual.color );
}

var a = new Module();
//Red
var b = new Module( { color: 'blue' } );
//Blue

---

En Javascript ES6 vous pouvez utiliser Objet.attribuer:

function Module(options = {}){
    let defaults = {
        color: 'red',
    };
    let actual = Object.assign({}, defaults, options);
    console.info( actual.color );
}

Pour obtenir les options par défaut sans dépendances supplémentaires, j'utilise le schéma suivant:

var my_function = function (arg1, arg2, options) {
    options = options || {};
    options.opt_a = options.hasOwnProperty('opt_a') ? options.opt_a : 'default_opt_a';
    options.opt_b = options.hasOwnProperty('opt_b') ? options.opt_b : 'default_opt_b';
    options.opt_c = options.hasOwnProperty('opt_c') ? options.opt_c : 'default_opt_b';


    //perform operation using options.opt_a, options.opt_b, etc.
};

Bien qu'un peu verbeux, je le trouve facile à lire, ajouter/supprimer des options et ajouter des valeurs par défaut. Lorsqu'il y a BEAUCOUP d'options, un peu plus compact version:

var my_function = function (arg1, arg2, options) {
    var default_options = {
        opt_a: 'default_opt_a',
        opt_b: 'default_opt_b',
        opt_c: 'default_opt_c'};

    options = options || {};
    for (var opt in default_options)
        if (default_options.hasOwnProperty(opt) && !options.hasOwnProperty(opt))
            options[opt] = default_options[opt];

    //perform operation using options.opt_a, options.opt_b, etc.
};

Si vous avez besoin de faire cela dans de nombreux consécutives fonctions, une façon de normaliser les processus et la vitesse est de:

function setOpts (standard, user) {
  if (typeof user === 'object' {
    for (var key in user) {
      standard[key] = user[key];
    }
  }
}

Ensuite, il vous suffit de définir vos fonctions simplement comme ceci:

var example = function (options) {
  var opts = {
    a: 1,
    b: 2,
    c:3
  };
  setOpts(opts, options);
}

De cette façon, vous ne définissez l'une des options de l'objet à l'intérieur de la fonction, qui contient les valeurs par défaut.

Si vous souhaitez mettre un supplément de vérifier à éviter l'héritage de prototype, la première fonction peut être:

function setOpts (standard, user) {
  if (typeof user === 'object') {
    Object.keys(user).forEach(function (key) {
      standard[key] = user[key];
    });
  }
}

Le dernier cas n'est pas pris en charge pour: IE < 9, Chrome < 5, Firefox < 4, Safari < 5

(vous pouvez consulter le tableau de compatibilité des ici)

---

Enfin ECMAScript 6 va nous apporter la meilleure façon de le faire: paramètres par défaut.

Il faudra quelques mois avant que cela est largement pris en charge dans les navigateurs.

Si vous avez accès à ES6 avec du stade 4 de la proposition (comme avec Babel) vous pouvez accomplir cela avec la diffusion et la déstructuration de l'affectation.

JS:

const defaultPrintOptions = {
  fontName: "times",
  fontStyle: "normal",
  fontSize: 10,
  align: "left"
};

//Setting the null default isn't necessary but
//makes it clear that the parameter is optional.
//Could use {} but would create a new object
//each time the function is called.
function print(text, options = null) {
  let {
    fontName,
    fontStyle,
    fontSize,
    align
  } = {
    ...defaultPrintOptions,
    ...options
  };

  console.log(text, fontName, fontStyle, fontSize, align);
}

print("All defaults:");
print("Override some:", {
  fontStyle: "italic",
  align: "center"
});
print("Override all:", {
  fontName: "courier",
  fontStyle: "italic",
  fontSize: 24,
  align: "right"
});

Cela fonctionne aussi (mais peut créer des objets):

function myFunction({ 
  text = "", 
  line = 0, 
  truncate = 100 
} = {}) {
  console.log(text, line, truncate);
}

(dernier exemple de David Walsh - @wprl la réponse mentionne également ce)

Maintenant que j'y pense, j'aime bien ceci:

function foo(a, b, opt_options) {
  //Force opt_options to be an object
  opt_options = opt_options || {};

  //opt_c, opt_d, and opt_e are read from 'opt_options', only c and d have defaults
  var opt_c = 'default_for_c' || opt_options.c;
  var opt_d = 'default_for_d' || opt_options.d;
  var opt_e = opt_options.e; //e has no default
}