Perché una variabile JavaScript dovrebbe iniziare con un simbolo di dollaro? [duplicare]

Vedo spesso JavaScript con variabili che iniziano con un segno di dollaro. Quando / perché dovresti scegliere di aggiungere un prefisso a una variabile in questo modo?

(Non sto chiedendo della $('p.foo')sintassi che vedi in jQuery e altri, ma variabili normali come $namee $order)

L'uso molto comune in jQuery è di distinguere gli oggetti jQuery memorizzati in variabili da altre variabili.

Ad esempio, definirei:

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

Trovo che ciò sia molto utile nella scrittura del codice jQuery e facilita la visualizzazione di oggetti jQuery che hanno un diverso set di proprietà.

Nella prima, seconda e terza edizione di ECMAScript , l'utilizzo di nomi di variabili prefissati in $ era esplicitamente scoraggiato dalle specifiche, tranne nel contesto del codice generato automaticamente:

Il simbolo del dollaro ( $) e il trattino basso ( _) sono consentiti ovunque in un identificatore. Il simbolo del dollaro è destinato esclusivamente all'uso nel codice generato meccanicamente.

Tuttavia, nella prossima versione (la 5a edizione , che è attuale), questa restrizione è stata abbandonata e il passaggio precedente è stato sostituito

Il simbolo del dollaro ( $) e il trattino basso ( _) sono consentiti ovunque in un IdentifierName .

Pertanto, il simbolo $ può ora essere utilizzato liberamente nei nomi delle variabili. Alcuni framework e librerie hanno le loro convenzioni sul significato del simbolo, annotate in altre risposte qui.

Come altri hanno già detto, il simbolo del dollaro deve essere utilizzato dal codice generato meccanicamente. Tuttavia, tale convenzione è stata infranta da alcune librerie JavaScript estremamente popolari. JQuery, Prototype e MS AJAX (AKA Atlas) usano tutti questo personaggio nei loro identificatori (o come un intero identificatore).

In breve, puoi usare il $quando vuoi. (L'interprete non si lamenterà.) La domanda è quando vuoi usarlo?

Personalmente non lo uso, ma penso che sia valido. Penso che MS AJAX lo usi per indicare che una funzione è un alias per qualche chiamata più dettagliata.

Per esempio:

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

Sembra una convenzione ragionevole.

Nel contesto di AngularJS, il $prefisso viene utilizzato solo per gli identificatori nel codice del framework. Agli utenti del framework viene richiesto di non utilizzarlo nei propri identificatori:

Spazi dei nomi angolari $e$$

Per evitare collisioni accidentali di nomi con il codice, Prefissi angolari indica nomi di oggetti pubblici $e nomi di oggetti privati ​​con $$. Non utilizzare il prefisso $o $$nel codice.

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

Ero la persona che ha dato origine a questa convenzione nel 2006 e l'ho promossa nella prima mailing list di jQuery, quindi vorrei condividere un po 'della storia e della motivazione che la circondano.

La risposta accettata fornisce questo esempio:

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

Ma questo non lo illustra davvero bene. Anche senza il $, avremmo comunque due nomi di variabili differenti qui emaile email_field. Va molto bene proprio lì. Perché dovremmo aggiungere a $uno dei nomi quando abbiamo già due nomi diversi?

In realtà, non avrei usato email_fieldqui per due motivi: names_with_underscoresnon sono JavaScript idiomatico e fieldnon ha davvero senso per un elemento DOM. Ma ho seguito la stessa idea.

Ho provato alcune cose diverse, tra cui qualcosa di molto simile all'esempio:

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

(Naturalmente un oggetto jQuery può avere più di un elemento DOM, ma il codice su cui stavo lavorando aveva molti idselettori, quindi in quei casi c'era una corrispondenza 1: 1.)

Ho avuto un altro caso in cui una funzione ha ricevuto un elemento DOM come parametro e ha anche bisogno di un oggetto jQuery per esso:

// 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
}

Bene, questo è un po 'confuso! In uno dei miei bit di codice, emailè l'oggetto jQuery ed emailElementè l'elemento DOM, ma nell'altro emailè l'elemento DOM ed emailJQè l'oggetto jQuery.

Non c'era coerenza e ho continuato a mescolarli. Inoltre, è stato un po 'fastidioso dover continuare a creare due nomi diversi per la stessa cosa: uno per l'oggetto jQuery e un altro per l'elemento DOM corrispondente. Inoltre email, emailElemente emailJQ, ho continuato a provare anche altre varianti.

Poi ho notato uno schema comune:

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

Dato che JavaScript tratta $semplicemente un'altra lettera per i nomi e dato che da una $(whatever)chiamata ho sempre ricevuto un oggetto jQuery , il modello mi è finalmente apparso. Potrei rispondere a una $(...)chiamata e rimuovere solo alcuni caratteri, e sarebbe venuto fuori con un bel nome:

$("#email")
$(email)

Strikeout non è perfetto, ma potresti avere l'idea: con alcuni caratteri eliminati, entrambe le linee finiscono per apparire come:

$email

Fu allora che mi resi conto che non avevo bisogno di inventare una convention come emailElemento emailJQ. C'era già una simpatica convention che mi fissava: prendi alcuni personaggi da una $(whatever)chiamata e si trasforma in $whatever.

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

e:

// 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!
}

Quindi non ho dovuto inventarmi sempre due nomi diversi, ma potevo semplicemente usare lo stesso nome con o senza $prefisso. E il $prefisso mi ha ricordato che avevo a che fare con un oggetto jQuery:

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

o:

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

Stevo ha ragione, il significato e l'uso del segno del dollaro (in Javascript e nella piattaforma jQuery, ma non in PHP) è completamente semantico. $ è un carattere che può essere utilizzato come parte del nome di un identificatore. Inoltre, il simbolo del dollaro non è forse la cosa più "strana" che puoi incontrare in Javascript. Ecco alcuni esempi di nomi identificativi validi:

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

Tutti gli esempi sopra funzioneranno.

Provali.

Il carattere $ non ha alcun significato speciale per il motore JavaScript. È solo un altro carattere valido in un nome variabile come az, AZ, _, 0-9, ecc ...

Dal momento che _all'inizio di un nome di variabile viene spesso utilizzato per indicare una variabile privata (o almeno una destinata a rimanere privata), trovo $conveniente per aggiungere davanti ai miei brevi alias a librerie di codici generici.

Ad esempio, quando utilizzo jQuery, preferisco usare la variabile $J (anziché solo $) e usare $Pquando si usa php.js, ecc.

Il prefisso lo rende visivamente distinto da altre variabili come le mie variabili statiche, indicandomi nel fatto che il codice fa parte di qualche libreria o altro, ed è meno probabile che sia in conflitto o confonda gli altri una volta che conoscono la convenzione.

Inoltre, non ingombra il codice (o non richiede una digitazione aggiuntiva) come un nome completamente specificato ripetuto per ogni chiamata in libreria.

Mi piace pensarlo come simile a quello che fanno i tasti modificatori per espandere le possibilità dei singoli tasti.

Ma questa è solo la mia convenzione.

Come ho sperimentato negli ultimi 4 anni, permetterà a qualcuno di identificare facilmente se la variabile che punta un valore / oggetto o un elemento DOM avvolto jQuery

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

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

nell'esempio sopra quando vedo la variabile "$ dataDiv" posso facilmente dire che questa variabile punta a un elemento DOM avvolto jQuery (in questo caso è div). e posso anche chiamare tutti i metodi jQuery senza ricoprire l'oggetto come $ dataDiv.append (), $ dataDiv.html (), $ dataDiv.find () invece di $ ($ dataDiv) .append ().

Spero che possa essere d'aiuto. quindi finalmente voglio dire che sarà una buona pratica seguire questo ma non obbligatorio.

${varname} è solo una convenzione di denominazione utilizzata dagli sviluppatori jQuery per distinguere le variabili che contengono elementi jQuery.

Plain {varname}è usato per archiviare cose generali come testi e stringhe. ${varname}contiene elementi restituiti da jQuery.

Puoi usare anche plain {varname}per memorizzare elementi jQuery, ma come ho detto all'inizio questo lo distingue dalle variabili semplici e rende molto più facile la comprensione (immagina di confonderlo per una variabile semplice e di cercare dappertutto per capire cosa contiene) .

Per esempio :

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

Qui, blah sta memorizzando un elemento jQuery restituito.

Quindi, quando qualcun altro vede il $blahcodice, capirà che non è solo una stringa o un numero, è un elemento jQuery.

Mentre puoi semplicemente usarlo per aggiungere il prefisso ai tuoi identificatori, dovrebbe essere usato per il codice generato, come ad esempio i token di sostituzione in un modello.

Gli usi angolari sono per le proprietà generate dal framework. Indovina, stanno seguendo il suggerimento (ora defunto) fornito dall'ECMA-262 3.0.

$ viene utilizzato per distinguere tra variabili comuni e variabili jquery in caso di variabili normali. ti consente di effettuare un ordine in FLIPKART, quindi se l'ordine è una variabile che ti mostra l'output della stringa, allora viene chiamato semplice come "ordine" ma se facciamo clic sull'ordine del posto, viene restituito un oggetto che verrà indicato da $ come "$ ordine "in modo che il programmatore sia in grado di estrarre le variabili javascript e le variabili jquery nell'intero codice.

Se vedi il simbolo del dollaro ($) o il doppio simbolo del dollaro ($$) e sei curioso di sapere cosa significhi nel framework Prototype, ecco la tua risposta:

$$('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'

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

Il motivo per cui a volte utilizzo convenzioni di nomi php con variabili javascript: quando eseguo la convalida dell'input, voglio eseguire gli stessi identici algoritmi sia sul lato client che sul lato server. Voglio davvero che le due parti del codice siano il più simili possibile, per semplificare la manutenzione. L'uso del simbolo del dollaro nei nomi delle variabili rende tutto più semplice.

(Inoltre, alcune funzioni di supporto giudiziose aiutano a rendere il codice simile, ad esempio il wrapping di ricerche di valori di input, versioni non OO di strlen, substr, ecc. Tuttavia richiede comunque alcune modifiche manuali.)

Un shuold identificatore JavaScript valido deve iniziare con una lettera, un trattino basso (_) o un segno di dollaro ($); i caratteri successivi possono anche essere cifre (0-9). Poiché JavaScript fa distinzione tra maiuscole e minuscole, le lettere includono i caratteri da "A" a "Z" (lettere maiuscole) e i caratteri da "a" a "z" (lettere minuscole).

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