เมื่อเร็ว ๆ นี้ฉันกำลังเรียกใช้โค้ดบางส่วนผ่าน JSLint เมื่อพบข้อผิดพลาดนี้ สิ่งที่ฉันคิดว่าตลกเกี่ยวกับข้อผิดพลาดนี้ก็คือมันจะถือว่า == ทั้งหมดควรเป็น === โดยอัตโนมัติ
มันสมเหตุสมผลจริงๆหรือ? ฉันเห็นหลายกรณีที่คุณไม่ต้องการเปรียบเทียบประเภทและฉันกังวลว่าสิ่งนี้อาจทำให้เกิดปัญหาได้
คำว่า "คาดว่า" จะบ่งบอกว่าควรทำทุกครั้ง ..... นั่นคือสิ่งที่ไม่สมเหตุสมผลสำหรับฉัน
myVar == nullตรวจสอบใช่การเปลี่ยนแปลงครั้งใหญ่ ; ^) ข้อโต้แย้งของ Crockford คือทำให้ความหมายของรหัสแม่นยำยิ่งขึ้นและยากที่จะโต้แย้ง
คำตอบ:
IMO โดยใช้สุ่มสี่สุ่มห้าโดย===ไม่พยายามทำความเข้าใจว่าการแปลงประเภททำงานอย่างไรไม่สมเหตุสมผล
ความกลัวหลักเกี่ยวกับตัวดำเนินการ Equals ==คือกฎการเปรียบเทียบที่ขึ้นอยู่กับประเภทที่เปรียบเทียบสามารถทำให้ตัวดำเนินการไม่สกรรมกริยาตัวอย่างเช่นถ้า:
A == B AND
B == C
ไม่รับประกันว่า:
A == C
ตัวอย่างเช่น:
'0' == 0; // true
0 == ''; // true
'0' == ''; // false
ตัวดำเนินการ Strict Equals ===ไม่จำเป็นจริงๆเมื่อคุณเปรียบเทียบค่าประเภทเดียวกันตัวอย่างที่พบบ่อยที่สุด:
if (typeof foo == "function") {
//..
}
เราเปรียบเทียบผลลัพธ์ของตัวtypeofดำเนินการซึ่งมักจะเป็นสตริงกับสตริงลิเทอรัล ...
หรือเมื่อคุณทราบกฎการบังคับประเภทเช่นตรวจสอบว่ามีบางสิ่งnullหรือundefinedบางสิ่ง:
if (foo == null) {
// foo is null or undefined
}
// Vs. the following non-sense version:
if (foo === null || typeof foo === "undefined") {
// foo is null or undefined
}
===ดำเนินการคือความชัดเจนของโค้ด ไม่มีสถานการณ์ที่สมเหตุสมผลที่จะใช้==เนื่องจากจะไม่มีวันชัดเจนและเข้าใจได้เท่ากับตัวดำเนินการระบุตัวตน ไม่ได้เกี่ยวกับว่าคุณเข้าใจตัวดำเนินการหรือไม่ แต่เป็นการใช้ตัวดำเนินการซึ่งทำให้โค้ดของคุณอ่านง่ายขึ้นโดยแทบไม่มีค่าใช้จ่ายใด ๆ นักพัฒนาเพียงรายเดียวที่โต้เถียงกับตัวดำเนินการระบุตัวตนคือนักพัฒนาเดี่ยวและผู้ที่ไม่ได้ทำงานเป็นทีม ตามความหมายคนที่เป็นรหัสไม่ได้รับการตรวจสอบด้วยสายตาเพียงพอ
there is no reasonable situationเป็นการแสดงข้อมูลที่ขัดต่อข้อเท็จจริงอย่างร้ายแรง คิดเกี่ยวกับ (native) ประเภท Javascript และNumber Stringการดำรงอยู่ของพวกเขาพิสูจน์ผู้เขียน Javascript ==มีกรณีการใช้งานบางอย่างในใจสำหรับ คุณคิดว่าnew String('hi') === 'hi'การประเมินfalseเป็นมีความชัดเจนมากหรือไม่? โปรดเขียนข้อมูลโค้ดที่ทดสอบอาร์กิวเมนต์ฟังก์ชันของคุณกับการ'hi'ยอมรับทั้ง String และ string และบอกฉันว่าชัดเจน
JSLint มีการป้องกันมากกว่าที่ไวยากรณ์ Javascript อนุญาตโดยเนื้อแท้
จากเอกสาร JSLint:
ตัวดำเนินการ
==และ!=ประเภทบังคับก่อนที่จะเปรียบเทียบ สิ่งนี้ไม่ดีเพราะมันทำให้' \t\r\n' == 0เป็นจริง สิ่งนี้สามารถมาสก์ข้อผิดพลาดประเภทเมื่อเปรียบเทียบกับค่าใด ๆ ต่อไปนี้ให้ใช้
===หรือ!==ตัวดำเนินการ (ซึ่งไม่ได้ทำการบังคับประเภท):0 '' undefined null false trueหากคุณสนใจเพียงว่าค่าเป็นจริงหรือเท็จให้ใช้รูปแบบสั้น ๆ แทน
(foo != 0)เพียงแค่พูดว่า
(foo)และแทนที่จะเป็น
(foo == 0)พูด
(!foo)ตัวดำเนินการ
===และ!==เป็นที่ต้องการ
==ดำเนินการ ===เป็นกรณีพิเศษ ... JSLint พยายามที่จะทำให้มันดูเหมือนเช่นการใช้==อย่างใดจะมีความผิด ... var x = 4, y = new Number(4); if (x == y) {alert('Javascript depends on == just embrace it!');}แต่ลองนี้ ประเภทดั้งเดิมมีคลาสที่สอดคล้องกันซึ่งใช้แทน ( Number, String) และ Javascript ขึ้นอยู่กับตัว==ดำเนินการในการเปรียบเทียบธรรมชาติเหล่านี้
โปรดทราบว่า JSLint บังคับให้บุคคลหนึ่งคิดว่า JavaScript ที่ดีควรเป็นอย่างไร คุณยังคงต้องใช้สามัญสำนึกในการดำเนินการเปลี่ยนแปลงที่แนะนำ
โดยทั่วไปการเปรียบเทียบประเภทและมูลค่าจะทำให้โค้ดของคุณปลอดภัยยิ่งขึ้น (คุณจะไม่พบพฤติกรรมที่ไม่คาดคิดเมื่อการแปลงประเภทไม่ทำในสิ่งที่คุณคิดว่าควร)
Triple-equal แตกต่างกับ double-equal เพราะนอกจากจะตรวจสอบว่าทั้งสองด้านมีค่าเท่ากันหรือไม่แล้ว triple-equal ยังตรวจสอบว่าเป็นประเภทข้อมูลเดียวกัน
ดังนั้น("4" == 4)เป็นความจริงในขณะที่("4" === 4)เป็นเท็จ
สามเท่ายังทำงานได้เร็วกว่าเล็กน้อยเนื่องจาก JavaScript ไม่ต้องเสียเวลาในการแปลงประเภทใด ๆ ก่อนที่จะให้คำตอบแก่คุณ
JSLint มีเป้าหมายโดยเจตนาที่จะทำให้โค้ด JavaScript ของคุณเข้มงวดมากที่สุดโดยมีจุดประสงค์เพื่อลดข้อบกพร่องที่คลุมเครือ มันเน้นสิ่งนี้เพื่อพยายามให้คุณเขียนโค้ดในลักษณะที่บังคับให้คุณเคารพประเภทข้อมูล
แต่สิ่งที่ดีเกี่ยวกับ JSLint ก็คือเป็นเพียงแนวทางเท่านั้น อย่างที่พวกเขาพูดบนเว็บไซต์มันจะทำร้ายความรู้สึกของคุณแม้ว่าคุณจะเป็นโปรแกรมเมอร์ JavaScript ที่เก่งมากก็ตาม แต่คุณไม่ควรรู้สึกว่าจำเป็นต้องทำตามคำแนะนำ หากคุณได้อ่านสิ่งที่จะพูดและคุณเข้าใจ แต่คุณแน่ใจว่ารหัสของคุณจะไม่พังคุณก็ไม่มีการบังคับให้คุณเปลี่ยนแปลงอะไร
คุณสามารถบอก JSLint ให้เพิกเฉยต่อการตรวจสอบประเภทต่างๆได้หากคุณไม่ต้องการถูกโจมตีด้วยคำเตือนว่าคุณจะไม่ทำอะไรเลย
คำพูดจากhttp://javascript.crockford.com/code.html :
=== และ! == ตัวดำเนินการ
การใช้ตัวดำเนินการ === และ! == จะดีกว่าเกือบตลอดเวลา ตัวดำเนินการ == และ! = ทำการบังคับประเภท โดยเฉพาะอย่าใช้ == เพื่อเปรียบเทียบกับค่าที่เป็นเท็จ
JSLint นั้นเข้มงวดมาก 'webjslint.js' ของพวกเขาไม่ผ่านการตรวจสอบความถูกต้องของตัวเอง
webjslint.jsไม่ตรวจสอบความถูกต้อง - แม้ว่าข้อผิดพลาดส่วนใหญ่ที่ฉันเห็นในตอนนี้เกี่ยวข้องกับการเว้นวรรค เห็นได้ชัดว่าเราต้องใช้สามัญสำนึกและวิจารณญาณอย่างสมเหตุสมผลเมื่อตรวจสอบ JavaScript โดยใช้ JSLint
alwaysนี้ตัดสิทธิ์โดยอัตโนมัติคำพูดนี้เป็นภูมิปัญญา โปรแกรมเมอร์ที่ฉลาดไม่ได้ดันทุรัง พวกเขาใช้สิ่งที่ดีที่สุดในสถานการณ์ที่กำหนด และพวกเขายินดีและยอมรับเครื่องมือใด ๆ ที่สร้างขึ้นเพื่อเป็นแกนหลักของภาษาไม่ใช่แค่ปิดด้วยไฟล์just never touch it. บรรทัดล่าง: รหัสของฉันสั้นลง (ไม่ใช่แค่การบันทึก=อักขระเพียงตัวเดียว) ดังนั้นไซต์ของฉันจึงโหลดได้เร็วขึ้นด้วยต้นทุนแบนด์วิดท์ที่น้อยลงผู้ใช้ของฉันจึงให้บริการได้ดีขึ้น
หากคุณต้องการทดสอบความเท็จ JSLint ไม่อนุญาต
if (foo == null)
แต่ไม่อนุญาต
if (!foo)
===ซึ่ง JSLint แนะนำ
foo == nullตรวจสอบค่าว่างหรือไม่ได้กำหนด !fooตรวจสอบค่าว่างไม่ได้กำหนด 0 และสตริงว่าง
เพื่อช่วยอธิบายคำถามนี้และอธิบายว่าเหตุใด NetBeans (จาก) 7.3 จึงเริ่มแสดงคำเตือนนี้ซึ่งเป็นส่วนสกัดจากการตอบสนองบนตัวติดตามข้อบกพร่องของ NetBeans เมื่อมีคนรายงานว่าสิ่งนี้เป็นข้อบกพร่อง:
เป็นแนวทางปฏิบัติที่ดีในการใช้ === แทนที่จะใช้ == ใน JavaScript
ตัวดำเนินการ == และ! = ทำการบังคับประเภทก่อนเปรียบเทียบ สิ่งนี้ไม่ดีเพราะทำให้ '\ t \ r \ n' == 0 เป็นจริง สิ่งนี้สามารถมาสก์ข้อผิดพลาดประเภท JSLint ไม่สามารถระบุได้อย่างน่าเชื่อถือว่ามีการใช้ == อย่างถูกต้องหรือไม่ดังนั้นจึงเป็นการดีที่สุดที่จะไม่ใช้ == และ! = เลยและใช้ตัวดำเนินการ === และ! == ที่เชื่อถือได้มากกว่าแทนเสมอ
มันไม่สามารถทำให้เกิดปัญหาได้จริง ๆ เพียงแค่ให้คำแนะนำแก่คุณ เอามันหรือปล่อยให้มัน. ที่กล่าวมาฉันไม่แน่ใจว่าฉลาดแค่ไหน อาจมีบริบทที่ไม่ได้นำเสนอเป็นประเด็น