ความเข้าใจในเชิงลึก (ฟังก์ชั่น () {... }) ();

1. มันถูกเรียกว่าฟังก์ชันนิรนามที่ทำงานทันที (เรียกอีกอย่างว่าฟังก์ชั่นที่เรียกทันที)

2. เมื่อมีการปิดฟังก์ชั่นที่ไม่ระบุชื่อแล้วจะเพิ่มตัวยึดไปทางด้านหลังฟังก์ชั่นที่ไม่ระบุชื่อสามารถทำงานได้ทันที! มีอะไรวิเศษหรือไม่?

3. ในการใช้ฟังก์ชั่นเราต้องประกาศการดำรงอยู่ก่อน วิธีที่พบบ่อยที่สุดที่เราใช้คือการกำหนดฟังก์ชั่นโดยใช้คำสั่งฟังก์ชั่น

4. วัตถุฟังก์ชั่น

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

ก่อนอื่นให้ดูว่าวัตถุฟังก์ชั่นสามารถใช้ตัวสร้างโดยตรงเพื่อสร้างฟังก์ชั่นใหม่ได้หรือไม่ คำตอบคือใช่

 var abc = ฟังก์ชั่นใหม่ ("x", "y", "return x*y;"); การแจ้งเตือน (ABC (2,3)); // "6"

5. ฟังก์ชั่นที่ไม่ระบุชื่อไม่มีชื่อดังนั้นจึงขยายไปถึงคำถามที่ว่าเราควรเรียกพวกเขาว่า (O_O) อย่างไร?

การเรียกฟังก์ชั่นนิรนาม①

 var abc = function (x, y) {return x+y; } การแจ้งเตือน (ABC (2,3)); // "5"

การดำเนินการข้างต้นนั้นเทียบเท่ากับการกำหนดฟังก์ชั่นในวิธีที่แตกต่างกัน การใช้งานนี้เป็นสิ่งที่เราพบบ่อยขึ้น

ตัวอย่างเช่นเมื่อเราตั้งค่าฟังก์ชั่นตัวจัดการเหตุการณ์องค์ประกอบ DOM เรามักจะไม่ตั้งชื่อพวกเขา แต่ให้การอ้างอิงเหตุการณ์ที่เกี่ยวข้องกับฟังก์ชันที่ไม่ระบุชื่อแทน

เรียกฟังก์ชันที่ไม่ระบุชื่อ②

ใช้ () เพื่อแนบฟังก์ชั่นที่ไม่ระบุชื่อแล้วเพิ่มคู่ของวงเล็บ (รวมถึงรายการพารามิเตอร์)

 การแจ้งเตือน ((ฟังก์ชั่นใหม่ ("x", "y", "return x*y;")) (2,3)); // "6"

6. บทบาทของวงเล็บคืออะไร?

วงเล็บสามารถแบ่งการแสดงออกของเราออกเป็นชิ้นและแต่ละชิ้นนั่นคือการจัดฟันแต่ละคู่มีค่าคืน ค่าส่งคืนนี้เป็นค่าส่งคืนของนิพจน์ในวงเล็บ

ดังนั้นเมื่อเราแนบฟังก์ชั่นที่ไม่ระบุชื่อกับคู่ของวงเล็บคู่วงเล็บจะส่งคืนวัตถุฟังก์ชันของฟังก์ชันที่ไม่ระบุชื่อ

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

7. การประกาศฟังก์ชั่นการแสดงออกของฟังก์ชั่นฟังก์ชั่นที่ไม่ระบุชื่อ

การประกาศฟังก์ชั่น: ฟังก์ชั่น fnname () {…}; ใช้คำหลักของฟังก์ชั่นเพื่อประกาศฟังก์ชั่นจากนั้นระบุชื่อฟังก์ชันที่เรียกว่าการประกาศฟังก์ชั่น

ฟังก์ชั่นนิพจน์ var fnname = function () {…}; ประกาศฟังก์ชั่นโดยใช้คำหลักฟังก์ชัน แต่ไม่ได้ตั้งชื่อฟังก์ชัน ในที่สุดฟังก์ชั่นที่ไม่ระบุชื่อจะถูกกำหนดตัวแปรที่เรียกว่านิพจน์ฟังก์ชันซึ่งเป็นรูปแบบที่พบบ่อยที่สุดของไวยากรณ์การแสดงออกของฟังก์ชั่น

ฟังก์ชั่นที่ไม่ระบุชื่อ: function () {}; ใช้คำหลักของฟังก์ชั่นเพื่อประกาศฟังก์ชั่น แต่ฟังก์ชั่นไม่ได้ตั้งชื่อดังนั้นจึงเรียกว่าฟังก์ชันที่ไม่ระบุชื่อ ฟังก์ชั่นนิรนามเป็นของนิพจน์ฟังก์ชั่น ฟังก์ชั่นที่ไม่ระบุชื่อมีฟังก์ชั่นมากมาย หากคุณกำหนดตัวแปรคุณจะสร้างฟังก์ชั่นและหากคุณกำหนดกิจกรรมคุณจะกลายเป็นตัวจัดการเหตุการณ์หรือสร้างการปิด ฯลฯ

ความแตกต่างระหว่างการประกาศฟังก์ชั่นและการแสดงออกของฟังก์ชั่นคือ

1. เมื่อเครื่องยนต์ JavaScript แยกวิเคราะห์รหัส JavaScript มันจะ 'ฟังก์ชั่นการประกาศฟังก์ชั่น' (ฟังก์ชั่นการประกาศฟังก์ชั่น) การประกาศฟังก์ชั่นเกี่ยวกับสภาพแวดล้อมการดำเนินการปัจจุบัน (ขอบเขต) การแสดงออกของฟังก์ชั่นจะต้องรอจนกว่าเอ็นจิ้น JavascirtP จะดำเนินการกับบรรทัดก่อนที่จะแยกวิเคราะห์การแสดงออกของฟังก์ชั่นจากบนลงล่างบรรทัด

2. การแสดงออกของฟังก์ชั่นสามารถเรียกได้ทันทีด้วยวงเล็บหลังจากนั้น การประกาศฟังก์ชั่นไม่สามารถทำได้และสามารถเรียกได้ในรูปแบบของ fnname () เท่านั้น

เกาลัด

 fnname (); ฟังก์ชั่น fnname () {... } // ปกติเพราะ 'การโปรโมต' การประกาศฟังก์ชันการเรียกใช้ฟังก์ชันสามารถ fnname (); var fnname = function () {... } // มีการรายงานข้อผิดพลาด

เกาลัด

 var fnname = function () {Alert ('Hello World');} (); // พัสดุถูกเพิ่มหลังจากการแสดงออกของฟังก์ชัน เมื่อเครื่องยนต์ JavaScript วิเคราะห์ที่นี่ฟังก์ชั่นสามารถเรียกได้ทันทีเมื่อเครื่องยนต์ JavaScript ที่นี่ฟังก์ชั่น fnname () {การแจ้งเตือน ('Hello World');} (); // จะไม่มีข้อผิดพลาด } (); // ข้อผิดพลาดทางไวยากรณ์แม้ว่าฟังก์ชั่นนิรนามจะเป็นของฟังก์ชันนิพจน์การดำเนินการที่กำหนดจะดำเนินการ // ดังนั้นเอ็นจิ้น JavaScript จึงปฏิบัติต่อคำหลักของฟังก์ชันที่จุดเริ่มต้นเป็นการประกาศฟังก์ชั่นและรายงานข้อผิดพลาด

หากคุณต้องการเพิ่มวงเล็บหลังฟังก์ชั่นคุณสามารถเรียกได้ทันทีฟังก์ชั่นนี้จะต้องเป็นนิพจน์ฟังก์ชันไม่ใช่การประกาศฟังก์ชั่น

เกาลัด

 (ฟังก์ชั่น (a) {console.log (a); // firebug output 123, ใช้ () ตัวดำเนินการ ()}) (123); (ฟังก์ชั่น (a) {console.log (a); // firebug output 1234, ใช้ () (1234)); // firebug output 12345, ใช้! โอเปอเรเตอร์} (12345); +ฟังก์ชั่น (a) {console.log (a); // Firebug Output 123456, ใช้ + Operator} (123456); -function (a) {console.log (a); // firebug output 1234567, ใช้ - Operator} (1234567); var fn = function (a) {console.log (a); // firebug output 12345678, use = operator} (12345678)

คุณสามารถดูผลลัพธ์ผลลัพธ์และเพิ่มก่อนฟังก์ชั่น! , +, - และแม้กระทั่งเครื่องหมายจุลภาคสามารถใช้เพื่อดำเนินการทันทีหลังจากกำหนดฟังก์ชั่นและ () ,! ,! ตัวดำเนินการเช่น +, -, = แปลงการประกาศฟังก์ชั่นเป็นนิพจน์ฟังก์ชั่นกำจัดความคลุมเครือระหว่างเครื่องยนต์ JavaScript ระบุฟังก์ชั่นการแสดงออกและการประกาศฟังก์ชั่นบอกกับเอ็นจิ้น JavaScript ว่านี่เป็นนิพจน์ฟังก์ชันไม่ใช่การประกาศฟังก์ชั่น

การเพิ่มวงเล็บเป็นวิธีที่ปลอดภัยที่สุดในการทำเพราะ! ผู้ประกอบการเช่น, +และ - จะดำเนินการกับค่าผลตอบแทนของฟังก์ชั่นซึ่งบางครั้งทำให้เกิดปัญหาที่ไม่จำเป็น

แต่การใช้วิธีการเขียนแบบนี้คืออะไร?

ไม่มีแนวคิดเกี่ยวกับขอบเขตส่วนตัวใน JavaScript หากคุณประกาศตัวแปรบางอย่างในขอบเขตทั่วโลกหรือท้องถิ่นในโครงการที่พัฒนาโดยคนหลายคนอาจถูกเขียนทับโดยคนอื่นด้วยชื่อเดียวกัน ตามลักษณะของห่วงโซ่ขอบเขตของฟังก์ชั่น JavaScript เทคนิคนี้สามารถใช้ในการเลียนแบบขอบเขตส่วนตัวและใช้ฟังก์ชันที่ไม่ระบุชื่อเป็น "คอนเทนเนอร์" "คอนเทนเนอร์" สามารถเข้าถึงตัวแปรภายนอกในขณะที่สภาพแวดล้อมภายนอกไม่สามารถเข้าถึงตัวแปรภายใน "คอนเทนเนอร์" ดังนั้นตัวแปรที่กำหนดไว้ภายใน (ฟังก์ชัน () {…}) () จะไม่ขัดแย้งกับตัวแปรภายนอกหรือที่รู้จักกันทั่วไปว่า

jQuery ใช้วิธีนี้ เมื่อรหัส jQuery ถูกห่อหุ้มด้วย (ฟังก์ชั่น (หน้าต่างที่ไม่ได้กำหนด) {…รหัส jQuery …} (หน้าต่าง) มันสามารถป้องกันตัวแปรภายในของ jQuery เมื่อโทรรหัส jQuery ในขอบเขตทั่วโลก