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

Vedo sempre più librerie JavaScript là fuori che usano virgolette singole durante la gestione delle stringhe. Quali sono i motivi per utilizzare l'uno rispetto all'altro? Ho pensato che fossero praticamente intercambiabili.

Il motivo più probabile per l'uso di single vs double in librerie diverse è la preferenza del programmatore e / o la coerenza delle API. Oltre ad essere coerente, utilizzare quello che meglio si adatta alla stringa.

Utilizzando l'altro tipo di citazione come letterale:

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

Questo può complicarsi:

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

Un'altra opzione, nuova in ES6, sono i letterali Template che usano il back-tickcarattere:

alert(`Use "double" and 'single' quotes in the same string`);
alert(`Escape the \` back-tick character and the \${ dollar-brace sequence in a string`);

I letterali template offrono una sintassi chiara per: interpolazione variabile, stringhe su più righe e altro.

Si noti che JSON è formalmente specificato per utilizzare le virgolette doppie, che potrebbe valere la pena considerare in base ai requisiti di sistema.

Se hai a che fare con JSON, va notato che in senso stretto, le stringhe JSON devono essere racchiuse tra virgolette. Certo, molte librerie supportano anche virgolette singole, ma ho avuto grossi problemi in uno dei miei progetti prima di rendermi conto che la virgoletta singola di una stringa non è in realtà secondo gli standard JSON.

Non esiste una soluzione migliore ; tuttavia, vorrei sostenere che a volte le virgolette doppie potrebbero essere più desiderabili:

• I nuovi arrivati ​​avranno già familiarità con le doppie citazioni dalla loro lingua . In inglese, dobbiamo usare le virgolette doppie "per identificare un passaggio di testo tra virgolette. Se dovessimo usare una sola citazione ', il lettore potrebbe interpretarla erroneamente come una contrazione. L'altro significato di un passaggio di testo circondato da 'indica il significato "colloquiale". Ha senso rimanere coerenti con le lingue preesistenti e ciò potrebbe probabilmente facilitare l'apprendimento e l'interpretazione del codice.
• Le virgolette doppie eliminano la necessità di sfuggire agli apostrofi (come nelle contrazioni). Si consideri la stringa: "I'm going to the mall", contro la versione altrimenti sfuggito: 'I\'m going to the mall'.

• Le virgolette doppie indicano una stringa in molte altre lingue . Quando impari una nuova lingua come Java o C, vengono sempre utilizzate le virgolette doppie. In Ruby, PHP e Perl, le stringhe a virgoletta singola non implicano escape di barra rovesciata mentre le doppie virgolette le supportano.

• La notazione JSON è scritta con virgolette doppie.

Tuttavia, come altri hanno affermato, è molto importante rimanere coerenti.

La sezione 7.8.4 della specifica descrive la notazione letterale della stringa. L'unica differenza è che DoubleStringCharacter è "SourceCharacter ma non virgoletta doppia" e SingleStringCharacter è "SourceCharacter ma non virgoletta singola". Quindi l' unica differenza può essere dimostrata così:

'A string that\'s single quoted'

"A string that's double quoted"

Quindi dipende da quanta citazione scappi vuoi fare. Ovviamente lo stesso vale per le virgolette doppie tra stringhe tra virgolette doppie.

Citazioni singole

Vorrei che le doppie virgolette fossero lo standard, perché hanno un po 'più senso , ma continuo a usare le virgolette singole perché dominano la scena.

Virgolette singole:

• Airbnb
• Facebook
• Google
• grugnito
• sorso
• nodo
• npm (anche se non definito nella guida dell'autore )
• wikimedia
• wordpress
• Yandex

Nessuna preferenza:

• Three.js

Virgolette:

• dattiloscritto
• Crockford
• d3 (anche se non definito in .eslintrc)
• jquery

Vorrei dire che la differenza è puramente stilistica, ma ho davvero i miei dubbi. Considera il seguente esempio:

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

In Safari, Chrome, Opera e Internet Explorer (testato in IE7 e IE8), questo restituirà quanto segue:

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

Tuttavia, Firefox produrrà un risultato leggermente diverso:

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

Le virgolette singole sono state sostituite da virgolette doppie. (Nota anche come lo spazio di rientro è stato sostituito da quattro spazi.) Questo dà l'impressione che almeno un browser analizzi JavaScript internamente come se tutto fosse scritto usando virgolette doppie. Si potrebbe pensare, Firefox impiega meno tempo per analizzare JavaScript se tutto è già scritto secondo questo "standard".

Il che, tra l'altro, mi rende un panda molto triste, dal momento che penso che le virgolette singole siano molto più belle nel codice. Inoltre, in altri linguaggi di programmazione, di solito sono più veloci da usare rispetto alle doppie virgolette, quindi avrebbe senso solo se lo stesso fosse applicato a JavaScript.

Conclusione: penso che dobbiamo fare ulteriori ricerche su questo.

Modifica: questo potrebbe spiegare i risultati dei test di Peter-Paul Koch nel 2003.

Sembra che le virgolette singole siano a volte più veloci in Windows Explorer (circa 1/3 dei miei test hanno mostrato un tempo di risposta più veloce), ma se Mozilla mostra una differenza, gestisce le virgolette doppie leggermente più velocemente. Non ho trovato alcuna differenza in Opera.

Modifica 2014: le versioni moderne di Firefox / Spidermonkey non lo fanno più.

Se stai facendo JavaScript incorporato (probabilmente una cosa "cattiva", ma evitando quella discussione), le singole virgolette sono la tua unica opzione per i letterali di stringa, credo.

ad esempio, funziona perfettamente:

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

Ma non puoi racchiudere il "ciao" tra virgolette doppie, tramite qualsiasi metodo di escape di cui sono a conoscenza. Anche "quale sarebbe stata la mia ipotesi migliore (dal momento che stai sfuggendo alle virgolette in un valore di attributo di HTML) non funziona per me in Firefox. \"non funzionerà neanche perché a questo punto stai scappando per HTML, non JavaScript.

Quindi, se il nome del gioco è coerenza e hai intenzione di creare JavaScript incorporato in alcune parti della tua app, penso che le virgolette singole siano il vincitore. Qualcuno, per favore, correggimi se sbaglio.

Tecnicamente non c'è differenza, è solo questione di stile e convenzione.

Douglas Crockford consiglia di utilizzare virgolette singole per stringhe interne e doppie virgolette per esterno (per esterno intendiamo quelli da visualizzare all'utente dell'applicazione, come messaggi o avvisi).

Lo seguo personalmente.

AGGIORNAMENTO: Sembra che il signor Crockford abbia cambiato idea e ora raccomanda di usare le doppie virgolette :)

A rigor di termini, non vi è alcuna differenza nel significato; quindi la scelta si riduce alla convenienza.

Ecco alcuni fattori che potrebbero influenzare la tua scelta:

• Stile house: alcuni gruppi di sviluppatori utilizzano già una convenzione o l'altra.
• Requisiti lato client: utilizzerai le virgolette nelle stringhe? (Vedi la risposta di Ady).
• Linguaggio lato server: le persone VB.Net potrebbero scegliere di utilizzare virgolette singole per java-script in modo che gli script possano essere costruiti sul lato server (VB.Net utilizza virgolette doppie per le stringhe, quindi le stringhe java-script sono facili da distinguere se usano virgolette singole).
• Codice libreria: se stai utilizzando una libreria che utilizza uno stile particolare, potresti considerare di utilizzare lo stesso stile da solo.
• Preferenza personale: potresti pensare che uno o l'altro stile sia migliore.

Diamo un'occhiata a cosa fa un riferimento.

All'interno di jquery.js, ogni stringa è racchiusa tra virgolette doppie.

Quindi, a partire da ora, userò stringhe tra virgolette doppie. (Stavo usando single!)

Mantieni la coerenza in ciò che usi. Ma non deludere il tuo livello di comfort.

"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

Aggiornamento ES6

Utilizzando la sintassi letterale del modello .

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

È principalmente una questione di stile e preferenza. Ci sono alcune esplorazioni tecniche piuttosto interessanti e utili nelle altre risposte, quindi forse l'unica cosa che potrei aggiungere è offrire un piccolo consiglio mondano.

• Se stai codifica di una società o di squadra, allora è probabilmente una buona idea di seguire la "stile della casa".

• Se sei da solo l'hacking alcuni progetti collaterali, quindi guardare alcuni leader di spicco nella comunità. Ad esempio, supponiamo che entri in Node.js. Dai un'occhiata ai moduli principali, ad esempio underscore.js o express e vedi quale convenzione usano, e considera di seguirlo.

• Se entrambe le convenzioni sono ugualmente utilizzati, quindi rinviare al personal
  preferenza.

• Se non avete preferenze personali, poi lancia una moneta.

• Se non hai una moneta, allora la birra è su di me;)

Spero di non aggiungere qualcosa di ovvio, ma ho lottato con Django e Ajax e JSON su questo.

Supponendo che nel tuo codice HTML utilizzi virgolette doppie, come normalmente dovrebbe essere, consiglio vivamente di usare virgolette singole per il resto in JavaScript.

Quindi sono d'accordo con @ady ma con una certa cura.

La mia linea di fondo è: in JavaScript probabilmente non ha importanza, ma non appena lo si incorpora in HTML o simili inizi a creare problemi. Dovresti sapere cosa sta effettivamente scappando, leggendo, passando la tua stringa.

Il mio semplice caso era:

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

Puoi individuare \ "nel terzo campo di showThis.

La doppia citazione non ha funzionato!

È chiaro perché, ma è anche chiaro perché dovremmo attenerci a virgolette singole ... .. Immagino ..

Questo caso è un incorporamento HTML molto semplice, l'errore è stato generato da una semplice copia / incolla da un codice JavaScript "tra virgolette doppie".

Quindi, per rispondere alla domanda:

Prova a usare virgolette singole all'interno di HTML. Potrebbe salvare un paio di problemi di debug ...

Non sono sicuro se questo è rilevante nel mondo di oggi, ma le doppie virgolette erano utilizzate per i contenuti che dovevano essere elaborati i caratteri di controllo e le virgolette singole per le stringhe che non lo facevano.

Il compilatore eseguirà la manipolazione della stringa su una stringa tra virgolette doppie lasciando letteralmente intatta una singola stringa tra virgolette. Questo portava agli sviluppatori "bravi" a scegliere di usare virgolette singole per stringhe che non contenevano caratteri di controllo simili \no \0(non elaborati tra virgolette singole) e virgolette doppie quando avevano bisogno della stringa analizzata (a un costo contenuto nei cicli cpu per elaborazione della stringa).

Se si utilizza jshint , genererà un errore se si utilizza una stringa di virgolette doppie.

L'ho usato attraverso l'impalcatura Yeoman di AngularJS ma forse c'è un modo per configurarlo.

A proposito, quando gestisci l'HTML in JavaScript, è più facile usare la singola citazione:

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

E almeno JSON utilizza le virgolette doppie per stringhe rappresentative.

Non esiste un modo banale per rispondere alla tua domanda

A proposito di prestazioni, le virgolette non saranno mai il collo di bottiglia, tuttavia le prestazioni sono le stesse in entrambi i casi.

Per quanto riguarda la velocità di codifica, se si utilizza 'per delimitare una stringa, sarà necessario evitare le "virgolette. È più probabile che sia necessario utilizzare "all'interno della stringa, ad esempio:

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

Quindi, preferisco usare 'per delimitare la stringa, quindi devo scappare meno caratteri.

Una (sciocca) ragione per usare le virgolette singole sarebbe che non richiedono di premere il tasto Maiusc per digitarle, mentre una doppia virgoletta lo fa. (Suppongo che la stringa media non richieda l'escaping, il che è un presupposto ragionevole.) Ora, supponiamo che ogni giorno codice 200 righe di codice. Forse in quelle 200 righe ho 30 virgolette. Forse digitare una virgoletta doppia richiede 0,1 secondi in più rispetto alla digitazione di una virgoletta singola (perché devo premere il tasto Maiusc). Quindi in un dato giorno, spreco 3 secondi. Se codifico in questo modo per 200 giorni all'anno per 40 anni, allora ho sprecato 6,7 ore della mia vita. Cibo per la mente.

Esaminando i pro e i contro

A favore di virgolette singole

• Meno disordine visivo.
• Generazione di HTML: gli attributi HTML sono generalmente delimitati da virgolette doppie.

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

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

Inoltre, l'HTML in linea è normalmente un anti-pattern. Preferisci modelli.

• Generazione di JSON: in JSON sono consentite solo virgolette doppie.

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

Ancora una volta, non dovresti costruire JSON in questo modo. JSON.stringify () è spesso abbastanza. In caso contrario, utilizzare i modelli.

A favore delle doppie virgolette

• I doppi sono più facili da individuare se non si dispone di un codice colore. Come in un registro della console o in una sorta di configurazione della vista-sorgente.
• Somiglianza con altre lingue: nella programmazione della shell (Bash ecc.) Esistono letterali stringa a virgoletta singola, ma gli escape non sono interpretati al loro interno. C e Java usano virgolette doppie per stringhe e virgolette singole per caratteri.
• Se si desidera che il codice sia JSON valido, è necessario utilizzare virgolette doppie.

A favore di entrambi

Non c'è alcuna differenza tra i due in JavaScript. Pertanto, è possibile utilizzare ciò che è conveniente al momento. Ad esempio, i seguenti valori letterali di stringa producono tutti la stessa stringa:

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

Virgolette singole per stringhe interne e doppie per esterno. Ciò consente di distinguere le costanti interne dalle stringhe che devono essere visualizzate all'utente (o scritte su disco, ecc.). Ovviamente, dovresti evitare di inserire quest'ultimo nel tuo codice, ma non è sempre possibile farlo.

Un'altra cosa che potresti considerare come una ragione per il passaggio da virgolette doppie a virgolette singole è l'aumento della popolarità degli script lato server. Quando usi PHP puoi passare variabili e analizzare le funzioni javascript usando stringhe e variabili in PHP.

Se scrivi una stringa e usi le virgolette doppie per il tuo PHP non dovrai sfuggire a nessuna delle virgolette singole e PHP recupererà automaticamente il valore delle variabili per te.

Esempio: ho bisogno di eseguire una funzione JavaScript utilizzando una variabile dal mio server.

public static function redirectPage( $pageLocation )
{
    echo "<script type='text/javascript'>window.location = '$pageLocation';</script>";
}

Questo mi fa risparmiare molta seccatura nel dover gestire le stringhe di unione e posso effettivamente chiamare un javascript da PHP. Questo è solo un esempio, ma questo può essere uno dei diversi motivi per cui i programmatori stanno impostando le virgolette singole su javascript.

Citazione da documenti PHP : "La caratteristica più importante delle stringhe tra virgolette doppie è il fatto che i nomi delle variabili verranno espansi. Vedere l'analisi delle stringhe per i dettagli."

Ci sono persone che affermano di vedere differenze di prestazioni: vecchio thread della mailing list . Ma non sono riuscito a trovarne nessuno da confermare.

La cosa principale è guardare che tipo di virgolette (doppie o singole) stai usando nella tua stringa. Aiuta a mantenere basso il numero di fughe. Ad esempio, quando lavori con HTML all'interno delle tue stringhe, è più facile usare le virgolette singole in modo da non dover sfuggire a tutte le doppie virgolette attorno agli attributi.

Vorrei usare le virgolette doppie quando non è possibile utilizzare virgolette singole e viceversa:

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

Invece di:

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

Non c'è differenza tra virgolette singole e doppie in JavaScript.

Le specifiche sono importanti:

Forse ci sono differenze di prestazioni, ma sono assolutamente minime e possono cambiare ogni giorno in base all'implementazione dei browser. Ulteriori discussioni sono inutili a meno che l'applicazione JavaScript non sia lunga centinaia di migliaia.

È come un punto di riferimento se

a=b;

è più veloce di

a = b;

(spazi extra)

oggi, in un particolare browser e piattaforma, ecc.

Quando uso CoffeeScript uso doppie virgolette. Sono d'accordo che dovresti scegliere uno dei due e attenersi ad esso. CoffeeScript fornisce interpolazione quando si utilizzano le virgolette doppie.

"This is my #{name}"

ES6 sta usando i segni di spunta indietro (`) per le stringhe del modello. Il che probabilmente ha una buona ragione, ma durante la codifica può essere scomodo cambiare il carattere letterale delle stringhe tra virgolette o virgolette doppie in back tick per ottenere la funzione di interpolazione. CoffeeScript potrebbe non essere perfetto, ma usare lo stesso carattere letterale di stringa ovunque (virgolette doppie) ed essere sempre in grado di interpolare è una bella caratteristica.

`This is my ${name}`

Se stai saltando indietro tra JavaScript e C #, è meglio allenare le dita per la convenzione comune che è tra virgolette doppie.

Ho seguito quanto segue circa 20 volte. E sembra che le doppie virgolette siano circa il 20% più veloci.

La parte divertente è che se cambi la parte 2 e la parte 1 in giro, le virgolette singole sono circa il 20% più veloci.

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

Non c'è assolutamente alcuna differenza, quindi è principalmente una questione di gusti e di ciò che è nella stringa (o se il codice JS stesso è in una stringa), per mantenere basso il numero di escape.

La legenda della differenza di velocità potrebbe provenire dal mondo PHP, in cui le due virgolette hanno un comportamento diverso.

Dopo aver letto tutte le risposte che dicono che potrebbe essere più veloce o forse avere dei vantaggi, direi che la doppia virgoletta è migliore o forse anche più veloce perché il compilatore di chiusura di Google converte le virgolette singole in virgolette doppie.

Ora che è il 2020, dovremmo considerare una terza opzione per Javascript: il singolo backtick per tutto.

Questo può essere usato ovunque anziché tra virgolette singole o doppie.

Ti permette di fare tutto!

1. Incorpora al suo interno virgolette singole: "È fantastico!"
2. Incorpora doppie virgolette al suo interno: "È" davvero "fantastico!`
3. Usa l'interpolazione di stringhe: `È" $ {better} "che great!`

4. Permette più linee: `

   Questo

   Fa

   Javascript

   Meglio!

   `

Inoltre non causa alcuna perdita di prestazioni quando si sostituiscono gli altri due: https://medium.com/javascript-in-plain-english/are-backticks-slower-than-other-strings-in-javascript-ce4abf9b9fa

Se la tua fonte JS è:

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

Il sorgente HTML sarà:

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

o per HTML5

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

JS consente matrici del genere:

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

Ma se lo stringi, sarà per ragioni compatibili:

JSON=["this","that"]

Sono sicuro che ci vorrà del tempo.

Solo per aggiungere i miei 2 centesimi: lavorando con JS e PHP qualche anno fa, mi sono abituato a usare virgolette singole in modo da poter digitare il carattere di escape ('\') senza doverlo scappare. Di solito lo usavo quando scrivevo stringhe non elaborate con percorsi di file, ecc. ( Http://en.wikipedia.org/wiki/String_literal#Raw_strings )

Ad ogni modo, la mia convenzione finì per diventare l'uso di virgolette singole su stringhe non elaborate di tipo identificativo, come if (typeof s == 'string') ...(in cui i caratteri di escape non sarebbero mai stati usati mai) e doppie virgolette per testi come "Ehi, come va?". Uso anche virgolette singole nei commenti come convenzione tipografica per mostrare i nomi degli identificatori. Questa è solo una regola empirica e mi interrompo solo quando necessario, ad esempio quando si digitano stringhe HTML '<a href="#"> like so <a>'(anche se qui è possibile invertire anche le virgolette). Sono anche consapevole che, nel caso di JSON, per i nomi vengono utilizzate le virgolette doppie, ma al di fuori di ciò, personalmente, preferisco le virgolette singole quando non è mai necessario scappare per il testo tra virgolette document.createElement('div').

In conclusione, e come alcuni hanno accennato / accennato, scegliere una convenzione, attenersi ad essa e deviare solo quando necessario.