มีสามวิธีในการประกาศฟังก์ชันที่กำหนดเองใน JavaScript ได้แก่ การใช้คำสั่งฟังก์ชัน การใช้ตัวสร้าง Function() และการกำหนดตัวอักษรของฟังก์ชัน
1. คำสั่งฟังก์ชัน
ใน JavaScript คุณสามารถใช้คำสั่งฟังก์ชันเพื่อประกาศฟังก์ชันได้ การใช้งานเฉพาะมีดังนี้:
ฟังก์ชั่น funName([args]) {
งบ
} funName คือชื่อฟังก์ชัน ซึ่งเหมือนกับชื่อตัวแปรจะต้องเป็นตัวระบุ JavaScript ตามกฎหมาย ถัดจากชื่อฟังก์ชันคือรายการพารามิเตอร์ที่อยู่ในวงเล็บและคั่นด้วยเครื่องหมายจุลภาค พารามิเตอร์เป็นทางเลือกและไม่มีการจำกัดจำนวน
ในฐานะตัวระบุ พารามิเตอร์จะเข้าถึงได้ภายในเนื้อหาของฟังก์ชันเท่านั้น พารามิเตอร์เป็นสมาชิกส่วนตัวของขอบเขตฟังก์ชัน เมื่อเรียกใช้ฟังก์ชัน ให้ส่งค่าไปยังฟังก์ชัน จากนั้นใช้พารามิเตอร์เพื่อรับค่าที่ส่งผ่านภายนอก และแทรกแซงการเรียกใช้ฟังก์ชันภายในเนื้อหาของฟังก์ชัน
หลังวงเล็บคือวงเล็บปีกกา และคำสั่งที่อยู่ในวงเล็บปีกกาคือเนื้อหาหลักของโครงสร้างเนื้อหาของฟังก์ชัน ในส่วนของฟังก์ชัน วงเล็บปีกกาถือเป็นสิ่งสำคัญ หากไม่มีเครื่องหมายปีกกา JavaScript จะส่งข้อผิดพลาดทางไวยากรณ์
ตัวอย่าง
คำสั่งฟังก์ชันต้องมีชื่อฟังก์ชัน วงเล็บ และเครื่องหมายปีกกา และโค้ดอื่นๆ สามารถละเว้นได้ ดังนั้นเนื้อความของฟังก์ชันที่ง่ายที่สุดจึงเป็นฟังก์ชันว่าง
function funName() {} //ฟังก์ชันว่าง หากคุณใช้ฟังก์ชันที่ไม่ระบุชื่อ คุณสามารถละชื่อฟังก์ชันได้
function () {} // คำสั่ง var ฟังก์ชันว่างที่ไม่ระบุชื่อและคำสั่งฟังก์ชันเป็นทั้งคำสั่งประกาศ และตัวแปรและฟังก์ชันที่ประกาศจะถูกแยกวิเคราะห์เมื่อมีการคอมไพล์ JavaScript ล่วงหน้า หรือที่เรียกว่าการส่งเสริมตัวแปรและการส่งเสริมฟังก์ชัน ในช่วงก่อนการคอมไพล์ กลไก JavaScript จะสร้างบริบทสำหรับแต่ละฟังก์ชัน กำหนดวัตถุตัวแปร และลงทะเบียนพารามิเตอร์ที่เป็นทางการ ตัวแปรส่วนตัว และฟังก์ชันที่ซ้อนกันในฟังก์ชันเป็นคุณลักษณะบนวัตถุตัวแปร
2. ตัวสร้าง Function()
ใช้ตัวสร้าง Function() เพื่อสร้างฟังก์ชันอย่างรวดเร็ว การใช้งานเฉพาะมีดังนี้:
var funName = new Function(p1, p2, ..., pn, body);
ประเภทพารามิเตอร์ของ Function() คือสตริงทั้งหมด p1~pn แสดงถึงรายการชื่อพารามิเตอร์ของฟังก์ชันที่สร้างขึ้น และเนื้อหาแสดงถึงฟังก์ชันที่สร้างขึ้นของฟังก์ชัน คั่นด้วยเครื่องหมายอัฒภาคระหว่างคำสั่งเนื้อหา
ตัวอย่างที่ 1
สามารถละเว้นพารามิเตอร์ทั้งหมดและส่งผ่านสตริงเพื่อแสดงเนื้อหาของฟังก์ชันเท่านั้น
var f = new Function ("a", "b", "return a+b"); // โคลนโครงสร้างฟังก์ชันผ่าน Constructor ในโค้ดข้างต้น f คือชื่อของฟังก์ชันที่สร้างขึ้น มีการกำหนดฟังก์ชันเดียวกัน และสามารถออกแบบฟังก์ชันที่มีโครงสร้างเดียวกันได้โดยใช้คำสั่งฟังก์ชัน
ฟังก์ชั่น f(a, b) { //ใช้คำสั่งฟังก์ชันเพื่อกำหนดโครงสร้างฟังก์ชันส่งคืน a + b;
} ตัวอย่างที่ 2
ใช้ตัวสร้าง Function() เพื่อสร้างโครงสร้างฟังก์ชันว่างโดยไม่ต้องระบุพารามิเตอร์ใดๆ
var f = new Function(); //กำหนดฟังก์ชันว่าง
ใช้ตัวสร้าง Function() เพื่อสร้างฟังก์ชันแบบไดนามิก โดยไม่ได้จำกัดผู้ใช้ไว้เฉพาะเนื้อหาของฟังก์ชันที่ประกาศล่วงหน้าโดยคำสั่งฟังก์ชัน การใช้ตัวสร้าง Function() ช่วยให้สามารถใช้ฟังก์ชันเป็นนิพจน์แทนโครงสร้างได้ ดังนั้นจึงมีความยืดหยุ่นในการใช้งานมากกว่า ข้อเสียคือตัวสร้าง Function() ถูกคอมไพล์ระหว่างการดำเนินการ ประสิทธิภาพการดำเนินการต่ำมาก และไม่แนะนำให้ใช้โดยทั่วไป
3. ฟังก์ชันนิรนาม (ฟังก์ชันลิเทอรัล)
ลิเทอรัลของฟังก์ชันเรียกอีกอย่างว่าฟังก์ชันที่ไม่ระบุชื่อ กล่าวคือ ฟังก์ชันไม่มีชื่อฟังก์ชัน และมีเพียงคีย์เวิร์ดของฟังก์ชัน พารามิเตอร์ และเนื้อหาของฟังก์ชันเท่านั้น การใช้งานเฉพาะมีดังนี้:
function ([args]) {
งบ
} ตัวอย่างที่ 1
รหัสต่อไปนี้กำหนดฟังก์ชันตามตัวอักษร
ฟังก์ชั่น (a, b) { // ฟังก์ชั่นส่งคืนตัวอักษร a + b;
} ในโค้ดข้างต้น ตัวอักษรของฟังก์ชันโดยพื้นฐานแล้วจะเหมือนกับการใช้คำสั่งฟังก์ชันเพื่อกำหนดโครงสร้างฟังก์ชัน และโครงสร้างของฟังก์ชันได้รับการแก้ไขแล้ว อย่างไรก็ตาม ฟังก์ชันลิเทอรัลไม่ได้ระบุชื่อฟังก์ชัน แต่ใช้ฟังก์ชันคีย์เวิร์ดเพื่อแสดงโครงสร้างของฟังก์ชันโดยตรง
ตัวอย่างที่ 2
ฟังก์ชันที่ไม่ระบุชื่อคือนิพจน์ นั่นคือ นิพจน์ฟังก์ชัน ไม่ใช่คำสั่งของโครงสร้างฟังก์ชัน จากนั้น กำหนดฟังก์ชันที่ไม่ระบุชื่อเป็นค่าให้กับตัวแปร f
//กำหนดฟังก์ชันเป็นค่าให้กับตัวแปร f โดยตรง
var f = ฟังก์ชัน (a, b) {
กลับ + b;
}; เมื่อกำหนดโครงสร้างฟังก์ชันให้กับตัวแปรเป็นค่า ตัวแปรนั้นสามารถเรียกได้ว่าเป็นฟังก์ชัน และตัวแปรจะชี้ไปที่ฟังก์ชันที่ไม่ระบุชื่อ
console.log(f(1,2)); //ส่งคืนค่า 3
ตัวอย่างที่ 3
ฟังก์ชันที่ไม่ระบุชื่อทำหน้าที่เป็นค่าและสามารถมีส่วนร่วมในการดำเนินการนิพจน์ที่ซับซ้อนมากขึ้น สำหรับตัวอย่างข้างต้น คุณสามารถใช้โค้ดต่อไปนี้เพื่อดำเนินการรวมคำจำกัดความของฟังก์ชันและการเรียกให้เสร็จสมบูรณ์
console.log( //เรียกใช้ฟังก์ชันเป็นตัวถูกดำเนินการ (ฟังก์ชัน (a,b) {
กลับ + b;
})(1, 2)); //คืนค่า 3 
เมื่อกำหนดฟังก์ชันแล้ว เราสามารถเรียกฟังก์ชันนั้นได้ทุกที่ในเอกสารปัจจุบัน การเรียกใช้ฟังก์ชันนั้นง่ายมาก เพียงเพิ่มวงเล็บหลังชื่อฟังก์ชัน เช่น alert(), write() โปรดทราบว่าหากมีการระบุพารามิเตอร์ในวงเล็บหลังชื่อฟังก์ชันเมื่อกำหนดฟังก์ชัน จะต้องระบุพารามิเตอร์ที่เกี่ยวข้องในวงเล็บเมื่อเรียกใช้ฟังก์ชัน
โค้ดตัวอย่างจะเป็นดังนี้:
ฟังก์ชัน sayHello(name){
document.write("สวัสดี" + ชื่อ);
-
//เรียกฟังก์ชัน sayHello() sayHello('เว็บไซต์ PHP ภาษาจีน'); 
เคล็ดลับ: JavaScript คำนึงถึงขนาดตัวพิมพ์ ดังนั้นคีย์เวิร์ดของฟังก์ชันจะต้องเป็นตัวพิมพ์เล็กเมื่อกำหนดฟังก์ชัน และฟังก์ชันจะต้องถูกเรียกใช้ในกรณีเดียวกับเมื่อมีการประกาศ
ข้างต้นเป็นการวิเคราะห์เชิงลึกของการประกาศและการเรียกใช้ฟังก์ชันที่กำหนดเองของ JS สำหรับข้อมูลเพิ่มเติม โปรดอ่านบทความอื่นๆ ที่เกี่ยวข้องบนเว็บไซต์ PHP Chinese
