การวิเคราะห์สั้น ๆ เกี่ยวกับประเภทฟังก์ชันใน JavaScript

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

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

2. วิธีการนิยามฟังก์ชั่นที่ใช้กันทั่วไป

1. การประกาศฟังก์ชั่น:

 ฟังก์ชั่นผลรวม (a, b) {return a+b;}

2. การแสดงออก:

 var sum = function () {return a+b; - // หมายเหตุ Semicolon // ความแตกต่างระหว่างสองวิธี: // ล่ามจะเป็นคนแรกที่อ่านการประกาศฟังก์ชั่นและทำให้สามารถเข้าถึงได้ก่อนการดำเนินการ เมื่อใช้นิพจน์คุณต้องรอจนกว่าตัวแยกวิเคราะห์จะดำเนินการกับบรรทัดของรหัสที่อยู่ก่อนที่มันจะถูกตีความและดำเนินการ (การประกาศตัวแปรขั้นสูงในขณะที่ค่าถูกทิ้งไว้) การแจ้งเตือน (ผลรวม (10, 10)); ฟังก์ชั่นผลรวม (a, b) {return a+b;} // ↑รหัสด้านบนจะถูกดำเนินการตามปกติเพราะก่อนที่รหัสจะถูกดำเนินการตัวแยกวิเคราะห์จะได้รับการส่งเสริมผ่านการประกาศฟังก์ชั่นอ่านและเพิ่มการประกาศฟังก์ชั่นลงในสภาพแวดล้อมการดำเนินการและวางไว้ที่ด้านบนของการแจ้งเตือน การแจ้งเตือน (ผลรวม (10, 10)); var sum = function (a, b) {return a+b;} // ↑เหตุผลคือฟังก์ชั่นอยู่ในคำสั่งเริ่มต้นไม่ใช่การประกาศฟังก์ชั่นและจะไม่ก้าวหน้า แต่จะเพิ่มค่า VAR Sum เท่านั้น

3. ชื่อฟังก์ชั่นเท่านั้นที่ถือตัวชี้ไปยังวัตถุฟังก์ชันดังนั้นชื่อฟังก์ชันจึงไม่แตกต่างจากตัวแปรอื่น ๆ ที่มีตัวชี้วัตถุนั่นคือวัตถุฟังก์ชันสามารถมีหลายชื่อ:

 ฟังก์ชั่นผลรวม (a, b) {return a+b;} console.log (ผลรวม (2, 3)); // 5var anothersum = sum; // anotheriable anotheriable ยังชี้ไปที่ฟังก์ชั่น Object Console.log (anothersum (4, 5)); // 9sum = null; // ตัวแปรผลรวมจะไม่บันทึกพอยน์เตอร์ลงในคอนโซลวัตถุฟังก์ชันอีกต่อไป (anothersum (1, 3)); // anotherible anotheriable ยังสามารถเรียกได้

4. เหตุใด JS จึงไม่โอเวอร์โหลดแนวคิด

 ฟังก์ชั่นเพิ่ม (a) {return a+3;} ฟังก์ชันเพิ่ม (a) {return a+5;} var result = เพิ่ม (3); // 8 // ทั้งสองฟังก์ชั่นมีชื่อเดียวกันและผลลัพธ์สามารถเป็นฟังก์ชันหลังเขียนทับฟังก์ชั่นก่อนหน้านี้เท่านั้นดังนั้นจึงไม่สามารถโหลดซ้ำได้

5. คุณสมบัติภายในของฟังก์ชั่น: ภายในฟังก์ชั่นมีวัตถุพิเศษสองข้ออาร์กิวเมนต์และสิ่งนี้

1. อาร์กิวเมนต์:

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

 function foo () {var a = arguments.callee; return a.toString ();} foo ();/*ส่งคืนผลลัพธ์: "ฟังก์ชั่นผลรวม () {var a = arguments.callee; return a.toString ();}" นั่นคือการพูดภายในฟังก์ชันอาร์กิวเมนต์ ฟังก์ชั่นนี้มีประโยชน์บ้างเมื่อเรียกว่าซ้ำมีข้อบกพร่องมากมายและถูกลบออกในโหมดที่เข้มงวดของ ES5*/

2. สิ่งนี้: เพียงแค่ใส่สิ่งนี้หมายถึงวัตถุสภาพแวดล้อมที่ฟังก์ชั่นถูกดำเนินการ นี่หมายถึงวัตถุที่วัตถุถูกดำเนินการ มันค่อนข้างซับซ้อนในการขยายบทความเพียงหนึ่งบทความ

// todo:

3. ES5 ระบุคุณสมบัติอื่นของฟังก์ชั่น: ผู้โทร คุณสมบัติฟังก์ชั่นนี้หมายถึงฟังก์ชั่นที่เรียกฟังก์ชันปัจจุบัน

 ฟังก์ชั่น inner () {console.log (inner.caller);} ฟังก์ชั่น OUTER () {inner ();} OUTER (); // ฟังก์ชั่น OUTER () {inner ();}

4. แอตทริบิวต์ความยาว: ระบุจำนวนพารามิเตอร์ที่ฟังก์ชั่นต้องการยอมรับ

 ฟังก์ชั่นเพิ่ม (a, b, c) {return a+b+c;} add.length; // 3

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

// todo:

6. สองวิธีของฟังก์ชั่น: call () และใช้ () พวกเขาทั้งคู่เรียกฟังก์ชั่นในขอบเขตที่เฉพาะเจาะจงและในความเป็นจริงพวกเขาตั้งค่านี้ภายในฟังก์ชั่น

1. CALL (): คล้ายกับวิธีการใช้ () ความแตกต่างคือวิธีการรับพารามิเตอร์นั้นแตกต่างกันและพารามิเตอร์จะต้องแสดงรายการทีละรายการ

2. ใช้ (): รับพารามิเตอร์สองตัวหนึ่งคือขอบเขตของการทำงานของฟังก์ชันและอีกพารามิเตอร์คืออาร์เรย์ของพารามิเตอร์ซึ่งสามารถเป็นอาร์เรย์หรืออาร์เรย์วัตถุของคลาสอาร์กิวเมนต์

 ฟังก์ชั่นผลรวม (a, b) {return a+b;} callsum (a, b) {return sum.apply (นี่, อาร์กิวเมนต์);} // พารามิเตอร์ที่สองเป็นอาร์เรย์อาร์เรย์อาร์กิวเมนต์ function callsum1 (a, b) {return sum.apply (นี่, [a, b]); // 5 console.log (callesum1 (3, 5)); // 8

3. พารามิเตอร์การส่งผ่านและฟังก์ชั่นการโทรไม่ใช่สถานที่ที่มีการใช้การโทร () และใช้ () สิ่งที่ทรงพลังที่แท้จริงเกี่ยวกับการดำเนินการฟังก์ชั่นการขยายคือขอบเขตของ

 var color = 'red'; var obj = {color: 'Blue'} function foo () {console.log (this.color); } foo (); //'red'foo.call( This);//'red'foo.call(obj); // 'blue' // สภาพแวดล้อมการดำเนินการของฟังก์ชันการโทรครั้งสุดท้ายไปยังฟังก์ชั่น foo () มีการเปลี่ยนแปลงและสิ่งนี้ชี้ไปที่วัตถุ OBJ ดังนั้นจึงเป็น 'สีน้ำเงิน'

ข้อได้เปรียบที่ใหญ่ที่สุดของการใช้การโทร () และ () เพื่อขยายขอบเขตคือการแยกวัตถุและวิธีการ

4. ES5 กำหนดวิธีการใหม่: bind () ซึ่งส่งคืนฟังก์ชันซึ่งค่านี้จะถูกผูกไว้กับค่าที่ส่งผ่านไปยังฟังก์ชัน bind ()

 var x = 9; var module = {x: 81, getx: function () {return this.x; }}; module.getx (); // 81VAR RetrievEx = module.getx; RetrievEx (); // 9 เนื่องจากในกรณีนี้ "นี่" ชี้ไปที่ตัวแปร global var boundGetX = retrievEx.bind (โมดูล); // ผูกสิ่งนี้ในฟังก์ชัน RetrievEx () ไปยังโมดูลตลอดไปจากนั้นเรียกใช้ฟังก์ชันนี้เพื่อเรียกใช้ boundgetx () ในวัตถุโมดูลเสมอ // 81

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