什么时候在JavaScript中使用双引号或单引号？
console.log("double"); vs console.log('single');
处理string时，我看到越来越多的JavaScript库使用单引号。 有什么理由相互使用呢？ 我认为他们几乎可以互换。
在不同的库中使用单对比的最可能的原因是程序员偏好和/或API一致性。
除了一致之外，请使用最适合string的内容。
使用其他types的引号作为文字：
alert('Say "Hello"'); alert("Say 'Hello'");
…但这可能会变得复杂…
alert("It's \"game\" time."); alert('It\'s "game" time.');
ES6中新增的另一个选项是使用back-tick字符的模板文字 ：
alert(`Use "double" and 'single' quotes in the same string`); alert(`The escape the \` back-tick character in a string`);
模板文字提供了一个干净的语法：可变插值，多行string，等等。
如果你正在处理JSON，应该注意，严格来说，JSONstring必须用双引号。 当然，很多图书馆也支持单引号，但是在实现单引号string实际上并不符合JSON标准之前，我在其中一个项目中遇到了很多问题。
没有更好的解决办法 。 不过，我想辩解一下，双引号有时候更可取：
- 新手已经熟悉他们的语言双引号 。 在英文中，我们必须使用双引号
"来标识引用的文本段落，如果我们用单引号'，读者可能会误解为一个收缩。 “口语”的含义，保持与已有的语言保持一致是有意义的，这可能会缓解对代码的学习和解释。 - 双引号消除了需要转义撇号 （如收缩）。 考虑一下string：
"I'm going to the mall"，而不是另外逃脱的版本：'I\'m going to the mall'。 -
双引号表示许多其他语言的string 。 当你学习像Java或C这样的新语言时，总是使用双引号。
-
JSON表示法用双引号编写。
尽pipe如此，正如其他人所说，保持一致是最重要的。
唯一的区别在于以下内容：
'A string that\'s single quoted' "A string that's double quoted"
所以，只有多less报价才能逃脱。 显然这同样适用于双引号string中的双引号。
我想说的区别是纯粹的风格，但我真的有我的怀疑。 考虑下面的例子：
/* 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);
在Safari，Chrome，Opera和Internet Explorer（在IE7和IE8中testing）中，这将返回以下内容：
function () { return this.replace(/^\s+|\s+$/g, ''); } function trim(str) { return str.replace(/^\s+|\s+$/g, ''); }
但是，Firefox会产生一个稍微不同的结果：
function () { return this.replace(/^\s+|\s+$/g, ""); } function trim(str) { return str.replace(/^\s+|\s+$/g, ""); }
单引号已被双引号replace。 （还要注意缩进空间是如何被四个空格replace的。）这给人的印象是，至less有一个浏览器在内部parsingJavaScript，就好像所有的东西都是用双引号写的一样。 有人可能会认为，如果所有的东西都已经按照这个“标准”编写的话，那么Firefox就会花更less的时间来parsingJavaScript。
顺便说一句，这使我成为一个非常难过的pandas，因为我觉得单引号在代码中看起来好多了。 另外，在其他编程语言中，它们通常比双引号使用起来更快，所以只有在应用于JavaScript时才有意义。
结论：我认为我们需要对此做更多的研究。
编辑：这可能解释了Peter-Paul Koch从2003年的testing结果 。
似乎单引号有时在资源pipe理器窗口中速度更快（大约1/3的testing显示了更快的响应时间），但是如果Mozilla显示出差异，它会稍微更快地处理双引号。 在Opera中我根本没有发现任何区别。
编辑2014年： Firefox / Spidermonkey的现代版本不再这样做。
单引号
我希望双引号是标准的，因为它们更有意义 ，但是我继续使用单引号，因为它们主宰了这个场景。
单引号：
- 制作的Airbnb
- Facebook的
- 谷歌
- 咕噜
- 吞
- 节点
- npm （虽然没有在作者指南中定义）
- 维基媒体
- WordPress的
- Yandex的
没有偏好：
- three.js所
双引号：
- 克罗克福德
- d3 （虽然没有在
.eslintrc定义） - jQuery的
如果你正在做内联JavaScript（可以说是一个“坏”的东西，但避免讨论），我相信单引号是你唯一的string文字选项。
例如，这工作正常：
<a onclick="alert('hi');">hi</a>
但是你不能用“双引号”来包装“hi”，通过我知道的任何转义方法。 即使" 这将是我最好的猜测（因为你是在HTML属性值中的引号转义）不适用于我的Firefox。 \"将无法正常工作，因为此时您正在转义HTML，而不是JavaScript。
因此，如果游戏的名称是一致的，而且您将在应用程序的某些部分使用一些内联JavaScript，那么我认为单引号就是赢家。 有人请纠正我，如果我错了。
从技术上讲，没有什么区别，只是风格和习惯的问题。
道格拉斯·克罗克福德（Douglas Crockford）build议使用内部string的单引号和外部的双引号（通过外部我们指的是显示给应用程序的用户，比如消息或警报）。
我亲自跟随。
更新：看起来，克罗克福德先生改变了主意 ，现在build议使用双引号:)
严格来说，没有意义上的差别; 所以select归结为方便。
这里有几个因素可能会影响你的select：
- 房子的风格：一些开发团队已经使用了一种惯例或另一种惯例。
- 客户端要求：你会在string中使用引号吗？ （见阿迪的答案）。
- 服务器端语言：VB.Net的人可能会select使用单引号为java脚本，使脚本可以build立服务器端（VB.Net使用双引号的string，所以java脚本string很容易区分如果他们使用单引号）。
- 库代码：如果您使用的是使用特定样式的库，则可以考虑自己使用相同的样式。
- 个人喜好：你可能会看起来更好。
让我们来看看参考文献是做什么的。
在jquery.js里面，每个string都用双引号。
所以，从现在开始，我将使用双引号的string。 （我正在使用单个！）
我希望我没有添加明显的东西，但我一直在Django和Ajax和JSON上苦苦挣扎。
假设在你的HTML代码中，你通常应该使用双引号，我强烈build议在JavaScript中使用单引号。
所以我同意@ady，但要小心。
我的底线是：在JavaScript中可能并不重要，但只要将它embedded到HTML或类似内容中，就会引起麻烦。 你应该知道什么是逃避，阅读，传递你的string。
我的简单情况是：
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>'
您可以在showThis的第三个字段中find“\”。
双引号不起作用！
这很明显，为什么，但也是为什么我们应该坚持单引号……我想..
这种情况是一个非常简单的HTMLembedded，错误是由一个“双引号”的JavaScript代码简单的复制/粘贴产生的。
所以要回答这个问题：
尝试在HTML中使用单引号。 这可能会节省一些debugging问题…
这主要是一个风格和偏好的问题。 在其他答案中有一些相当有趣和有用的技术探索，所以也许我唯一可以补充的是提供一些世俗的build议。
-
如果你在一个公司或团队编码， 那么按照“家庭风格”来做一个好主意。
-
如果你独自一人攻击一些项目， 那就看看社区中一些着名的领导人吧。 比方说，你进入Node.js。 看一下核心模块，比如underscore.js或者express，看看他们使用什么约定，然后考虑一下。
-
如果两个惯例都是平等使用的， 那么请遵照你的个人惯例
偏爱。 -
如果你没有个人喜好， 那么扔一枚硬币。
-
如果你没有硬币， 那么啤酒就在我身上;）
不确定这是否与今天的世界相关，但是双引号用于需要处理控制字符的内容以及没有处理控制字符的单引号。
编译器将在双引号string上运行string操作，而保留单引号string不变。 这导致“好”开发人员select使用单引号的string不包含控制字符像\n或\0 （不在单引号内处理）和双引号，当他们需要stringparsing（在一个小的成本在处理string的cpu周期中）。
如果您使用的是jshint ，如果使用双引号string，则会引发错误。
我通过Yeoman的AngularJS的脚手架使用它，但也许有某种方法来configuration这个。
顺便说一下，当你将HTML处理成JavaScript时，使用单引号更容易：
var foo = '<div class="cool-stuff">Cool content</div>';
至lessJSON使用双引号来表示string。
没有简单的方法来回答你的问题
谈到性能，报价永远不会是你的瓶颈，但是，两种情况下的性能是一样的。
谈到编码速度，如果使用'用于分隔string，你将需要转义"引号，你更可能需要使用"在string内，例如：
//JSON Objects: var jsonObject = '{"foo":"bar"}'; //HTML attributes: document.getElementById("foobar").innerHTML = '<input type="text">';
然后，我更喜欢使用'来分隔string，所以我不得不逃脱更less的字符。
只要保持一致你使用什么。 但不要让你的舒适程度下降。
"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
ES6更新
使用模板文字语法 。
`Be "my" guest. You're in complete freedom.`; // most comfort :D
还有一件事，你可能会考虑作为从双引号转换到单引号的理由是服务器端脚本的stream行度的增加。 在使用PHP时，您可以使用PHP中的string和variables传递variables并parsingjavascript函数。
如果您为PHP编写了一个string并使用双引号，则不必转义任何单引号，PHP将自动为您检索variables的值。
示例：我需要使用我的服务器中的variables来运行javascript函数。
public static function redirectPage( $pageLocation ) { echo "<script type='text/javascript'>window.location = '$pageLocation';</script>"; }
这节省了我在处理连接string方面的很多麻烦，并且我可以从PHP有效地调用一个javascript。 这只是一个例子，但这可能是程序员在javascript中单引号默认的几个原因之一。
从PHP文档引用 ：“双引号string的最重要的特点是variables名称将被扩展，请参阅stringparsing的细节。
一个（愚蠢的）使用单引号的理由是，他们不要求你按Shift键键入它们，而双引号。 （我假设平均string不需要转义，这是一个合理的假设。）现在，假设我每天编码200行代码。 也许在这200行中，我有30个引号。 也许input一个双引号比input一个单引号多花费0.1秒（因为我必须按shift键）。 然后在任何一天，我浪费了3秒钟。 如果我以这样的方式编码一年200天，40年，那么我的生命浪费了6.7个小时。 食物的思想。
检查利弊
赞成单引号
- 不那么直观的混乱。
- 生成HTML：HTML属性通常用双引号分隔。
elem.innerHTML = '<a href="' + url + '">Hello</a>';
单引号无法使用时，我会使用双引号，反之亦然：
"'" + singleQuotedValue + "'" '"' + doubleQuotedValue + '"'
代替：
'\'' + singleQuotedValue + '\'' "\"" + doubleQuotedValue + "\""
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.
There is no difference between single and double quotes in JavaScript.
Specification is important:
Maybe there are performance diffs, but they are absolutely minimum and can change everyday according to browsers' implementation. Further discussion is futile unless your JavaScript application is hundreds of thousands long.
It's like a benchmark if
a=b;
比…更快
a = b;
(extra spaces)
today, in a particular browser and platform, etc.
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}`
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.
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));
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.
If your JS source is:
elem.innerHTML="<img src='smily' alt='It\'sa Smily' style='width:50px'>";
The HTML source will be:
<img src="smiley" alt="It's a Smiley" style="width:50px">
or for HTML5
<img src=smiley alt="It's a Smiley" style=width:50px>
JS allows arrays like that:
var arr=['this','that'];
But if you stringify it, it will be for compatibly reason:
JSON=["this","that"]
I'm sure this takes some time.
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, and as some have mentioned/alluded to, pick a convention, stick with it, and only deviate when necessary.
You can use single quotes or double quotes. This enables you for example to easily nest javascript inside HTML attributes, without the need to escape the quotes. The same is when you create javascript with PHP.
The general idea is: if it is possible use such quotes that you won't need to escape. Less escaping = better code.
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.
