Por que uma variável JavaScript começaria com um cifrão? [duplicado]

Frequentemente vejo JavaScript com variáveis ​​que começam com um cifrão. Quando / por que você escolheria o prefixo de uma variável dessa maneira?

(Eu não estou perguntando sobre a $('p.foo')sintaxe que você vê no jQuery e outros, mas variáveis ​​normais como $namee $order)

O uso muito comum no jQuery é distinguir objetos jQuery armazenados em variáveis ​​de outras variáveis.

Por exemplo, eu definiria:

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

Acho que isso é muito útil para escrever código jQuery e facilita a exibição de objetos jQuery que possuem um conjunto diferente de propriedades.

Na 1ª, 2ª e 3ª edição do ECMAScript , o uso de nomes de variáveis ​​com prefixo $ foi explicitamente desencorajado pelas especificações, exceto no contexto do código gerado automaticamente:

O cifrão ( $) e o sublinhado ( _) são permitidos em qualquer lugar do identificador. O cifrão destina-se ao uso somente em código gerado mecanicamente.

No entanto, na próxima versão (a 5ª edição , atual), essa restrição foi descartada e a passagem acima substituída por

O cifrão ( $) e o sublinhado ( _) são permitidos em qualquer lugar em um IdentifierName .

Como tal, o sinal $ agora pode ser usado livremente em nomes de variáveis. Certas estruturas e bibliotecas têm suas próprias convenções sobre o significado do símbolo, anotadas em outras respostas aqui.

Como outros mencionaram, o cifrão deve ser usado pelo código gerado mecanicamente. No entanto, essa convenção foi quebrada por algumas bibliotecas JavaScript muito populares. JQuery, Prototype e MS AJAX (AKA Atlas), todos usam esse caractere em seus identificadores (ou como um identificador inteiro).

Em suma, você pode usar o $quando quiser. (O intérprete não vai reclamar.) A questão é quando você quer usá-lo?

Eu pessoalmente não o uso, mas acho que seu uso é válido. Eu acho que o MS AJAX usa para significar que uma função é um alias para uma chamada mais detalhada.

Por exemplo:

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

Parece uma convenção razoável.

No contexto do AngularJS, o $prefixo é usado apenas para identificadores no código da estrutura. Os usuários da estrutura são instruídos a não usá-la em seus próprios identificadores:

Namespaces angulares $e$$

Para evitar colisões acidentais de nomes com seu código, Angular prefixa nomes de objetos públicos $e nomes de objetos particulares $$. Por favor, não use o prefixo $ou $$no seu código.

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

Eu fui a pessoa que originou essa convenção em 2006 e a promoveu na lista de discussão inicial do jQuery, então deixe-me compartilhar um pouco da história e da motivação em torno dela.

A resposta aceita dá este exemplo:

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

Mas isso realmente não ilustra bem. Mesmo sem o $, ainda teríamos dois nomes de variáveis ​​diferentes aqui, emaile email_field. Isso é muito bom aqui. Por que precisaríamos colocar um $em um dos nomes quando já temos dois nomes diferentes?

Na verdade, eu não teria usado email_fieldaqui por dois motivos: names_with_underscoresnão é JavaScript idiomático e fieldrealmente não faz sentido para um elemento DOM. Mas eu segui a mesma ideia.

Eu tentei algumas coisas diferentes, entre elas algo muito semelhante ao exemplo:

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

(É claro que um objeto jQuery pode ter mais de um elemento DOM, mas o código no qual eu estava trabalhando tinha muitas id seletores; portanto, nesses casos, havia uma correspondência 1: 1.)

Eu tive outro caso em que uma função recebeu um elemento DOM como parâmetro e também precisava de um objeto jQuery:

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

Bem, isso é um pouco confuso! Em um dos meus bits de código, emailestá o objeto jQuery e emailElementé o elemento DOM, mas no outro, emailé o elemento DOM e emailJQé o objeto jQuery.

Não havia consistência e eu continuei misturando-os. Além disso, era um pouco incômodo continuar criando dois nomes diferentes para a mesma coisa: um para o objeto jQuery e outro para o elemento DOM correspondente. Além de email, emailElementeemailJQ , eu continuei tentando outras variações também.

Então notei um padrão comum:

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

Como o JavaScript trata $simplesmente como outra letra para nomes, e como sempre recebi um objeto jQuery de uma $(whatever)chamada, o padrão finalmente me ocorreu. Eu poderia atender uma $(...)ligação e apenas remover alguns caracteres, e ele teria um nome muito bonito:

$("#email")
$(email)

Strikeout não é perfeito, mas você pode ter a idéia: com alguns caracteres excluídos, ambas as linhas acabam parecendo:

$email

Foi quando percebi que não precisava criar uma convenção como emailElementou emailJQ. Já havia uma boa convenção me encarando: desconecte alguns caracteres de uma $(whatever)ligação e ela se transforma $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!
}

Portanto, não tive que inventar dois nomes diferentes o tempo todo, mas poderia usar o mesmo nome com ou sem um $prefixo. E o $prefixo era um bom lembrete de que eu estava lidando com um objeto jQuery:

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

ou:

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

Stevo está certo, o significado e o uso do cifrão (em Javascript e na plataforma jQuery, mas não em PHP) é totalmente semântico. $ é um caractere que pode ser usado como parte de um nome de identificador. Além disso, o cifrão talvez não seja a coisa mais "estranha" que você pode encontrar em Javascript. Aqui estão alguns exemplos de nomes 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 os exemplos acima funcionarão.

Tente eles.

O caractere $ não tem significado especial para o mecanismo JavaScript. É apenas outro caractere válido em um nome de variável como az, AZ, _, 0-9, etc ...

Como _no início de um nome de variável é frequentemente usado para indicar uma variável privada (ou pelo menos uma que se destina a permanecer privada), acho$ conveniente adicionar em frente aos meus breves aliases às bibliotecas de códigos genéricas.

Por exemplo, ao usar jQuery, prefiro usar a variável $J(em vez de apenas $) e usar$P ao usar o php.js, etc.

O prefixo o torna visualmente distinto de outras variáveis, como minhas próprias variáveis ​​estáticas, levando-me ao fato de que o código faz parte de alguma biblioteca ou outra e é menos provável que entre em conflito ou confunda outras pessoas quando conhecerem a convenção.

Ele também não confunde o código (ou requer digitação extra), assim como um nome totalmente especificado repetido para cada chamada de biblioteca.

Eu gosto de pensar nisso como sendo semelhante ao que as teclas modificadoras fazem para expandir as possibilidades de teclas únicas.

Mas esta é apenas a minha própria convenção.

Como experimentei nos últimos 4 anos, permitirá que alguém identifique facilmente se a variável que aponta um valor / objeto ou um elemento DOM envolto por jQuery

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

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

no exemplo acima, quando vejo a variável "$ dataDiv", posso facilmente dizer que essa variável está apontando para um elemento DOM envolto em jQuery (nesse caso, é div). e também posso chamar todos os métodos jQuery sem quebrar o objeto novamente como $ dataDiv.append (), $ dataDiv.html (), $ dataDiv.find () em vez de $ ($ dataDiv) .append ().

Espero que possa ter ajudado. então, finalmente, quero dizer que será uma boa prática seguir isso, mas não obrigatório.

${varname} é apenas uma convenção de nomenclatura que os desenvolvedores do jQuery usam para distinguir variáveis ​​que estão contendo elementos do jQuery.

Plain {varname}é usado para armazenar materiais em geral, como textos e strings. ${varname}contém elementos retornados do jQuery.

Você pode usar planície {varname} para armazenar elementos jQuery, mas, como eu disse no começo, isso os diferencia das variáveis ​​simples e facilita muito o entendimento (imagine confundi-lo com uma variável simples e pesquisar por tudo para entender o que ele contém) .

Por exemplo :

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

Aqui, blá está armazenando um elemento jQuery retornado.

Portanto, quando alguém vê o $blahcódigo, ele entende que não é apenas uma sequência ou um número, é um elemento jQuery.

Embora você possa simplesmente usá-lo para prefixar seus identificadores, ele deve ser usado para o código gerado, como tokens de substituição em um modelo, por exemplo.

Usos angulares são para propriedades geradas pela estrutura. Acho que eles estão seguindo a dica (agora extinta) fornecida pelo ECMA-262 3.0.

$ é usado para DISTINGUISH entre variáveis ​​comuns e variáveis ​​de jquery no caso de variáveis ​​normais. permitir que você faça um pedido no FLIPKART; se o pedido for uma variável que mostre a saída da string, ele será nomeado simples como "order"; order "para que o programador consiga extrair as variáveis ​​javascript e as variáveis ​​jquery em todo o código.

Se você vir o cifrão ($) ou o cifrão duplo ($$) e estiver curioso para saber o que isso significa na estrutura do Prototype, aqui está sua resposta:

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

Às vezes, uso convenções de nomes php com variáveis ​​javascript: Ao fazer a validação de entrada, quero executar exatamente os mesmos algoritmos, tanto do lado do cliente quanto do lado do servidor. Eu realmente quero que os dois lados do código pareçam o mais semelhante possível, para simplificar a manutenção. O uso de cifrões em nomes de variáveis ​​facilita isso.

(Além disso, algumas funções auxiliares criteriosas ajudam a tornar o código parecido, por exemplo, agrupar pesquisas de valor de entrada, versões não OO de strlen, substr, etc. Ainda requer alguns ajustes manuais.)

Um identificador JavaScript válido deve começar com uma letra, sublinhado (_) ou cifrão ($); caracteres subsequentes também podem ser dígitos (0-9). Como o JavaScript diferencia maiúsculas de minúsculas, as letras incluem os caracteres "A" a "Z" (maiúsculas) e os caracteres "a" a "z" (minúsculas).

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