Quand utiliser des guillemets simples ou doubles en JavaScript?
console.log("double"); vs console.log('single');
Je vois de plus en plus de bibliothèques JavaScript utiliser des guillemets simples lors de la manipulation de chaînes. Quelles sont les raisons pour utiliser l'un sur l'autre? Je pensais qu'ils étaient plutôt interchangeables.
La raison la plus probable d'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, utiliser celui qui convient le mieux à la chaîne:.
En utilisant l'autre type de citation comme un 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, est Littéraux de modèle , qui utilise le caractère back-tick:
alert(`Use "double" and 'single' quotes in the same string`);
alert(`Escape the \` back-tick character and the \${ dollar-brace sequence in a string`);
Les littéraux de modèle offrent une syntaxe épurée pour: interpolation de variable, chaînes multilignes, etc.
Si vous utilisez JSON, il convient de noter que, à proprement parler, les chaînes JSON doivent être doubles. Bien sûr, de nombreuses bibliothèques prennent également en charge les guillemets simples, mais j’ai eu de gros problèmes dans l’un de mes projets avant de réaliser que les guillemets simples ne sont en fait pas conformes aux normes JSON.
Il n'y a pas de meilleure solution; Cependant, je voudrais dire que les guillemets doubles sont parfois plus souhaitables:
- Les nouveaux arrivants seront déjà familiarisés avec les guillemets doubles de leur langue. En anglais, nous devons utiliser des guillemets
"pour identifier un passage de texte cité. Si nous utilisions un seul guillemet', le lecteur pourrait l’interpréter à tort comme une contraction. L’autre sens d’un passage de texte entouré du'indique le sens "familier". Il est logique de rester cohérent avec les langues préexistantes, ce qui pourrait faciliter l’apprentissage et l’interprétation du code. - Les guillemets doubles éliminent le besoin d'échapper aux apostrophes (comme dans les contractions). Considérez la chaîne:
"I'm going to the mall", par rapport à la version échappée:'I\'m going to the mall'. Les guillemets doubles signifient une chaîne dans de nombreuses autres langues. Lorsque vous apprenez un nouveau langage comme Java ou C, les guillemets sont toujours utilisés. En Ruby, PHP et Perl, les chaînes entre guillemets simples n'impliquent aucune fausse barre oblique inversée alors que les guillemets doubles les prennent en charge.
la notation JSON est écrite avec des guillemets doubles.
Néanmoins, comme d’autres l’ont dit, il est primordial de rester cohérent.
La différence niquement 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 le nombre de citations que vous souhaitez échapper. Évidemment, la même chose s'applique aux guillemets doubles entre chaînes.
Guillemets simples
Je souhaite que les guillemets doubles soient la norme, car ils ont un sens un peu plus logique , mais je continue à utiliser des guillemets simples car ils dominent la scène.
Guillemets simples:
- airbnb
- grunt
- gulp
- noeud
- npm (bien que non défini dans l'auteur guide )
- wikimedia
- wordpress
- yandex
Pas de préférence:
Double citation:
J'aimerais dire que la différence est purement stylistique, mais j'ai vraiment des doutes. Prenons l'exemple suivant:
/*
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);
Dans Safari, Chrome, Opera et Internet Explorer (testé dans IE7 et IE8), les informations suivantes seront renvoyées:
function () {
return this.replace(/^\s+|\s+$/g, '');
}
function trim(str) {
return str.replace(/^\s+|\s+$/g, '');
}
Cependant, Firefox donnera un résultat légèrement différent:
function () {
return this.replace(/^\s+|\s+$/g, "");
}
function trim(str) {
return str.replace(/^\s+|\s+$/g, "");
}
Les guillemets simples ont été remplacés par des guillemets doubles. (Notez également que l'espace d'indentation a été remplacé par quatre espaces.) Cela donne l'impression qu'au moins un navigateur analyse JavaScript en interne, comme si tout avait été écrit entre guillemets. On pourrait penser qu'il faut moins de temps à Firefox pour analyser JavaScript si tout est déjà écrit selon ce "standard".
Ce qui, au fait, fait de moi un panda très triste, car je pense que les guillemets simples sont beaucoup plus agréables en code. De plus, dans d’autres langages de programmation, ils sont généralement plus rapides à utiliser que les guillemets, il n’a donc de sens que si la même chose s’applique à JavaScript.
Conclusion: Je pense que nous devons faire plus de recherches à ce sujet.
Edit: Cela pourrait expliquer résultats des tests de Peter-Paul Koch depuis 2003.
Il semble que les guillemets simples soient parfois plus rapides dans Windows Explorer (environ 1/3 de mes tests ont montré un temps de réponse plus court), mais si Mozilla montre une différence, il gère les guillemets un peu plus vite. Je n'ai trouvé aucune différence dans Opera.
Edit 2014: Les versions modernes de Firefox/Spidermonkey ne le font plus.
Si vous utilisez du JavaScript intégré (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 mettre le "salut" entre guillemets, via une méthode d'échappement dont je suis au courant. Même " ce qui aurait été ma meilleure hypothèse (puisque vous échappez des guillemets dans une valeur d'attribut HTML) ne fonctionne pas pour moi dans Firefox. \" cela ne fonctionnera pas non plus car à ce stade, vous échappez au HTML, pas à JavaScript.
Donc, si le nom du jeu est la cohérence, et que vous allez faire du JavaScript intégré dans certaines parties de votre application, je pense que les guillemets simples sont les gagnants. S'il vous plaît, corrigez-moi si je me trompe.
Techniquement, il n'y a pas de différence, c'est juste une question de style et de convention.
Douglas Crockford recommande d'utiliser des guillemets simples pour les chaînes internes et des guillemets doubles pour les chaînes externes (par externe, nous entendons celles à afficher pour l'utilisateur de l'application, comme les messages ou les alertes).
Personnellement, je suis ça.
UPDATE: Il semble que M. Crockford a changé d'avis et recommande désormais d'utiliser des guillemets doubles:)
Strictement parlant, il n'y a pas de différence de sens; le choix revient donc à la commodité.
Voici plusieurs facteurs qui pourraient influencer votre choix:
- Style maison: Certains groupes de développeurs utilisent déjà l'une ou l'autre convention.
- Exigences côté client: utiliserez-vous des guillemets dans les chaînes? (Voir la réponse d'Ady).
- Langage côté serveur: les utilisateurs VB.Net peuvent choisir d’utiliser des guillemets simples pour le script Java afin que les scripts puissent être construits côté serveur (VB.Net utilise des guillemets doubles pour les chaînes, de sorte que les chaînes de script Java sont faciles à distinguer. s’ils utilisent des guillemets simples).
- Code de la 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 penser que l’un ou l’autre style a l’air meilleur.
Regardons ce que fait une référence.
Dans jquery.js, chaque chaîne est double.
Donc, à partir de maintenant, je vais utiliser des chaînes entre guillemets. (J'utilisais single!)
C'est surtout une question de style et de préférence. Il y a quelques explorations techniques assez intéressantes et utiles dans les autres réponses, alors peut-être que la seule chose que je pourrais ajouter est de donner un petit conseil mondain.
Si vous codez dans une entreprise ou une équipe, alors c'est probablement une bonne idée de suivre le "style maison".
Si vous êtes le seul à pirater quelques projets annexes, alors regardez quelques leaders importants de la communauté. Par exemple, disons que vous entrez dans Node.js. Examinez les modules de base, par exemple underscore.js ou express, et voyez quelle convention ils utilisent, puis envisagez de le suivre.
Si les deux conventions sont utilisées de la même façon, alors reportez à votre
préférence.Si vous n'avez aucune préférence personnelle, alors lancer une pièce de monnaie.
Si vous n'avez pas de pièce, alors la bière est sur moi;)
J'espère que je ne vais pas ajouter quelque chose d'évident, mais je me suis battu avec Django et Ajax et JSON à ce sujet.
En supposant que, dans votre code HTML, vous utilisiez des guillemets, comme il se doit normalement, je suggère fortement d'utiliser des guillemets simples pour le reste en JavaScript.
Donc, je suis d’accord avec @ady mais avec précaution.
Ce qui compte, c’est: En JavaScript, ce n’est probablement pas grave, mais dès que vous l’intégrez au HTML, vous rencontrez des problèmes. Vous devriez savoir ce qui s'échappe, lit, passe 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 nous en tenir à des guillemets 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 "à double guillemet".
Donc, pour répondre à la question:
Essayez d’utiliser des guillemets simples en HTML. Cela pourrait sauver quelques problèmes de débogage ...
Gardez juste la cohérence dans ce que vous utilisez. Mais n'abaissez pas votre niveau de confort.
"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
mise à jour ES6
Utilisation de syntaxe littérale de modèle .
`Be "my" guest. You're in complete freedom.`; // most comfort :D
Je ne sais pas si cela est pertinent dans le monde d'aujourd'hui, mais les guillemets doubles étaient utilisés pour le contenu nécessitant le traitement des caractères de contrôle et les guillemets simples pour les chaînes qui n'en contenaient pas.
Le compilateur exécutera la manipulation de chaîne sur une chaîne entre guillemets tout en laissant une chaîne entre guillemets littéralement intacte. Cela poussait les "bons" développeurs à choisir d'utiliser des guillemets simples pour les chaînes ne contenant pas de caractères de contrôle comme \n ou \0 (non traitées entre guillemets simples) et des guillemets doubles lorsqu'ils avaient besoin de la chaîne. analysé (à un faible coût en cycles CPU pour le traitement de la chaîne).
Si vous utilisez jshint , une erreur sera générée si vous utilisez une chaîne de guillemets double.
Je l'ai utilisé par le biais de l'échafaudage Yeoman d'AngularJS mais il y a peut-être une manière de configurer cela.
En passant, lorsque vous manipulez HTML en JavaScript, il est plus facile d'utiliser une citation 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 moyen trivial de répondre à votre question
En parlant de performance, les guillemets ne seront jamais votre goulot d'étranglement, cependant, les performances sont les mêmes dans les deux cas.
En parlant de vitesse de codage, si vous utilisez ' pour délimiter une chaîne, vous devrez échapper les guillemets ". Il est plus probable que vous ayez besoin d'utiliser " à l'intérieur de la chaîne, par exemple:
//JSON Objects:
var jsonObject = '{"foo":"bar"}';
//HTML attributes:
document.getElementById("foobar").innerHTML = '<input type="text">';
Ensuite, je préfère utiliser ' pour délimiter la chaîne, donc je dois échapper à moins de caractères.
Une raison (stupide) d’utiliser des guillemets simples est qu’ils ne vous obligent pas à appuyer sur la touche Maj pour les saisir, alors qu’un guillemet double le fait. (Je suppose que la chaîne moyenne ne nécessite pas d'échappement, ce qui est une hypothèse raisonnable.) Supposons maintenant que je code chaque jour 200 lignes de code. Peut-être que dans ces 200 lignes, j'ai 30 citations. Peut-être que taper un guillemet double prend 0,1 seconde de plus que taper un guillemet simple (parce que je dois appuyer sur la touche majuscule). Puis, chaque jour, je perds 3 secondes. Si je code de cette manière pendant 200 jours par an pendant 40 ans, alors j'ai perdu 6,7 heures de ma vie. Nourriture pour la pensée.
Examiner le pour et le contre
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>';elem.innerHTML = "<a href='" + url + "'>Hello</a>";De plus, le HTML en ligne est normalement un anti-motif. 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 guillemets
- Les doubles sont plus faciles à repérer si vous n'avez pas de code de couleur. Comme dans un journal de console ou une sorte d'installation de view-source.
- Similitude avec d'autres langages: dans la programmation Shell (Bash, etc.), des littéraux de chaîne entre guillemets simples existent, mais les échappements ne sont pas interprétés à l'intérieur de ceux-ci. 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 un code JSON valide, 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 vous convient 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 chaînes internes et double pour les externes. Cela vous permet de distinguer les constantes internes des chaînes à afficher à l'utilisateur (ou à écrire sur le disque, etc.). Évidemment, vous devriez éviter de mettre ce dernier dans votre code, mais cela ne peut pas toujours être fait.
L’augmentation de la popularité des scripts côté serveur est une autre chose que vous voudrez peut-être prendre en compte pour expliquer le passage des guillemets doubles aux guillemets simples. Lorsque vous utilisez PHP, vous pouvez transmettre des variables et analyser des fonctions javascript à l'aide de chaînes et de variables en PHP.
Si vous écrivez une chaîne et utilisez des guillemets doubles pour votre PHP, vous ne devrez échapper à aucun des guillemets simples et PHP récupérera automatiquement la valeur des variables pour vous.
Exemple: Je dois exécuter une fonction javascript à l'aide d'une variable de mon serveur.
public static function redirectPage( $pageLocation )
{
echo "<script type='text/javascript'>window.location = '$pageLocation';</script>";
}
Cela me évite beaucoup de tracas en ce qui concerne le fait de joindre des chaînes, et je peux effectivement appeler un code JavaScript à partir de PHP. Ce n’est qu’un exemple, mais c’est peut-être l’une des raisons pour lesquelles les programmeurs utilisent par défaut des guillemets simples en javascript.
Extrait de PHP documents : "La caractéristique la plus importante des chaînes entre guillemets est le fait que les noms de variables seront développés. Voir l'analyse des chaînes pour plus de détails."
J'utilise des guillemets doubles lorsque les guillemets simples ne peuvent pas être utilisés et inversement:
"'" + singleQuotedValue + "'"
'"' + doubleQuotedValue + '"'
Au lieu de:
'\'' + singleQuotedValue + '\''
"\"" + doubleQuotedValue + "\""
Lorsque j'utilise CoffeeScript, j'utilise des guillemets doubles. Je conviens que vous devriez choisir l'un ou l'autre et vous en tenir à cela. CoffeeScript vous donne une interpolation lorsque vous utilisez les guillemets doubles.
"This is my #{name}"
ES6 utilise des ticks arrière (`) pour les chaînes de modèle. Ce qui a probablement une bonne raison, mais lors du codage, il peut être fastidieux de changer le caractère littéral de chaîne de guillemets ou de guillemets doubles en guillemets arrière afin d'obtenir la fonction d'interpolation. CoffeeScript n'est peut-être pas parfait, mais utiliser le même caractère littéral partout (guillemets) et pouvoir toujours interpoler est une fonctionnalité intéressante.
`This is my ${name}`
Il n'y a pas de différence entre les guillemets simples et doubles en JavaScript.
La spécification est importante:
Il existe peut-être des différences de performances, mais elles sont absolument minimales et peuvent changer tous les jours en fonction de la mise en œuvre des navigateurs. Toute discussion ultérieure est futile à moins que votre application JavaScript ne soit longue de plusieurs centaines de milliers.
C'est comme une référence si
a=b;
est plus rapide que
a = b;
(espaces supplémentaires)
aujourd'hui, dans un navigateur et une plate-forme particuliers, etc.
Si vous sautez entre JavaScript et C #, il est préférable d'entraîner vos doigts pour la convention commune qui consiste à utiliser des guillemets.
Certaines personnes prétendent voir des différences de performances: ancien fil de discussion . Mais je n'ai trouvé aucun d'entre eux à confirmer.
L'essentiel est de regarder quel type de guillemets (doubles ou simples) vous utilisez dans votre chaîne. Il est utile de limiter le nombre d’évasions. Par exemple, lorsque vous travaillez avec du HTML dans vos chaînes, il est plus facile d'utiliser des guillemets simples pour ne pas avoir à échapper à tous les guillemets doubles autour des attributs.
J'ai couru le suivant environ 20 fois. Et il semble que les guillemets doubles sont environ 20% plus rapides.
La partie amusante est que, si vous modifiez les parties 2 et 1, les guillemets simples sont environ 20% plus rapides.
//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));
Après avoir lu toutes les réponses qui disent que cela peut être plus rapide ou peut-être avoir des avantages, je dirais que les guillemets doubles sont meilleurs ou peut-être plus rapidement aussi parce que compilateur de fermeture Google convertit les guillemets simples en guillemets doubles.
Juste pour ajouter mes 2 centimes: En travaillant à la fois avec JS et PHP il y a quelques années, je me suis habitué à utiliser des guillemets simples pour pouvoir taper le caractère d'échappement ('\') sans avoir à échapper ça aussi. Je l'utilisais généralement lors de la saisie de chaînes brutes avec des chemins d'accès, etc. ( http://en.wikipedia.org/wiki/String_literal#Raw_strings )
Quoi qu'il en soit, ma convention a fini par devenir l'utilisation de guillemets simples sur des chaînes brutes de type identificateur, telles que if (typeof s == 'string') ... (dans laquelle les caractères d'échappement ne seraient jamais utilisés - jamais), et les guillemets doubles pour textes , tels que "Hey, quoi de neuf?". J'utilise également les guillemets simples dans les commentaires comme convention typographique pour montrer les noms d'identifiant. Ceci est juste une règle empirique, et je ne m'interromps que lorsque cela est nécessaire, par exemple lorsque vous tapez des chaînes HTML '<a href="#"> like so <a>' (vous pouvez également inverser les guillemets ici). Je suis également conscient que, dans le cas de JSON, les guillemets sont utilisés pour les noms - mais en dehors de cela, personnellement, je préfère les guillemets simples lorsque l'échappement est jamais requis pour le texte entre guillemets - comme document.createElement('div').
En fin de compte, et comme certains l’ont mentionné/mentionné, choisissez une convention, respectez-la et ne déviez que lorsque cela est nécessaire.
Il n'y a strictement aucune différence, c'est donc essentiellement une question de goût et de contenu de la chaîne (ou si le code JS est lui-même une chaîne), pour limiter le nombre d'échappées.
La légende des différences de vitesse pourrait provenir de PHP monde, où les deux guillemets ont un comportement différent.
Si votre source JS est:
elem.innerHTML="<img src='smily' alt='It\'s a Smily' style='width:50px'>";
La source HTML sera:
<img src="smiley" alt="It's a Smiley" style="width:50px">
ou pour HTML5
<img src=smiley alt="It's a Smiley" style=width:50px>
JS permet des tableaux comme celui-ci:
var arr=['this','that'];
Mais si vous le stigmatisez, ce sera pour des raisons de compatibilité:
JSON=["this","that"]
Je suis sûr que cela prend du temps.
Vous pouvez utiliser des guillemets simples ou doubles. Cela vous permet par exemple d'imbriquer facilement du javascript dans des attributs HTML, sans avoir besoin d'échapper aux guillemets. La même chose se produit lorsque vous créez du javascript avec PHP.
L’idée générale est la suivante: s’il est possible d’utiliser des citations que vous n’aurez pas besoin d’échapper. Moins d'échappement = meilleur code.
Est-ce juste une question temps pour moi. Quelques millisecondes de ma vie sont perdues chaque fois que je dois appuyer sur la touche shift avant de pouvoir taper "
Je préfère ' simplement parce que vous n'avez pas à le faire!
Sinon, vous pouvez échapper un ' à l'intérieur de guillemets simples avec une barre oblique inversée \'
console.log('Don\'t lose time'); // "Don't lose time"
La différence est purement stylistique. J'étais un nazi à double guillemet. Maintenant, j'utilise des guillemets simples dans presque tous les cas. Il n'y a pas de différence pratique au-delà de la syntaxe utilisée par votre éditeur.
Je pense qu’il est important de ne pas oublier que, bien que IE puisse avoir 0 extensions/barres d’outils installées, il est possible que certaines extensions soient installées dans Firefox (par exemple, je pense à firebug). Ces extensions auront une influence sur le résultat de référence.
Cela n’a rien d’important, car le navigateur X obtient plus rapidement les styles d’élément, alors que le navigateur Y peut rendre plus rapidement le rendu d’un élément de la toile. (D'où la raison pour laquelle un "fabricant" de navigateur a toujours le moteur javascript le plus rapide)
j'utilise des guillemets simples la plupart du temps, car lors du développement en php, les guillemets simples ne sont en aucun cas modifiés, ce qui est ce que je veux. quand j'utilise
echo "$xyz";
en php, $ xyz est évalué, ce qui n’est PAS ce que je veux. Par conséquent, j’utilise toujours "au lieu de" pour le développement Web. Je veille donc au moins à la cohérence des chaînes en ce qui concerne php/jscript.
malheureusement, cela ne peut pas être fait dans Java ou en Objective C, où '' signifie char et "" une chaîne. mais c'est une autre question.
Pour moi, si je code dans un éditeur VIM et que quelque chose est placé entre guillemets, je peux double-cliquer pour sélectionner SEULEMENT le texte à l'intérieur des guillemets. Les guillemets doubles, en revanche, incluent les guillemets qui me gênent lorsque je veux effectuer rapidement des copier-coller.
Par exemple. 'myVar' double-cliquez dans VIM éditeur copies:> myVar <"myVar" copie littéralement:> "myVar" <et lorsque je colle, je dois supprimer les guillemets de chaque côté.
Mes deux centimes quand même ...
Si vous utilisez php pour générer du code JavaScript, vous devez utiliser la déclaration suivante.
let value = "<?php echo 'This is my message, "double quoted" - \'single quoted\' ?>";
La sortie sera:
This is my message, "double quoted" - 'single quoted'
Pour certaines raisons, il est recommandé d'utiliser des guillemets simples plutôt que des guillemets doubles en PHP. Pour le comportement normal en Javascript, il est recommandé d'utiliser des guillemets simples.
var value = 'This is my message';
document.getElementById('sample-text').innerHTML = value;<span id="sample-text"></span>Vous ne pouvez pas exécuter ce code dans du texte sublime et vscode avec une double citation:
<a href="javascript:alert(“Hello World!”);">Execute JavaScript</a>
Ce code fonctionne:
<a href="javascript:alert('Hello World!');">Execute JavaScript</a>
Je pense que tout cela est une question de commodité/préférence.
Je préfère les guillemets doubles car ils correspondent à ce que C # a et à mon environnement sur lequel je travaille normalement: C # + JS.
Une autre raison possible pour les guillemets doubles par rapport aux guillemets simples est la suivante (que j’ai trouvée dans le code de mon projet): le français ou d’autres langues utilisent beaucoup les guillemets simples (comme l’anglais en fait); côté serveur (ce que je sais est une mauvaise pratique), alors un seul devis rendra à tort.
La probabilité d'utiliser des guillemets doubles dans le langage courant est faible, donc je pense qu'elle a de meilleures chances de ne pas casser quelque chose.
Personnellement, je préfère les guillemets simples pour des raisons de lisibilité. Si je regarde le code toute la journée, il est plus facile de voir les mots avec des guillemets simples plutôt que des guillemets doubles.
Plus facile à lire comme démontré ici:
'facile à lire'
"plus difficile à lire"
"" le plus difficile à lire ""