¿Las comillas simples y dobles son intercambiables en JavaScript?

Question 1

Considere las siguientes dos alternativas:

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

El primero usa comillas dobles alrededor de la cadena, mientras que el segundo usa comillas simples alrededor de la cadena.

Veo más y más bibliotecas de JavaScript que usan comillas simples al manejar cadenas.

¿Son estos dos usos intercambiables? Si no, ¿hay alguna ventaja en usar uno sobre el otro?

Question 2

Si está tratando con JSON, debe tener en cuenta que, estrictamente hablando, las cadenas JSON deben estar entre comillas dobles. Claro, muchas bibliotecas también admiten comillas simples, pero tuve grandes problemas en uno de mis proyectos antes de darme cuenta de que las comillas simples de una cadena, de hecho, no están de acuerdo con los estándares JSON.

Question 3

Comillas simples

Desearía que las comillas dobles fueran el estándar, porque tienen un poco más de sentido, pero sigo usando comillas simples porque dominan la escena.

Comillas simples:

airbnb
Facebook
Google
Gruñido
Gulp.js
Nodo.js
npm (aunque no definido en la guía del autor)
wikimedia
WordPress
Yandex

Sin preferencias:

tres.js

Doble comillas:

Mecanografiado
douglas crockford
D3.js (aunque no definido en .eslintrc)
jQuery

Question 4

Sección 7.8.4 de la especificación describe la notación de cadenas literales. La única diferencia es que DoubleStringCharacter es “SourceCharacter pero no entre comillas dobles” y SingleStringCharacter es “SourceCharacter pero no entre comillas simples”. Entonces el solo diferencia se puede demostrar así:

'A string that\'s single quoted'

"A string that's double quoted"

Por lo tanto, depende de la cantidad de escape de cotización que desee hacer. Obviamente, lo mismo se aplica a las comillas dobles en las cadenas entre comillas dobles.

Question 5

Me gustaría decir que la diferencia es puramente estilística, pero realmente tengo mis dudas. Considere el siguiente ejemplo:

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

En Safari, Chrome, Opera e Internet Explorer (probado en explorador de Internet 7 y explorador de Internet 8), esto devolverá lo siguiente:

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

Sin embargo, Firefox producirá un resultado ligeramente diferente:

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

Las comillas simples han sido reemplazadas por comillas dobles. (También tenga en cuenta cómo el espacio de sangría fue reemplazado por cuatro espacios). Esto da la impresión de que al menos un navegador analiza JavaScript internamente como si todo estuviera escrito con comillas dobles. Uno podría pensar que a Firefox le lleva menos tiempo analizar JavaScript si todo ya está escrito de acuerdo con este “estándar”.

Lo cual, por cierto, me pone muy triste, ya que creo que las comillas simples se ven mucho mejor en el código. Además, en otros lenguajes de programación, generalmente son más rápidos de usar que las comillas dobles, por lo que solo tendría sentido si se aplicara lo mismo a JavaScript.

Conclusión: Creo que tenemos que investigar más sobre esto.

Esto podría explicar Resultados de la prueba de Peter-Paul Koch desde allá por 2003.

Parece que las comillas simples son a veces más rápido en Explorer Windows (aproximadamente 1/3 de mis pruebas mostraron un tiempo de respuesta más rápido), pero si Mozilla muestra alguna diferencia, maneja las comillas dobles un poco más rápido. No encontré ninguna diferencia en absoluto en Opera.

2014: Las versiones modernas de Firefox/Spidermonkey ya no hacen esto.

Comillas simples

¿Ha sido útil esta solución?