Quando usar duplas ou aspas simples em JavaScript?
https://stackoverflow.com/questions/242813
-
04-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
console.log("double"); vs console.log('single');
Eu vejo mais e mais bibliotecas JavaScript lá fora, usando aspas simples durante a manipulação de cadeias de caracteres.Quais são as razões para o uso de um sobre o outro?Eu pensei que eles são praticamente intercambiáveis.
Solução
A razão mais provável para o uso da única vs dupla em diferentes bibliotecas é preferência programador e / ou a consistência API.
Além de ser consistente, use a que melhor se adequa à string:.
Usando a outro tipo de citação como um literal:
alert('Say "Hello"');
alert("Say 'Hello'");
... mas isso pode ficar complicado ...
alert("It's \"game\" time.");
alert('It\'s "game" time.');
Outra opção, novo em ES6, são Template literais que usar o caractere back-tick:
alert(`Use "double" and 'single' quotes in the same string`);
alert(`Escape the \` back-tick character and the \${ dollar-brace sequence in a string`);
literais Modelo oferecer uma sintaxe limpa para:. Interpolação variável, cordas multi-linha, e mais
Outras dicas
Se você está lidando com JSON, deve-se notar que, estritamente falando, cordas JSON deve ser dupla citado. Claro, muitas bibliotecas apoiar aspas simples assim, mas eu tive grandes problemas em um dos meus projetos antes de perceber que só citando uma string é na verdade não de acordo com os padrões JSON.
Não há uma solução melhor ; no entanto, eu gostaria de argumentar que as aspas duplas pode ser mais desejável às vezes:
- Os recém-chegados já estará familiarizado com aspas duplas de sua língua . Em Inglês, devemos usar duplo aspas
"para identificar uma passagem de texto citado. Se tivéssemos que usar uma única citação', o leitor pode interpretar mal-lo como uma contração. O outro significado de uma passagem de texto rodeado pela'indica o 'coloquial' significado. Faz sentido para ficar consistente com línguas pré-existentes, e isso, provavelmente, pode facilitar a aprendizagem e interpretação de código. - aspas duplas eliminar a necessidade de escapar apóstrofos (como em contrações). Considere a string:
"I'm going to the mall", contra a versão de outro modo escapou:.'I\'m going to the mall' -
aspas duplas significa uma string em muitas outras línguas . Quando você aprende uma nova linguagem como Java ou C, aspas duplas são sempre utilizados. Em Ruby, PHP e Perl, cordas individuais citado implica não escapa barra invertida enquanto aspas apoiá-los.
-
notação JSON é escrito com aspas duplas.
No entanto, como já foi dito, é mais importante para manter a coerência.
O
'A string that\'s single quoted'
"A string that's double quoted"
Então, é só para baixo a quanto Citação escapar que você quer fazer. Obviamente, o mesmo se aplica aos aspas em cadeias entre aspas duplas.
aspas simples
Desejo aspas duplas eram o padrão, porque eles fazer um pouco mais de sentido , mas eu continuo usando aspas simples porque eles dominam a cena.
As aspas simples:
- airbnb
- grunhido
- gole
- nó
- npm (embora não definidos no autor de guia )
- wikimedia
- wordpress
- yandex
Sem preferência:
As aspas duplas:
Eu gostaria de dizer a diferença é puramente estilístico, mas eu realmente estou tendo minhas dúvidas. Considere o seguinte exemplo:
/*
Add trim() functionality to JavaScript...
1. By extending the String prototype
2. By creating a 'stand-alone' function
This is just to demonstrate results are the same in both cases.
*/
// Extend the String prototype with a trim() method
String.prototype.trim = function() {
return this.replace(/^\s+|\s+$/g, '');
};
// 'Stand-alone' trim() function
function trim(str) {
return str.replace(/^\s+|\s+$/g, '');
};
document.writeln(String.prototype.trim);
document.writeln(trim);
No Safari, Chrome, Opera e Internet Explorer (testado no IE7 e IE8), este retornará o seguinte:
function () {
return this.replace(/^\s+|\s+$/g, '');
}
function trim(str) {
return str.replace(/^\s+|\s+$/g, '');
}
No entanto, o Firefox irá produzir um resultado ligeiramente diferente:
function () {
return this.replace(/^\s+|\s+$/g, "");
}
function trim(str) {
return str.replace(/^\s+|\s+$/g, "");
}
As aspas simples foram substituídos por aspas duplas. (Observe também como o espaço o recuo foi substituído por quatro espaços.) Isto dá a impressão de que pelo menos um navegador analisa JavaScript internamente como se tudo foi escrito usando aspas duplas. Pode-se pensar, leva Firefox menos tempo para analisar JavaScript se tudo já está escrito de acordo com este 'padrão'.
O que, por sinal, faz-me um panda muito triste, pois acho aspas simples olhar muito mais agradável no código. Além disso, em outras linguagens de programação, eles são geralmente mais rápido de usar do que as aspas duplas, por isso só faria sentido se o mesmo aplicado para JavaScript.
Conclusão:. Eu acho que nós precisamos fazer mais pesquisas sobre este
Editar: Isto pode explicar Peter- os resultados dos testes de Paul Koch de volta em 2003.
Parece que aspas simples são às vezes mais rápido em Windows Explorer (cerca de 1/3 dos meus testes mostrou um tempo de resposta mais rápido), mas se mostra Mozilla uma diferença em tudo, ele lida com aspas duplas um pouco mais rápido. Eu não encontrei nenhuma diferença em tudo na Opera.
Editar 2014:. Versões modernas de Firefox / Macaco-Aranha não mais fazer isso
Se você está fazendo o JavaScript inline (indiscutivelmente um "ruim", mas evitando que a discussão) único as cotações são a sua única opção para literais de seqüência de caracteres, eu acredito.
por exemplo, isso funciona bem:
<a onclick="alert('hi');">hi</a>
Mas você não pode moldar o "oi" em aspas duplas, através de qualquer de escapar método que eu estou ciente.Mesmo " o que teria sido meu melhor palpite (desde que você está escapando citações em um valor de atributo de HTML) não funciona para mim no Firefox. \" não vai funcionar porque neste momento você está escapando por HTML, JavaScript não.
Assim, se o nome do jogo é a consistência, e você vai fazer alguns inline JavaScript em partes do seu aplicativo, eu acho que as aspas simples são o vencedor.Alguém por favor me corrija se eu estiver errado embora.
Tecnicamente não há diferença, é apenas questão de estilo e convenções.
Douglas Crockford recomenda o uso de aspas simples para cordas internas e aspas duplas para externo (por externo queremos dizer aqueles a ser exibido para o usuário do aplicativo, como mensagens ou alertas).
Eu, pessoalmente, acompanhar isso.
UPDATE: Parece que o Sr. Crockford mudou de idéia agora recomenda o uso de aspas duplas em todo:)
A rigor, não há diferença de significado; por isso a escolha se resume a conveniência.
Aqui estão alguns fatores que poderiam influenciar sua escolha:
-
estilo
- House:. Alguns grupos de desenvolvedores já utilizam uma convenção ou outro
- requisitos do lado do cliente: Você vai estar usando aspas dentro das cordas? (Resposta See do Ady).
- linguagem do lado do servidor: VB.Net pessoas podem optar por usar aspas simples para Java-script para que os scripts podem ser construídas do lado do servidor (VB.Net usa aspas para cordas, de modo que as cordas java-script são fácil de distinguidos se usar aspas simples).
- código Biblioteca:. Se você estiver usando uma biblioteca que usa um estilo particular, você pode considerar usando o mesmo estilo se
- A preferência pessoal:. Você pode coisa que um ou outros olhares estilo melhor
Vamos olhar o que uma referência fazer.
jquery.js dentro, cada corda está entre aspas.
Assim, a partir de agora, vou usar strings delimitadas por aspas. (Eu estava usando single!)
É principalmente uma questão de estilo e preferência. Há algumas explorações técnicas bastante interessantes e úteis em outras respostas, por isso, talvez a única coisa que eu poderia acrescentar é oferecer um conselho mundano pouco.
-
Se você está codificando em uma empresa ou equipe, então é provavelmente uma boa ideia seguir o "estilo de casa".
-
Se você está sozinho cortar alguns projetos paralelos, então olhada em alguns líderes proeminentes da comunidade. Por exemplo, digamos que você entrar em Node.js. Dê uma olhada em módulos principais, por exemplo underscore.js ou expressar e ver o que convenção que eles usam, e após considerar isso.
-
Se duas convenções são igualmente utilizados, então Adiar a seu
pessoal preferência. -
Se você não tem preferência pessoal, então jogar uma moeda.
-
Se você não tem uma moeda, então cerveja está em mim;)
Espero não estou adicionando algo óbvio, mas eu tenho lutado com Django e Ajax e JSON sobre isso.
Assumindo que em seu código HTML você usar aspas duplas, como normalmente deveria ser, eu sugiro usar aspas simples para o resto em JavaScript.
Então, eu concordo com @ady mas com alguns cuidados.
A minha linha de fundo é: Em JavaScript, provavelmente, não importa, mas assim que você incorporar -lo dentro de HTML ou similar você começa a ter problemas. Você deveria saber o que realmente está escapando, lendo, passando a cadeia.
O meu caso foi simples:
tbox.innerHTML = tbox.innerHTML + '<div class="thisbox_des" style="width:210px;" onmouseout="clear()"><a href="/this/thislist/'
+ myThis[i].pk +'"><img src="/site_media/'
+ myThis[i].fields.thumbnail +'" height="80" width="80" style="float:left;" onmouseover="showThis('
+ myThis[i].fields.left +','
+ myThis[i].fields.right +',\''
+ myThis[i].fields.title +'\')"></a><p style="float:left;width:130px;height:80px;"><b>'
+ myThis[i].fields.title +'</b> '
+ myThis[i].fields.description +'</p></div>'
Você pode manchar o \' no terceiro campo de showThis.
A citação dupla não funcionou!
É claro por que, mas é também claro por que devemos ficar em aspas simples ... .. eu acho ..
Este caso é muito simples incorporação de HTML, o erro foi gerado por um simples copiar / colar a partir de um código JavaScript 'citado double'.
Assim, para responder à pergunta:
Tente usar aspas simples, enquanto dentro de HTML. Ele pode salvar um par de questões de depuração ...
Apenas consistência sustento no que você usar. Mas não deixe que o seu nível de conforto.
"This is my string."; // :-|
"I'm invincible."; // comfortable :)
'You can\'t beat me.'; // uncomfortable :(
'Oh! Yes. I can "beat" you.'; // comfortable :)
"Do you really think, you can \"beat\" me?"; // uncomfortable :(
"You're my guest. I can \"beat\" you."; // sometimes, you've to :P
'You\'re my guest too. I can "beat" you too.'; // sometimes, you've to :P
atualização ES6
Usando modelo literal sintaxe .
`Be "my" guest. You're in complete freedom.`; // most comfort :D
Não sei se isso é relevante no mundo de hoje, mas aspas utilizadas para ser usado para o conteúdo que precisava ter caracteres de controle processado e aspas simples para strings que não.
O compilador irá executar a manipulação de cadeia em uma cadeia entre aspas dupla, deixando uma única string literalmente intocada. Este utilizado para levar a 'boas' desenvolvedores optam por usar aspas simples para strings que não contêm caracteres de controle como \n ou \0 (não processados ??dentro de aspas simples) e aspas duplas quando precisavam seqüência analisada (com uma ligeira custo em cpu ciclos para processar a string).
Se você estiver usando jshint , ele irá gerar um erro se você usar corda aspas duplas.
Eu usei-o através do scafflholding Yeoman de AngularJS mas talvez haja alguma forma um maner para configurar isso.
A propósito, quando você lida com HTML em JavaScript, é mais fácil de usar aspas simples:
var foo = '<div class="cool-stuff">Cool content</div>';
E pelo menos JSON está usando aspas para cordas reprensent.
Não há nenhuma maneira trivial para responder à sua pergunta
Falando sobre o desempenho, citações nunca será o gargalo, no entanto, o desempenho é o mesmo em ambos os casos.
Falando sobre codificação de velocidade, se você usar ' para delimitar uma seqüência, você terá que escapar citações ". Você é mais provável a necessidade de uso " dentro da cadeia, no exemplo:
//JSON Objects:
var jsonObject = '{"foo":"bar"}';
//HTML attributes:
document.getElementById("foobar").innerHTML = '<input type="text">';
Então, eu prefiro usar ' para delimitar a corda, então eu tenho que escapar menos caracteres.
One (bobo) razão para usar aspas simples seria a de que eles não exigem que você pressione a tecla shift para escrever-lhes, enquanto que um aspas duplas fazer. (Estou assumindo que a cadeia média não requer escapar, que é uma suposição razoável.) Agora, vamos supor que todos os códigos dia eu 200 linhas de código. Talvez naqueles 200 linhas Eu tenho 30 citações. Talvez digitando aspas duplas leva 0,1 segundos mais tempo do que escrever uma única citação (porque eu tenho que pressionar a tecla shift). Em seguida, em um determinado dia, eu desperdiçar 3 segundos. Se o código I dessa maneira por 200 dias por ano para 40 anos, então eu perdi 6.7 horas da minha vida. Alimento para o pensamento.
Examinando os prós e contras
Em favor de aspas simples
- Menos desordem visual.
- Gerar HTML:. Atributos HTML são geralmente delimitada por aspas duplas
elem.innerHTML = '<a href="' + url + '">Hello</a>';
elem.innerHTML = "<a href='" + url + "'>Hello</a>";
Além disso, inline HTML é normalmente um anti-padrão. Prefere modelos.
- Gerar JSON:. Citações Apenas duplas são permitidos em JSON
myJson = '{ "hello world": true }';
Mais uma vez, você não deve ter para construir JSON desta forma. JSON.stringify () é muitas vezes suficiente. Se não, usar modelos.
Em favor de aspas duplas
- Duplas são mais fáceis de detectar se você não tem código de cores. Como em um log console ou algum tipo de configuração view-fonte.
- semelhança com outras línguas: Na programação shell (Bash etc.), existem strings literais único citado, mas escapes não são interpretados dentro deles. C e Java usar aspas duplas para cordas e aspas simples para caracteres.
- Se você quiser código para ser JSON válido, você precisa usar aspas duplas.
Em favor de ambos
Não há nenhuma diferença entre os dois em JavaScript. Portanto, você pode usar o que é conveniente no momento. Por exemplo, a seguinte seqüência de caracteres literais todos os produtos da mesma cadeia:
"He said: \"Let's go!\""
'He said: "Let\'s go!"'
"He said: \"Let\'s go!\""
'He said: \"Let\'s go!\"'
As aspas simples para cordas internas e dupla para externa. Que lhe permite distinguir as constantes internas de cordas que estão a ser exibida para o usuário (ou gravados em disco etc.). Obviamente, você deve evitar colocar este último em seu código, mas isso nem sempre pode ser feito.
Mais uma coisa que você pode querer considerar como uma razão para a mudança de aspas para aspas simples é o aumento na popularidade de scripts do lado do servidor. Ao usar o PHP pode passar variáveis ??e funções javascript de análise usando cordas e variáveis ??em PHP.
Se você escrever uma corda e usar aspas duplas para o seu PHP você não tem que escapar qualquer uma das aspas simples e PHP irá recuperar automaticamente o valor das variáveis ??para você.
Exemplo: Eu preciso executar uma função JavaScript usando uma variável do meu servidor
.public static function redirectPage( $pageLocation )
{
echo "<script type='text/javascript'>window.location = '$pageLocation';</script>";
}
Esta me salva um monte de problemas em ter que lidar com cordas juntando, e eu pode efetivamente chamar um javascript de PHP. Este é apenas um exemplo, mas esta pode ser uma das várias razões pelas quais os programadores estão inadimplentes com aspas simples em JavaScript.
cotação de documentos PHP : "a característica mais importante de cordas duplas citado é o fato de que nomes de variáveis ??serão substituídos. Veja análise de cadeia para mais detalhes."
Gostaria de usar aspas quando aspas simples não pode ser usado e vice-versa:
"'" + singleQuotedValue + "'"
'"' + doubleQuotedValue + '"'
Em vez de:
'\'' + singleQuotedValue + '\''
"\"" + doubleQuotedValue + "\""
There is no difference between single and double quotes in JavaScript.
Specification is important:
Maybe there are performance diffs, but they are absolutely minimum and can change everyday according to browsers' implementation. Further discussion is futile unless your JavaScript application is hundreds of thousands long.
It's like a benchmark if
a=b;
is faster than
a = b;
(extra spaces)
today, in a particular browser and platform, etc.
When using CoffeeScript I use double quotes. I agree that you should pick either one and stick to it. CoffeeScript gives you interpolation when using the double quotes.
"This is my #{name}"
ES6 is using back ticks (`) for template strings. Which probably has a good reason, but when coding it can be cumbersome to change the string literals character from quotes or double quotes to back ticks in order to get the interpolation feature. CoffeeScript might not be perfect, but using the same string literals character everywhere (double quotes) and always be able to interpolate is a nice feature.
`This is my ${name}`
There are people that claim to see performance differences: old mailing list thread. But I couldn't find any of them to be confirmed.
The main thing is to look at what kind of quotes (double or single) you are using inside your string. It helps to keep the number of escapes low. For instance when you are working with html inside your strings, it is easier to use single quotes so that you don't have to escape all double quotes around the attributes.
If you're jumping back an forth between JavaScript and C#, it's best to train your fingers for the common convention which is double quotes.
I've been running the following about 20 times. And it appears that double quotes are about 20% faster.
The fun part is, if you change part 2 and part 1 around, single quotes are about 20% faster.
//Part1
var r='';
var iTime3 = new Date().valueOf();
for(var j=0; j<1000000; j++) {
r+='a';
}
var iTime4 = new Date().valueOf();
alert('With single quote : ' + (iTime4 - iTime3));
//Part 2
var s="";
var iTime1 = new Date().valueOf();
for(var i=0; i<1000000; i++) {
s += "a";
}
var iTime2 = new Date().valueOf();
alert('With double quote: ' + (iTime2 - iTime1));
After reading all the answers that say it maybe be faster or maybe have advantages, I would say double quote is better or maybe faster too because Google closure compiler convert single quotes to double quotes.
There is strictly no difference, so it is mostly a matter of taste and of what is in the string (or if the JS code itself is in a string), to keep number of escapes low.
The speed difference legend might come from PHP world, where the two quotes have different behavior.
If your JS source is:
elem.innerHTML="<img src='smily' alt='It\'s a Smily' style='width:50px'>";
The HTML source will be:
<img src="smiley" alt="It's a Smiley" style="width:50px">
or for HTML5
<img src=smiley alt="It's a Smiley" style=width:50px>
JS allows arrays like that:
var arr=['this','that'];
But if you stringify it, it will be for compatibly reason:
JSON=["this","that"]
I'm sure this takes some time.
Just to add my 2 cents: In working with both JS and PHP a few years back, I've become accustom to using single quotes so I can type the escape character ('\') without having to escape it as well. I usually used it when typing raw strings with file paths, etc. (http://en.wikipedia.org/wiki/String_literal#Raw_strings)
Anyhow, my convention ended up becoming the use of single quotes on identifier-type raw strings, such as if (typeof s == 'string') ... (in which escape characters would never be used - ever), and double quotes for texts, such as "Hey, what's up?". I also use single quotes in comments as a typographical convention to show identifier names. This is just a rule of thumb, and I break off only when needed, such as when typing HTML strings '<a href="#"> like so <a>' (though you could reverse the quotes here also). I'm also aware that, in the case of JSON, double quotes are used for the names - but outside that, personally, I prefer the single quotes when escaping is never required for the text between the quotes - like document.createElement('div').
Bottom line, and as some have mentioned/alluded to, pick a convention, stick with it, and only deviate when necessary.
You can use single quotes or double quotes. This enables you for example to easily nest javascript inside HTML attributes, without the need to escape the quotes. The same is when you create javascript with PHP.
The general idea is: if it is possible use such quotes that you won't need to escape. Less escaping = better code.
