ในระหว่างกระบวนการสมัคร JavaScript เราจะพบการเปรียบเทียบที่หลากหลาย วันนี้ฉันได้รวบรวมสามสถานการณ์สำหรับคุณและเรียนรู้ด้วยกัน
1. การเปรียบเทียบวัตถุสองชิ้น
การเปรียบเทียบ JavaScript ผสมกับคุณสมบัติแปลก ๆ มาดูการเปรียบเทียบง่ายๆ
// การเปรียบเทียบค่าดิบ> var a = 12undefined> var b = 12undefined> a == btrue> a === btrue // การเปรียบเทียบวัตถุ> var c = [] undefined> var d = [] undefined> c == dfalse> c === dfalse
จากผลลัพธ์ข้างต้นเราจะเห็นว่าการเปรียบเทียบค่าดั้งเดิมสองค่าดูเหมือนจะแตกต่างจากการเปรียบเทียบวัตถุเล็กน้อย หากคุณเปรียบเทียบค่าของวัตถุสองชิ้นแม้ว่าค่าของพวกเขาจะเหมือนกันผลลัพธ์สุดท้ายจะแตกต่างกัน เมื่อเปรียบเทียบวัตถุสองวัตถุควรเปรียบเทียบวัตถุทั้งสองวัตถุ
ถ้าเราทำสิ่งนี้:
> var m = {} undefined> n = m {}> n === mtrueหมายความว่าตัวแปรทั้งสองชี้ไปที่วัตถุเดียวกันดังนั้นจึงเหมือนกัน
2. การเปรียบเทียบประเภทต่าง ๆ
นอกจากนี้ยังมีสถานการณ์พิเศษต่อไปนี้
> 12 == "12" true> null == undefinedtrue> undefined == falsefalse> null == falsefalse> null === undefinedFalse
ทำไมจำนวนเต็มจึงเท่ากับสตริง? นี่เป็นเพราะ == (เท่ากับไม่สอดคล้องกัน) ไม่ได้เปรียบเทียบประเภท ก่อนเปรียบเทียบจะพิมพ์ค่าที่ต้องเปรียบเทียบ ที่นี่ สตริงจะถูกแปลงเป็นประเภทตัวเลขแล้วเปรียบเทียบ ทำไมถึงแน่นอน? มาทดลองกันเถอะ
> 1 + 23> 1 + "2" '12'> 2 <"12" True> "2" <"12" FALSE
จากตัวอย่างข้างต้นเราจะเห็นว่าค่า 2 นั้นเล็กกว่าสตริง 12 ถ้าการเปรียบเทียบถูกแปลงเป็นสตริงก่อนที่ค่าจะถูกแปลงเป็นสตริงผลลัพธ์ควรเป็น "2"> "12"
ยังไม่เชื่อ? ให้ฉันยกตัวอย่างให้คุณอีก
> "12d"> 12false> "12d" <12false> "12d" == 12false> "12" <"12d" จริง
ทำไมถึงเป็นเช่นนี้? หากคุณแปลง 12 เป็นสตริงแล้ว 12D ควรมากกว่า 12 ใช่ไหม? ทำไมคุณเปรียบเทียบกับเท็จ? ฉันเดาว่าเป็นเพราะคนพิเศษด้านล่าง
> nan <1false> nan> 1false
ไม่ว่า NAN จะเปรียบเทียบอะไรมันจะกลับมาเป็นเท็จ รวมถึงตัวเอง ดังนั้นวิธีที่ดีที่สุดในการตรวจสอบว่าตัวแปรคือ NAN คือ x! = x หากกลับมาจริงหรือไม่หมายความว่า X คือ NAN จากนั้นที่นี่ควรเป็นเมื่อ 12D จะถูกแปลงเป็นประเภทตัวเลขเพราะมีอักขระพิเศษและในที่สุดก็กลายเป็นน่าน ไม่ว่าคุณจะเปรียบเทียบกับประเภทตัวเลขได้อย่างไรผลลัพธ์ก็เป็นเท็จ
สำหรับตัวดำเนินการตัวเลขและสตริงตัวดำเนินการเครื่องหมายบวกจะทำงานแตกต่างจากตัวดำเนินการเปรียบเทียบ ตัวดำเนินการบวกชอบสตริงและหากหนึ่งในตัวถูกดำเนินการเป็นสตริงมันจะถูกแปลงเป็นสตริง ตัวดำเนินการเปรียบเทียบต้องการตัวเลขและการเปรียบเทียบสตริงจะดำเนินการเฉพาะเมื่อตัวเลขทั้งสองเป็นสตริง
สำหรับโมฆะและไม่ได้กำหนดไว้ข้างต้น - - - - ฉันไม่รู้วิธีอธิบายพฤติกรรมของพวกเขาในขณะนี้ ตอนนี้ฉันจำได้เท่านั้น เพราะพวกเขาพิเศษ
3. การเปรียบเทียบวัตถุที่มีค่าดั้งเดิม
หากวัตถุสองชิ้นที่ต้องเปรียบเทียบคือวัตถุ JavaScript และโครงกระดูกการแปลงประเภทระดับหนึ่งจะดำเนินการ ค้นหาวิธีในการแปลงค่าของวัตถุเป็นค่าดั้งเดิม โดยทั่วไปการพูดมีสองวิธี valueOf, toString ต่อไปนี้เป็นกระบวนการแปลงของวัตถุเปล่า:
// ฉันเขียนออกมาโดยตรง> a = {} {} // 1. ค่าของการแปลง> A.ValueOf () {} // 2. หากการดำเนินการข้างต้นส่งผลให้ค่าดิบจากนั้นใช้ toString เพื่อแปลง (และในทางกลับกัน)> a.toString () '[วัตถุวัตถุ]'> a == '[วัตถุวัตถุ]' จริง ข้างต้นเป็นกระบวนการแปลงวัตถุในตัวและกลไก JavaScript ก่อนอื่นมันจะเรียก valueOf ของการแปลง หากค่าที่ได้รับไม่ใช่ค่าดั้งเดิมมันจะเรียก toString สำหรับการแปลง ค่าสุดท้ายคือ '[object Object]' ค่าที่แปลกมาก แต่เป็นค่าดั้งเดิม หากตัวแปร A และค่านี้เท่ากัน (ไม่สอดคล้องกัน) สามารถรับผลลัพธ์ที่แท้จริงได้ (มันล่มสลายหรือไม่?)
อย่างไรก็ตามคู่มือที่มีสิทธิ์ให้หลักการต่อไปนี้เราสามารถอ้างถึงได้
แปลงค่าดิบ JavaScript Language Core คลาสในตัวก่อนพยายามแปลงด้วย ValueO F จากนั้นใช้ toString สำหรับการแปลง ยกเว้นคลาสวันที่จะใช้ toString สำหรับการแปลงเท่านั้น วัตถุที่ไม่ได้อยู่ในแกนกลางของจาวาสคริปต์จะถูกแปลงเป็นค่าดั้งเดิมผ่านวิธีที่พวกเขากำหนดไว้ในการใช้งานที่เกี่ยวข้อง
ตามคำอธิบายข้างต้น เมื่อเราเปรียบเทียบ A = {} กับค่าดั้งเดิมเราจะเรียกฟังก์ชัน valueOf ก่อนและผลลัพธ์คือ {} เห็นได้ชัดว่าไม่ใช่ค่าดั้งเดิม จากนั้นการแปลงจะดำเนินการโดยใช้ toString ในที่สุดผลลัพธ์ที่แปลกประหลาดก็ออกมา แต่ผลลัพธ์ที่แปลกประหลาดนี้ '[object Object]' เป็นค่าดั้งเดิมของ {} (มันเป็นตัวอักษรของสตริง)
ข้างต้นเป็นบทสรุปเปรียบเทียบใน JavaScript ฉันหวังว่าคำอธิบายในบทความนี้จะเป็นประโยชน์กับทุกคนเมื่อเรียนรู้ JavaScript