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

ฉันเห็นไลบรารี JavaScript มากขึ้นเรื่อย ๆ โดยใช้เครื่องหมายคำพูดเดี่ยวเมื่อจัดการสตริง อะไรคือเหตุผลที่จะใช้อย่างใดอย่างหนึ่งมากกว่าที่อื่น? ฉันคิดว่าพวกมันสามารถใช้แทนกันได้

เหตุผลที่เป็นไปได้มากที่สุดสำหรับการใช้ single vs double ในไลบรารีที่แตกต่างกันคือการตั้งค่าโปรแกรมเมอร์และ / หรือความสอดคล้องของ API นอกจากความสอดคล้องแล้วให้ใช้วิธีที่เหมาะสมกับสตริงมากที่สุด

การใช้เครื่องหมายคำพูดประเภทอื่นเป็นตัวอักษร:

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(`Escape the \` back-tick character and the \${ dollar-brace sequence in a string`);

แม่แบบเทมเพลตเสนอไวยากรณ์ที่สะอาดสำหรับ: การแก้ไขตัวแปรสตริงหลายบรรทัดและอื่น ๆ

โปรดทราบว่าJSONมีการระบุอย่างเป็นทางการให้ใช้เครื่องหมายคำพูดคู่ซึ่งอาจคุ้มค่าที่จะพิจารณาทั้งนี้ขึ้นอยู่กับข้อกำหนดของระบบ

หากคุณกำลังจัดการกับ JSON ควรสังเกตว่าการพูดอย่างเคร่งครัดสตริง JSON ต้องถูกยกมาสองครั้ง แน่นอนว่าห้องสมุดหลายแห่งสนับสนุนการเสนอราคาเดียวเช่นกัน แต่ฉันมีปัญหาอย่างมากในโครงการหนึ่งของฉันก่อนที่จะทราบว่าการอ้างถึงสตริงเดี่ยวนั้นอันที่จริงไม่ได้เป็นไปตามมาตรฐานของ JSON

ไม่มีใครแก้ปัญหาได้ดีกว่า ; อย่างไรก็ตามฉันต้องการยืนยันว่าการเสนอราคาซ้ำซ้อนอาจเป็นที่ต้องการมากกว่าในบางครั้ง:

• มาใหม่แล้วจะคุ้นเคยกับคำพูดสองจากภาษาของพวกเขา ในภาษาอังกฤษเราต้องใช้เครื่องหมายคำพูดคู่"เพื่อระบุเนื้อเรื่องของข้อความที่ยกมา ถ้าเราจะใช้คำพูดเดียว'ผู้อ่านอาจตีความมันผิดเป็นการตีความ ความหมายอื่นของข้อความที่ล้อมรอบด้วยเครื่องหมาย'แสดงถึงความหมาย 'ภาษาพูด' มันสมเหตุสมผลที่จะคงความสอดคล้องกับภาษาที่มีอยู่แล้วและสิ่งนี้อาจช่วยให้การเรียนรู้และตีความรหัสง่าย
• เครื่องหมายอัญประกาศคู่ช่วยลดความจำเป็นในการหลีกเลี่ยง apostrophes (ดังที่หดตัว) พิจารณาสตริง: เทียบกับรุ่นหนีอย่างอื่น"I'm going to the mall"'I\'m going to the mall'

• เครื่องหมายคำพูดคู่หมายถึงสตริงในภาษาอื่น ๆ อีกมากมาย เมื่อคุณเรียนรู้ภาษาใหม่เช่น Java หรือ C จะมีการใช้อัญประกาศคู่เสมอ ใน Ruby, PHP และ Perl สตริงที่ยกมาเดี่ยวบ่งบอกว่าไม่มีเครื่องหมายแบ็กสแลชในขณะที่เครื่องหมายคำพูดคู่สนับสนุน

• สัญลักษณ์ JSON เขียนด้วยเครื่องหมายคำพูดคู่

อย่างไรก็ตามอย่างที่คนอื่นได้กล่าวไว้มันเป็นสิ่งสำคัญที่สุดที่จะต้องคงไว้ซึ่งความสอดคล้อง

มาตรา 7.8.4 ของข้อกำหนดอธิบายสัญลักษณ์สัญกรณ์ตัวอักษร ข้อแตกต่างเพียงอย่างเดียวคือ DoubleStringCharacter คือ "SourceCharacter แต่ไม่ได้เป็นเครื่องหมายคำพูดคู่" และ SingleStringCharacter คือ "SourceCharacter แต่ไม่ใช่เครื่องหมายคำพูดเดี่ยว" ดังนั้นความแตกต่างเพียงอย่างเดียวจึงสามารถแสดงได้ดังนี้:

'A string that\'s single quoted'

"A string that's double quoted"

ขึ้นอยู่กับว่าคุณต้องการจะพูดมากแค่ไหน เห็นได้ชัดว่าเหมือนกันกับคำพูดสองครั้งในสตริงที่ยกมาคู่

คำพูดเดียว

ฉันต้องการคำพูดสองเท่าเป็นมาตรฐานเพราะพวกเขามีความหมายมากกว่านี้นิดหน่อยแต่ฉันก็ใช้คำพูดเดียวเพราะพวกเขาครองฉาก

คำพูดเดียว:

• Airbnb
• Facebook
• Google
• เสี้ยงฮึดฮัดแสดงความไม่พอใจ
• อึก
• ปม
• NPM (แม้ว่าจะไม่ได้กำหนดไว้ในคู่มือผู้เขียน)
• วิกิพีเดีย
• WordPress
• Yandex

ไม่มีการตั้งค่า:

• Three.js

คำพูดคู่:

• สิ่งที่พิมพ์ด้วยพิมพ์ดีด
• Crockford
• d3 (แม้ว่าจะไม่ได้นิยามไว้.eslintrc)
• jQuery

ฉันอยากจะบอกว่าความแตกต่างนั้นมีสไตล์โวหารล้วนๆ แต่ฉันมีข้อสงสัยจริงๆ ลองพิจารณาตัวอย่างต่อไปนี้:

/*
   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) สิ่งนี้จะส่งคืนสิ่งต่อไปนี้:

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, "");
}

เครื่องหมายคำพูดเดี่ยวถูกแทนที่ด้วยเครื่องหมายคำพูดคู่ (โปรดทราบว่าการเว้นวรรคเยื้องนั้นถูกแทนที่ด้วยช่องว่างสี่ช่อง) สิ่งนี้ให้ความรู้สึกว่าเบราว์เซอร์อย่างน้อยหนึ่งตัวแยกวิเคราะห์ JavaScript ภายในราวกับว่าทุกอย่างถูกเขียนโดยใช้เครื่องหมายคำพูดคู่ หนึ่งอาจคิดว่ามันใช้เวลาน้อยลงในการแยกวิเคราะห์ JavaScript หากทุกอย่างถูกเขียนแล้วตามมาตรฐานนี้

ซึ่งทำให้ฉันเป็นหมีแพนด้าที่เศร้ามากเพราะฉันคิดว่าคำพูดเดียวดูดีกว่ามากในรหัส นอกจากนี้ในภาษาการเขียนโปรแกรมอื่นพวกเขามักจะใช้งานได้เร็วกว่าคำพูดสองคำดังนั้นมันจะสมเหตุสมผลถ้าใช้กับ JavaScript เท่านั้น

สรุป:ฉันคิดว่าเราต้องทำวิจัยเพิ่มเติมเกี่ยวกับเรื่องนี้

แก้ไข:สิ่งนี้อาจอธิบายผลการทดสอบของ Peter-Paul Kochตั้งแต่หลังในปี 2003

ดูเหมือนว่าบางครั้งราคาจะเร็วกว่าใน Explorer Windows (ประมาณ 1/3 ของการทดสอบของฉันแสดงเวลาตอบสนองที่เร็วขึ้น) แต่ถ้า Mozilla แสดงความแตกต่างเลยก็จัดการได้กับราคาสองเท่าเร็วกว่าเล็กน้อย ฉันไม่พบความแตกต่างเลยใน Opera

แก้ไข 2014: Firefox / Spidermonkey เวอร์ชันทันสมัยไม่ต้องทำสิ่งนี้อีกต่อไป

หากคุณกำลังทำ JavaScript แบบอินไลน์ (อาจเป็นสิ่งที่ "ไม่ดี" แต่การหลีกเลี่ยงการสนทนา) เครื่องหมายคำพูดเดียวเป็นตัวเลือกเดียวสำหรับตัวอักษรสตริงฉันเชื่อว่า

เช่นทำงานได้ดี:

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

แต่คุณไม่สามารถใส่คำว่า "hi" ในเครื่องหมายคำพูดคู่โดยใช้วิธีการหลบหนีใด ๆ ที่ฉันทราบ แม้แต่"สิ่งที่จะเป็นการคาดเดาที่ดีที่สุดของฉัน (เนื่องจากคุณกำลังหลีกเลี่ยงการเสนอราคาในค่าคุณลักษณะของ HTML) จะไม่ทำงานสำหรับฉันใน Firefox \"จะไม่ทำงานอย่างใดอย่างหนึ่งเนื่องจากตอนนี้คุณกำลังหลบหนีสำหรับ HTML ไม่ใช่ JavaScript

ดังนั้นหากชื่อของเกมมีความสอดคล้องและคุณจะต้องทำ JavaScript แบบอินไลน์ในบางส่วนของแอปของคุณฉันคิดว่าคำพูดเดียวเป็นผู้ชนะ มีคนโปรดแก้ไขฉันถ้าฉันคิดผิด

ในทางเทคนิคไม่มีความแตกต่างเป็นเรื่องของสไตล์และการประชุมเท่านั้น

Douglas Crockford แนะนำให้ใช้เครื่องหมายคำพูดเดี่ยวสำหรับสตริงภายในและเครื่องหมายคำพูดคู่สำหรับภายนอก (โดยภายนอกเราหมายถึงข้อความที่จะแสดงต่อผู้ใช้แอปพลิเคชันเช่นข้อความหรือการเตือน)

ผมเองก็ทำตามนั้น

ปรับปรุง: ดูเหมือนว่านาย Crockford เปลี่ยนความคิดของเขาและตอนนี้แนะนำให้ใช้อัญประกาศตลอด :)

การพูดอย่างเคร่งครัดไม่มีความหมายแตกต่างกัน ดังนั้นทางเลือกจึงลงมาเพื่อความสะดวก

นี่คือปัจจัยหลายประการที่อาจมีผลต่อการเลือกของคุณ:

• แบบบ้าน: นักพัฒนาบางกลุ่มใช้การประชุมหนึ่งครั้งหรืออีกแบบหนึ่ง
• ข้อกำหนดฝั่งไคลเอ็นต์: คุณจะใช้เครื่องหมายคำพูดภายในสตริงหรือไม่ (ดูคำตอบของเลดี้)
• ภาษาฝั่งเซิร์ฟเวอร์: คน VB.Net อาจเลือกใช้อัญประกาศเดี่ยวสำหรับ java-script เพื่อให้สคริปต์สามารถสร้างได้ฝั่งเซิร์ฟเวอร์ (VB.Net ใช้เครื่องหมายคำพูดคู่สำหรับสตริงดังนั้นสตริง java-script จึงแยกแยะได้ง่าย ถ้าพวกเขาใช้คำพูดเดียว)
• รหัสห้องสมุด: หากคุณกำลังใช้ห้องสมุดที่ใช้สไตล์เฉพาะคุณอาจลองใช้สไตล์เดียวกันกับตัวเอง
• การตั้งค่าส่วนตัว: คุณอาจคิดว่าสไตล์ใดสไตล์หนึ่งดูดีขึ้น

ลองดูสิ่งที่อ้างอิงทำ

ภายใน jquery.js สตริงทุกตัวจะถูกอ้างอิงสองครั้ง

ดังนั้นเริ่มต้นตอนนี้ฉันจะใช้สตริงที่มีเครื่องหมายคำพูดคู่ (ฉันใช้ซิงเกิ้ล!)

เพียงให้ความมั่นคงในสิ่งที่คุณใช้ แต่อย่าให้ระดับความสะดวกสบายของคุณลดลง

"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

มันเป็นเรื่องของสไตล์และความชอบเป็นส่วนใหญ่ มีการสำรวจทางเทคนิคที่ค่อนข้างน่าสนใจและมีประโยชน์ในคำตอบอื่น ๆ ดังนั้นบางทีสิ่งเดียวที่ฉันอาจเพิ่มคือการให้คำแนะนำทางโลกเล็กน้อย

• หากคุณกำลังเขียนโปรแกรมใน บริษัท หรือทีมแล้วมันอาจเป็นความคิดที่ดีที่จะทำตาม "บ้านสไตล์"

• หากคุณกำลังเพียงอย่างเดียวแฮ็โครงการด้านไม่กี่แล้วมองไปที่ผู้นำที่โดดเด่นไม่กี่คนในชุมชน เช่นสมมติว่าคุณเข้าสู่ Node.js ดูโมดูลหลักเช่น underscore.js หรือแสดงและดูว่าพวกเขาใช้การประชุมแบบใดและพิจารณาตามนั้น

• หากทั้งสองการประชุมจะมีการใช้อย่างเท่าเทียมกันแล้วเลื่อนไปยังส่วนบุคคลของคุณ
  การตั้งค่า

• หากคุณไม่มีการตั้งค่าส่วนตัวแล้วพลิกเหรียญ

• หากคุณไม่ได้เหรียญแล้วเบียร์กับฉัน;)

ฉันหวังว่าฉันจะไม่เพิ่มสิ่งที่ชัดเจน แต่ฉันได้ต่อสู้กับDjangoและAjaxและ JSON ในเรื่องนี้

สมมติว่าในโค้ด HTML ของคุณคุณใช้เครื่องหมายคำพูดคู่ตามปกติฉันขอแนะนำให้ใช้เครื่องหมายคำพูดเดี่ยวสำหรับส่วนที่เหลือใน JavaScript

ดังนั้นฉันเห็นด้วยกับ @ady แต่ด้วยความระมัดระวัง

สิ่งที่สำคัญที่สุดของฉันคือ: ใน JavaScript อาจไม่เป็นไร แต่ทันทีที่คุณฝังไว้ใน HTML หรือสิ่งที่คุณเริ่มจะมีปัญหา คุณควรรู้ว่าอะไรคือการหลบหนีการอ่านการส่งผ่านสตริงของคุณ

กรณีที่เรียบง่ายของฉันคือ:

tbox.innerHTML = tbox.innerHTML + '<div class="thisbox_des" style="width:210px;" onmouseout="clear()"><a href="https://stackoverflow.com/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

คำพูดสองครั้งไม่ทำงาน!

มันชัดเจนว่าทำไม แต่มันก็ชัดเจนว่าทำไมเราควรติดราคาเดียว ... .. ฉันเดา ..

กรณีนี้คือการฝัง HTML ที่ง่ายมากข้อผิดพลาดเกิดขึ้นจากการคัดลอก / วางอย่างง่ายจากรหัส JavaScript 'ยกมาสองครั้ง'

ดังนั้นเพื่อตอบคำถาม:

ลองใช้คำพูดเดียวในขณะที่อยู่ใน HTML มันอาจบันทึกปัญหาการดีบักสองสาม ...

ไม่แน่ใจว่าสิ่งนี้เกี่ยวข้องกับโลกในปัจจุบันหรือไม่ แต่ใช้เครื่องหมายคำพูดคู่สำหรับเนื้อหาที่จำเป็นต้องมีอักขระควบคุมและประมวลผลคำพูดเดี่ยวสำหรับสตริงที่ไม่ได้รับ

คอมไพเลอร์จะเรียกใช้การจัดการสตริงบนสตริงที่ยกมาสองเท่าในขณะที่ปล่อยให้สตริงที่ยกมาเดี่ยวไม่มีใครแตะต้องแท้จริง สิ่งนี้ใช้เพื่อนำไปสู่การพัฒนา 'ดี' เลือกใช้อัญประกาศเดี่ยวสำหรับสตริงที่ไม่มีอักขระควบคุมเช่น\nหรือ\0(ไม่ประมวลผลภายในอัญประกาศเดียว) และอัญประกาศคู่เมื่อต้องการแยกวิเคราะห์สตริง (โดยมีค่าใช้จ่ายเล็กน้อยในรอบ cpu สำหรับ กำลังประมวลผลสตริง)

หากคุณใช้jshintจะทำให้เกิดข้อผิดพลาดหากคุณใช้สตริงคำพูดคู่

ฉันใช้มันผ่าน Yeoman scafflholding ของ AngularJS แต่อาจมี maner เพื่อกำหนดค่านี้

อย่างไรก็ตามเมื่อคุณจัดการ HTML เป็น JavaScript คุณสามารถใช้เครื่องหมายคำพูดเดี่ยวได้ง่ายขึ้น:

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

และอย่างน้อย JSON ใช้เครื่องหมายคำพูดคู่กับสตริงที่พิมพ์ซ้ำได้

ไม่มีวิธีตอบคำถามของคุณ

การพูดเกี่ยวกับประสิทธิภาพราคาจะไม่เป็นคอขวดของคุณอย่างไรก็ตามประสิทธิภาพจะเหมือนกันในทั้งสองกรณี

การพูดเกี่ยวกับความเร็วการเข้ารหัสหากคุณใช้'เพื่อกำหนดสตริงคุณจะต้องหลีกเลี่ยงการ"พูด คุณมีแนวโน้มที่จะต้องใช้"ภายในสตริงตัวอย่างเช่น:

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

จากนั้นฉันชอบที่จะใช้'เพื่อกำหนดสตริงดังนั้นฉันจึงต้องหลีกเลี่ยงอักขระที่น้อยลง

เหตุผลหนึ่งข้อ (โง่) ในการใช้เครื่องหมายคำพูดเดียวคือพวกเขาไม่ต้องการให้คุณกดปุ่ม Shift เพื่อพิมพ์พวกเขา (ฉันสมมติว่าสตริงเฉลี่ยไม่จำเป็นต้องมีการหลบหนีซึ่งเป็นข้อสมมติฐานที่สมเหตุสมผล) ทีนี้ลองสมมติว่าฉันเขียนโค้ด 200 บรรทัดทุกวัน บางทีใน 200 บรรทัดที่ฉันมี 30 คำพูด บางทีการพิมพ์เครื่องหมายคำพูดคู่ต้องใช้เวลามากกว่า 0.1 วินาทีในการพิมพ์คำพูดเดี่ยว (เพราะฉันต้องกดปุ่ม Shift) จากนั้นในวันใดก็ตามฉันเสียเวลา 3 วินาที ถ้าฉันใช้รหัสในลักษณะนี้เป็นเวลา 200 วันต่อปีเป็นเวลา 40 ปีแสดงว่าฉันเสียชีวิตไปแล้ว 6.7 ชั่วโมง อาหารสมอง.

ตรวจสอบข้อดีข้อเสีย

ในความโปรดปรานของคำพูดเดียว

• ความยุ่งเหยิงทางสายตาน้อยลง
• การสร้าง HTML: โดยปกติแล้วแอตทริบิวต์ HTML จะถูกคั่นด้วยเครื่องหมายคำพูดคู่

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

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

นอกจากนี้ HTML แบบอินไลน์มักจะเป็นแบบป้องกัน ชอบเทมเพลต

• การสร้าง JSON: อนุญาตให้ใช้เครื่องหมายคำพูดคู่เท่านั้นใน JSON

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

อีกครั้งคุณไม่ควรสร้าง JSON ด้วยวิธีนี้ JSON.stringify () มักจะเพียงพอ ถ้าไม่ใช้เท็มเพลต

ในความโปรดปรานของคำพูดสองครั้ง

• การจับคู่ง่ายกว่าหากคุณไม่มีการเข้ารหัสสี เช่นเดียวกับในบันทึกของคอนโซลหรือการตั้งค่าแหล่งข้อมูลบางประเภท
• ความคล้ายคลึงกับภาษาอื่น ๆ : ในการเขียนโปรแกรมเชลล์ (Bash ฯลฯ ) มีการใช้ตัวอักษรสตริงที่มีเครื่องหมายคำพูดเดี่ยวอยู่ แต่จะไม่มีการแปล escapes ภายใน C และ Java ใช้เครื่องหมายคำพูดคู่สำหรับสตริงและเครื่องหมายคำพูดเดี่ยวสำหรับอักขระ
• หากคุณต้องการให้รหัสเป็น JSON ที่ถูกต้องคุณต้องใช้เครื่องหมายคำพูดคู่

ในความโปรดปรานของทั้งสอง

ไม่มีความแตกต่างระหว่างสองอย่างใน JavaScript ดังนั้นคุณสามารถใช้สิ่งที่สะดวกในขณะนี้ ตัวอย่างเช่นตัวอักษรสตริงต่อไปนี้ทั้งหมดผลิตสตริงเดียวกัน:

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

อัญประกาศเดี่ยวสำหรับสตริงภายในและสองครั้งสำหรับภายนอก ที่ช่วยให้คุณสามารถแยกความแตกต่างของค่าคงที่ภายในจากสตริงที่จะแสดงต่อผู้ใช้ (หรือเขียนลงดิสก์ ฯลฯ ) เห็นได้ชัดว่าคุณควรหลีกเลี่ยงการใส่รหัสลงในโค้ด แต่ก็ไม่สามารถทำได้

อีกสิ่งหนึ่งที่คุณอาจต้องการพิจารณาเป็นเหตุผลสำหรับการเปลี่ยนจากราคาสองครั้งเป็นราคาเดียวคือการเพิ่มความนิยมของสคริปต์ฝั่งเซิร์ฟเวอร์ เมื่อใช้ PHP คุณสามารถส่งผ่านตัวแปรและฟังก์ชั่นวิเคราะห์จาวาสคริปต์โดยใช้สตริงและตัวแปรใน PHP

หากคุณเขียนสตริงและใช้อัญประกาศคู่กับ PHP ของคุณคุณจะไม่ต้องออกจากราคาเดียวและ PHP จะดึงค่าของตัวแปรให้คุณโดยอัตโนมัติ

ตัวอย่าง: ฉันต้องการเรียกใช้ฟังก์ชันจาวาสคริปต์โดยใช้ตัวแปรจากเซิร์ฟเวอร์ของฉัน

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

สิ่งนี้ช่วยประหยัดความยุ่งยากในการจัดการสตริงการเข้าร่วมและฉันสามารถเรียกจาวาสคริปต์จาก PHP ได้อย่างมีประสิทธิภาพ นี่เป็นเพียงตัวอย่างเดียว แต่นี่อาจเป็นหนึ่งในหลายสาเหตุที่โปรแกรมเมอร์เริ่มต้นด้วยเครื่องหมายคำพูดเดี่ยวในจาวาสคริปต์

อ้างจากเอกสาร PHP : "คุณสมบัติที่สำคัญที่สุดของสตริงที่มีเครื่องหมายคำพูดคู่คือข้อเท็จจริงที่ว่าชื่อตัวแปรจะถูกขยายดูที่การวิเคราะห์สตริงสำหรับรายละเอียด"

มีคนที่เรียกร้องให้เห็นความแตกต่างที่มีประสิทธิภาพ: ด้ายรายชื่อผู้รับจดหมายเก่า แต่ฉันไม่พบใครที่จะยืนยัน

สิ่งสำคัญคือดูชนิดของอัญประกาศ (คู่หรือเดี่ยว) ที่คุณใช้ในสายอักขระของคุณ ช่วยลดจำนวนการหลบหนี ตัวอย่างเช่นเมื่อคุณทำงานกับ html ภายในสตริงของคุณจะง่ายกว่าที่จะใช้เครื่องหมายคำพูดเดี่ยวเพื่อที่คุณจะได้ไม่ต้องหลีกเลี่ยงอัญประกาศคู่ทั้งหมดรอบ ๆ แอตทริบิวต์

ฉันจะใช้เครื่องหมายคำพูดคู่เมื่อไม่สามารถใช้เครื่องหมายคำพูดเดี่ยวและในทางกลับกัน:

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

แทน:

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

ไม่มีความแตกต่างระหว่างเครื่องหมายคำพูดเดี่ยวและคู่ใน JavaScript

ข้อกำหนดเป็นสิ่งสำคัญ:

อาจมีประสิทธิภาพแตกต่างกันไป แต่มีค่าน้อยที่สุดและสามารถเปลี่ยนแปลงได้ทุกวันตามการใช้งานของเบราว์เซอร์ การอภิปรายเพิ่มเติมนั้นไม่ได้ผลเว้นแต่ว่าแอปพลิเคชัน JavaScript ของคุณจะยาวเป็นแสน

มันเหมือนมาตรฐานถ้า

a=b;

เร็วกว่า

a = b;

(ช่องว่างเพิ่มเติม)

วันนี้ในเบราว์เซอร์และแพลตฟอร์มเฉพาะ ฯลฯ

เมื่อใช้ CoffeeScript ฉันใช้เครื่องหมายคำพูดคู่ ฉันยอมรับว่าคุณควรเลือกอย่างใดอย่างหนึ่งและติดกับมัน CoffeeScript ให้การแก้ไขเมื่อใช้เครื่องหมายคำพูดคู่

"This is my #{name}"

ES6 ใช้เครื่องหมายขีดหลัง (`) สำหรับสตริงแม่แบบ ซึ่งอาจมีเหตุผลที่ดี แต่เมื่อการเขียนโค้ดอาจเป็นเรื่องยุ่งยากในการเปลี่ยนอักขระตัวอักษรสตริงจากเครื่องหมายคำพูดหรือเครื่องหมายคำพูดคู่เป็นเครื่องหมายขีดหลังเพื่อรับคุณลักษณะการแก้ไข CoffeeScript อาจไม่สมบูรณ์แบบ แต่การใช้อักขระตัวอักษรสตริงเดียวกันทุกที่ (เครื่องหมายคำพูดคู่) และสามารถแก้ไขได้เสมอเป็นคุณสมบัติที่ดี

`This is my ${name}`

หากคุณกระโดดกลับไปมาระหว่าง JavaScript และ C # วิธีที่ดีที่สุดคือฝึกฝนนิ้วมือของคุณสำหรับการประชุมทั่วไปซึ่งเป็นเครื่องหมายคำพูดคู่

ฉันทำงานต่อไปนี้ประมาณ 20 ครั้ง และปรากฏว่าเครื่องหมายคำพูดคู่นั้นเร็วขึ้นประมาณ 20%

ส่วนที่สนุกคือถ้าคุณเปลี่ยนส่วนที่ 2 และส่วนที่ 1 รอบคำพูดเดียวจะเร็วกว่าประมาณ 20%

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

ไม่มีความแตกต่างอย่างเคร่งครัดดังนั้นส่วนใหญ่เป็นเรื่องของรสนิยมและสิ่งที่อยู่ในสตริง (หรือหากรหัส JS เองอยู่ในสตริง) เพื่อให้จำนวนการหลีกหนีต่ำ

ตำนานความแตกต่างของความเร็วอาจมาจากโลก PHP ซึ่งทั้งสองคำพูดนั้นมีพฤติกรรมที่แตกต่างกัน

หลังจากอ่านคำตอบทั้งหมดที่บอกว่าอาจจะเร็วกว่าหรืออาจมีข้อได้เปรียบฉันจะบอกว่า double quote นั้นดีกว่าหรือเร็วกว่านั้นเพราะคอมไพเลอร์การปิดของ Google จะแปลงเครื่องหมายคำพูดเดี่ยวเป็นเครื่องหมายคำพูดคู่

ตอนนี้เป็นปี 2020 เราควรพิจารณาตัวเลือกที่สามสำหรับ Javascript: backtick เดียวสำหรับทุกสิ่ง

สามารถใช้งานได้ทุกที่แทนที่จะเป็นราคาเดียวหรือสองครั้ง

มันช่วยให้คุณทำทุกสิ่งได้!

1. ฝังคำพูดเดี่ยวไว้ในนั้น: `เยี่ยมมาก! '
2. ฝังเครื่องหมายคำพูดคู่ในนั้น: `มันยอดเยี่ยมจริง ๆ !
3. ใช้การแก้ไขสตริง: `มันคือ" $ {better} "ดีกว่าดีกว่า! '

4. อนุญาตให้มีหลายบรรทัด: `

   นี้

   ยี่ห้อ

   จาวาสคริ

   ดีกว่า!

   `

นอกจากนี้ยังไม่ทำให้ประสิทธิภาพลดลงเมื่อแทนที่อีกสองรายการ: https://medium.com/javascript-in-plain-english/are-backticks-slower-than-other-strings-in-javascript-ce-about/ https://medium.com/

หากซอร์ส JS ของคุณคือ:

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

แหล่งที่มา HTML จะเป็น:

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

หรือ HTML5

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

JS อนุญาตอาร์เรย์ดังนี้

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

แต่ถ้าคุณทำให้มันเป็นไปได้มันจะเป็นเพราะเหตุผล

JSON=["this","that"]

ฉันแน่ใจว่าใช้เวลาพอสมควร

เพียงเพิ่ม 2 เซ็นต์ของฉัน: ในการทำงานกับทั้ง JS และ PHP ไม่กี่ปีก่อนฉันคุ้นเคยกับการใช้เครื่องหมายคำพูดเดี่ยวเพื่อให้ฉันสามารถพิมพ์อักขระตัวหลีกเลี่ยง ('\') โดยไม่ต้องหลบหนีเช่นกัน ฉันมักจะใช้มันเมื่อพิมพ์สตริงดิบพร้อมเส้นทางไฟล์ ฯลฯ ( http://en.wikipedia.org/wiki/String_literal#Raw_strings )

อย่างไรก็ตามการประชุมของฉันก็กลายเป็นการใช้เครื่องหมายคำพูดเดี่ยวในสตริง raw ของตัวระบุเช่นif (typeof s == 'string') ...(ซึ่งในตัวอักษร escape จะไม่ถูกนำมาใช้เลย) และเครื่องหมายคำพูดคู่สำหรับข้อความเช่น "เฮ้เกิดอะไรขึ้น?" ฉันยังใช้เครื่องหมายคำพูดเดี่ยวในความคิดเห็นเป็นหลักการพิมพ์เพื่อแสดงชื่อตัวระบุ นี่เป็นเพียงกฎง่ายๆและฉันจะหยุดเมื่อจำเป็นเช่นเมื่อพิมพ์สตริง HTML '<a href="#"> like so <a>'(แม้ว่าคุณสามารถย้อนกลับคำพูดได้ที่นี่) ฉันยังทราบว่าในกรณีของ JSON ที่ราคาคู่จะใช้สำหรับชื่อ - แต่นอกนั้นส่วนตัวผมชอบคำพูดเดียวเมื่อ Escape ที่จะไม่document.createElement('div')จำเป็นสำหรับข้อความที่อยู่ระหว่างคำพูดที่ชอบ -

บรรทัดล่างและบางคนได้กล่าวถึง / พาดพิงถึงเลือกการประชุมติดกับมันและเบี่ยงเบนเมื่อจำเป็นเท่านั้น