with - simple quote javascript




Quand utiliser des guillemets doubles ou simples en JavaScript? (20)

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

Je vois de plus en plus de bibliothèques JavaScript utilisant des guillemets simples lors de la gestion des chaînes. Quelles sont les raisons d'utiliser l'un sur l'autre? Je pensais qu'ils sont à peu près interchangeables.


Examiner les avantages et les inconvénients

En faveur des guillemets simples

  • Moins d'encombrement visuel.
  • Génération HTML: les attributs HTML sont généralement délimités par des guillemets doubles.

elem.innerHTML = '<a href="' + url + '">Hello</a>';
Cependant, les guillemets simples sont tout aussi légaux en HTML.

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

De plus, le HTML en ligne est normalement un anti-pattern. Préférez les modèles.

  • Génération de JSON: seules les guillemets doubles sont autorisés dans JSON.

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

Encore une fois, vous ne devriez pas avoir à construire JSON de cette façon. JSON.stringify () est souvent suffisant. Sinon, utilisez des modèles.

En faveur des doubles quotes

  • Les doublons sont plus faciles à repérer si vous n'avez pas de code couleur. Comme dans un journal de la console ou une sorte de configuration vue-source.
  • Similitude avec d'autres langages: Dans la programmation shell (Bash etc.), les littéraux de chaîne entre guillemets simples existent, mais les échappements ne sont pas interprétés en leur sein. C et Java utilisent des guillemets doubles pour les chaînes et des guillemets simples pour les caractères.
  • Si vous voulez que le code soit valide JSON, vous devez utiliser des guillemets doubles.

En faveur des deux

Il n'y a pas de différence entre les deux en JavaScript. Par conséquent, vous pouvez utiliser ce qui est pratique pour le moment. Par exemple, les littéraux de chaîne suivants produisent tous la même chaîne:

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

Guillemets simples pour les cordes internes et doubles pour les cordes externes. Cela vous permet de distinguer les constantes internes des chaînes qui doivent être affichées à l'utilisateur (ou écrites sur le disque, etc.). Évidemment, vous devriez éviter de mettre ce dernier dans votre code, mais cela ne peut pas toujours être fait.



J'espère ne pas ajouter quelque chose d'évident, mais j'ai lutté avec Django et Ajax et JSON à ce sujet.

En supposant que dans votre code HTML vous utilisez des guillemets doubles, comme cela devrait normalement être le cas, je suggère fortement d'utiliser des guillemets simples pour le reste en JavaScript.

Donc je suis d'accord avec @ady mais avec un peu de soin.

Ma ligne de fond est la suivante: En JavaScript, cela n'a probablement pas d'importance, mais dès que vous l'intégrez dans du HTML ou autre, vous commencez à avoir des problèmes. Vous devriez savoir ce qui s'échappe réellement, lire, passer votre chaîne.

Mon cas simple était:

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

Vous pouvez repérer le \ 'dans le troisième champ de showThis.

La double citation n'a pas fonctionné!

Il est clair pourquoi, mais il est également clair pourquoi nous devrions coller sur des citations simples ... .. Je suppose ..

Ce cas est une incorporation HTML très simple, l'erreur a été générée par un simple copier / coller à partir d'un code JavaScript 'entre guillemets'.

Donc, pour répondre à la question:

Essayez d'utiliser des guillemets simples en HTML. Cela pourrait sauver quelques problèmes de débogage ...


Je ne sais pas si cela est pertinent dans le monde d'aujourd'hui, mais les guillemets étaient utilisés pour le contenu qui nécessitait le traitement des caractères de contrôle et les guillemets simples pour les chaînes qui ne l'étaient pas.

Le compilateur exécutera la manipulation de chaîne sur une chaîne entre guillemets doubles tout en laissant une seule chaîne entre guillemets intacte. Cela conduisait les 'bons' développeurs à utiliser des guillemets simples pour les chaînes qui ne contenaient pas de caractères de contrôle comme \n ou \0 (non traitées entre guillemets simples) et des guillemets quand ils avaient besoin de la chaîne analysée (à un faible coût en cycles de processeur pour le traitement de la chaîne).


La seule différence est démontrée dans ce qui suit:

'A string that\'s single quoted'

"A string that's double quoted"

Donc, ce n'est que la quantité de citation que vous voulez faire. Évidemment, il en va de même pour les guillemets doubles dans les guillemets doubles.


La raison la plus probable de l'utilisation de single vs double dans différentes bibliothèques est la préférence du programmeur et / ou la cohérence de l'API.

Autre que d'être cohérent, utilisez celui qui convient le mieux à la chaîne :.

En utilisant l'autre type de citation comme littéral:

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

... mais cela peut se compliquer ...

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

Une autre option, nouvelle dans ES6, sont les littéraux de modèle qui utilisent le caractère back-tick :

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

Les littéraux de gabarit offrent une syntaxe propre pour: l'interpolation de variables, les chaînes multilignes, etc.


Regardons ce que fait une référence.

À l'intérieur de jquery.js, chaque chaîne est entre guillemets.

Donc, en commençant maintenant, je vais utiliser des chaînes entre guillemets. (J'utilisais seul!)


Si vous faites JavaScript en ligne (sans doute une "mauvaise" chose, mais en évitant cette discussion), les guillemets simples sont votre seule option pour les littéraux de chaîne, je crois.

par exemple, cela fonctionne bien:

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

Mais vous ne pouvez pas envelopper le "salut" entre guillemets, via n'importe quelle méthode d'échappement dont je suis conscient. Même &quot; ce qui aurait été ma meilleure estimation (puisque vous évitez des citations dans une valeur d'attribut de HTML) ne fonctionne pas pour moi dans Firefox. \" ne fonctionnera pas non plus car à ce stade vous échappez pour le HTML, pas JavaScript.

Donc, si le nom du jeu est cohérent, et que vous allez faire du JavaScript en ligne dans certaines parties de votre application, je pense que les guillemets simples sont les gagnants. Quelqu'un s'il vous plaît corrigez-moi si je me trompe bien.


Si vous utilisez jshint , une erreur se produira si vous utilisez une chaîne de guillemets doubles.

Je l'ai utilisé à travers l'échafaud Yeoman de AngularJS mais peut-être qu'il y a un moyen de le configurer.

En passant, lorsque vous manipulez HTML en JavaScript, il est plus facile d'utiliser un guillemet simple:

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

Et au moins JSON utilise des guillemets doubles pour représenter les chaînes.

Il n'y a pas de manière triviale de répondre à votre question


Strictement parlant, il n'y a pas de différence de sens; donc le choix se résume à la commodité.

Voici plusieurs facteurs qui pourraient influencer votre choix:

  • Style de maison: Certains groupes de développeurs utilisent déjà une convention ou l'autre.
  • Exigences côté client: utiliserez-vous des guillemets dans les chaînes? (Voir la réponse d'Ady).
  • Langage côté serveur: les utilisateurs de VB.Net peuvent choisir d'utiliser des guillemets simples pour java-script afin que les scripts puissent être construits côté serveur (VB.Net utilise des guillemets doubles pour les chaînes, donc les chaînes java-script sont faciles à distinguer s'ils utilisent des guillemets simples).
  • Code de bibliothèque: Si vous utilisez une bibliothèque qui utilise un style particulier, vous pouvez envisager d'utiliser le même style vous-même.
  • Préférence personnelle: Vous pourriez trouver l'un ou l'autre style meilleur.

Une autre chose que vous pourriez vouloir considérer comme une raison pour le passage des guillemets doubles aux guillemets simples est l'augmentation de la popularité des scripts côté serveur. Lorsque vous utilisez PHP, vous pouvez passer des variables et analyser les fonctions javascript en utilisant des chaînes et des variables en PHP.

Si vous écrivez une chaîne et que vous utilisez des guillemets doubles pour votre PHP, vous n'aurez à échapper aucune des guillemets simples et PHP récupérera automatiquement la valeur des variables pour vous.

Exemple: J'ai besoin d'exécuter une fonction javascript en utilisant une variable de mon serveur.

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

Cela me sauve beaucoup de tracas à devoir composer avec des chaînes, et je peux effectivement appeler un javascript de PHP. Ceci n'est qu'un exemple, mais cela peut être l'une des raisons pour lesquelles les programmeurs utilisent par défaut des guillemets simples en javascript.

Citation tirée de documents PHP : "La caractéristique la plus importante des chaînes de caractères entre guillemets est le fait que les noms de variables seront développés.


Une raison (idiote) d'utiliser des guillemets simples serait qu'ils ne vous obligent pas à appuyer sur la touche majuscule pour les taper, alors qu'une double citation fait. (Je suppose que la chaîne moyenne ne nécessite pas d'échappement, ce qui est une hypothèse raisonnable.) Maintenant, supposons que je code chaque jour 200 lignes de code. Peut-être que dans ces 200 lignes, j'ai 30 citations. Peut-être que taper une double citation prend 0,1 secondes de plus que de taper une seule citation (parce que je dois appuyer sur la touche majuscule). Puis, un jour donné, je perds 3 secondes. Si je code de cette manière pendant 200 jours par an pendant 40 ans, alors j'ai gaspillé 6,7 heures de ma vie. Nourriture pour la pensée.


Il n'y a pas de meilleure solution . cependant, je voudrais faire valoir que les guillemets peuvent être plus désirables parfois:

  • Les nouveaux arrivants seront déjà familiers avec les guillemets de leur langue . En anglais, nous devons utiliser des guillemets doubles " pour identifier un passage de texte cité .Si nous devions utiliser une seule citation ' , le lecteur peut mal interpréter cela comme une contraction.L'autre signification d'un passage de texte entouré par le ' indique le sens «familier» Il est logique de rester cohérent avec les langues préexistantes, ce qui peut faciliter l'apprentissage et l'interprétation du code.
  • Les doubles guillemets éliminent le besoin d'échapper aux apostrophes (comme dans les contractions). Considérez la chaîne: "I'm going to the mall" , par opposition à la version autrement échappée: 'I\'m going to the mall' .
  • Les guillemets doubles signifient une chaîne dans de nombreuses autres langues . Lorsque vous apprenez une nouvelle langue comme Java ou C, les guillemets sont toujours utilisés. Dans Ruby, PHP et Perl, les chaînes entre guillemets simples n'impliquent aucune échappement de type barre oblique inverse tandis que les guillemets doubles les supportent.

  • La notation JSON est écrite avec des guillemets doubles.

Néanmoins, comme d'autres l'ont indiqué, il est très important de rester cohérent.


After reading all the answers that say it maybe be faster or maybe have advantages, I would say double quote is better or maybe faster too because Google closure compiler convert single quotes to double quotes.


I've been running the following about 20 times. And it appears that double quotes are about 20% faster.

The fun part is, if you change part 2 and part 1 around, single quotes are about 20% faster.

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

If you're jumping back an forth between JavaScript and C#, it's best to train your fingers for the common convention which is double quotes.


Just to add my 2 cents: In working with both JS and PHP a few years back, I've become accustom to using single quotes so I can type the escape character ('\') without having to escape it as well. I usually used it when typing raw strings with file paths, etc. ( http://en.wikipedia.org/wiki/String_literal#Raw_strings )

Anyhow, my convention ended up becoming the use of single quotes on identifier-type raw strings, such as if (typeof s == 'string') ... (in which escape characters would never be used - ever), and double quotes for texts , such as "Hey, what's up?". I also use single quotes in comments as a typographical convention to show identifier names. This is just a rule of thumb, and I break off only when needed, such as when typing HTML strings '<a href="#"> like so <a>' (though you could reverse the quotes here also). I'm also aware that, in the case of JSON, double quotes are used for the names - but outside that, personally, I prefer the single quotes when escaping is never required for the text between the quotes - like document.createElement('div') .

Bottom line, et comme certains l'ont mentionné / fait allusion à, choisissez une convention, respectez-le, et ne dévier que lorsque cela est nécessaire.


There are people that claim to see performance differences: old mailing list thread . But I couldn't find any of them to be confirmed.

The main thing is to look at what kind of quotes (double or single) you are using inside your string. It helps to keep the number of escapes low. For instance when you are working with html inside your strings, it is easier to use single quotes so that you don't have to escape all double quotes around the attributes.


There is strictly no difference, so it is mostly a matter of taste and of what is in the string (or if the JS code itself is in a string), to keep number of escapes low.

The speed difference legend might come from PHP world, where the two quotes have different behavior.


When using CoffeeScript I use double quotes. I agree that you should pick either one and stick to it. CoffeeScript gives you interpolation when using the double quotes.

"This is my #{name}"

ES6 is using back ticks (`) for template strings. Which probably has a good reason, but when coding it can be cumbersome to change the string literals character from quotes or double quotes to back ticks in order to get the interpolation feature. CoffeeScript might not be perfect, but using the same string literals character everywhere (double quotes) and always be able to interpolate is a nice feature.

`This is my ${name}`






conventions