นี่คือวัตถุพิเศษภายในฟังก์ชั่น สิ่งนี้หมายถึงวัตถุสภาพแวดล้อมที่ใช้ฟังก์ชั่นที่ดำเนินการ (เราจะอธิบายเพิ่มเติมในตอนท้ายของบทความ) ค่าของสิ่งนี้ไม่แน่นอนก่อนที่จะเรียกฟังก์ชั่น วิธีการโทรที่แตกต่างกันจะทำให้ค่านี้เปลี่ยน
window.num = 22; var o = {num: 11}; ฟังก์ชั่น saynum () {การแจ้งเตือน (this.num)} saynum (); // 22o.saynum = saynum; o.saynum (); // 11ข้อควรจำ: ชื่อฟังก์ชั่นเป็นเพียงตัวแปรที่มีตัวชี้ ดังนั้นแม้ว่าจะดำเนินการในสภาพแวดล้อมที่แตกต่างกันฟังก์ชั่น Global Saynum () ยังคงเป็นฟังก์ชั่นเดียวกับ O.saynum ()
1. เมื่อเรียกฟังก์ชั่นในขอบเขตทั่วโลก
เรียกในขอบเขตทั่วโลกวัตถุนี้หมายถึงหน้าต่าง
การดำเนินการของฟังก์ชั่นที่ไม่ระบุชื่อเป็นระดับโลกดังนั้นวัตถุนี้มักจะชี้ไปที่หน้าต่างเช่นกัน
ฟังก์ชั่น fn1 () {console.log (นี่);} fn1 ();2. เรียกผ่านตัวดำเนินการใหม่
สิ่งนี้อ้างอิงวัตถุอินสแตนซ์
ฟังก์ชันบุคคล (ชื่อ) {this.name = name;} person.prototype.printName = function () {การแจ้งเตือน (this.name); // byron}; var p1 = บุคคลใหม่ ('byron');3. วิธีการเรียกว่าเป็นวัตถุ
สิ่งนี้อ้างอิงวัตถุ
var obj1 = {ชื่อ: 'byron', fn: function () {console.log (นี่); }}; obj1.fn ();4. การโทรทางอ้อม
โทรและสมัคร
แต่ละฟังก์ชั่นมีสองวิธีที่ไม่ได้อยู่ในตัว: call () และใช้ () วัตถุประสงค์ของวิธีการทั้งสองนี้คือการเรียกฟังก์ชั่นในขอบเขตที่เฉพาะเจาะจงซึ่งจริง ๆ แล้วเทียบเท่ากับการตั้งค่าของวัตถุนี้ในร่างกายฟังก์ชั่น กล่าวอีกนัยหนึ่งฟังก์ชั่นเรียกโดยตรงและสภาพแวดล้อมการดำเนินการจะถูกระบุเมื่อโทร
window.color = 'red'; var o = {color: 'blue'}; function sayscolor () {alert (this.color);} saycolor.call (นี่); // redsaycolor.call (หน้าต่าง); // redsaycolor.call (o);(1) ใช้วิธีการ
รับพารามิเตอร์สองพารามิเตอร์หนึ่งคือขอบเขตของฟังก์ชั่นที่ทำงานในฟังก์ชั่นและอื่น ๆ คืออาร์เรย์พารามิเตอร์
(2) วิธีการโทร
วิธีการโทรเหมือนกับวิธีการใช้ความแตกต่างคือวิธีการรับพารามิเตอร์นั้นแตกต่างกัน สำหรับวิธีการโทรพารามิเตอร์แรกคือค่านี้ไม่เปลี่ยนแปลงและการเปลี่ยนแปลงคือพารามิเตอร์อื่น ๆ จะถูกส่งผ่านไปยังฟังก์ชันโดยตรง
ฟังก์ชั่น fn () {console.log (นี่) // ฟังก์ชั่น windwow innerfn () {console.log (นี่)} innerfn.call (นี่) // window} fn (); ฟังก์ชั่น fn0 () {console.log (นี่) // หน้าต่าง} ฟังก์ชั่น fn1 () {fn0.call (นี่); console.log (นี่); // window} fn1 (); ฟังก์ชั่น fn0 () {console.log (นี่) // object} var o = {fn1: ฟังก์ชัน fn1 () {fn0.call (นี่); console.log (this); // object}} o.fn1 ();5. วิธีการ bind
วิธีนี้สร้างอินสแตนซ์ของฟังก์ชั่นที่มีค่าถูกผูกไว้กับค่าที่ส่งผ่านไปยังฟังก์ชัน bind () กล่าวคือฟังก์ชั่นใหม่จะถูกส่งคืนและสิ่งนี้ภายในฟังก์ชั่นจะเป็นพารามิเตอร์แรกที่ส่งผ่าน
window.color = 'red'; var o = {color: 'blue'}; function sayscolor () {alert (this.color)} var objectsaycolor = saycolor.bind (o); objectsaycolor (); // สีน้ำเงินหมายเหตุเพิ่มเติม: ดำเนินการนิยามสภาพแวดล้อม
กำหนดตัวแปรหรือข้อมูลอื่น ๆ ที่ฟังก์ชั่นได้รับอนุญาตให้เข้าถึง แต่ละสภาพแวดล้อมการดำเนินการมีวัตถุตัวแปรที่เกี่ยวข้อง ตัวแปรและฟังก์ชั่นทั้งหมดที่กำหนดไว้ในสภาพแวดล้อมจะถูกเก็บไว้ในวัตถุนี้ รหัสที่เราเขียนไม่สามารถเข้าถึงวัตถุนี้ได้ แต่ตัวแยกวิเคราะห์จะใช้มันในพื้นหลังเมื่อประมวลผลข้อมูล
1. การสร้างสภาพแวดล้อมการดำเนินการ:
1. สภาพแวดล้อมการดำเนินการทั่วโลก
ในเว็บเบราว์เซอร์สภาพแวดล้อมการดำเนินการทั่วโลกถือเป็นวัตถุหน้าต่างดังนั้นตัวแปรและฟังก์ชั่นส่วนกลางทั้งหมดถูกสร้างขึ้นเป็นคุณสมบัติและวิธีการของวัตถุหน้าต่าง เมื่อรหัสถูกโหลดลงในเบราว์เซอร์สภาพแวดล้อมการดำเนินการทั่วโลกจะถูกสร้างขึ้น (สภาพแวดล้อมการดำเนินการทั่วโลกจะถูกทำลายเฉพาะเมื่อเราปิดหน้าเว็บหรือเบราว์เซอร์)
2. สภาพแวดล้อมการดำเนินการในท้องถิ่น
แต่ละฟังก์ชั่นมีสภาพแวดล้อมการดำเนินการของตัวเองดังนั้นสภาพแวดล้อมการดำเนินการในท้องถิ่นจึงเป็นวัตถุฟังก์ชัน เมื่อมีการเรียกฟังก์ชั่นสภาพแวดล้อมท้องถิ่นของฟังก์ชั่นจะถูกสร้างขึ้น (หลังจากรหัสในฟังก์ชันถูกดำเนินการสภาพแวดล้อมจะถูกทำลายและตัวแปรและคำจำกัดความของฟังก์ชั่นทั้งหมดที่เก็บไว้ในนั้นก็ถูกทำลายด้วย)
สภาพแวดล้อมการดำเนินการนี้และวัตถุตัวแปรที่เกี่ยวข้องเป็นแนวคิดที่เป็นนามธรรมอธิบายดังนี้
var a = 1; ฟังก์ชั่น fn (num1, num2) {var b = 2; ฟังก์ชั่น fninner () {var c = 3; การแจ้งเตือน (a + b + c); } fninner (); // การสร้างสภาพแวดล้อมการดำเนินการในท้องถิ่นเมื่อ fninner เรียกว่า} fn (4,5); // การสร้างสภาพแวดล้อมการดำเนินการในท้องถิ่นเมื่อ FN ถูกเรียก2. โซ่ขอบเขต
การดำเนินการของฟังก์ชั่น JavaScript ใช้โซ่ขอบเขต โซ่ขอบเขตนี้ถูกสร้างขึ้นเมื่อกำหนดฟังก์ชั่น เมื่อมีการกำหนดฟังก์ชั่นจริง ๆ แล้วจะช่วยประหยัดขอบเขตโซ่ เมื่อฟังก์ชั่นนี้เรียกว่ามันจะสร้างวัตถุใหม่เพื่อจัดเก็บตัวแปรท้องถิ่นและเพิ่มวัตถุนี้ในห่วงโซ่ขอบเขตที่บันทึกไว้ ส่วนหน้าของห่วงโซ่ขอบเขตมักจะเป็นวัตถุตัวแปรในสภาพแวดล้อมที่รหัสดำเนินการในปัจจุบันอยู่ จุดสิ้นสุดของห่วงโซ่ขอบเขตเป็นวัตถุตัวแปรของสภาพแวดล้อมการดำเนินการทั่วโลกเสมอ จุดประสงค์ของห่วงโซ่ขอบเขตคือเพื่อให้แน่ใจว่าตัวแปรและฟังก์ชั่นทั้งหมดที่ได้รับอนุญาตให้เข้าถึงสภาพแวดล้อมการดำเนินการได้รับอนุญาตให้เข้าถึง
var scope = 'Global Scope'; ฟังก์ชั่น checkscope () {var scope = 'ขอบเขตท้องถิ่น'; ฟังก์ชั่น f () {return scope}; return f;} checkscope () (); // ขอบเขตท้องถิ่นความเข้าใจ: เมื่อเรียกว่า checkscope ฟังก์ชั่น F ถูกกำหนดและผูกพันกับห่วงโซ่ขอบเขตการตรวจสอบเป็นตัวแปรท้องถิ่น ดังนั้นไม่ว่าจะเรียกฟังก์ชั่น F ที่ใดการเชื่อมโยงนี้ยังคงถูกต้องดังนั้นค่าส่งคืนจึงเป็นขอบเขตท้องถิ่น
var num1 = 1; ฟังก์ชันด้านนอก () {var num2 = 2; console.log (num1 + num2); // 3 ฟังก์ชั่น inner () {// ที่นี่คุณสามารถเข้าถึง num3, num2, num1 var num3 = 3; console.log (num1 + num2 + num3); // 6} // ที่นี่คุณสามารถเข้าถึง num2, inner (), num1 แต่ไม่ใช่ num3 inner ();} uter (); console.log (num1); // 1, สภาพแวดล้อมการดำเนินการ // ที่นี่โซ่ขอบเขต (ค้นหา): สภาพแวดล้อมภายในสามารถเข้าถึงสภาพแวดล้อมภายนอกทั้งหมดผ่านห่วงโซ่ขอบเขต แต่สภาพแวดล้อมภายนอกไม่สามารถเข้าถึงตัวแปรและฟังก์ชั่นใด ๆ ในสภาพแวดล้อมภายใน
ชื่อ var = 'byron'; ฟังก์ชั่น fn () {var name = 'csper'; console.log (ชื่อ); // casper} fn ();ยิ่งสภาพแวดล้อมภายในมากเท่าไหร่น้ำหนักตัวแปรก็จะยิ่งสูงขึ้นเท่านั้น
หมายเหตุ: ตัวแปรที่ไม่ได้ประกาศโดยตรงกับคำหลัก VAR เป็นตัวแปรส่วนกลาง ตัวอย่างเช่นหากมีการประกาศ A = 1 โดยตรง A เป็นตัวแปรทั่วโลกในเวลานี้
เมื่อเครื่องยนต์ Javscript เข้าสู่ขอบเขตมันจะประมวลผลรหัสในสองรอบ รอบแรกเริ่มต้นตัวแปร รอบที่สองเรียกใช้รหัส
var a = 1; ฟังก์ชั่นคุก (a) {console.log (a); // 1 var a; console.log (a); // 1} เรือนจำ (1);3. ฟังก์ชั่นการดำเนินการ
เมื่อการเรียกใช้ฟังก์ชันเข้าสู่สภาพแวดล้อมการดำเนินการอาร์กิวเมนต์กระบวนการแรกเริ่มต้นพารามิเตอร์ที่เป็นทางการ (ค่าเริ่มต้นจะไม่ได้กำหนด) จากนั้นเริ่มต้นการประกาศฟังก์ชั่นในฟังก์ชัน เมื่อรหัสถูกดำเนินการทีละขั้นตอนการประกาศตัวแปรในฟังก์ชั่นจะเริ่มต้น (เมื่อรหัสไม่ได้ดำเนินการหลังจากป้อนสภาพแวดล้อมค่าจะไม่ถูกกำหนด) ดังนั้นลำดับการเริ่มต้นในฟังก์ชั่นคือพารามิเตอร์อย่างเป็นทางการการประกาศฟังก์ชั่นและการประกาศตัวแปร สามารถมองเห็นได้จากภาพด้านบน ให้ฉันยกตัวอย่างให้คุณ (สภาพแวดล้อมทั่วโลกทั้งหมดเป็นฟังก์ชั่นด้วย)
การแจ้งเตือน (typeof fn); // ฟังก์ชั่นการประกาศฟังก์ชันการแจ้งเตือนล่วงหน้า (typeof fn0); // undefined, การประกาศตัวแปรล่วงหน้า แต่ไม่ได้กำหนดฟังก์ชัน fn () {// ฟังก์ชันนิพจน์} var fn0 = ฟังก์ชัน () {// ฟังก์ชันนิยาม}