w3schools style practices method guide camelcase best javascript naming-conventions

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



javascript method init (16)

A menudo veo JavaScript con variables que comienzan con un signo de dólar. ¿Cuándo / por qué elegirías prefijar una variable de esta manera?

(No pregunto por la sintaxis de $(''p.foo'') que ves en jQuery y otros, pero las variables normales como $name y $order )

$ se usa para DISTINGUIR entre variables comunes y variables de jQuery en el caso de variables normales. le permite hacer un pedido en FLIPKART y luego, si el orden es una variable que le muestra el resultado de la cadena, se denomina simple como "orden" pero si hacemos clic en orden de lugar, se devuelve un objeto, ese objeto se denota con $ como "$ orden "para que el programador pueda cortar las variables javascript y las variables jquery en todo el código.

Como he experimentado durante los últimos 4 años, permitirá a alguien identificar fácilmente si la variable señala 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 "$ 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 volver a envolver el objeto como $ dataDiv.append (), $ dataDiv.html (), $ dataDiv.find () en lugar de $ ($ dataDiv) .append ().

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

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

En resumen puedes usar el $ 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 indicar 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.

Dado que _ al comienzo de una variable, el nombre a menudo se usa para indicar una variable privada (o al menos una que pretende seguir siendo privada), me parece conveniente $ para agregar delante de mis propios alias breves a las bibliotecas de códigos genéricos.

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, y me confirma el hecho de que el código es parte de una biblioteca u otra, y es menos probable que entre en conflicto o confunda con otras una vez que conozcan la convención.

Tampoco desordena el código (ni requiere que se escriba más) al igual que un nombre completamente especificado que se repite para cada llamada a la biblioteca.

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

Pero esto es sólo mi propia convención.

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

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

Espacios $ nombres angulares $ y $$

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

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

En la 1ª, 2ª y 3ª edición de ECMAScript , el uso de nombres de variables prefijados con $ $ fue explícitamente desaconsejado por la especificación, excepto en el contexto del código generado automáticamente:

El signo de dólar ( $ ) y el guión bajo ( _ ) están permitidos en cualquier parte en un identificador. El signo de dólar está destinado para uso exclusivo en código generado mecánicamente.

Sin embargo, en la próxima versión (la 5ª edición , que es actual), esta restricción se eliminó y el pasaje anterior se reemplazó con

El signo de dólar ( $ ) y el guión bajo ( _ ) están permitidos en cualquier parte de un Nombre de identificador .

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

Fui la persona que originó esta convención en 2006 y la promocioné en la primera lista de correo de jQuery, así que permítame compartir parte de la historia y la motivación que la rodea.

La respuesta aceptada da este ejemplo:

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 es bastante bueno allí mismo. ¿Por qué tendríamos que agregar un $ en uno de los nombres cuando ya tenemos dos nombres diferentes?

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

Probé algunas cosas diferentes, entre ellas algo muy similar al ejemplo:

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 de id , por lo que en esos casos había una correspondencia 1: 1).

Tuve otro caso en el que una función recibió 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, el email es el objeto jQuery y emailElement es el elemento DOM, pero en el otro, el 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 tener que inventar dos nombres diferentes para la misma cosa: uno para el objeto jQuery y otro para el elemento DOM correspondiente. Además de email , emailElement y emailJQ , también emailJQ otras variaciones.

Entonces noté un patrón común:

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

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

$("#email") $(email)

Strikeout no es perfecto, pero puedes tener una idea: con algunos caracteres eliminados, ambas líneas se ven como:

$email

Fue entonces cuando me di cuenta de que no tenía que inventar una convención como emailElement o emailJQ . Ya había una buena convención mirándome: tomar algunos personajes de una llamada de $(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, solo podía usar el mismo nombre con o sin el 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( ... );

La razón por la que a veces uso las convenciones de nombres de php con variables de javascript: al realizar la validación de entrada, quiero ejecutar exactamente los mismos algoritmos del 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 facilita esto.

(Además, algunas funciones de ayuda juiciosas ayudan a que el código tenga un aspecto similar, por ejemplo, ajuste de las búsquedas de valor de entrada, versiones de OO de Strlen, substr, etc. que aún requieren algunos ajustes manuales).

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

Si ve el signo de dólar ($) o el signo de dólar doble ($$), y siente curiosidad por lo que esto significa en el marco de 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

Stevo tiene razón, el significado y el uso del signo de dólar (en Javascript y en 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 tal vez no sea lo más "raro" que puede encontrar en Javascript. Aquí hay algunos ejemplos de nombres de identificadores 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.

Un uso muy común en jQuery es distinguir los objetos jQuery almacenados en variables de otras variables. Por ejemplo, yo definiría

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

Considero que esto es muy útil para escribir el código jQuery y facilita la visualización de objetos jQuery que tienen un conjunto diferente de propiedades.

Usos angulares es para propiedades generadas por el framework. Supongo que están siguiendo la sugerencia (ahora desaparecida) proporcionada por el ECMA-262 3.0.

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

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

También puede usar {varname} para almacenar elementos de jQuery, pero como dije al principio, esto lo distingue de las variables simples y lo hace mucho más fácil de entender (imagínese confundirlo con una variable simple y buscar por todas partes para entender qué se mantiene).

Por ejemplo :

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

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

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