เรามาพูดถึงความแตกต่างระหว่าง typeof และ instanceof กันดีกว่า

ตัวดำเนินการ typeof และ instanceof ใช้เพื่อกำหนดประเภทข้อมูล แต่สถานการณ์การใช้งานแตกต่างกัน และรายละเอียดบางอย่างจำเป็นต้องได้รับการดูแลเป็นพิเศษ มาดูกันต่อไป เชี่ยวชาญประเด็นความรู้นี้อย่างถี่ถ้วน และอย่ากลัวคำถามของผู้สัมภาษณ์อีกต่อไป

typeof

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

const type = typeof 'Long Live China'; // string
ประเภท 666; //หมายเลข
ประเภทจริง; // บูลีน
ประเภทของไม่ได้กำหนด; // ไม่ได้กำหนด
ประเภทของสัญลักษณ์(); // สัญลักษณ์
ประเภท 1n; // bigint
typeof () => {}; // ฟังก์ชั่น

ประเภทของ []; // วัตถุ
ประเภทของ {}; // วัตถุ
ประเภทของสตริงใหม่ ('xxx'); // object

typeof null; // object

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

สิ่งหนึ่งที่ควรทราบคือการเรียก typeof null ส่งคืน object นี่เป็นเพราะค่าพิเศษ null ถือเป็นการอ้างอิงถึงวัตถุ null (เรียกอีกอย่างว่าตัวชี้วัตถุ null)

หากคุณต้องการระบุประเภทข้อมูลอ้างอิงอย่างถูกต้อง คุณสามารถใช้ตัวดำเนินการ instanceof

instanceof

ตัวดำเนินการ instanceof จะถูกวางไว้หลังตัวถูกดำเนินการและก่อนวัตถุที่กำหนด มันจะส่งกลับค่าบูลีนที่ระบุว่าตัวถูกดำเนินการเป็นอินสแตนซ์ของวัตถุที่กำหนดหรือไม่:

const result = [] instanceof Array; // true

const บุคคล = ฟังก์ชั่น () {};
const p = บุคคลใหม่ ();
p อินสแตนซ์ของบุคคล; // จริง

ข้อความ const = สตริงใหม่ ('xxx');
ข้อความ instanceof String; // true

Difference

• typeof จะส่งคืนประเภทพื้นฐานของตัวถูกดำเนินการ, instanceof ส่งคืนค่าบูลีน

• instanceof สามารถกำหนดประเภทข้อมูลอ้างอิงได้อย่างถูกต้อง แต่ไม่สามารถระบุประเภทข้อมูลพื้นฐานของประเภทข้อมูลได้อย่างถูกต้อง

• แม้ว่าจะสามารถกำหนดประเภทข้อมูลพื้นฐานได้ ( ยกเว้น null) แต่เป็นไปไม่ได้ที่จะกำหนดประเภทข้อมูลอ้างอิง (ยกเว้นฟังก์ชัน)

ที่ขยาย

Object.prototype.toString.call()

typeof และ instanceof มีข้อเสียบางประการและไม่สามารถตอบสนองความต้องการของทุกสถานการณ์ได้ หากคุณต้องการตรวจจับประเภทข้อมูลแบบสากล คุณสามารถใช้เมธอด Object.prototype.toString.call() ได้:

Object.prototype.toString.call({}); // "[object Object]"
Object.prototype.toString.call([]); // "[อาร์เรย์วัตถุ]"
Object.prototype.toString.call(666); // "[หมายเลขวัตถุ]"
Object.prototype.toString.call('xxx'); // "[object String]"

โปรดทราบว่าเมธอดนี้จะส่งคืนสตริงในรูปแบบของ "[object Object]"

ฟังก์ชันแบบห่อหุ้ม

เพื่อความสะดวกในการใช้งาน เราสามารถสรุปวิธีนี้ได้:

function getType(value) {
    ให้ type = ค่า typeof;
    if (type !== 'object') { // ถ้าเป็นประเภทข้อมูลพื้นฐาน ให้ return โดยตรง return type;
    -
    // หากเป็นประเภทข้อมูลอ้างอิง จะมีการพิจารณาเพิ่มเติม และผลลัพธ์ที่ส่งคืนปกติคือ return Object.prototype.toString.call(value).replace(/^[object (S+)]$/, ' $1');
-

getType(123); // หมายเลข
getType('xxx'); // string
getType(() => {}); // ฟังก์ชั่น
getType([]); // Array
getType({}); // วัตถุ
getType(null); // Null