พูดคุยอย่างชาญฉลาดเกี่ยวกับนิพจน์ฟังก์ชั่น JavaScript

มีสองวิธีหลักสำหรับการสร้างฟังก์ชั่นใน JavaScript: การประกาศฟังก์ชั่นและการแสดงออกของฟังก์ชั่น ทั้งสองวิธีมีสถานการณ์ที่แตกต่างกัน บันทึกนี้ส่วนใหญ่มุ่งเน้นไปที่คุณสมบัติที่สำคัญหลายประการของการแสดงออกของฟังก์ชั่นและสถานการณ์การใช้งานซึ่งอธิบายไว้ด้านล่าง

คุณสมบัติหลัก

•ชื่อฟังก์ชันเสริม

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

 var sub = function (a1, a2) {return a1-a2; -

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

 var sub = function f (a1, a2) {return a1-a2; } console.log (f (5,3)); // วิธีการโทรไม่ถูกต้องคอนโซลล็อก (ย่อย (5,3)); // วิธีการโทรที่ถูกต้อง

ในตัวอย่างนี้ชื่อของนิพจน์ฟังก์ชันคือ f ชื่อนี้ F กลายเป็นตัวแปรท้องถิ่นภายในฟังก์ชั่นและอ้างถึงวัตถุฟังก์ชันเอง มันใช้งานได้ดีเมื่อฟังก์ชั่นเรียกซ้ำและจะมีการหารือในรายละเอียดในภายหลัง

•สร้างระหว่างขั้นตอนการดำเนินการ (แตกต่างจากการประกาศฟังก์ชั่น)

คุณลักษณะนี้คือการแสดงออกของฟังก์ชั่นนั้นแตกต่างจากการประกาศฟังก์ชั่นอย่างชัดเจน

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

 console.log (เพิ่ม (1,2)); // "3" console.log (ย่อย (5,3)); // "ตัวระบุที่ไม่คาดคิด", ฟังก์ชั่นข้อผิดพลาดเพิ่ม (a1, a2) {return a1+a2; } var sub = function (a1, a2) {return a1-a2; -

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

•ไม่ส่งผลกระทบต่อวัตถุตัวแปร

 var sub = function f (a1, a2) {console.log (typeof f); // "ฟังก์ชั่น" ส่งคืน A1-A2; } console.log (typeof f); // "uncreferenterror: f ไม่ได้กำหนด (... )"

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

ใช้สถานการณ์

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

•ฟังก์ชั่นการเรียกซ้ำ

ดูตัวอย่างต่อไปนี้:

 ฟังก์ชั่นแฟคทอเรียล (num) {ถ้า (num <= 1) {return 1; } else {return num * factorial (num - 1); -

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

 var อื่น factorial = factorial; แฟคทอเรียล = null; console.log (อื่น ๆ (5)); // "uncaught typeerror: แฟคทอเรียลไม่ใช่ฟังก์ชั่น"

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

 ฟังก์ชั่นแฟคทอเรียล (num) {ถ้า (num <= 1) {return 1; } else {return num * arguments.callee (num - 1); -

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

 var factorial = (ฟังก์ชัน f (num) {ถ้า (num <= 1) {return 1;} else {return num * f (num - 1);}}); console.log (แฟคทอเรียล (5)); // "120"

•รหัสโมดูล

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

 var person = (function () {var _name = ""; return {getName: function () {return _name;}, setName: function (newName) {_name = newName;}};} ()); person.setName ("John"); person.getName (); //"จอห์น"

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

 (function () {var _name = ""; var root = this; var person = {getName: function () {return _name;}, setName: function (newName) {_name = newName;}}; root.person = person;} .call (this)); person.setName ("John"); person.getName (); //"จอห์น"

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

นิพจน์ฟังก์ชั่น JavaScript Clichéด้านบนเป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่าคุณจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น