JavaScript:ตัวดำเนินการความเท่าเทียมกัน

มีสี่วิธีในการเปรียบเทียบความเท่าเทียมกันใน JavaScript บทความนี้กล่าวถึงตัวดำเนินการเฉพาะที่ใช้ในการกำหนดความเท่าเทียมกัน ประเภทการบีบบังคับ และลักษณะเฉพาะบางอย่างที่พบเมื่อประเมินค่าที่เป็นจริงหรือเท็จในภาษา JavaScript

การเปรียบเทียบความเท่าเทียมกันอย่างเข้มงวด

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

const strictComparison = (a, b) => {
 console.log(typeof a);
 console.log(typeof b);
 return a === b;
}
 
strictComparison(8, '8'); //false

strictComparison ฟังก์ชันในตัวอย่างด้านบนรับค่าสองค่าและคืนค่าว่าค่าทั้งสองมีค่าเท่ากันหรือไม่

เมื่อมองแวบแรก ค่าจะเหมือนกันเพราะเป็นค่าทั้งคู่ 8 . อย่างไรก็ตาม ตัวดำเนินการความเท่าเทียมที่เข้มงวดก็ดูที่ประเภทด้วยเช่นกัน หากเราจะดูที่ a ในกรณีนี้และดูที่ typeof a , มันจะส่งคืน ‘number’ . หากเราทำเช่นเดียวกันกับ b ด้วย typeof b , มันจะส่งคืน ‘string’ .

เนื่องจากประเภทไม่เหมือนกัน มันจะส่งคืน false .

การเปรียบเทียบที่ผิดปกติกับ ===

มีการเปรียบเทียบที่ผิดปกติบางอย่างที่สามารถทำได้ด้วยตัวดำเนินการเท่ากับที่เข้มงวดใน JavaScript ต่อไปนี้คือข้อมูลบางส่วนที่มักถูกถามในสถานการณ์สัมภาษณ์:

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

รายการส่วนใหญ่ที่นี่ประเมินวิธีที่พวกเขาทำเพราะประเภทตรงกันหรือไม่ตรงกัน ข้อยกเว้นประการหนึ่งคือ NaN – สิ่งนี้ประเมินเป็น false เนื่องจากว่า NaN ในทางทฤษฎีสามารถเป็นอะไรก็ได้ - ดังนั้นจึงไม่มีข้อบ่งชี้ว่ามันจะเท่ากันหรือไม่ ดังนั้นจึงประเมินว่าเป็นเท็จ

81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้

ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก

การเปรียบเทียบความไม่เท่าเทียมกันอย่างเข้มงวด

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

const strictInequalityComparison = (a, b) => {
 console.log(typeof a);
 console.log(typeof b);
 return a !== b;
}
 
strictInequalityComparison("8", 8); //true

strictInequalityComparison ฟังก์ชันในตัวอย่างด้านบนรับค่าสองค่าและคืนค่าว่าทั้งสองค่าไม่เท่ากันหรือไม่

เมื่อมองแวบแรก ค่าต่างๆ จะดูเหมือนเท่ากัน (และไม่เท่ากัน) เนื่องจากทั้งคู่มีค่าเท่ากัน อย่างไรก็ตาม ตัวดำเนินการความไม่เท่าเทียมกันที่เข้มงวด เช่น ตัวดำเนินการความเท่าเทียมกันที่เข้มงวด ก็จะดูที่ประเภทด้วยเช่นกัน

หากเราจะดูที่ a ในตัวอย่างนี้ และดูที่ typeof a มันจะส่งคืน ‘string’ . หากเราทำเช่นเดียวกันกับ b ด้วย typeof b มันจะส่งคืน ‘number’ . เนื่องจากประเภทไม่เหมือนกัน มันจะกลับ true .

การเปรียบเทียบที่ผิดปกติกับ !==

มีการเปรียบเทียบที่ผิดปกติบางอย่างที่สามารถทำได้ด้วยตัวดำเนินการความไม่เท่าเทียมกันที่เข้มงวดใน JavaScript ต่อไปนี้คือคำถามที่มักถูกถามในสถานการณ์สัมภาษณ์:

เช่นเดียวกับตัวดำเนินการความเท่าเทียมกันที่เข้มงวด ไม่สามารถทำการเปรียบเทียบระหว่างอ็อบเจ็กต์หรืออาร์เรย์ได้

อีกสิ่งหนึ่ง…

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

การเปรียบเทียบความเท่าเทียมกันที่หลวม

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

const looseComparison = (a, b) => {
 console.log(typeof a);
 console.log(typeof b);
 return a == b;
}
 
strictComparison(8, '8'); //true

looseComparison ฟังก์ชันในตัวอย่างด้านบนรับค่าสองค่าและคืนค่าว่าค่าทั้งสองมีค่าเท่ากันหรือไม่

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

การเปรียบเทียบที่ผิดปกติกับ ==

มีการเปรียบเทียบที่ผิดปกติบางอย่างที่สามารถทำได้ด้วยตัวดำเนินการเท่ากับที่เข้มงวดใน JavaScript ต่อไปนี้คือคำถามที่มักถูกถามในสถานการณ์สัมภาษณ์:

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

การเปรียบเทียบความไม่เท่าเทียมกันหลวม

ตัวดำเนินการอสมการหลวมแสดงด้วยเครื่องหมายอัศเจรีย์และเครื่องหมายเท่ากับหนึ่งตัว (!=) มันจะประเมินว่าทั้งสองค่าไม่เท่ากันในมูลค่าเท่านั้น โดยพยายามแปลงอาร์กิวเมนต์ทั้งสองให้เป็นประเภทเดียวกัน

 const looseInequalityComparison = (a, b) => {
 console.log(typeof a);
 console.log(typeof b);
 return a != b;
}
 
looseInequalityComparison("8", 8); //false

looseInequalityComparison ฟังก์ชันในตัวอย่างด้านบนรับค่าสองค่าและคืนค่าว่าทั้งสองค่าไม่เท่ากันหรือไม่

เมื่อมองแวบแรก ค่าต่างๆ จะดูเท่ากันเพราะทั้งสองมีค่าเท่ากัน อย่างไรก็ตาม ตัวดำเนินการความไม่เท่าเทียมกันแบบหลวม ๆ เช่น ตัวดำเนินการความเท่าเทียมกันที่หลวม จะบังคับประเภทให้เหมือนกันบนตัวถูกดำเนินการทั้งสองก่อนที่จะเปรียบเทียบ เนื่องจากค่าที่ได้จะเหมือนกันหลังจากการบีบบังคับ มันจะส่งคืน false .

การเปรียบเทียบที่ผิดปกติกับ !=

มีการเปรียบเทียบที่ผิดปกติบางอย่างที่สามารถทำได้ด้วยตัวดำเนินการความไม่เท่าเทียมกันใน JavaScript ต่อไปนี้คือคำถามที่มักถูกถามในสถานการณ์สัมภาษณ์:

เช่นเดียวกับตัวดำเนินการความเท่าเทียมกันที่เข้มงวด ไม่สามารถทำการเปรียบเทียบระหว่างอ็อบเจ็กต์หรืออาร์เรย์ได้

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

บทสรุป

บทความนี้ได้กล่าวถึงสี่วิธีในการเปรียบเทียบความเท่าเทียมกันใน JavaScript สิ่งสำคัญที่ต้องจำไว้คือ Triple Equals (===) และ double Equals (==) ไม่ใช่ตัวดำเนินการเดียวกัน คนหนึ่งประเมินอย่างเคร่งครัดในประเภทและมูลค่า และอีกคนหนึ่งประเมินเฉพาะค่าหลังจากพยายามบังคับให้ทั้งคู่เป็นประเภทเดียวกัน