การอภิปรายสั้น ๆ เกี่ยวกับจาวาสคริปต์ประเภทข้อมูลหกประเภทและจุดสนใจพิเศษ

มีประเภทข้อมูลทั่วไปหกประเภทใน js: ประเภทสตริง, ประเภท Null, ประเภทตัวเลข, ประเภทบูลีน และประเภทวัตถุ

1. หมายเหตุเกี่ยวกับประเภทของ

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

1. typeof เป็นตัวดำเนินการ ไม่ใช่วิธีการ แม้ว่าเรามักจะใช้ typeof() เพื่อรับประเภทข้อมูลของวัตถุ

2. Typeof สำหรับ null คือวัตถุ (เนื่องจาก null คือการอ้างอิงวัตถุว่าง) และ typeof สำหรับฟังก์ชันคือฟังก์ชัน

คัดลอกรหัสรหัสดังต่อไปนี้:

การแจ้งเตือน (ประเภทของ null); // return object

ฟังก์ชั่นสาธิต () {

การแจ้งเตือน ('สาธิต');

-

การแจ้งเตือน (ประเภทการสาธิต); // ฟังก์ชั่น return

2. ตั้งค่าเริ่มต้นสำหรับตัวแปรออบเจ็กต์ประเภทข้อมูลต่างๆ

โปรดทราบว่าหากตัวแปรอ็อบเจ็กต์ประเภท Object ไม่รู้ว่าจะกำหนดอะไรในตอนแรก อย่าใช้ var demo={};

คัดลอกรหัสรหัสดังต่อไปนี้:

var d2=null;

d2={'key':"อึ"};

var d3='';//ค่าเริ่มต้นของสตริง

var d4=0; //ค่าเริ่มต้นของประเภทตัวเลขถูกตั้งค่าเป็น 0

var d5=null; //ตั้งค่าเริ่มต้นสำหรับประเภทวัตถุ

3. ความแตกต่างและประเด็นที่ควรทราบระหว่าง undefinition และ null

1. หากคุณใช้ "==" เพื่อเปรียบเทียบ ค่าเหล่านี้จะเท่ากันเนื่องจากเปรียบเทียบค่าต่างๆ

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

1) ใช้ typeof เพื่อแยกแยะความแตกต่าง

2) ใช้ความสอดคล้องกัน "===": การเปรียบเทียบอยู่ระหว่างค่าและประเภทข้อมูล และค่าจริงจะถูกส่งกลับก็ต่อเมื่อเหมือนกันทั้งหมด

คัดลอกรหัสรหัสดังต่อไปนี้:

การแจ้งเตือน (ไม่ได้กำหนด == null); //true

การแจ้งเตือน (typeof ไม่ได้กำหนด == typeof null); //false

การแจ้งเตือน (ไม่ได้กำหนด === null); //true

4. หมายเหตุเกี่ยวกับบูลีน

1. การเปรียบเทียบระหว่าง true กับ 1 เหมือนกัน และการเปรียบเทียบระหว่าง false กับ 0 ก็เหมือนกัน (เป็นการเปรียบเทียบ "==") เนื่องจากการแปลงชนิดข้อมูลถูกนำมาใช้ภายใน โดยแปลง true เป็น 1 และแปลง false เป็น 0 มีข้อมูลมากมายภายใน js การแปลงประเภทอัตโนมัติเป็นสิ่งที่ทุกคนต้องใส่ใจ อีกมากมายจะถูกกล่าวถึงในภายหลัง แต่การใช้ "===" นั้นไม่เท่ากัน เนื่องจากชนิดข้อมูลไม่เท่ากัน

2. แสดงการแปลงเป็นบูลีน ใช้เมธอด Boolean() เพื่อแสดงการแปลง สิ่งที่คุณต้องใส่ใจคือประเภทข้อมูลต่างๆ เมื่อใดควรแปลงเป็นจริงและเมื่อใดควรแปลงเป็นเท็จ

1) ประเภทสตริง ตราบใดที่ไม่ใช่สตริงว่าง จะถูกแปลงเป็นจริง

2) ประเภทตัวเลข ตราบใดที่ไม่ใช่ 0 แม้แต่จำนวนลบก็จะถูกแปลงเป็นจริง

3) ประเภทอ็อบเจ็กต์ ตราบใดที่ไม่ใช่ประเภท null จะถูกแปลงเป็นจริง

4) ประเภทที่ไม่ได้กำหนดจะถูกแปลงเป็นเท็จ

ฉันจะไม่สาธิต คุณสามารถลองเองได้

3. (***) ฟังก์ชันบูลีนถูกเรียกภายใน () ของคำสั่ง if()

5. ข้อควรทราบเกี่ยวกับประเภทตัวเลข

1. ประเภทลูกลอยไม่สามารถดำเนินการได้อย่างแม่นยำ

คัดลอกรหัสรหัสดังต่อไปนี้:

การแจ้งเตือน (0.1+0.2); // กลับ 0.3000000000000000004

2. สนับสนุนการดำเนินงานสัญกรณ์วิทยาศาสตร์

3. NaN (ไม่ใช่ตัวเลข)

1) var d=0/0; หมายเหตุ: จะไม่มีการรายงานข้อผิดพลาดใน js แต่ NaN จะถูกส่งกลับ

2) สามารถรับได้จาก Number.NaN

3) การดำเนินการใด ๆ ระหว่าง NaN และวัตถุใด ๆ จะส่งคืน NaN

4) isNaN() กำหนดว่าเป็น NaN หรือไม่

คัดลอกรหัสรหัสดังต่อไปนี้:

alert(isNaN(NaN));//true

alert(isNaN(12));//false

alert(isNaN('123'));//false: เนื่องจากตัวเลขประเภทสตริงสามารถแปลงเป็นตัวเลขได้โดยอัตโนมัติ

alert(isNaN('lew'));//true

alert(isNaN(false));//(*)false: เนื่องจากค่าบูลสามารถแปลงเป็นตัวเลขได้ ค่าจริงจะกลายเป็น 1 ค่าเท็จกลายเป็น 0

5) หลักการดำเนินการภายในของ isNaN(): เช่นเดียวกับวัตถุ หลักการดำเนินการ: นายกรัฐมนตรีเรียกเมธอด valueOf() ของอ็อบเจ็กต์ หากสามารถแปลงเป็นตัวเลขได้ จะถูกตัดสินโดยตรง หากไม่สามารถแปลงเป็นตัวเลขได้ ก็จะเรียกเมธอด toString() อีกครั้ง แล้วทดสอบค่าที่ส่งคืน

valueOf() เรียกใช้เมธอด toObject() ภายใน หลักการดำเนินการภายในของทั้งสองวิธีมีดังนี้:

คัดลอกรหัสรหัสดังต่อไปนี้:

กล่อง var={

//แทนที่เมธอด toString() ของอ็อบเจ็กต์ box

toString:ฟังก์ชั่น(){

กลับ '123';

-

-

alert(isNaN(box));//false

alert(box);//123 ภายใน alert() จะเรียก valueOf() ของอ็อบเจ็กต์ก่อนแล้วจึงเรียกเมธอด toString()

6) แปลงประเภทข้อมูลอื่นเป็นประเภทตัวเลข

ประกอบด้วยสามฟังก์ชัน: Number(): สามารถแปลงข้อมูลทุกประเภท parseInt() และ parseFloat() แปลงเฉพาะสตริงเท่านั้น

คัดลอกรหัสรหัสดังต่อไปนี้:

alert(หมายเลข('123'));//123

alert(หมายเลข('0234'));//234

alert(ตัวเลข(จริง));//1

alert(หมายเลข(null));//(**)0

//ยกเว้นที่กล่าวมาข้างต้น ทุกอย่างจะส่งคืน NaN

alert(หมายเลข(ไม่ได้กำหนด))//NaN

หลักการใช้งานภายในของ Number(): เช่นเดียวกับ isNaN() จะถูกเรียก valueOf() ก่อน จากนั้นจึงเรียก toString() - จึงสามารถจินตนาการได้ว่าผลงานค่อนข้างแย่ - ดังนั้นตราบใดที่วัตถุที่จะแปลงเป็นสตริง ให้เรียก parseInt() หรือ parseFloat() เพราะไม่จำเป็นต้องตัดสินประเภทภายใน

หมายเหตุเมื่อเรียก parseInt() และ parseFloat(): ส่วนของสตริงที่เริ่มต้นจากอักขระตัวเลขตัวแรกไปจนถึงตัวเลข ก่อนที่อักขระตัวเลขตัวแรกจะถูกแปลงเป็นตัวเลข

คัดลอกรหัสรหัสดังต่อไปนี้:

alert(parseInt('123leb'));//123

alert(parseInt('123leb345'));//123

การแจ้งเตือน (parseInt ('len234')); // NaN

เมื่อพารามิเตอร์ใน parseInt() เป็นประเภท float จะได้เฉพาะส่วนจำนวนเต็มของตัวเลขเท่านั้น

คัดลอกรหัสรหัสดังต่อไปนี้:

การแจ้งเตือน (parseInt (56.12)); //56

6. ประเภทสตริง

1) (*สำคัญ*) สตริงไม่สามารถเปลี่ยนรูปได้ใน ECMAScript: สตริงจะไม่เปลี่ยนแปลงหลังจากสร้างขึ้นแล้ว

หากต้องการเปลี่ยนตัวแปรสตริงที่ได้รับการกำหนดค่า ให้ทำลายสตริงในตัวแปรก่อน จากนั้นจึงเติมตัวแปรด้วยสตริงที่มีค่าใหม่

คัดลอกรหัสรหัสดังต่อไปนี้:

var d='สวัสดี';

d=d+' shit';//กระบวนการดำเนินการ: ขั้นแรกกำหนดค่าให้กับ 'hello' จากนั้นล้างสตริงใน d เชื่อมต่อสตริง 'hello' และ 'shit' จากนั้นกำหนดค่าให้กับตัวแปร d (ดังนั้นค่าของสตริงจะไม่เปลี่ยนแปลงเมื่อสร้างแล้ว)

2) วิธีการ toString() แปลงประเภทข้อมูลอื่น ๆ ให้เป็นประเภทสตริง แต่ถ้าคุณดำเนินการเป็นค่าว่างหรือไม่ได้กำหนด จะมีการรายงานข้อผิดพลาด

3) อย่างไรก็ตาม เมธอด String() ยังสามารถบรรลุผลของ toString() ได้ แต่สามารถดำเนินการกับค่าว่างและไม่ได้กำหนดได้

หลักการภายใน: ให้เรียก toString() ก่อน และหากสามารถแปลงเป็นสตริงได้ ผลลัพธ์จะถูกส่งกลับโดยตรง ไม่ ให้ตัดสินว่าเป็นโมฆะหรือไม่ได้กำหนด แล้วส่งคืน 'null' หรือ 'unknown'

สรุป: หากคุณรู้ว่าตัวแปรไม่สามารถเป็นค่าว่างหรือไม่ได้กำหนดได้ ให้ใช้ toString() ซึ่งมีประสิทธิภาพมากกว่า String() เนื่องจาก String() ต้องทำการตัดสินใจภายใน จึงเป็นอันตรายต่อประสิทธิภาพ