ประเภทการแปลง

โดยส่วนใหญ่แล้ว ตัวดำเนินการและฟังก์ชันจะแปลงค่าที่กำหนดให้เป็นประเภทที่ถูกต้องโดยอัตโนมัติ

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

นอกจากนี้ยังมีกรณีที่เราต้องแปลงค่าให้เป็นประเภทที่คาดไว้อย่างชัดเจน

ยังไม่พูดถึงวัตถุเลย

ในบทนี้ เราจะไม่กล่าวถึงวัตถุต่างๆ สำหรับตอนนี้ เราจะพูดถึงเรื่องพื้นฐาน

ต่อมา หลังจากที่เราเรียนรู้เกี่ยวกับวัตถุ ในบท Object to primitive Conversion เราจะดูว่าวัตถุเข้ากันได้อย่างไร

การแปลงสตริง

การแปลงสตริงเกิดขึ้นเมื่อเราต้องการรูปแบบสตริงของค่า

ตัวอย่างเช่น alert(value) ทำเพื่อแสดงค่า

นอกจากนี้เรายังสามารถเรียกใช้ฟังก์ชัน String(value) เพื่อแปลงค่าเป็นสตริงได้:

 ให้ค่า = จริง;
การแจ้งเตือน (ประเภทของค่า); //บูลีน

ค่า = สตริง (ค่า); // ตอนนี้ค่าเป็นสตริง "จริง"
การแจ้งเตือน (ประเภทของค่า); //สตริง

การแปลงสตริงนั้นชัดเจนเป็นส่วนใหญ่ false กลายเป็น "false" null กลายเป็น "null" ฯลฯ

การแปลงตัวเลข

การแปลงตัวเลขในฟังก์ชันทางคณิตศาสตร์และนิพจน์จะเกิดขึ้นโดยอัตโนมัติ

ตัวอย่างเช่น เมื่อใช้การหาร / กับตัวเลขที่ไม่ใช่ตัวเลข:

 การแจ้งเตือน( "6" / "2" ); // 3 สตริงถูกแปลงเป็นตัวเลข

เราสามารถใช้ฟังก์ชัน Number(value) เพื่อแปลง value เป็นตัวเลขได้อย่างชัดเจน:

 ให้ str = "123";
การแจ้งเตือน (ประเภทของ str); //สตริง

ให้ num = จำนวน (str); // กลายเป็นตัวเลข 123

การแจ้งเตือน (ประเภทหมายเลข); // ตัวเลข

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

หากสตริงไม่ใช่ตัวเลขที่ถูกต้อง ผลลัพธ์ของการแปลงดังกล่าวจะเป็น NaN ตัวอย่างเช่น:

 ให้ age = Number("สตริงที่กำหนดเองแทนตัวเลข");

การแจ้งเตือน(อายุ); // NaN การแปลงล้มเหลว

กฎการแปลงตัวเลข:

ตัวอย่าง:

 การแจ้งเตือน( หมายเลข(" 123 ") ); // 123
การแจ้งเตือน( หมายเลข("123z") );      // NaN (เกิดข้อผิดพลาดในการอ่านตัวเลขที่ "z")
alert( ตัวเลข(จริง) );        // 1
alert( ตัวเลข(เท็จ) );       // 0

โปรดทราบว่า null และ undefined มีพฤติกรรมแตกต่างออกไปที่นี่: null กลายเป็นศูนย์ ในขณะที่ undefined กลายเป็น NaN

ตัวดำเนินการทางคณิตศาสตร์ส่วนใหญ่ก็ทำการแปลงเช่นกัน เราจะได้ทราบกันในบทถัดไป

การแปลงบูลีน

การแปลงบูลีนเป็นวิธีที่ง่ายที่สุด

มันเกิดขึ้นในการดำเนินการเชิงตรรกะ (ต่อมาเราจะพบกับการทดสอบเงื่อนไขและสิ่งอื่นที่คล้ายคลึงกัน) แต่ยังสามารถทำได้อย่างชัดเจนด้วยการเรียกไปที่ Boolean(value)

กฎการแปลง:

• ค่าที่ "ว่างเปล่า" ตามสัญชาตญาณ เช่น 0 สตริงว่าง null undefined และ NaN จะกลายเป็น false

• ค่าอื่นๆ จะกลายเป็น true

ตัวอย่างเช่น:

 การแจ้งเตือน( บูลีน(1) ); // จริง
การแจ้งเตือน ( บูลีน (0) ); // เท็จ

alert( บูลีน("สวัสดี") ); // จริง
การแจ้งเตือน( บูลีน("") ); // เท็จ

โปรดทราบ: สตริงที่มีศูนย์ "0" เป็น true

บางภาษา (เช่น PHP) ถือว่า "0" เป็น false แต่ใน JavaScript สตริงที่ไม่ว่างเปล่าจะ true เสมอ

 alert( บูลีน("0") ); // จริง
การแจ้งเตือน( บูลีน(" ") ); // ช่องว่างก็เป็นจริงเช่นกัน (สตริงที่ไม่ว่างใดๆ จะเป็นจริง)

สรุป

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

String Conversion - เกิดขึ้นเมื่อเราส่งออกบางสิ่ง สามารถทำได้ด้วย String(value) การแปลงเป็นสตริงมักจะชัดเจนสำหรับค่าดั้งเดิม

Numeric Conversion – เกิดขึ้นในการดำเนินการทางคณิตศาสตร์ สามารถทำได้ด้วย Number(value)

การแปลงเป็นไปตามกฎ:

Boolean Conversion – เกิดขึ้นในการดำเนินการเชิงตรรกะ สามารถทำได้ด้วย Boolean(value)

ปฏิบัติตามกฎ:

กฎเหล่านี้ส่วนใหญ่เข้าใจและจดจำได้ง่าย ข้อยกเว้นที่น่าสังเกตซึ่งผู้คนมักจะทำผิดพลาดคือ:

• undefined คือ NaN เป็นตัวเลขไม่ใช่ 0

• "0" และสตริงเฉพาะช่องว่าง เช่น " " เป็นจริงในฐานะบูลีน

วัตถุไม่ครอบคลุมที่นี่ เราจะกลับมาดูในภายหลังในบท Object to primitive Conversion ที่เน้นเฉพาะกับ object หลังจากที่เราเรียนรู้สิ่งพื้นฐานเพิ่มเติมเกี่ยวกับ JavaScript