oop - En Javascript, que signifie ce trait de soulignement?




backbone.js (6)

Habituellement _ est utilisé pour indiquer à l'utilisateur / programmeur qu'il s'agit d'une variable privée / protégée en question.

var Gallery = Backbone.Controller.extend({
    _index: null,
    _photos: null,
    _album :null,
    _subalbums:null,
    _subphotos:null,
    _data:null,
    _photosview:null,
    _currentsub:null,
    routes: {
        "": "index",
        "subalbum/:id": "subindex",
        "subalbum/:id/" : "directphoto",
        "subalbum/:id/:num" : "hashphoto"
    },
    initialize: function(options) {
        var ws = this;
        if (this._index === null){
            $.ajax({
                url: 'data/album1.json',
                dataType: 'json',
                data: {},
                success: function(data) {
                    ws._data = data;
                    ws._photos =
                    new PhotoCollection(data);
                    ws._index =
                    new IndexView({model: ws._photos});
                    Backbone.history.loadUrl();
                }
            });
            return this;
        }
        return this;
    },
    //Handle rendering the initial view for the
    //application
    index: function() {
        this._index.render();
    },

Je suis en train de lire un tutoriel sur backbone.js ici: http://addyosmani.com/blog/building-spas-jquerys-best-friends/

Quels sont les traits de soulignement? (_index, _photos, _album) Pourquoi les utiliser?


Cela signifie des champs privés ou des méthodes privées. Les méthodes qui sont seulement pour usage interne.

Ils ne devraient pas être invoqués en dehors de la classe.

Les champs privés contiennent des données à usage interne.

Ils ne devraient pas être lus ou écrits (directement) de l'extérieur de la classe.

Il est très important de noter que le simple fait d'ajouter un trait de soulignement à une variable ne le rend pas privé, c'est seulement une convention de nommage.


Il est probablement utilisé pour marquer les propriétés internes / privées. Tout comme en python, préfixer une variable avec un underscore est un moyen facile de dire aux développeurs qu'une variable est interne et mieux vaut ne pas l'altérer (et s'ils le font, même une mise à jour mineure de la bibliothèque concernée peut casser des choses).


Lorsqu'il est utilisé comme _varname il fait juste partie du nom des variables et n'a pas de signification javascript. Les développeurs l'utilisent pour indiquer la signification ou la portée de la variable. Dans ce cas, il semble que le développeur doive indiquer que cette variable doit être une variable locale ou privée.

Quelques points à noter, dans cet exemple particulier en utilisant _.varname signifierait une variable ou une fonction avec la bibliothèque underscore.js. De plus, on pourrait utiliser _varname pour signifier une variable contenant un objet de soulignement, de même dans notre bureau, nous utilisons $varname pour indiquer une variable contenant un objet Jquery.


Comme mentionné, c'est une pratique parmi de nombreux développeurs, un mauvais à cela. Si vous devez recourir à des conventions comme celle-ci dans vos méthodes de programmation, vous devriez apprendre la langue, les méthodes et les modèles avant de tenter d'utiliser la langue. Si quelqu'un ne peut pas faire la distinction entre les méthodes publiques / privées dans votre code sans l'utilisation du "trait de soulignement", alors vos compétences en documentation sont extrêmement insuffisantes. Beaucoup de projets publics sur le web sont très mal documentés, ce qui explique probablement pourquoi les conventions de «soulignement» étaient «acceptées» par la plupart des développeurs éduqués tandis que d'autres décidaient de suivre le courant plutôt que de conserver les modèles et méthodes formels. Il y a une raison pour laquelle "underscore" n'a pas été écrit dans les versions ES6 / 7.

Dans un blog, je suis récemment tombé sur un responsable de l'ingénierie logicielle qui a déclaré: « La convention de dénomination de soulignement rend très facile de dire, en un coup d'œil, si une fonction variable est destinée à être publique ou privée . Ma réponse est: "Les commentaires sont comme des images, dans ce cas ils valent mille sous-entendus.

Il existe un outil de documentation gratuit appelé Doxygen. Bien qu'il ne supporte pas spécifiquement JavaScript, il peut générer une documentation professionnelle pour vos applications JavaScript lorsque vous utilisez les préfixes Doxygen dans vos commentaires. Il est très simple de créer des applications JavaScript avec de la documentation, tant pour les développeurs que pour les utilisateurs lorsque vous mettez un peu d'effort dans vos commentaires de code.

Rappelez-vous, il existe des outils qui peuvent supprimer les commentaires et des instructions de console pour les "versions de production". Cela étant dit, l'utilisation des cartes sources est également une perte de temps et de ressources. Ne minimisez pas jusqu'à ce que vous soyez prêt à publier .. ie Construire le Dev (pas de minification, conserver les commentaires et les consoles), Construire la version (supprimer les commentaires, et les consoles et réduire la version Dev. code de qualité, il suffit de le préparer pour la publication et de le déployer).


Chaque fois que vous voyez le mot-clé de fonction dans une autre fonction, la fonction interne a accès aux variables de la fonction externe.

function foo(x) {
  var tmp = 3;

  function bar(y) {
    console.log(x + y + (++tmp)); // will log 16
  }

  bar(10);
}

foo(2);

Cela consignera toujours 16, car bar peut accéder au x défini comme argument de foo et à tmp de foo .

C'est une fermeture. Une fonction n'a pas à retourner pour s'appeler une fermeture. Accéder simplement à des variables en dehors de votre portée lexicale immédiate crée une fermeture .

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + (++tmp)); // will also log 16
  }
}

var bar = foo(2); // bar is now a closure.
bar(10);

La fonction ci-dessus consignera également le journal 16, car bar peut toujours se référer à x et à tmp , même s’il ne se trouve plus directement dans la portée.

Cependant, étant donné que tmp traîne toujours à l'intérieur de la fermeture du bar , il est également incrémenté. Il sera incrémenté chaque fois que vous appelez bar .

L'exemple le plus simple d'une fermeture est le suivant:

var a = 10;

function test() {
  console.log(a); // will output 10
  console.log(b); // will output 6
}
var b = 6;
test();

Lorsqu'une fonction JavaScript est appelée, un nouveau contexte d'exécution est créé. Avec les arguments de la fonction et l'objet parent, ce contexte d'exécution reçoit également toutes les variables déclarées en dehors de celui-ci (dans l'exemple ci-dessus, les deux expressions "a" et "b").

Il est possible de créer plusieurs fonctions de fermeture, soit en renvoyant une liste de celles-ci, soit en les définissant comme variables globales. Tous feront référence au même x et au même tmp , ils ne font pas leurs propres copies.

Ici, le nombre x est un nombre littéral. Comme avec les autres littéraux en JavaScript, lorsque foo est appelé, le nombre x est copié dans foo tant qu'argument x .

D'autre part, JavaScript utilise toujours des références lorsqu'il traite des objets. Si par exemple, vous avez appelé foo avec un objet, la fermeture qu'il renvoie fera référence à cet objet d'origine!

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + tmp);
    x.memb = x.memb ? x.memb + 1 : 1;
    console.log(x.memb);
  }
}

var age = new Number(2);
var bar = foo(age); // bar is now a closure referencing age.
bar(10);

Comme prévu, chaque appel à la bar(10) incrémentera x.memb . Ce qui pourrait ne pas être attendu, c'est que x fait simplement référence au même objet que la variable age ! Après quelques appels au bar , age.memb sera 2! Ce référencement constitue la base des fuites de mémoire avec les objets HTML.





javascript oop backbone.js