Pregunta ¿Cuándo usar comillas dobles o simples en JavaScript?


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

Cada vez veo más bibliotecas de JavaScript usando comillas simples al manejar cadenas. ¿Cuáles son las razones para usar una sobre la otra? Pensé que son bastante intercambiables.


1684


origen


Respuestas:


La razón más probable para el uso de bibliotecas individuales y dobles en bibliotecas diferentes es la preferencia del programador y / o la consistencia API.

Aparte de ser consistente, use el que mejor se adapte a la cadena:

Usar el otro tipo de cita como un literal:

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

... pero esto puede complicarse ...

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

Otra opción, nueva en ES6, es Literales de plantilla que usan el back-tick personaje:

alert(`Use "double" and 'single' quotes in the same string`);
alert(`The escape the \` back-tick character in a string`);

Los literales de plantilla ofrecen una sintaxis limpia para: interpolación variable, cadenas de varias líneas y más.


1042



Si está tratando con JSON, debe tenerse en cuenta que, en sentido estricto, las cadenas JSON deben tener una doble cita. Claro, muchas bibliotecas también admiten comillas simples, pero tuve grandes problemas en uno de mis proyectos antes de darme cuenta de que el solo hecho de citar una cadena de hecho no está de acuerdo con los estándares JSON.


567



No hay una mejor solución; Sin embargo, me gustaría argumentar que las comillas dobles pueden ser más deseables a veces:

  • Los recién llegados ya estarán familiarizados con las comillas dobles de su idioma. En inglés, debemos usar comillas dobles " para identificar un pasaje de texto citado. Si fuéramos a usar una sola cita ', el lector puede malinterpretarlo como una contracción. El otro significado de un pasaje de texto rodeado por el ' indica el significado 'coloquial'. Tiene sentido mantenerse consistente con los idiomas preexistentes, y esto puede facilitar el aprendizaje y la interpretación del código.
  • Las comillas dobles eliminan la necesidad de escapar apóstrofes (como en contracciones). Considera la cadena: "I'm going to the mall", frente a la versión de otro modo escapada: 'I\'m going to the mall'.
  • Las comillas dobles significan una cadena en muchos otros idiomas. Cuando aprende un nuevo idioma como Java o C, siempre se utilizan comillas dobles. En Ruby, PHP y Perl, las cadenas de comillas simples implican que no se escapa la barra invertida, mientras que las comillas dobles las admiten.

  • La notación JSON está escrita con comillas dobles.

Sin embargo, como otros han declarado, lo más importante es mantener la coherencia.


244



los solamente la diferencia se demuestra en lo siguiente:

'A string that\'s single quoted'

"A string that's double quoted"

Por lo tanto, solo depende de la cantidad de comillas que deseas evitar. Obviamente, lo mismo se aplica a las comillas dobles en cadenas de comillas dobles.


111



Comillas simples

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

Comillas simples:

Sin preferencias:

Doble comillas:


68



Me gustaría decir que la diferencia es puramente estilística, pero realmente estoy teniendo 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 IE7 e IE8), esto devolverá lo siguiente:

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

Sin embargo, Firefox arrojará 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 observe cómo el espacio sangrado fue reemplazado por cuatro espacios). Esto da la impresión de que al menos un navegador analiza el código interno de JavaScript como si todo estuviera escrito usando comillas dobles. Uno podría pensar que a Firefox le toma menos tiempo analizar el JavaScript si todo está escrito de acuerdo con este 'estándar'.

Lo que, por cierto, me convierte en un panda 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.

Editar: Esto podría explicar Resultados de las pruebas de Peter-Paul Koch desde el año 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 una diferencia, maneja las comillas dobles un poco más rápido. No encontré ninguna diferencia en Opera.

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


54



Si está haciendo JavaScript en línea (podría decirse que es algo "malo", pero evitando esa discusión) soltero las citas son su única opción para los literales de cadenas, creo.

Por ejemplo, esto funciona bien:

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

Pero no puede envolver el "hi" entre comillas dobles, a través de cualquier método de escape que yo sepa. Incluso &quot; cuál habría sido mi mejor suposición (ya que estás escapando comillas en un valor de atributo de HTML) no funciona para mí en Firefox. \" tampoco funcionará porque en este punto está escapando para HTML, no para JavaScript.

Entonces, si el nombre del juego es consistente, y vas a hacer un poco de JavaScript en línea en partes de tu aplicación, creo que las comillas simples son las ganadoras. Alguien por favor corrígeme si me equivoco.


30



Técnicamente no hay diferencia, es solo cuestión de estilo y convención.

Douglas Crockford recomienda utilizar comillas simples para cadenas internas y comillas dobles para externas (por externas queremos decir las que se mostrarán al usuario de la aplicación, como mensajes o alertas).

Yo personalmente sigo eso.

ACTUALIZACIÓN: parece que el Sr. Crockford cambió de opinión y ahora recomienda usar comillas dobles durante todo :)


29