เรามาพูดถึงคำจำกัดความและการใช้งานพื้นฐานของฟังก์ชัน JavaScript กันดีกว่า

1. กำหนดด้วยคำสั่งฟังก์ชัน

เรามายกตัวอย่างกันก่อน ฟังก์ชันของฟังก์ชันนี้คือการส่งคืนผลรวมขององค์ประกอบอาร์เรย์

ฟังก์ชัน sumArray(arr) {  
    ผลรวม var = 0;  
    สำหรับ (var i = 0,aLength = arr.length;i < aLength;i++) {  
        ผลรวม += arr[i];  
    -  
    return sum; }

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

พารามิเตอร์ในวงเล็บหรือที่เรียกว่า พารามิเตอร์ที่เป็นทางการ ต้องการเพียงชื่อพารามิเตอร์เท่านั้น พารามิเตอร์อาจเป็น 0 , 1 ขึ้นไป คั่นด้วย , และ {} มี เนื้อหาของฟังก์ชัน ประกอบด้วยคำสั่งตั้งแต่หนึ่งคำสั่งขึ้นไป เนื้อความของฟังก์ชันใช้เพื่อนำฟังก์ชันของฟังก์ชันไปใช้

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

ฟังก์ชันที่กำหนดในลักษณะนี้ สามารถเรียกได้ทั้งก่อนและหลังการกำหนดฟังก์ชัน ตราบใดที่ฟังก์ชันและคำสั่งที่เรียกใช้ฟังก์ชันอยู่ในไฟล์ต้นฉบับเดียวกัน

2. ใช้คำจำกัดความของนิพจน์

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

• ด้วยชื่อ;

var funct = ฟังก์ชั่น getMax(a,b) {  
    return a>b?a:b; };//โปรดทราบว่าเครื่องหมายอัฒภาคหลังจากนี้ไม่สามารถหายไปได้ เนื่องจากเรากำลังกำหนดตัวแปร!

แตกต่างจาก การกำหนดด้วยคำสั่งฟังก์ชัน ฟังก์ชันสามารถเรียกได้ หลังจากคำสั่งนิยามฟังก์ชัน เท่านั้น และเมื่อเรียกใช้ จะสามารถใช้ได้เฉพาะ funct ชื่อตัวแปร เท่านั้น และไม่สามารถใช้ชื่อฟังก์ชัน getMax ได้ เช่น:

var funct = function getMax(a,b) {  
    กลับ >b?a:b;  
-  
console.log(funct(1,2));//เอาต์พุต 2

• ฟังก์ชันที่ไม่ระบุชื่อ;
  ฟังก์ชันที่ไม่ระบุตัวตนที่เรียกว่าเป็นรายการพารามิเตอร์ที่อยู่หลัง function คีย์เวิร์ด :

var funct = function(a,b) {  
    return a>b?a:b; };

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

var funct = ฟังก์ชั่น (ก, ข) {  
    return a>b?a:b; }; console.log(funct(1,2));//

สรุปเอาต์พุต 2: การกำหนดฟังก์ชันด้วยนิพจน์สามารถใช้งานได้ทันทีเมื่อกำหนดแล้วเท่านั้น ใช้ในคำสั่งนี้ แล้วเรียกใช้ฟังก์ชัน

3 การเรียกใช้ฟังก์ชัน

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

// คำจำกัดความของฟังก์ชัน: ค้นหาค่าสูงสุดของฟังก์ชันตัวเลขสามตัว สูงสุด(a,b,c) {  
    ถ้า(ก > ข) {  
        ถ้า(ก > ค)  
            กลับ;  
        อื่น   
            กลับค;  
    -  
    อื่น {  
        ถ้า(ข > ค)  
            กลับข;  
        อื่น   
            กลับค;  
    -  
-  
//เรียกใช้ฟังก์ชันนี้ var result = max(1,2,3);//result คือ 3  
console.log(result);//Output 3

เมื่อเรียกใช้ฟังก์ชันคุณจะต้องส่งค่าเฉพาะจำนวนเดียวกันกับพารามิเตอร์อย่างเป็นทางการ ฟังก์ชันด้านบนมี 3 พารามิเตอร์ ดังนั้นเมื่อเรียกใช้ฟังก์ชันด้านล่าง ให้ส่งผ่านใน 3 ค่าเฉพาะ ค่า , 1 ถูกส่งผ่านไปยังพารามิเตอร์ a , 2 ถูกส่งผ่านไปยังพารามิเตอร์ b 3 ถูกส่งผ่านไปยังพารามิเตอร์ c ค่าที่ส่งคืนของฟังก์ชันจะถูกส่งผ่านไปยัง result ของตัวแปรผ่านสัญลักษณ์การกำหนด = หากไม่มีคีย์เวิร์ด return ในเนื้อหาของฟังก์ชัน ระบบจะส่งคืน undefined

ฟังก์ชันการเรียกที่กำหนดไว้ในวัตถุ:

var ob = {  
    รหัส:1,  
    getMax: ฟังก์ชั่น (ก, ข) {  
        กลับ >b?a:b;  
    } }; var result = ob.getMax(2,1);//ค่าผลลัพธ์คือ 2 var result1 = ob["getMax"](2,1);//ค่าของ result1 ก็คือ 2

ความแตกต่างจาก ข้างต้นคือที่นี่ ในการค้นหาฟังก์ชัน คุณต้องใช้对象名.函数名หรือ对象名["函数名"] ส่วนอื่นๆ จะเหมือนกัน

4. พารามิเตอร์จริงที่ไม่ได้กำหนด

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

function myFunction(a,b,c) {  
    console.log(ก);  
    console.log(ข);  
    console.log(c); } myFunction(1,2,3);

พารามิเตอร์จริง 1 ถูกส่งผ่านไปยังพารามิเตอร์ที่เป็นทางการ a พารามิเตอร์จริง 2 จะถูกส่งผ่านไปยังพารามิเตอร์ที่เป็นทางการ b และพารามิเตอร์จริง 3 ถูกส่งผ่านไปยัง พารามิเตอร์อย่างเป็นทางการ c เมื่อจำนวนพารามิเตอร์จริงน้อยกว่าพารามิเตอร์ทางการ ค่า undefined จะถูกส่งผ่านไปยังพารามิเตอร์ทางการที่ถูกต้อง ตัวอย่างเช่น:

ฟังก์ชัน myFunction(a,b,c) {  
    console.log(ก);  
    console.log(ข);  
    console.log(c); } myFunction(1,2);

พารามิเตอร์จริง 1 ถูกส่งผ่านไปยังพารามิเตอร์ที่เป็นทางการ a พารามิเตอร์จริง 2 ถูกส่งผ่านไปยังพารามิเตอร์ที่เป็นทางการ b และ undefined ถูกส่งผ่านไปยังพารามิเตอร์ที่เป็นทางการ c หากคุณต้องการส่งข้อมูลไปยังพารามิเตอร์ทางด้านขวาเท่านั้น คุณสามารถส่งผ่าน undefined ไปยังพารามิเตอร์จริงสองสามตัวแรกได้ ตัวอย่างเช่น:

function myFunction(a,b,c){ console.log(a); console.log(c); } myFunction(unknown,1,2)

; เข้มงวดเพียงพอ แนวทางปฏิบัติที่ดีที่สุดคือการตั้ง ค่าเริ่มต้น สำหรับพารามิเตอร์ที่เป็นทางการที่อาจส่งผ่านค่า undefined ตัวอย่างเช่น:

ฟังก์ชัน getSum(a,b,c) {  
    ถ้า (c === ไม่ได้กำหนด)   
        ค = 0;  
    console.log(a+b+c); } myFunction(1,2);

5. วัตถุพารามิเตอร์จริง

ทุกอย่าง JavaScript นั้น arguments วัตถุและพารามิเตอร์ที่แท้จริงก็เป็น วัตถุ เช่นกัน ถือเป็นอาร์เรย์ (เหมือนอาร์เรย์ ไม่ใช่อาร์เรย์จริง) พารามิเตอร์จริงคือ arguments[0]、arguments[1]... จากซ้ายไปขวา arguments.length แสดงถึงจำนวนพารามิเตอร์จริง

//ค้นหาผลรวมของฟังก์ชัน getSum() {  
    var aLength = อาร์กิวเมนต์.ความยาว;  
    ผลรวม var = 0;  
    สำหรับ (var i = 0;i < aLength;i++) {  
        ผลรวม += อาร์กิวเมนต์ [i];  
    -  
    return sum; } console.log(getSum(1,2,3,4,5))//Output 15

พารามิเตอร์อย่างเป็นทางการที่นี่ถูกละเว้นโดยตรงและแสดงด้วย arguments[i]

JavaScript ที่ซับซ้อน

ซึ่งมีอ็อบเจ็กต์เป็นพารามิเตอร์

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

ฟังก์ชั่น myFunction(obj) {  
    console.log(obj.ชื่อ);  
    วัตถุ.number++;  
    return obj.number; } myObj = {name:"myObj",number:34}; myFunction(myObj);//Output myObj console.log(myObj.number);//Output 35

7. ฟังก์ชัน object เป็นฟังก์ชันอื่น พารามิเตอร์ของ

ฟังก์ชัน (เรียกว่า a เพื่อความสะดวกในการเขียน) สามารถใช้เป็น พารามิเตอร์ ของฟังก์ชันอื่นได้ (เรียกว่าฟังก์ชัน b ) และฟังก์ชัน b ก็สามารถส่งคืนค่าเฉพาะได้ในที่สุด

โดยหลักการแล้ว การเรียกใช้ฟังก์ชัน b ฟังก์ชัน a ในตัวฟังก์ชันของตัวเอง ดังนั้นจำเป็นต้องส่งชื่อของฟังก์ชัน a ไปยังฟังก์ชัน b เป็นพารามิเตอร์จริง ดังนี้:

//ค้นหาฟังก์ชันค่าสูงสุด getMax(a,b) {  
    return a>b?a:b; } // ค้นหาฟังก์ชันค่าต่ำสุด getMin(a,b) {  
    return a<b?a:b; } //ฟังก์ชันต่อไปนี้รับฟังก์ชันเป็นพารามิเตอร์และส่งคืนฟังก์ชันค่า getM(func,num1,num2) {  
    return func(num1,num2); } getM(getMax,1,2);//ส่งคืน 2 getM(getMin,1,2);//ส่งคืน 1

เราส่งชื่อของฟังก์ชัน a ( getMax หรือ getMin ) ไปยังฟังก์ชัน b ( getM（） ) จากนั้นเรียกใช้ a ที่ส่งผ่านภายในฟังก์ชัน b เพื่อรับผลลัพธ์ที่เกี่ยวข้อง