เมื่อดำเนินการ +, -, *, /, ==,! = ฯลฯ ในจาวาสคริปต์หากค่าของค่าทั้งสองด้านของผู้ปฏิบัติงานไม่สอดคล้องกับประเภทที่คาดหวัง JavaScript จะแปลงค่าทั้งสองด้านของผู้ปฏิบัติงานเป็นประเภทที่คาดหวังก่อนดำเนินการ เมื่อประเภทค่าที่คาดหวังคือสตริง JavaScript จะแปลงค่าเป็นสตริง เมื่อประเภทค่าที่คาดหวังคือหมายเลข JavaScript จะแปลงค่าเป็นหมายเลข (หากไม่สามารถแปลงเป็นค่าตัวเลขจะส่งคืน NAN) ตัวอย่างเช่น:
การคัดลอกรหัสมีดังนี้:
console.log (10 + "แมว"); // 10 แมว
console.log (10 * "cats"); // nan, "แมว" จะถูกแปลงเป็น nan
console.log (10 + "2"); // 102
console.log (10 - "2"); // 8
console.log (10/"2"); // 5
console.log (10 * "2"); // 20
console.log (10 * "2"); // 20
console.log ("10" * "2"); // 20
กฎการแปลงประเภทค่า
สำหรับกฎการแปลงค่าใน JavaScript โปรดดูที่ตารางที่ 3-2 การแปลงประเภท JavaScript ในหนังสือ "JavaScript the Definitive Guide" สถานที่ที่น่าจดจำมากขึ้นคือ:
1. ผลลัพธ์คือ NAN หลังจากการแปลงที่ไม่ได้กำหนดเป็นจำนวน
2. ผลลัพธ์คือ 0 หลังจากแปลงค่าว่างเป็นจำนวน
3. ผลลัพธ์คือ 0 หลังจากแปลงสตริงว่าง "" เป็นหมายเลข
4. ผลลัพธ์คือ "0" หลังจากแปลง -0 เป็นสตริง
5. ผลลัพธ์คือ 0 หลังจากแปลงอาร์เรย์ที่ว่างเปล่า [] เป็นตัวเลข
6. อาร์เรย์ที่มีสมาชิกหมายเลขหนึ่งเพียงหนึ่ง (เช่น [9]) จะถูกแปลงเป็นหมายเลขและผลลัพธ์คือค่าตัวเลข (9)
เมื่อ JavaScript แปลงสตริงเป็นหมายเลขมีกฎที่น่าสนใจอีกสองกฎ:
1. JavaScript จะลบอักขระ Whitespace ที่จุดเริ่มต้นและจุดสิ้นสุดของสตริงก่อนที่จะแปลงดังนั้นสตริงเช่น "42" สามารถแปลงเป็นหมายเลข 42 ได้สำเร็จ
2. หลังจากลบอักขระช่องว่างที่จุดเริ่มต้นและสิ้นสุดหากสตริงยังคงมีอักขระที่ไม่ใช่ตัวเลขสตริงจะถูกแปลงเป็น NAN ตัวอย่างเช่น: "3 M" จะถูกแปลงเป็น NAN
ตัวอย่าง:
การคัดลอกรหัสมีดังนี้:
console.log (10 * "3"); // 30
console.log (10 * "3 m"); // nan, "3 m" จะถูกแปลงเป็น nan
การแปลงประเภทค่าและการเปรียบเทียบ
ใน JavaScript การใช้ตัวดำเนินการที่เท่าเทียมกัน (==) เกี่ยวข้องกับการแปลงประเภทค่า: หากประเภทค่าทั้งสองด้านของตัวดำเนินการ == ไม่สอดคล้องกัน JS จะแปลงเป็นประเภทที่สอดคล้องกันก่อนที่จะตัดสิน ระวังว่าค่าสองประเภทที่แตกต่างกันอาจเทียบเท่าหลังจากการแปลงประเภท แต่นี่ไม่ได้หมายความว่าผลลัพธ์ของการใช้ตัวดำเนินการ == สำหรับพวกเขาจะต้องเป็นจริง ตัวอย่างง่ายๆคือไม่ได้กำหนดและเท็จ: ผลลัพธ์ของการไม่ได้กำหนดหลังจากการแปลงที่ไม่ได้กำหนดเป็นประเภทบูลีนนั้นเป็นเท็จ แต่ในความเป็นจริงผลลัพธ์ของการไม่ได้กำหนด == False เป็นเท็จ
การแปลงประเภทที่ชัดเจน
การแปลงประเภทอัตโนมัติโดยใช้ JavaScript นั้นสะดวกมาก แต่อาจทำให้เกิดปัญหาได้อย่างง่ายดายเช่นการบำรุงรักษารหัส เพื่อให้รหัสโปรแกรมชัดเจนขึ้นและมีความคลุมเครือน้อยลงการแปลงประเภทที่ชัดเจนบางครั้งใช้ในโปรแกรม JS:
การคัดลอกรหัสมีดังนี้:
หมายเลข ("3") // 3
สตริง (เท็จ) // "เท็จ"
บูลีน ([]) // true
ในกรณีส่วนใหญ่ผลลัพธ์ของการแปลงประเภทที่ชัดเจนสอดคล้องกับผลลัพธ์ของการแปลงประเภทอัตโนมัติ JS; แต่มีกรณีพิเศษ: เมื่อ null หรือ undefined ถูกแปลงเป็นวัตถุโดยอัตโนมัติ JS จะโยนข้อผิดพลาด typeerror; แต่เมื่อ null หรือ undefined ถูกแปลงเป็นวัตถุอย่างชัดเจน JS จะส่งคืนวัตถุเปล่า:
การคัดลอกรหัสมีดังนี้:
console.log (วัตถุ (undefined)); // วัตถุเปล่า
console.log (วัตถุ (null)); // วัตถุเปล่า
ในเวลาเดียวกันหากประเภทที่ระบุโดยการแปลงที่ชัดเจนนั้นแตกต่างจากประเภทที่ระบุโดยการแปลงอัตโนมัติของ JS ผลลัพธ์ที่ได้รับก็แตกต่างกันเช่นกัน ตัวอย่างเช่นผลลัพธ์ของ undefined == False ที่กล่าวถึงก่อนหน้านี้เป็นเท็จ หากประเภทการแปลงถูกระบุอย่างชัดเจนว่าเป็นบูลีนผลลัพธ์จะเป็นจริง:
การคัดลอกรหัสมีดังนี้:
console.log (undefined == false); // false
console.log (บูลีน (ไม่ได้กำหนด) == บูลีน (เท็จ)); // true
การใช้การแปลงประเภทอัตโนมัติ
ใน JS การแปลงประเภทค่าอัตโนมัติสามารถใช้เพื่อให้ได้เอฟเฟกต์เช่นเดียวกับการแปลงที่ชัดเจนผ่านตัวดำเนินการเช่น:
การคัดลอกรหัสมีดังนี้:
console.log (false + ""); // "false"
console.log (+false); // 0
console.log (!! 3); // true