Perché una variabile JavaScript dovrebbe iniziare con un segno di dollaro?

Molto spesso vedo JavaScript con variabili che iniziano con un segno di dollaro. Quando / perché sceglieresti come prefisso una variabile in questo modo?

(Non sto chiedendo la syntax $('p.foo') che vedi in jQuery e altri, ma variabili normali come $name e $order )

Un uso molto comune in jQuery è quello 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 questo sia molto utile nella scrittura del codice jQuery e rende facile vedere oggetti jQuery che hanno un diverso insieme di proprietà.

Nella 1a, 2a e 3a edizione di ECMAScript , l’uso dei nomi delle variabili $ -prefixed è stato esplicitamente scoraggiato dalla specifica tranne nel contesto del codice generato automaticamente:

Il simbolo del dollaro ( $ ) e il carattere di sottolineatura ( _ ) sono consentiti ovunque in un identificatore. Il simbolo del dollaro è destinato all’uso solo nel codice generato meccanicamente.

Tuttavia, nella prossima versione (la 5th Edition , che è attuale), questa restrizione è stata eliminata e il passaggio sopra sostituito con

Il simbolo di dollaro ( $ ) e il carattere di sottolineatura ( _ ) sono consentiti ovunque in un IdentifierName .

Come tale, il segno $ può ora essere usato liberamente nei nomi delle variabili. Certi quadri e biblioteche hanno le loro convenzioni sul significato del simbolo, annotato in altre risposte qui.

Come altri hanno menzionato, il simbolo del dollaro è destinato ad essere usato dal codice generato meccanicamente. Tuttavia, tale convenzione è stata interrotta da alcune librerie JavaScript molto popolari. JQuery, Prototype e MS AJAX (AKA Atlas) usano tutti questo carattere nei loro identificatori (o come un intero identificatore).

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

Io personalmente non lo uso, ma penso che il suo uso sia valido. Penso che MS AJAX lo usi per significare che una funzione è un alias per qualche chiamata più prolissa.

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 di nomi accidentali con il tuo codice, i prefissi angolari prefissano nomi di oggetti pubblici con $ e nomi di oggetti privati ​​con $$ . Si prega di non utilizzare il prefisso $ o $$ nel codice.

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

Stevo ha ragione, il significato e l’uso del segno dello script del dollaro (in Javascript e nella piattaforma jQuery, ma non in PHP) è completamente semantico. $ è un carattere che può essere usato come parte di un nome identificativo. 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.

Provale.

Ero la persona che ha creato questa convenzione nel 2006 e l’ho promossa nella prima mailing list di jQuery, quindi lasciatemi condividere parte della storia e delle motivazioni che la circondano.

La risposta accettata dà 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 $ , avremmo ancora due diversi nomi di variabili qui, email e email_field . Questo è molto buono proprio lì. Perché dovremmo buttare un $ in uno dei nomi quando abbiamo già due nomi diversi?

In realtà, non avrei usato email_field qui per due motivi: i names_with_underscores non sono JavaScript idiomatici, e il field non 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 

(Ovviamente un object jQuery può avere più di un elemento DOM, ma il codice su cui stavo lavorando aveva molti selettori di id , 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 aveva anche bisogno di un object jQuery per questo:

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

Beh, questo è un po ‘di confusione! In uno dei miei bit di codice, la email è l’object jQuery e emailElement è l’elemento DOM, ma nell’altra la email è l’elemento DOM e emailJQ è l’object jQuery.

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

Poi ho notato un modello comune:

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

Dal momento che JavaScript considera $ semplicemente come un’altra lettera per i nomi, e dal momento che ho sempre ottenuto un object jQuery da una chiamata $(whatever) , il pattern finalmente mi è apparso. Potrei prendere una chiamata $(...) e rimuovere solo alcuni caratteri, e mi viene in mente un bel nome:

$   ( "#   e-mail   ") 
$   (   e-mail   ) 

Strikeout non è perfetto, ma potresti avere l’idea: con alcuni personaggi cancellati, entrambe le righe finiscono per apparire come:

 $email 

In quel momento ho capito che non avevo bisogno di creare una convention come emailElement o emailJQ . C’era già una bella convention che mi fissava: prendi alcuni personaggi da una chiamata $(whatever) 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 dovevo inventare due nomi diversi per tutto il tempo, ma potevo semplicemente usare lo stesso nome con o senza un prefisso $ . E il prefisso $ era un bel promemoria del fatto che avevo a che fare con un object jQuery:

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

o:

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

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

Poiché _ all’inizio di un nome di variabile viene spesso usato per indicare una variabile privata (o almeno una destinata a rimanere privata), trovo $ conveniente per aggiungere di fronte ai miei brevi alias alle librerie di codice generiche.

Ad esempio, quando si usa jQuery, preferisco usare la variabile $J (invece di solo $ ) e usare $P quando si usa php.js, ecc.

Il prefisso lo rende visivamente distinto da altre variabili come le mie variabili statiche, facendomi capire che il codice fa parte di una libreria o di un’altra ed è meno probabile che possa confondere o confondere gli altri una volta che conoscono la convenzione.

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

Mi piace pensare che sia simile a ciò che i tasti modificatori fanno per espandere le possibilità delle singole chiavi.

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 / object o un elemento DOM avvolto da jQuery

 Ex: var name = 'jQuery'; var lib = {name:'jQuery',version:1.6}; var $dataDiv = $('#myDataDiv'); 

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

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

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

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

Per esempio :

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

Qui, blah sta memorizzando un elemento jQuery restituito.

Quindi, quando qualcun altro vede il $blah nel codice, capirà che non si tratta solo di una stringa o di un numero, è un elemento jQuery.

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

$ è usato 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, viene chiamato semplice “ordine”, ma se facciamo clic sull’ordine posto viene restituito un object che verrà indicato con $ come “$ ordine “in modo che il programmatore possa 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 significa questo 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

La ragione per cui a volte uso le convenzioni dei nomi php con le variabili javascript: quando si esegue la convalida dell’input, voglio eseguire esattamente gli stessi algoritmi sia lato client che lato server. Voglio davvero che le due parti del codice siano il più simili ansible, per semplificare la manutenzione. Usare i simboli del dollaro nei nomi delle variabili lo rende più facile.

(Inoltre, alcune sapienti funzioni di aiuto aiutano a rendere il codice simile, ad es. Avvolgendo ricerche di valori di input, versioni non OO di strlen, substr, ecc. Tuttavia richiede ancora un po ‘di regolazione manuale.)

Un identificatore JavaScript valido shuold deve iniziare con una lettera, un carattere di sottolineatura (_) 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” (maiuscolo) ei caratteri da “a” a “z” (lettere minuscole).

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