1. มูลค่าดั้งเดิมและค่าอ้างอิง
ค่าดั้งเดิมจะถูกเก็บไว้ในสแต็ก และค่าอ้างอิงจะถูกเก็บไว้ในฮีป เช่นโปรแกรม:
คัดลอกรหัสรหัสดังต่อไปนี้:
ฟังก์ชั่น บุคคล(id,ชื่อ,อายุ){
this.id = ไอดี;
this.name = ชื่อ;
this.age = อายุ;
-
วาร์นัม = 10;
var bol = จริง;
var str = "เอบีซี";
var obj = วัตถุใหม่ ();
var arr = ['a','b','c'];
var person = บุคคลใหม่ (100, "คำขวัญของคนโง่", 25);
2.ไม่ได้กำหนดและเป็นโมฆะ
ไม่ได้กำหนด: ตัวแปรไม่ได้กำหนดไว้ มันเป็นค่าเฉพาะของประเภทที่ไม่ได้กำหนด
null: การอ้างอิงไม่ได้รับการจัดสรร มันเป็นค่าเฉพาะของประเภท Null
typeof (ไม่ได้กำหนด) == ไม่ได้กำหนด;
typeof (null) == วัตถุ;
ไม่ได้กำหนด==null;
ไม่ได้กำหนด!==null;
อินสแตนซ์ที่เป็นโมฆะของวัตถุ == false;
อินสแตนซ์ของวัตถุที่ไม่ได้กำหนด == false;
แม้ว่าจะมีประเภท Undefined และ Null แต่ตัวอย่างต่อไปนี้แสดงให้เห็นว่าทั้งสองประเภทนี้มองไม่เห็น ซึ่งหมายความว่าเราสามารถใช้ได้เฉพาะค่าเท่านั้น:
การแจ้งเตือน (อินสแตนซ์ที่ไม่ได้กำหนดของไม่ได้กำหนด);
การแจ้งเตือน (อินสแตนซ์ว่างของ Null);
3. อาร์เรย์หลอก
คุณสมบัติ:
1) มีคุณสมบัติความยาว
2) เข้าถึงข้อมูลตามลำดับดัชนีเช่นอาร์เรย์
3) ไม่มีวิธีจัดการข้อมูลเฉพาะอาเรย์เช่น push, pop, Slice...
อาร์เรย์หลอกสามารถแปลงเป็นอาร์เรย์จริงได้ผ่าน Array.prototype.slice:
var faceArray = {0: 'a', 1: 'b', ความยาว: 2}//อาร์เรย์หลอกมาตรฐาน;
var realArray = Array.prototype.slice.call(fakeArray);
อาร์เรย์หลอกใน js: อาร์กิวเมนต์, node.childNodes, document.getElementsByTagName()...
ปัญหาใน IE: node.childNodes ใน IE ไม่สามารถแปลงเป็นชิ้นได้
อาร์เรย์หลอกใน Jquery: Jquery นั้นเป็นอาร์เรย์หลอก:
alert($('.class1').length($('.class1').[0].tagName);
4. เกี่ยวกับตัวอักษรประเภทธรรมดา
var a = 1; b = จริง, c = "ซีซีซี";
ตัวอักษรดูเหมือนจะมีประเภท
alert(ประเภทของ a);//number
การแจ้งเตือน (ประเภท b); //boolean
alert(typeof c);//string
แต่ไม่สามารถวัดผ่านอินสแตนซ์ได้
alert(อินสแตนซ์ของ Number)//false
alert(อินสแตนซ์ของ Object)//false
alert(b อินสแตนซ์ของ Boolean)//false
การแจ้งเตือน (b อินสแตนซ์ของวัตถุ) // false
alert(c อินสแตนซ์ของ String)//false
alert(c อินสแตนซ์ของ Object)//false
5. คุณลักษณะต้นแบบของฟังก์ชันและคุณลักษณะต้นแบบภายในของอินสแตนซ์ออบเจ็กต์
แต่ละฟังก์ชัน (ตัวสร้าง) มีแอตทริบิวต์ต้นแบบ และแต่ละอินสแตนซ์ของวัตถุจะมองไม่เห็น (mozilla ทำให้เป็นแบบสาธารณะและสามารถรับผ่าน __proto__) คุณลักษณะต้นแบบภายใน ซึ่งชี้ไปที่แอตทริบิวต์ต้นแบบของตัวสร้างต้นแบบยังสามารถมีได้ คุณสมบัติต้นแบบของตัวเองซึ่งสร้างสายโซ่ต้นแบบ ออบเจ็กต์เป็นออบเจ็กต์บนสุด ดังนั้นสายโซ่ต้นแบบทั้งหมดจะชี้ไปที่ Object.prototype ในที่สุดเมื่อเข้าถึงคุณสมบัติ/วิธีการของอินสแตนซ์ออบเจ็กต์ เริ่มค้นหาจากอินสแตนซ์ออบเจ็กต์เอง หากไม่พบ ให้ค้นหาขึ้นไปตามสายโซ่ต้นแบบจนกระทั่ง Object.prototype.prototype == null
6. ความลับเล็กน้อยของตัวสร้าง
คัดลอกรหัสรหัสดังต่อไปนี้:
var s = new function(){return "sss"};
alert(s);//[วัตถุวัตถุ]
s = new function(){return new String("sss"});
การแจ้งเตือน //sss
คำอธิบายของรหัสนี้:
ตราบใดที่ Constructor หลังจากนิพจน์ใหม่ส่งคืนอ็อบเจ็กต์อ้างอิง (อาร์เรย์ อ็อบเจ็กต์ ฟังก์ชัน ฯลฯ) มันจะเขียนทับอ็อบเจ็กต์ที่ไม่ระบุชื่อที่สร้างโดย new หากส่งคืนชนิดดั้งเดิม (เมื่อไม่มีการส่งคืน ก็จะส่งคืนจริง ประเภทดั้งเดิม undefinition ) จากนั้นออบเจ็กต์ที่ไม่ระบุชื่อที่สร้างโดย new จะถูกส่งคืน
7. กระบวนการสร้างวัตถุ
คัดลอกรหัสรหัสดังต่อไปนี้:
ฟังก์ชั่นบุคคล (ชื่อ) {
this.name = ชื่อ;
-
บุคคล.ต้นแบบ = {
getName: ฟังก์ชั่น () {ส่งคืน this.name}
-
var p = บุคคลใหม่ ('จางซาน');
ถอดรหัสกระบวนการสร้าง p:
o สร้างวัตถุบิวด์อิน obj และเริ่มต้นมัน
ชี้ [[ต้นแบบ]] ภายในของ p ไปที่ Person.prototype
ให้ใช้ p เป็นค่านี้และใช้พารามิเตอร์อาร์กิวเมนต์เพื่อเรียกเมธอด [[Call]] ภายในของบุคคล ซึ่งก็คือ ดำเนินการกับเนื้อหาของฟังก์ชัน Person และส่งกลับค่าที่ส่งคืน หากไม่มีค่าส่งคืน ระบบจะส่งคืนค่าที่ไม่ได้กำหนด
— หากขั้นตอนก่อนหน้านี้ส่งคืนประเภทวัตถุ ให้คืนค่านี้เป็น p หรือส่งคืน obj
8. คุณสมบัติของวัตถุและคุณสมบัติที่สืบทอดมา
คัดลอกรหัสรหัสดังต่อไปนี้:
ฟังก์ชั่นบุคคล (ชื่อ) {
this.name = ชื่อ;
-
บุคคล.ต้นแบบ = {
ประเภท: 'มนุษย์'
getName: ฟังก์ชั่น () {ส่งคืน this.name}
-
var p = บุคคลใหม่ ('จางซาน');
alert(p.hasOwnProperty('type'));//false
p.type = 'เรน';
alert(p.hasOwnProperty('type'));//true
ผลลัพธ์การทำงานมีความชัดเจนมาก คุณสมบัติของวัตถุไม่สามารถแก้ไขคุณสมบัติของชื่อเดียวกันในต้นแบบได้ แต่จะสร้างคุณสมบัติที่มีชื่อเดียวกันและกำหนดค่าให้กับมันเท่านั้น
9.กระบวนการสร้างออบเจ็กต์ฟังก์ชัน
สร้างวัตถุวัตถุบิวด์อิน fn;
ตั้งค่า [[Prototype]] ภายในของ fn เป็น Function.prototype;
ตั้งค่าแอตทริบิวต์ภายใน [[Call]] ซึ่งเป็นวิธีการนำไปใช้ภายในที่จัดการตรรกะของการเรียกใช้ฟังก์ชัน (เข้าใจง่าย ๆ ว่าชี้ไปที่เนื้อหาของฟังก์ชัน);
ตั้งค่า fn.length เป็น funArgs.length หากฟังก์ชันไม่มีพารามิเตอร์ ให้ตั้งค่า fn.length เป็น 0
ตัวสร้างของ fn.prototype ชี้ไปที่ fn เอง
กลับ FN
10.หลักการอินสแตนซ์ของ
ในการตรวจสอบว่า a เป็นอินสแตนซ์ของ B หรือไม่ คุณต้องตรวจสอบว่าวัตถุที่ต้นแบบของ B ชี้ไปนั้น (แอตทริบิวต์ต้นแบบของตัวสร้าง) อยู่บนสายโซ่ต้นแบบของ a หรือไม่
11. เดาเกี่ยวกับฟังก์ชันและวัตถุ
alert(ฟังก์ชันอินสแตนซ์ของฟังก์ชัน);//true
alert(ฟังก์ชั่นของ Object);//true
การแจ้งเตือน (อินสแตนซ์ของวัตถุของฟังก์ชัน);//true
การแจ้งเตือน (อินสแตนซ์ของวัตถุของวัตถุ);//true
คิดมานานแล้วแต่คิดไม่ออก...