Pourquoi une variable JavaScript commencerait-elle par un signe dollar?

dans la 1ère, 2ème, et dans la 3ème édition D'ECMAScript , en utilisant des noms de variables préfixés par $a été explicitement découragé par le spec sauf dans le contexte du code autogénéré:

le signe du dollar ( $ ) et le trait de soulignement ( _ ) sont autorisés à n'importe quel endroit d'un identificateur. Le signe dollar est destiné à être utilisé uniquement en code généré mécaniquement.

cependant, dans la version suivante (le 5ème Édition , qui est en cours), cette restriction a été supprimée, et le passage ci-dessus remplacé par

le signe du dollar ( $ ) et le trait de soulignement ( _ ) sont permis n'importe où dans un nom D'identification .

en tant que tel, le signe $ peut maintenant être utilisé librement dans les noms variables. Certains cadres et bibliothèques ont leurs propres conventions sur le sens de la symbole, a noté dans d'autres réponses ici.

Comme d'autres l'ont mentionné, le signe dollar est destiné à être utilisé par mécaniquement le code généré. Cependant, cette convention a été enfreinte par certaines bibliothèques JavaScript follement populaires. JQuery, Prototype et MS AJAX (alias Atlas) utilisent tous ce caractère dans leurs identificateurs (ou comme un identifiant complet).

en bref, vous pouvez utiliser le $ quand vous voulez. (L'interprète de ne pas se plaindre.) La question Est de savoir quand veut à l'utiliser?

personnellement, je ne l'utilise pas, mais je pense que son utilisation est valide. Je pense que MS AJAX l'utilise pour signifier qu'une fonction est un alias pour un appel plus verbeux.

par exemple:

var $get = function(id) { return document.getElementById(id); }

cela semble être une convention raisonnable.

dans le contexte D'AngularJS, le préfixe $ n'est utilisé que pour les identificateurs dans le code du framework. Les utilisateurs sont avisés de ne pas l'utiliser dans leurs propres identifiants:

espaces-noms angulaires $ et $$

pour prévenir les collisions accidentelles de noms avec votre code, préfixes angulaires noms d'objets publics avec $ et noms d'objets privés avec $$ . Merci n'utilisez pas le préfixe $ ou $$ dans votre code.

Source: https://docs.angularjs.org/api

Stevo a raison, la signification et l'utilisation du signe dollar script (en Javascript et la plate-forme jQuery, mais pas en PHP) est complètement sémantique. $ est un personnage qui peut être utilisé comme partie d'un nom d'identificateur. En outre, le signe dollar n'est peut-être pas la chose la plus "bizarre" que vous pouvez rencontrer dans Javascript. Voici quelques exemples de noms d'identificateurs valides:

var _       = function() { alert("hello from _"); }
var \u0024  = function() { alert("hello from $ defined as u0024"); }
var Ø       = function() { alert("hello from Ø"); }
var $$$$$   = function() { alert("hello from $$$$$"); }

tous les exemples ci-dessus fonctionneront.

essayez-les.

j'ai été la personne qui a créé cette convention en 2006 et l'a promue sur la première liste de diffusion de jQuery, alors permettez-moi de partager une partie de l'histoire et de la motivation autour de lui.

la réponse acceptée donne cet exemple:

var $email = $("#email"); // refers to the jQuery object representation of the dom object
var email_field = $("#email").get(0); // refers to the dom object itself

mais cela ne l'illustre pas vraiment bien. Même sans le $ , nous aurions encore ici deux noms de variables différentes, email et email_field . C'est beaucoup de bon droit y. Pourquoi aurions-nous besoin de lancer une $ dans l'un des noms que nous avons déjà deux noms différents?

en fait, je n'aurais pas utilisé email_field ici pour deux raisons: names_with_underscores ne sont pas JavaScript idiomatique, et field n'a pas vraiment de sens pour un élément DOM. Mais j'ai fait suivre la même idée.

j'ai essayé quelques choses différentes, parmi lesquelles quelque chose de très similaire à l'exemple:

var email = $("#email"), emailElement = $("#email")[0];
// Now email is a jQuery object and emailElement is the first/only DOM element in it

(bien sûr, un objet jQuery peut avoir plus d'un élément DOM, mais le code sur lequel je travaillais avait beaucoup de sélecteurs id , donc dans ces cas il y avait une correspondance 1:1.)

j'ai eu un autre cas où une fonction a reçu un élément DOM comme paramètre et avait aussi besoin d'un objet jQuery pour cela:

// email is a DOM element passed into this function
function doSomethingWithEmail( email ) {
    var emailJQ = $(email);
    // Now email is the DOM element and emailJQ is a jQuery object for it
}

Eh bien c'est un peu confus! Dans un de mes bits de code, email est l'objet jQuery et emailElement est l'élément du DOM, mais dans l'autre email est l'élément DOM et emailJQ est l'objet jQuery.

il n'y avait pas de consistance et je n'arrêtais pas de les mélanger. De plus, c'était un peu gênant de devoir continuer à composer deux noms différents pour la même chose: un pour l'objet jQuery et un autre pour L'élément DOM correspondant. Outre email , emailElement , et emailJQ , j'ai continué à essayer d'autres variations aussi.

Alors Je

var email = $("#email");
var emailJQ = $(email);

comme JavaScript traite $ comme une simple autre lettre pour les noms, et comme j'ai toujours reçu un objet jQuery de retour d'un appel $(whatever) , le modèle finalement m'est apparu. Je pourrais prendre un appel $(...) et juste enlever quelques caractères, et il viendrait avec un joli nom:

$("#email")
$(email)

Strikeout n'est pas parfait, mais vous pouvez avoir l'idée: avec certains caractères supprimés, à la fois de ces lignes finissent par ressembler à:

$email

c'est alors que j'ai réalisé que je n'avais pas besoin de faire une convention comme emailElement ou emailJQ . Il y avait déjà une belle convention qui me fixait: prenez quelques personnages d'un appel $(whatever) et il se transforme en $whatever .

var $email = $("#email"), email = $email[0];
// $email is the jQuery object and email is the DOM object

et:

// email is a DOM element passed into this function
function doSomethingWithEmail( email ) {
    var $email = $(email);
    // $email is the jQuery object and email is the DOM object
    // Same names as in the code above. Yay!
}

Donc je n'ai pas eu à faire jusqu'à deux noms différents tout le temps, mais pourrait utiliser le même nom avec ou sans préfixe $ . Et le préfixe $ était un joli rappel que j'avais affaire à un objet jQuery:

$('#email').click( ... );

ou:

var $email = $('#email');
// Maybe do some other stuff with $email here
$email.click( ... );

Le caractère $ n'a pas de signification particulière pour le moteur JavaScript. C'est juste un autre caractère valide dans un nom de variable comme A-z, A-Z, _, 0-9, etc...

puisque _ au début d'un nom de variable est souvent utilisé pour indiquer une variable privée (ou au moins une destinée à rester privée), je trouve $ pratique pour ajouter en face de mes propres pseudonymes à des bibliothèques de codes génériques.

par exemple, en utilisant jQuery, je préfère utiliser la variable $J (au lieu de juste $ ) et utiliser $P en utilisant php.js, etc.

le préfixe le rend visuellement distinct d'autres variables telles que mes propres variables statiques, ce qui me fait comprendre que le code fait partie d'une bibliothèque ou d'une autre, et est moins susceptible d'entrer en conflit ou de confondre d'autres une fois qu'ils connaissent la convention.

il n'embrouille pas non plus le code (ou ne nécessite pas de Dactylographie supplémentaire) comme le fait un nom complètement spécifié répété pour chaque appel de bibliothèque.

j'aime à penser qu'il est similaire à ce que les touches modificatrices font pour étendre les possibilités de des touches uniques.

mais c'est juste ma propre convention.

comme je l'ai vécu pendant les 4 dernières années, il permettra à quelqu'un d'identifier facilement si la variable pointant une valeur / objet ou un élément jQuery enveloppé DOM

Ex:
var name = 'jQuery';
var lib = {name:'jQuery',version:1.6};

var $dataDiv = $('#myDataDiv');

dans l'exemple ci-dessus quand je vois la variable" $dataDiv " je peux facilement dire que cette variable pointant vers un élément jQuery wrapped DOM (dans ce cas c'est div). et aussi, je peux appeler toutes les méthodes jQuery avec habillage de l'objet comme $ dataDiv.annexe (), $dataDiv.html (), $dataDiv.find () au lieu de $($dataDiv).annexer.)(

J'espère que ça peut aider. enfin, je voudrais dire que ce sera une bonne pratique de suivre cette procédure, mais qu'elle n'est pas obligatoire.

alors que vous pouvez simplement l'utiliser pour préfixer vos identificateurs, il est censé être utilisé pour le code généré, comme des jetons de remplacement dans un modèle, par exemple.

${varname} est juste une convention de nommage que les développeurs jQuery utilisent pour distinguer les variables qui contiennent des éléments jQuery.

Plain {varname} est utilisé pour stocker des articles généraux comme des textes et des cordes. ${varname} contient des éléments retournés de jQuery.

vous pouvez utiliser simple {varname} pour stocker des éléments jQuery aussi bien, mais comme je l'ai dit au début ce qui le distingue des variables simples et rend beaucoup plus facile à comprendre (imaginez la confondre avec une simple variable et chercher partout pour comprendre ce qu'elle contient).

par exemple:

var $blah = $(this).parents('.blahblah');

ici, blah stocke un élément jQuery retourné.

donc, quand quelqu'un d'autre voit le $blah dans le code, ils comprendront que ce n'est pas juste une chaîne ou un nombre, c'est un élément jQuery.

Angulaire utilise est pour les propriétés générées par le cadre. Devinez, ils vont par le (maintenant défunte) indice fourni par L'ECMA-262 3.0.

$ est utilisé pour distinguer entre les variables communes et les variables jquery dans le cas de variables normales. laissez-vous placer une commande dans FLIPKART puis si l'ordre est une variable vous montrant la sortie de chaîne alors il est nommé simple comme "ordre" mais si nous cliquons sur l'ordre de place puis un objet est retourné que l'objet sera dénoté par $ comme "$ordre" de sorte que le programmeur peut couper les variables javascript et les variables jquery dans le code entier.

si vous voyez le signe dollar ( $ ) ou le signe double dollar ( $ $ ), et que vous êtes curieux de savoir ce que cela signifie dans le cadre du Prototype, voici votre réponse:

$$('div');
// -> all DIVs in the document.  Same as document.getElementsByTagName('div')!

$$('#contents');
// -> same as $('contents'), only it returns an array anyway (even though IDs must be unique within a document).

$$('li.faux');
// -> all LI elements with class 'faux'

Source:

http://www.prototypejs.org/api/utility/dollar-dollar

la raison pour laquelle j'utilise parfois des conventions de noms php avec des variables javascript: Lors de la validation des entrées, je veux exécuter exactement les mêmes algorithmes côté client, et côté serveur. Je veux vraiment que les deux côtés du code se ressemblent le plus possible, pour simplifier la maintenance. L'utilisation de signes en dollars dans les noms de variables rend cela plus facile.

(en outre, certaines fonctions d'aide judicieuses aident à faire paraître le code similaire, par exemple enrubannage de recherche de valeurs d'entrée, des versions non-OO de strlen, substr, etc. Il nécessite encore quelques réglages.)

un identifiant JavaScript valide shuold doit commencer par une lettre, trait de soulignement ( _ ), ou signe du dollar ($); les caractères suivants peuvent également être des chiffres (0-9). Parce que JavaScript est sensible à la casse, lettre inclure les caractères "A" à "Z" ( majuscule) et caractères " a "à" z " (minuscules).

détails:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Grammar_and_types#Variables