¿Por qué una variable JavaScript comenzaría con un signo de dólar?

En la 1ª, 2ª y 3ª Edición de ECMAScript, el uso de nombres de variables con prefijo $fue explícitamente desaconsejado por la especificación, excepto en el contexto del código autogenerado:

El signo de dólar ($) y el subrayado (_) se permiten en cualquier lugar de un identificador. El signo de dólar está destinado a ser utilizado solo en código generado mecánicamente.

Sin embargo, en la siguiente versión (la 5a Edición, que es actual), esta restricción fue eliminada, y el el pasaje anterior se sustituye por

El signo de dólar ($) y el subrayado (_) se permiten en cualquier lugar de un IdentifierName.

Como tal, el signo $ ahora se puede usar libremente en nombres de variables. Ciertos frameworks y bibliotecas tienen sus propias convenciones sobre el significado del símbolo, anotadas en otras respuestas aquí.

Como otros han mencionado, el signo de dólar está destinado a ser utilizado por código generado mecánicamente. Sin embargo, esa convención ha sido rota por algunas bibliotecas JavaScript muy populares. jQuery, Prototype y MS AJAX (TAMBIÉN conocido como Atlas) usan este carácter en sus identificadores (o como un identificador completo).

En resumen, puedes usar $ cuando quieras. (El intérprete no se quejará.) La pregunta es ¿cuándo quieres usarlo?

Yo personalmente no lo uso, pero creo que su uso es válido. Creo que MS AJAX lo usa para significar que una función es un alias para una llamada más detallada.

Por ejemplo:

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

Eso parece una convención razonable.

En el contexto de AngularJS, el prefijo $ se usa solo para identificadores en el código del framework. Los usuarios del framework reciben instrucciones de no usarlo en sus propios identificadores:

Espacios de nombres angulares $ y $$

Para evitar colisiones accidentales de nombres con su código, Angular prefigura los nombres de objetos públicos con $ y los nombres de objetos privados con $$. Por favor, no utilice el prefijo $ o $$ en su código.

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

Stevo tiene razón, el significado y uso del signo de script dollar (en Javascript y la plataforma jQuery, pero no en PHP) es completamente semántico. $ es un carácter que se puede usar como parte de un nombre de identificador. Además, el signo de dólar quizás no sea la cosa más" extraña " que pueda encontrar en Javascript. Estos son algunos ejemplos de nombres de identificación válidos:

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

Todos los ejemplos anteriores funcionarán.

Pruébalos.

Fui la persona que originó esta convención en 2006 y la promovió en la lista de correo temprana de jQuery, así que permítanme compartir algo de la historia y la motivación alrededor de ella.

La respuesta aceptada da este ejemplo: {[35]]}

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

Pero eso realmente no lo ilustra bien. Incluso sin el $, todavía tendríamos dos nombres de variables diferentes aquí, email y email_field. Eso está muy bien ahí. ¿Por qué tendríamos que tirar un $ en uno de los nombres cuando ¿ya tienes dos nombres diferentes?

En realidad, no habría usado email_field aquí por dos razones: names_with_underscores no son JavaScript idiomático, y field realmente no tiene sentido para un elemento DOM. Pero seguí la misma idea.

Probé algunas cosas diferentes, entre ellas algo muy similar al ejemplo:{[35]]}

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

(Por supuesto, un objeto jQuery puede tener más de un elemento DOM, pero el código en el que estaba trabajando tenía muchos selectores id, por lo que en esos casos había una correspondencia 1:1.)

Tuve otro caso en el que una función recibía un elemento DOM como parámetro y también necesitaba un objeto jQuery para ello:

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

Bueno, eso es un poco confuso! En uno de mis bits de código, email es el objeto jQuery y emailElement es el elemento DOM, pero en el otro, email es el elemento DOM y emailJQ es el objeto jQuery.

No había consistencia y seguí mezclándolos. Además, era un poco molesto seguir teniendo que hacer dos diferentes nombres para la misma cosa: uno para el objeto jQuery y otro para el elemento DOM coincidente. Además email, emailElement, y emailJQ, seguí probando otras variaciones también.

Entonces noté un patrón común:{[35]]}

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

Dado que JavaScript trata a $ como simplemente otra letra para los nombres, y dado que siempre recibí un objeto jQuery de vuelta de una llamada $(whatever), el patrón finalmente se me ocurrió. Podría tomar una llamada $(...) y simplemente eliminar algunos caracteres, y se le ocurriría un nombre bastante bonito:

$("#email")
$(email)

Strikeout no es perfecto, pero puede hacerse una idea: con algunos caracteres eliminados, ambas líneas terminan pareciéndose a:

$email

Fue entonces cuando me di cuenta de que no necesitaba hacer una convención como emailElement o emailJQ. Ya había una bonita convención mirándome fijamente: tomar algunos personajes de una llamada $(whatever) y se convierte en $whatever.

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

Y:

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

Así que no tuve que inventar dos nombres diferentes todo el tiempo, pero pude simplemente use el mismo nombre con o sin un prefijo $. Y el prefijo $ fue un buen recordatorio de que estaba tratando con un objeto jQuery:

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

O:

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

El carácter $ no tiene un significado especial para el motor JavaScript. Es solo otro carácter válido en un nombre de variable como a-z, A-Z,_, 0-9, etc...

Dado que _ al principio de una variable se usa a menudo para indicar una variable privada (o al menos una destinada a permanecer privada), encuentro que $ es conveniente agregar delante de mis propios alias breves a bibliotecas de código genérico.

Por ejemplo, cuando uso jQuery, prefiero usar la variable $J (en lugar de solo $) y usar $P cuando uso php.js, etc.

El prefijo lo hace visualmente distinto de otras variables, como mis propias variables estáticas, me cluing en el hecho de que el código es parte de una biblioteca u otra, y es menos probable que entre en conflicto o confunda a otros una vez que conocen la convención.

Tampoco desordena el código (o requiere tecleo adicional), al igual que un nombre completamente especificado repetido para cada llamada a la biblioteca.

Me gusta pensar que es similar a lo que hacen las teclas modificadoras para expandir las posibilidades de las teclas individuales.

Pero esto es solo mi propia convención.

Como he experimentado durante los últimos 4 años, permitirá a alguien identificar fácilmente si la variable que apunta a un valor/objeto o un elemento DOM envuelto en jQuery

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

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

En el ejemplo anterior cuando veo la variable "dat dataDiv" puedo decir fácilmente que esta variable apunta a un elemento DOM envuelto en jQuery (en este caso es div). y también puedo llamar a todos los métodos jQuery sin envolver el objeto de nuevo como dat dataDiv.append (), dat dataDiv.HTML(), dat dataDiv.find () en lugar de dat (dat dataDiv).anexar().

Espero que pueda ayudar. así que finalmente quiero decir que será una buena práctica seguir esto, pero no obligatorio.

Si bien puede usarlo simplemente para prefijar sus identificadores, se supone que debe usarse para el código generado, como los tokens de reemplazo en una plantilla, por ejemplo.

${varname} es solo una convención de nomenclatura que usan los desarrolladores de jQuery para distinguir las variables que contienen elementos de jQuery.

Plain {varname} se utiliza para almacenar materias generales como textos y cadenas. ${varname} contiene elementos devueltos desde jQuery.

Puede usar plain {varname} para almacenar elementos jQuery también, pero como dije al principio, esto lo distingue de las variables plain y lo hace mucho más fácil de entender (imagine confundirlo con una variable plain y buscar en todo entender lo que contiene).

Por ejemplo:

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

Aquí, blah está almacenando un elemento jQuery devuelto.

Entonces, cuando alguien más vea el $blah en el código, entenderán que no es solo una cadena o un número, es un elemento jQuery.

Angular uses es para propiedades generadas por el framework. Adivina, van por la (ahora desaparecida) pista proporcionada por el ECMA-262 3.0.

$ se usa para DISTINGUIR entre variables comunes y variables jquery en el caso de variables normales. le permite colocar un orden en FLIPKART luego, si el orden es una variable que muestra la salida de la cadena, entonces se llama simple como "order", pero si hacemos clic en place order, se devuelve un objeto que se denotará por object como" order order " para que el programador pueda cortar las variables javascript y las variables jquery en todo el código.

Si ve el signo de dólar ($) o el signo de dólar doble (double), y siente curiosidad por lo que esto significa en el marco del prototipo, aquí está su respuesta:

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

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

La razón por la que a veces uso nombres php-convenciones con variables javascript: Al hacer la validación de entrada, quiero ejecutar los mismos algoritmos tanto en el lado del cliente, y del lado del servidor. Realmente quiero que los dos lados del código se vean lo más similares posible, para simplificar el mantenimiento. El uso de signos de dólar en nombres de variables hace que esto sea más fácil.

(Además, algunas funciones de ayuda juiciosas ayudan a hacer que el código se vea similar, por ejemplo, empaquetando búsquedas de valores de entrada, versiones no OO de strlen, substr, etc. Se sin embargo, todavía requiere algunos ajustes manuales.)

Un identificador JavaScript válido shuold debe comenzar con una letra, subrayado ( _ ), o signo de dólar ($); los caracteres posteriores también pueden se dígitos (0-9). Porque JavaScript distingue entre mayúsculas y minúsculas, carta incluir los caracteres " A "a" Z " (mayúsculas) y el caracteres " a " a " z " (minúsculas).

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