tipos simples sencillas reemplazar programacion por entre dobles diferencia dentro concatenar comillas javascript string conventions

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



reemplazar comillas dobles por simples javascript (30)

Examinando los pros y los contras.

A favor de comillas simples

  • Menos desorden visual.
  • Generación de HTML: los atributos HTML suelen estar delimitados por comillas dobles.

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

Sin embargo, las comillas simples son tan legales en HTML.

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

Además, el HTML en línea es normalmente un anti-patrón. Prefiero plantillas.

  • Generación de JSON: solo se permiten comillas dobles en JSON.

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

De nuevo, no deberías tener que construir JSON de esta manera. JSON.stringify () es a menudo suficiente. Si no, usa plantillas.

A favor de las comillas dobles

  • Los dobles son más fáciles de detectar si no tienes codificación de colores. Como en un registro de consola o algún tipo de configuración de fuente de vista.
  • Similitud con otros lenguajes: En la programación de shell (Bash, etc.), existen literales de cadena con comillas simples, pero los escapes no se interpretan dentro de ellos. C y Java utilizan comillas dobles para cadenas y comillas simples para caracteres.
  • Si desea que el código sea JSON válido, debe usar comillas dobles.

A favor de ambos

No hay diferencia entre los dos en JavaScript. Por lo tanto, puedes usar lo que sea conveniente en este momento. Por ejemplo, los siguientes literales de cadena producen la misma cadena:

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

Comillas simples para cadenas internas y dobles para externas. Eso le permite distinguir las constantes internas de las cadenas que se mostrarán al usuario (o se escribirán en el disco, etc.). Obviamente, debes evitar poner esto último en tu código, pero eso no siempre se puede hacer.

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

Veo más y más bibliotecas de JavaScript por ahí usando comillas simples al manejar cadenas. ¿Cuáles son las razones para usar uno sobre el otro? Pensé que son bastante intercambiables.

Es sobre todo una cuestión de estilo y preferencia. Hay algunas exploraciones técnicas bastante interesantes y útiles en las otras respuestas, así que quizás lo único que podría agregar es ofrecer un pequeño consejo mundano.

  • Si está codificando en una empresa o equipo, entonces probablemente sea una buena idea seguir el "estilo de casa".

  • Si está solo hackeando algunos proyectos paralelos, mire a algunos líderes prominentes en la comunidad. Por ejemplo, digamos que te metes en Node.js. Eche un vistazo a los módulos principales, por ejemplo, underscore.js o express y vea qué convención utilizan, y considere seguir eso.

  • Si ambas convenciones se utilizan por igual, entonces difiera a su personal
    preferencia.

  • Si no tienes preferencias personales, entonces lanza una moneda.

  • Si no tienes una moneda, entonces la cerveza está en mí;)

Espero no estar agregando algo obvio, pero he estado luchando con Django Ajax y JSON en esto.

Suponiendo que en su código HTML use comillas dobles, como normalmente debería ser, le sugiero que use comillas simples para el resto en JavaScript.

Así que estoy de acuerdo con @ady pero con un poco de cuidado.

Mi conclusión es: en JavaScript probablemente no importa, pero tan pronto como lo incruste en HTML o similar, comenzará a tener problemas. Debes saber qué es lo que realmente está escapando, leyendo, pasando tu cadena.

Mi caso simple fue:

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

Puedes ver el / ''en el tercer campo de showThis.

La doble cita no funcionó!

Está claro por qué, pero también está claro por qué deberíamos usar comillas simples ... .. Supongo ...

Este caso es una incrustación de HTML muy simple, el error se generó mediante una simple copia / pegado de un código JavaScript de "doble cita".

Así que para responder a la pregunta:

Trate de usar comillas simples dentro de HTML. Podría ahorrar un par de problemas de depuración ...

Estrictamente hablando, no hay diferencia en el significado; Así que la elección se reduce a la conveniencia.

Aquí hay varios factores que podrían influir en su elección:

  • Estilo de la casa: Algunos grupos de desarrolladores ya usan una convención u otra.
  • Requisitos del lado del cliente: ¿Utilizará comillas dentro de las cadenas? (Ver la respuesta de Ady).
  • Lenguaje del lado del servidor: la gente de VB.Net puede optar por usar comillas simples para java-script de modo que los guiones se puedan construir en el lado del servidor (VB.Net usa comillas dobles para las cadenas, por lo que las cadenas de java-script son fáciles de distinguir si usan comillas simples).
  • Código de biblioteca: si está utilizando una biblioteca que usa un estilo particular, puede considerar usar el mismo estilo usted mismo.
  • Preferencia personal: Usted podría pensar que uno u otro estilo se ve mejor.

Hablando de rendimiento, las citas nunca serán su cuello de botella, sin embargo, el rendimiento es el mismo en ambos casos.

Hablando de la velocidad de codificación, si usa '' para delimitar una cadena, necesitará escapar de " comillas. Es más probable que tenga que usar " dentro de la cadena, en el ejemplo:

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

Luego, prefiero usar '' para delimitar la cadena, así que tengo que escapar de menos caracteres.

La única diferencia se demuestra en lo siguiente:

''A string that/'s single quoted'' "A string that''s double quoted"

Por lo tanto, solo se reduce a la cantidad de cotización que desea realizar. Obviamente, lo mismo se aplica a las comillas dobles en cadenas entre comillas dobles.

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

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

Usando 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, son los literales de plantilla que usan el carácter de back-tick :

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

Los literales de plantilla ofrecen una sintaxis limpia para: interpolación de variables, cadenas multilínea y más.

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 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 dará 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 Firefox tarda menos tiempo en analizar JavaScript si todo está escrito de acuerdo con este "estándar".

Lo que, por cierto, me hace 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, suelen ser 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 necesitamos hacer más investigación sobre esto.

Edit: Esto podría explicar los resultados de las pruebas de Peter-Paul Koch en 2003.

Parece que las comillas simples a veces son más rápidas en el Explorador de 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 la ópera.

Edición 2014: las versiones modernas de Firefox / Spidermonkey ya no hacen esto.

No estoy seguro de si esto es relevante en el mundo de hoy, pero las comillas dobles solían usarse para el contenido que necesitaba tener caracteres de control procesados ​​y comillas simples para cadenas que no lo tenían.

El compilador ejecutará la manipulación de cadenas en una cadena con doble comillas mientras deja una cadena entre comillas literalmente intacta. Esto solía llevar a que los desarrolladores ''buenos'' eligieran usar comillas simples para cadenas que no contenían caracteres de control como /n o /0 (no procesadas dentro de comillas simples) y comillas dobles cuando necesitaban la cadena analizada (a un ligero costo en ciclos de cpu para procesar la cadena).

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

Si está utilizando jshint , generará un error si usa una cadena de comillas dobles.

Lo utilicé a través del andamiaje Yeoman de AngularJS, pero tal vez haya alguna forma de configurar esto.

Por cierto, cuando manejas HTML en JavaScript, es más fácil usar comillas simples:

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

Y al menos JSON está utilizando comillas dobles para volver a mostrar las cadenas.

No hay una forma trivial de responder a tu pregunta.

Si estás haciendo JavaScript en línea (posiblemente una cosa "mala", pero evitando esa discusión) las comillas simples son tu única opción para los literales de cadena, creo.

Por ejemplo, esto funciona bien:

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

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

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

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

Douglas Crockford recomienda el uso de comillas simples para cadenas internas y comillas dobles para las externas (entendemos por externos 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 crockford y ahora recomienda usar comillas dobles en todo :)

Una cosa más que podría considerar como una razón para el cambio de comillas dobles a comillas simples es el aumento en la popularidad de los scripts del lado del servidor. Al usar PHP puede pasar variables y analizar funciones de javascript usando cadenas y variables en PHP.

Si escribe una cadena y usa comillas dobles para su PHP, no tendrá que escapar de ninguna de las comillas simples y PHP recuperará automáticamente el valor de las variables para usted.

Ejemplo: necesito ejecutar una función javascript usando una variable de mi servidor.

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

Esto me ahorra un montón de problemas al tener que lidiar con unirme a cadenas, y efectivamente puedo llamar a un javascript desde PHP. Este es solo un ejemplo, pero esta puede ser una de las varias razones por las que los programadores están omitiendo comillas simples en JavaScript.

Cita de documentos PHP : "La característica más importante de las cadenas entre comillas dobles es el hecho de que los nombres de las variables se expandirán. Consulte el análisis de cadenas para obtener más detalles".

Una razón (tonta) para usar comillas simples sería que no requieren que pulses la tecla de mayúsculas para escribirlas, mientras que una comilla doble sí. (Supongo que la cadena promedio no requiere que se escape, lo cual es una suposición razonable). Ahora, supongamos que cada día codifico 200 líneas de código. Tal vez en esas 200 líneas tengo 30 citas. Tal vez escribir una comilla doble toma 0.1 segundos más tiempo que escribir una comilla simple (porque tengo que presionar la tecla Mayús). Luego, en un día cualquiera, desperdicio 3 segundos. Si codifico de esta manera durante 200 días al año durante 40 años, desperdicié 6,7 horas de mi vida. Comida para el pensamiento.

Veamos lo que hace una referencia.

Dentro de jquery.js, todas las cadenas tienen comillas dobles.

Así que, comenzando ahora, usaré cadenas entre comillas dobles. (Estaba usando solo!)

No hay una solución mejor ; 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 tuviéramos que usar una comilla simple '' , el lector puede malinterpretarlo como una contracción. El otro significado de un pasaje de texto rodeado de '' indica el Significado "coloquial". Tiene sentido mantener la coherencia con los lenguajes preexistentes, y esto puede facilitar el aprendizaje y la interpretación del código.
  • Las comillas dobles eliminan la necesidad de escapar de los apóstrofes (como en las contracciones). Considere la cadena: "I''m going to the mall" , en comparación con la versión de otro modo escapada: ''I/'m going to the mall'' .

  • Las comillas dobles significan una cadena en muchos otros idiomas . Cuando aprendes un nuevo lenguaje como Java o C, siempre se utilizan comillas dobles. En Ruby, PHP y Perl, las cadenas entre comillas simples implican que no hay escapes de barra invertida mientras que las comillas dobles las admiten.

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

No obstante, como han dicho otros, es muy importante mantener la coherencia.

Solo mantén la consistencia en lo que usas. Pero no baje su nivel de comodidad.

"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

Actualización ES6

Utilizando plantilla de sintaxis literal .

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

No hay diferencia entre comillas simples y dobles en JavaScript.

La especificación es importante:

Quizás haya diferencias de rendimiento, pero son absolutamente mínimas y pueden cambiar todos los días según la implementación de los navegadores. Más discusión es inútil a menos que su aplicación de JavaScript tenga cientos de miles de personas.

Es como un punto de referencia si

a=b;

es más rápido que

a = b;

(espacios extra)

Hoy, en un navegador y plataforma particular, etc.

No hay ninguna diferencia estrictamente, por lo que es principalmente una cuestión de gusto y de lo que está en la cadena (o si el código JS está en una cadena), mantener el número de escapes bajo.

La leyenda de la diferencia de velocidad puede provenir del mundo PHP, donde las dos citas tienen un comportamiento diferente.

Si está saltando hacia atrás entre JavaScript y C #, es mejor entrenar sus dedos para la convención común que es comillas dobles.

Si su fuente JS es:

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

La fuente HTML será:

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

o para HTML5

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

JS permite matrices así:

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

Pero si lo haces, será por razones compatibles:

JSON=["this","that"]

Estoy seguro de que esto lleva algún tiempo.

Usaría comillas dobles cuando no se pueden usar comillas simples y viceversa:

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

En lugar de:

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

Cuando uso CoffeeScript uso comillas dobles. Estoy de acuerdo en que debes elegir cualquiera y seguirlo. CoffeeScript le da interpolación cuando utiliza las comillas dobles.

"This is my #{name}"

ES6 está utilizando marcas de retroceso (`) para las cadenas de la plantilla. Lo que probablemente tiene una buena razón, pero cuando se codifica puede ser engorroso cambiar el carácter de los literales de la cadena de comillas o comillas dobles a comillas anteriores para obtener la función de interpolación. CoffeeScript puede no ser perfecto, pero usar la misma cadena de caracteres literales en todas partes (comillas dobles) y siempre ser capaz de interpolar es una buena característica.

`This is my ${name}`

Después de leer todas las respuestas que dicen que puede ser más rápido o tener ventajas, yo diría que las comillas dobles son mejores o quizás más rápidas también porque el compilador de cierre de Google convierte comillas simples en comillas dobles.

Hay personas que afirman ver diferencias de rendimiento: hilo de lista de correo antiguo . Pero no pude encontrar ninguno de ellos para confirmar.

Lo principal es mirar qué tipo de comillas (dobles o simples) está usando dentro de su cadena. Ayuda a mantener bajo el número de escapes. Por ejemplo, cuando trabaja con html dentro de sus cadenas, es más fácil usar comillas simples para que no tenga que escapar todas las comillas dobles alrededor de los atributos.

He estado corriendo lo siguiente unas 20 veces. Y parece que las comillas dobles son un 20% más rápidas.

La parte divertida es que, si cambia la parte 2 y la parte 1, las comillas simples son aproximadamente un 20% más 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));

Puede utilizar comillas simples o dobles. Esto le permite, por ejemplo, anidar fácilmente javascript dentro de los atributos HTML, sin la necesidad de escapar de las comillas. Lo mismo ocurre cuando creas javascript con PHP.

La idea general es: si es posible, use citas que no necesite escapar. Menos escapando = mejor código.

Solo para agregar mis 2 centavos: al trabajar con JS y PHP hace unos años, me he acostumbrado a usar comillas simples para que pueda escribir el carácter de escape (''/') sin tener que escapar también. Por lo general, lo usaba cuando escribía cadenas en bruto con rutas de archivos, etc. ( http://en.wikipedia.org/wiki/String_literal#Raw_strings )

De todos modos, mi convención terminó convirtiéndose en el uso de comillas simples en cadenas sin formato de tipo identificador, como if (typeof s == ''string'') ...(en las que nunca se usarían caracteres de escape), y comillas dobles para textos , como "Hey, ¿qué pasa?" También uso comillas simples en los comentarios como una convención tipográfica para mostrar nombres de identificadores. Esto es solo una regla de oro, y solo se interrumpe cuando es necesario, como cuando se escriben cadenas HTML ''<a href="#"> like so <a>''(aunque también se pueden revertir las comillas aquí). También soy consciente de que, en el caso de JSON, las comillas dobles se usan para los nombres, pero fuera de eso, personalmente, prefiero las comillas simples cuando el escape nunca se requiere para el texto entre comillas, como document.createElement(''div'').

En pocas palabras, y como algunos han mencionado / aludido, elija una convención, manténgala y desvíese cuando sea necesario.