console.log("double"); vs console.log('single');

Vejo cada vez mais bibliotecas JavaScript por aí usando aspas simples ao manipular strings. Quais são os motivos para usar um sobre o outro? Eu pensei que eles eram praticamente intercambiáveis.

O motivo mais provável para o uso de single vs double em diferentes bibliotecas é a preferência do programador e / ou a consistência da API. Além de consistente, use o que melhor se adequar à sequência.

Usando o outro tipo de citação como literal:

alert('Say "Hello"');
alert("Say 'Hello'");

Isso pode ser complicado:

alert("It's \"game\" time.");
alert('It\'s "game" time.');

Outra opção, nova no ES6, são literais de modelo que usam o back-tickcaractere:

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 de modelo oferecem uma sintaxe limpa para: interpolação variável, seqüências de várias linhas e muito mais.

Observe que o JSON é formalmente especificado para usar aspas duplas, o que pode ser considerado dependendo dos requisitos do sistema.

Se você estiver lidando com JSON, observe que, estritamente falando, as strings JSON devem ser citadas duas vezes. Claro, muitas bibliotecas também suportam aspas simples, mas eu tive grandes problemas em um dos meus projetos antes de perceber que a citação única de uma sequência não é, de fato, de acordo com os padrões JSON.

Não existe uma solução melhor ; no entanto, gostaria de argumentar que aspas duplas podem ser mais desejáveis ​​às vezes:

• Os recém-chegados já estarão familiarizados com aspas duplas do seu idioma . Em inglês, precisamos usar aspas duplas "para identificar uma passagem do texto citado. Se usarmos uma única citação ', o leitor pode interpretá-la mal como uma contração. O outro significado de uma passagem de texto cercada por 'indica o significado "coloquial". Faz sentido permanecer consistente com os idiomas pré-existentes, e isso pode facilitar a aprendizagem e a interpretação do código.
• As aspas duplas eliminam a necessidade de escapar dos apóstrofos (como nas 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 significam uma sequência em muitos outros idiomas . Quando você aprende um novo idioma como Java ou C, aspas duplas são sempre usadas. Em Ruby, PHP e Perl, cadeias de citação única não implicam escapes de barra invertida, enquanto aspas duplas as suportam.

• A notação JSON é escrita com aspas duplas.

No entanto, como outros já declararam, é mais importante permanecer consistente.

A seção 7.8.4 da especificação descreve a notação literal de cadeias. A única diferença é que DoubleStringCharacter é "SourceCharacter, mas não aspas duplas" e SingleStringCharacter é "SourceCharacter, mas não aspas simples". Portanto, a única diferença pode ser demonstrada assim:

'A string that\'s single quoted'

"A string that's double quoted"

Portanto, depende da quantidade de cotação que você deseja fazer. Obviamente, o mesmo se aplica a aspas duplas em strings entre aspas duplas.

Citações simples

Eu gostaria que as aspas duplas fossem o padrão, porque elas fazem um pouco mais de sentido , mas continuo usando aspas simples porque elas dominam a cena.

Citações simples:

• airbnb
• Facebook
• Google
• grunhido
• gole
• nó
• npm (embora não definido no guia do autor )
• wikimedia
• wordpress
• yandex

Sem preferência:

• three.js

Aspas duplas:

• datilografado
• Crockford
• d3 (embora não definido em .eslintrc)
• jquery

Eu gostaria de dizer que a diferença é puramente estilística, mas estou realmente 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), isso retornará o seguinte:

function () {
 return this.replace(/^\s+|\s+$/g, '');
}
function trim(str) {
 return str.replace(/^\s+|\s+$/g, '');
}

No entanto, o Firefox 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ídas por aspas duplas. (Observe também como o espaço de recuo foi substituído por quatro espaços.) Isso dá a impressão de que pelo menos um navegador analisa JavaScript internamente como se tudo estivesse escrito com aspas duplas. Pode-se pensar que o Firefox leva menos tempo para analisar o JavaScript se tudo já estiver escrito de acordo com esse 'padrão'.

O que, a propósito, me deixa um panda muito triste, pois acho que aspas simples parecem muito mais agradáveis ​​no código. Além disso, em outras linguagens de programação, eles costumam ser mais rápidos do que aspas duplas, portanto, só faria sentido se o mesmo se aplicasse ao JavaScript.

Conclusão: acho que precisamos fazer mais pesquisas sobre isso.

Edit: Isso pode explicar os resultados dos testes de Peter-Paul Koch em 2003.

Parece que as aspas simples às vezes são mais rápidas no Explorer Windows (aproximadamente 1/3 dos meus testes mostraram um tempo de resposta mais rápido), mas se o Mozilla mostra alguma diferença, ele manipula aspas duplas um pouco mais rápido. Não encontrei nenhuma diferença no Opera.

Edit 2014: As versões modernas do Firefox / Spidermonkey não fazem mais isso.

Se você estiver usando JavaScript embutido (sem dúvida uma coisa "ruim", mas evitando essa discussão), as aspas simples são sua única opção para literais de string, acredito.

por exemplo, isso funciona bem:

<a onclick="alert('hi');">hi</a>

Mas você não pode agrupar o "oi" entre aspas duplas, por qualquer método que eu saiba. Mesmo "qual teria sido meu melhor palpite (já que você está escapando de aspas em um valor de atributo de HTML) não funciona para mim no Firefox. \"também não funcionará porque, neste momento, você está escapando para HTML, não para JavaScript.

Portanto, se o nome do jogo for consistente e você usar JavaScript embutido em partes do seu aplicativo, acho que as aspas simples são as vencedoras. Alguém por favor me corrija se eu estiver errado.

Tecnicamente, não há diferença, é apenas uma questão de estilo e convenção.

Douglas Crockford recomenda o uso de aspas simples para strings internas e aspas duplas para externas (por externas, queremos dizer aquelas que serão exibidas ao usuário do aplicativo, como mensagens ou alertas).

Eu pessoalmente sigo isso.

ATUALIZAÇÃO: Parece que o Sr. Crockford mudou de idéia e agora recomenda o uso de aspas duplas em todo :)

A rigor, não há diferença de significado; então a escolha se resume à conveniência.

Aqui estão vários fatores que podem influenciar sua escolha:

• Estilo interno: alguns grupos de desenvolvedores já usam uma convenção ou outra.
• Requisitos do lado do cliente: você usará aspas dentro das strings? (Veja a resposta de Ady).
• Linguagem do lado do servidor: o pessoal do VB.Net pode optar por usar aspas simples para java-script, para que os scripts possam ser criados no lado do servidor (o VB.Net usa aspas duplas para seqüências de caracteres, para facilitar a distinção entre as seqüências de caracteres do script java. se eles usam aspas simples).
• Código da biblioteca: se você estiver usando uma biblioteca que usa um estilo específico, considere usar o mesmo estilo.
• Preferência pessoal: você pode pensar que um ou outro estilo fica melhor.

Vejamos o que uma referência faz.

Dentro do jquery.js, todas as strings são aspas duplas.

Então, a partir de agora, usarei cadeias de caracteres com aspas duplas. (Eu estava usando single!)

Apenas mantenha a consistência no que você usa. Mas não diminua 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 a sintaxe literal do modelo .

`Be "my" guest. You're in complete freedom.`; // most comfort :D

É principalmente uma questão de estilo e preferência. Existem algumas explorações técnicas bastante interessantes e úteis nas outras respostas, então talvez a única coisa que eu possa acrescentar seja oferecer um pequeno conselho mundano.

• Se você estiver codificação em uma empresa ou equipe, então provavelmente é uma boa idéia seguir a "casa de estilo".

• Se você está sozinho cortar alguns projetos paralelos, em seguida, olhar para alguns líderes proeminentes da comunidade. Por exemplo, digamos que você entre no Node.js. Dê uma olhada nos módulos principais, por exemplo, underscore.js ou express e veja qual convenção eles usam, e considere seguir isso.

• Se ambas as convenções são igualmente utilizados, em seguida, adiar para o seu pessoal
  preferência.

• Se você não tem preferência pessoal, em seguida, jogar uma moeda.

• Se você não tem uma moeda, então a cerveja está em mim;)

Espero que eu não estou adicionando algo óbvio, mas eu tenho lutado com Django e Ajax e JSON sobre este assunto.

Supondo que em seu código HTML você use aspas duplas, como normalmente deveria ser, sugiro usar aspas simples para o restante em JavaScript.

Então, eu concordo com @ady, mas com alguns cuidados.

Minha conclusão é: No JavaScript, provavelmente não importa, mas assim que você o incorpora ao HTML ou algo semelhante, você começa a ter problemas. Você deve saber o que realmente está escapando, lendo, passando sua string.

Meu caso simples foi:

tbox.innerHTML = tbox.innerHTML + '<div class="thisbox_des" style="width:210px;" onmouseout="clear()"><a href="https://stackoverflow.com/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 identificar o \ 'no terceiro campo do showThis.

As aspas duplas não funcionaram!

Está claro o porquê, mas também está claro por que devemos ficar com aspas simples ... .. eu acho ..

Nesse caso, é uma incorporação HTML muito simples, o erro foi gerado por uma cópia / colar simples a partir de um código JavaScript 'com aspas duplas'.

Então, para responder à pergunta:

Tente usar aspas simples enquanto estiver em HTML. Pode salvar alguns problemas de depuração ...

Não tenho certeza se isso é relevante no mundo de hoje, mas as aspas duplas costumavam ser usadas para conteúdo que precisava ter caracteres de controle processados ​​e aspas simples para strings que não eram.

O compilador executará a manipulação de cadeias de caracteres em uma cadeia de caracteres dupla entre aspas, deixando uma única cadeia de caracteres entre aspas literalmente intocada. Isso costumava levar os desenvolvedores 'bons' a optarem por usar aspas simples para strings que não continham caracteres de controle como \nou \0(não processados ​​entre aspas simples) e aspas duplas quando precisavam que a string fosse analisada (a um pequeno custo em ciclos de CPU para processando a string).

Se você estiver usando jshint , ocorrerá um erro se você usar uma cadeia de aspas duplas.

Usei-o através do suporte Yeoman do AngularJS, mas talvez exista alguma maneira de configurar isso.

A propósito, quando você manipula HTML em JavaScript, é mais fácil usar aspas simples:

var foo = '<div class="cool-stuff">Cool content</div>';

E pelo menos o JSON está usando aspas duplas para seqüências reprensivas.

Não há uma maneira trivial de responder à sua pergunta

Falando sobre desempenho, as cotações nunca serão o seu gargalo, no entanto, o desempenho é o mesmo nos dois casos.

Falando sobre a velocidade de codificação, se você usar 'para delimitar uma string, precisará escapar de "aspas. É mais provável que você precise usar "dentro da string, por exemplo:

//JSON Objects:
var jsonObject = '{"foo":"bar"}';
//HTML attributes:
document.getElementById("foobar").innerHTML = '<input type="text">';

Então, eu prefiro usar 'para delimitar a string, então tenho que escapar menos caracteres.

Uma razão (boba) para usar aspas simples seria que elas não exigem que você pressione a tecla Shift para digitá-las, enquanto as aspas duplas o fazem. (Estou supondo que a string média não exija escape, o que é uma suposição razoável.) Agora, vamos supor que todos os dias eu codifique 200 linhas de código. Talvez nessas 200 linhas eu tenha 30 citações. Talvez digitar uma aspas duplas leve 0,1 segundos a mais do que digitar uma aspas simples (porque eu tenho que pressionar a tecla Shift). Então, em qualquer dia, eu perco 3 segundos. Se eu codifico dessa maneira por 200 dias por ano por 40 anos, perdi 6,7 horas da minha vida. Alimento para o pensamento.

Examinando os prós e contras

A favor de aspas simples

• Menos confusão visual.
• Gerando HTML: os atributos HTML geralmente são delimitados por aspas duplas.

elem.innerHTML = '<a href="' + url + '">Hello</a>';

elem.innerHTML = "<a href='" + url + "'>Hello</a>";

Além disso, o HTML embutido é normalmente um anti-padrão. Preferir modelos.

• Gerando JSON: Somente aspas duplas são permitidas em JSON.

myJson = '{ "hello world": true }';

Novamente, você não precisa construir o JSON dessa maneira. JSON.stringify () geralmente é suficiente. Caso contrário, use modelos.

A favor de aspas duplas

• As duplas são mais fáceis de identificar se você não tiver código de cores. Como em um log do console ou algum tipo de configuração da fonte de exibição.
• Semelhança com outras linguagens: Na programação de shell (Bash etc.), existem literais de string com aspas simples, mas as fugas não são interpretadas dentro delas. C e Java usam aspas duplas para seqüências de caracteres e aspas simples para caracteres.
• Se você deseja que o código seja JSON válido, é necessário usar aspas duplas.

A favor de ambos

Não há diferença entre os dois em JavaScript. Portanto, você pode usar o que for conveniente no momento. Por exemplo, os seguintes literais de sequência produzem a mesma sequência:

    "He said: \"Let's go!\""
    'He said: "Let\'s go!"'
    "He said: \"Let\'s go!\""
    'He said: \"Let\'s go!\"'

Aspas simples para cadeias internas e duplas para externas. Isso permite distinguir constantes internas das seqüências que serão exibidas para o usuário (ou gravadas no disco etc.). Obviamente, você deve evitar colocar o último em seu código, mas isso nem sempre pode ser feito.

Mais uma coisa que você pode considerar como uma razão para a mudança de aspas duplas para aspas simples é o aumento da popularidade dos scripts do lado do servidor. Ao usar o PHP, você pode passar variáveis ​​e analisar funções javascript usando strings e variáveis ​​no PHP.

Se você escrever uma string e usar aspas duplas no seu PHP, não precisará escapar de nenhuma das aspas simples e o PHP recuperará automaticamente o valor das variáveis ​​para você.

Exemplo: 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>";
}

Isso me poupa muito trabalho em ter que lidar com a junção de strings, e posso chamar efetivamente um javascript do PHP. Este é apenas um exemplo, mas esse pode ser um dos vários motivos pelos quais os programadores estão usando aspas simples em javascript.

Cite documentos PHP : "O recurso mais importante das strings com aspas duplas é o fato de os nomes das variáveis ​​serem expandidos. Consulte a análise de strings para obter detalhes."

Há pessoas que afirmam ter diferenças de desempenho: segmento antigo da lista de discussão . Mas não consegui encontrar nenhum deles para ser confirmado.

O principal é analisar que tipo de aspas (duplas ou simples) você está usando dentro da sua string. Ajuda a manter baixo o número de fugas. Por exemplo, quando você trabalha com html dentro de suas strings, é mais fácil usar aspas simples, para que você não precise escapar de todas as aspas duplas ao redor dos atributos.

Eu usaria aspas duplas quando aspas simples não puderem ser usadas e vice-versa:

"'" + singleQuotedValue + "'"
'"' + doubleQuotedValue + '"'

Ao invés de:

'\'' + singleQuotedValue + '\''
"\"" + doubleQuotedValue + "\""

Não há diferença entre aspas simples e duplas no JavaScript.

A especificação é importante:

Talvez haja diferenças de desempenho, mas elas são absolutamente mínimas e podem mudar todos os dias de acordo com a implementação dos navegadores. Discussões adicionais são inúteis, a menos que seu aplicativo JavaScript tenha centenas de milhares de comprimento.

É como uma referência se

a=b;

é mais rápido que

a = b;

(espaços extras)

hoje, em um navegador e plataforma específicos, etc.

Ao usar o CoffeeScript, uso aspas duplas. Concordo que você deve escolher um deles e cumpri-lo. O CoffeeScript fornece interpolação ao usar aspas duplas.

"This is my #{name}"

O ES6 está usando back ticks (`) para seqüências de caracteres de modelo. O que provavelmente tem um bom motivo, mas, ao codificar, pode ser complicado alterar o caractere literal de string de aspas ou aspas duplas para back ticks para obter o recurso de interpolação. O CoffeeScript pode não ser perfeito, mas usar o mesmo caractere de literal de string em todos os lugares (aspas duplas) e sempre poder interpolar é um recurso interessante.

`This is my ${name}`

Se você está alternando entre JavaScript e C #, é melhor treinar os dedos para a convenção comum, que é aspas duplas.

Eu estive executando o seguinte cerca de 20 vezes. E parece que aspas duplas são cerca de 20% mais rápidas.

A parte divertida é que, se você alterar as partes 2 e 1, as aspas simples são cerca de 20% mais rápidas.

//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));

Não há nenhuma diferença estrita; portanto, é principalmente uma questão de gosto e do que está na string (ou se o próprio código JS estiver em uma string), para manter baixo o número de escapes.

A legenda da diferença de velocidade pode vir do mundo PHP, onde as duas aspas têm um comportamento diferente.

Depois de ler todas as respostas que dizem que talvez seja mais rápido ou que tenha vantagens, eu diria que as aspas duplas são melhores ou talvez mais rápidas também porque o compilador de fechamento do Google converte aspas simples em aspas duplas.

Agora que é 2020, devemos considerar uma terceira opção para o Javascript: o backtick único para tudo.

Isso pode ser usado em qualquer lugar, em vez de aspas simples ou duplas.

Ele permite que você faça todas as coisas!

1. Incorpore aspas simples dentro dele: `É ótimo!`
2. Coloque aspas duplas dentro dele: `É" realmente "ótimo!`
3. Use a interpolação de strings: `É" $ {better} "do que ótimo!`

4. Permite várias linhas: `

   este

   Faz

   Javascript

   Melhor!

   `

Também não causa perda de desempenho ao substituir os outros dois: https://medium.com/javascript-in-plain-english/are-backticks-slower-than-other-strings-in-javascript-ce4abf9b9fa

Se sua fonte JS for:

elem.innerHTML="<img src='smily' alt='It\'s a Smily' style='width:50px'>";

A fonte HTML será:

<img src="smiley" alt="It's a Smiley" style="width:50px">

ou para HTML5

<img src=smiley alt="It's a Smiley" style=width:50px>

JS permite matrizes assim:

var arr=['this','that'];

Mas se você o especificar, será por uma razão compatível:

JSON=["this","that"]

Tenho certeza que isso leva algum tempo.

Apenas para adicionar meus 2 centavos: Ao trabalhar com JS e PHP há alguns anos, me acostumei a usar aspas simples para poder digitar o caractere de escape ('\') sem precisar escapar também. Normalmente, eu o usava ao digitar cadeias brutas com caminhos de arquivo etc. ( http://en.wikipedia.org/wiki/String_literal#Raw_strings )

De qualquer forma, minha convenção acabou se tornando o uso de aspas simples em cadeias brutas do tipo identificador, como if (typeof s == 'string') ...(nas quais caracteres de escape nunca seriam usados ​​- nunca) e aspas duplas nos textos , como "Ei, e aí?". Também uso aspas simples nos comentários como uma convenção tipográfica para mostrar nomes de identificadores. Esta é apenas uma regra de ouro e interrompo apenas quando necessário, como ao digitar seqüências de caracteres HTML '<a href="#"> like so <a>'(embora você também possa reverter as aspas aqui). Também sei que, no caso do JSON, aspas duplas são usadas para os nomes - mas fora disso, pessoalmente, prefiro aspas simples quando a fuga nunca é necessária para o texto entre aspas - como document.createElement('div').

Resumindo, e como alguns já mencionaram / aludiram, escolha uma convenção, cumpra-a e desvie-se apenas quando necessário.