การแนะนำ
ในภาษาดั้งเดิมหลายภาษา (C/C ++/Java/C#ฯลฯ ) ฟังก์ชั่นมีอยู่ในฐานะพลเมืองชั้นสอง คุณสามารถประกาศฟังก์ชั่นที่มีคำหลักของภาษาแล้วเรียกมันว่า หากคุณต้องการส่งฟังก์ชั่นเป็นพารามิเตอร์ไปยังฟังก์ชันอื่นหรือกำหนดค่าให้กับตัวแปรท้องถิ่นหรือเป็นค่าคืนคุณต้องทำการพัฒนาผ่านวิธีการพิเศษเช่นตัวชี้ฟังก์ชั่นและพร็อกซี (มอบหมาย)
ในโลกจาวาสคริปต์ฟังก์ชั่นเป็นพลเมืองชั้นหนึ่ง พวกเขาไม่เพียง แต่มีวิธีการใช้ฟังก์ชั่นดั้งเดิมทั้งหมด (การประกาศและการโทร) แต่ยังสามารถกำหนดค่าพารามิเตอร์การส่งผ่านและกลับมาเหมือนค่าที่ง่าย ฟังก์ชั่นดังกล่าวเรียกอีกอย่างว่าฟังก์ชั่นชั้นหนึ่ง ไม่เพียงแค่นั้นฟังก์ชั่นใน JavaScript ยังทำหน้าที่เป็นตัวสร้างคลาสและยังเป็นอินสแตนซ์ของคลาสฟังก์ชั่น ตัวตนหลายอย่างดังกล่าวทำให้ฟังก์ชั่น JavaScript สำคัญมาก
1. ฟังก์ชัน JavaScript ระดับเริ่มต้น
เช่นเดียวกับภาษาธรรมดาฟังก์ชั่น JavaScript ยังเป็นไปตามหลักการของการประกาศก่อนแล้วใช้ ชื่อฟังก์ชั่นสามารถมีตัวอักษรตัวเลขขีดล่างหรือ $ เท่านั้นและไม่สามารถเริ่มต้นได้ด้วยตัวเลข มีสองวิธีทั่วไปในการประกาศฟังก์ชั่น:
การคัดลอกรหัสมีดังนี้:
// ประกาศฟังก์ชั่น myfunc โดยตรง
ฟังก์ชั่น myfunc (/ * อาร์กิวเมนต์ */) {
-
// กำหนดฟังก์ชั่นที่ไม่ระบุชื่อให้กับตัวแปรท้องถิ่น myfunc
var myfunc = function (/ * อาร์กิวเมนต์ */) {
-
โปรดทราบว่ามีความแตกต่างเล็กน้อยในวิธีการประกาศสองฟังก์ชั่นข้างต้น: วิธีแรกคือฟังก์ชั่นชื่อเมื่อประกาศไม่ว่าจะเป็นฟังก์ชั่นที่ประกาศมาก่อนหลังจากการโทรหรือแม้แต่ตำแหน่งที่จะไม่ถูกดำเนินการ (ตัวอย่างเช่นหลังจากคำสั่งคืนหรือในสาขาที่จะไม่เป็นจริง) วิธีที่สองคือการกำหนดฟังก์ชั่นที่ไม่ระบุชื่อให้กับตัวแปร การพูดอย่างเคร่งครัดนี่ไม่ใช่การประกาศฟังก์ชั่น แต่เป็นการแสดงออกของฟังก์ชั่น ก่อนที่จะได้รับมอบหมายฟังก์ชั่นนี้ไม่สามารถเข้าถึงได้ด้วยรหัสใด ๆ ซึ่งหมายความว่าการกำหนดจะต้องเสร็จสิ้นก่อนการโทรมิฉะนั้นข้อผิดพลาดจะปรากฏขึ้นเมื่อโทร: "typeError: undefined ไม่ใช่ฟังก์ชั่น" ตัวอย่างเช่น:
การคัดลอกรหัสมีดังนี้:
myfunc1 (); // สามารถเรียกได้ตามปกติเพราะ MyFunc1 ใช้วิธีการประกาศโดยตรง
ฟังก์ชั่น myfunc1 () {
-
myfunc2 (); // ข้อผิดพลาด typeerror: undefined ไม่ใช่ฟังก์ชัน
var myfunc2 = function () {
-
วิธีการเรียกใช้ฟังก์ชันพื้นฐานเรียกว่าในลักษณะเดียวกับในภาษาดั้งเดิม: myfunc () ฟังก์ชั่น JavaScript ยังรองรับการโทรแบบเรียกซ้ำโดยตรงหรือโดยอ้อม ตัวอย่างเช่นฟังก์ชัน Fibonacci แบบคลาสสิกสามารถนำไปใช้ใน JavaScript เช่นนี้:
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น fib (n) {
if (n == 1 || n == 2) {
กลับ 1;
} อื่น {
return fib (n - 2) + fib (n - 1);
-
-
ฟังก์ชั่นใน JavaScript สามารถจัดการพารามิเตอร์ความยาวตัวแปร พวกเขาทั้งหมดมีตัวแปรท้องถิ่นที่เรียกว่าอาร์กิวเมนต์ภายในฟังก์ชั่น มันเป็นวัตถุคล้ายอาร์เรย์ที่มีพารามิเตอร์ทั้งหมดที่ส่งผ่านเมื่อโทรและมีแอตทริบิวต์ความยาวเพื่อแสดงจำนวนพารามิเตอร์ ตัวอย่างเช่น:
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นทดสอบ () {
การแจ้งเตือน (อาร์กิวเมนต์ความยาว);
-
ทดสอบ (1); // 1
ทดสอบ (1, 'a'); // 2
ทดสอบ (จริง, [], {}); // 3 ใช้อาร์กิวเมนต์เพื่อใช้ฟังก์ชั่นคล้ายกับ PRINTF ในภาษา C และยังสามารถใช้ในการใช้ความหลากหลายของวิธีการ
2. ฟังก์ชั่น JavaScript ขั้นสูง
2.1 ฟังก์ชั่นที่ไม่ระบุชื่อและซ้อนกัน
ใน JavaScript คุณสามารถประกาศฟังก์ชั่นที่ไม่มีชื่อเรียกว่าฟังก์ชันนิรนาม (ฟังก์ชั่นที่ไม่ระบุชื่อ) ในเวลาเดียวกัน JavaScript ยังอนุญาตให้มีการประกาศฟังก์ชั่นภายในฟังก์ชั่นที่เรียกว่าฟังก์ชั่นซ้อนกันและขอบเขตของฟังก์ชั่นซ้อนกันคือฟังก์ชั่นหลักทั้งหมด
ในส่วนก่อนหน้าของการประกาศฟังก์ชั่นฉันเห็นการใช้งานที่ไม่ระบุชื่อและฟังก์ชั่นซ้อนกัน เนื่องจากฟังก์ชั่นที่ไม่ระบุชื่อไม่มีชื่อพวกเขาจะไม่แนะนำตัวแปรใหม่เพื่อสร้างมลพิษบริบทและจะนำขอบเขตตัวแปรใหม่ ดังนั้นฟังก์ชั่นที่ไม่ระบุชื่อจึงมักใช้เพื่อป้องกันมลพิษสิ่งแวดล้อมทั่วโลก
มีวัตถุระดับโลกพิเศษในรันไทม์ JavaScript วัตถุนี้เก็บฟังก์ชั่นและตัวแปรทั่วโลก ในการพัฒนาจริงมักใช้ไลบรารีของบุคคลที่สามหรือไฟล์ JS หลายไฟล์ หากคุณแนะนำตัวแปรที่ซ้ำกันหรือการประกาศฟังก์ชั่นในวัตถุทั่วโลกโดยไม่ตั้งใจจะทำให้เกิดความสับสนในการดำเนินการรหัส ตัวอย่างเช่นไฟล์ JS สองไฟล์ได้รับการแนะนำอย่างต่อเนื่องและบันทึกฟังก์ชั่นของตัวเองถูกกำหนดเป็นการใช้งานภายใน ฟังก์ชั่นที่แนะนำครั้งที่สองจะเขียนทับคำจำกัดความของฟังก์ชันแรกและจะไม่โยนข้อผิดพลาดใด ๆ การเรียกใช้ฟังก์ชั่นบันทึกในการดำเนินการครั้งต่อไปอาจทำให้เกิดข้อผิดพลาด ในเวลานี้การใช้ฟังก์ชั่นที่ไม่ระบุชื่อเพื่อห่อตรรกะใน JS ทั้งหมดสามารถหลีกเลี่ยงข้อผิดพลาดนี้ได้ วิธีนี้ถูกใช้โดยไลบรารี JS โอเพนซอร์สส่วนใหญ่
การคัดลอกรหัสมีดังนี้:
(function () {// ฟังก์ชันที่ไม่ระบุชื่อ
ฟังก์ชั่นบันทึก (ผงชูรส) {
console.log (ผงชูรส);
-
// รหัสอื่น ๆ
- // ดำเนินการทันที
รหัสด้านบนเป็นตัวอย่างง่ายๆ ขอบเขตของฟังก์ชั่นบันทึกถูก จำกัด เฉพาะฟังก์ชั่นที่ไม่ระบุชื่อนี้ ฟังก์ชั่นที่ไม่ระบุชื่อนั้นรวมอยู่ในคู่ของวงเล็บ () ด้านนอกเพื่อสร้างการแสดงออกของฟังก์ชั่น ค่าของนิพจน์เป็นฟังก์ชั่นตามด้วยคู่ของวงเล็บเพื่อระบุว่าฟังก์ชั่นจะถูกดำเนินการทันทีเพื่อให้รหัสต้นฉบับสามารถดำเนินการได้ตามปกติ อย่างไรก็ตามฟังก์ชั่นที่ประกาศด้วยวิธีนี้ตัวแปรที่ประกาศผ่าน VAR ฯลฯ เป็นภายในและไม่สามารถเข้าถึงได้โดยรหัสใด ๆ นอกเหนือจากฟังก์ชั่นที่ไม่ระบุชื่อ หากคุณต้องการเปิดเผยฟังก์ชั่นบางอย่างเป็นอินเทอร์เฟซมีหลายวิธี:
การคัดลอกรหัสมีดังนี้:
var mylib = (ฟังก์ชั่น (ทั่วโลก) {
ฟังก์ชั่นบันทึก (ผงชูรส) {
console.log (ผงชูรส);
-
log1 = log; // วิธีที่ 1: ใช้พฤติกรรมเริ่มต้นของการประกาศตัวแปรโดยไม่มี VAR เพื่อเป็นตัวแปรส่วนกลางใน log1 (ไม่แนะนำ)
global.log2 = log; // วิธีที่ 2: เพิ่มแอตทริบิวต์ log2 โดยตรงไปยังวัตถุโกลบอลและกำหนดให้กับฟังก์ชั่นบันทึก (แนะนำ)
return {// วิธีที่ 3: ส่งคืนชุดของการรวบรวมฟังก์ชั่นอินเตอร์เฟสผ่านฟังก์ชั่นที่ไม่ระบุชื่อและกำหนดให้กับตัวแปรส่วนกลาง mylib (แนะนำ)
บันทึก: บันทึก
-
}(หน้าต่าง));
2.2 ฟังก์ชั่นลำดับสูง
หากใช้ฟังก์ชันเป็นพารามิเตอร์หรือค่าส่งคืนจะเรียกว่าฟังก์ชันลำดับสูงกว่า ฟังก์ชั่นใน JavaScript สามารถใช้เป็นฟังก์ชั่นลำดับที่สูงกว่าซึ่งเป็นคุณสมบัติของฟังก์ชั่นประเภทแรก มาวิเคราะห์วิธีการใช้งานสองวิธีด้านล่าง
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นลบ (n) {
return -n; // ใช้ค่าตรงข้ามของ n
-
ฟังก์ชั่นสแควร์ (n) {
กลับ n*n; // สแควร์ของ n
-
กระบวนการฟังก์ชั่น (NUMS, callback) {
var result = [];
สำหรับ (var i = 0, length = nums.length; i <length; i ++) {
ผลลัพธ์ [i] = การโทรกลับ (nums [i]); // ส่งองค์ประกอบทั้งหมดในอาร์เรย์ nums เพื่อเรียกกลับเพื่อประมวลผลและบันทึกค่าส่งคืนตามผลลัพธ์
-
ผลการกลับมา;
-
var nums = [-3, -2, -1, 0, 1, 2, 3, 4];
var n_neg = process (nums, ลบ);
// n_neg = [3, 2, 1, 0, -1, -2, -3, -4];
var n_square = process (nums, square);
// n_square = [9, 4, 1, 0, 1, 4, 9, 16];
รหัสด้านบนแสดงตัวอย่างของการส่งฟังก์ชั่นเป็นพารามิเตอร์ในการเรียกกระบวนการฟังก์ชั่นอื่น ในการใช้งานฟังก์ชั่นกระบวนการการโทรกลับถือเป็นกล่องดำซึ่งรับผิดชอบในการส่งพารามิเตอร์ไปยังมันจากนั้นรับค่าส่งคืน การใช้งานการเรียกกลับโดยเฉพาะนั้นไม่ชัดเจนก่อนการโทร เฉพาะเมื่อมีการเรียกใช้บรรทัด 20 และ 22 บรรทัดการเรียกกลับจะถูกแทนด้วยค่าลบหรือสี่เหลี่ยมตามลำดับและแต่ละองค์ประกอบจะถูกนำมาใช้กับค่าตรงข้ามหรือค่าสแควร์
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น Generator () {
var i = 0;
return function () {
กลับ i ++;
-
-
var gen1 = generator (); // รับเครื่องกำเนิดตัวเลขธรรมชาติ
var gen2 = generator (); // รับเครื่องกำเนิดตัวเลขธรรมชาติอื่น
var r1 = gen1 (); // r1 = 0
var r2 = gen1 (); // r2 = 1
var r3 = gen2 (); // r3 = 0
var r4 = gen2 (); // r4 = 1
รหัสด้านบนแสดงตัวอย่างของการใช้ฟังก์ชันเป็นค่าส่งคืน เครื่องกำเนิดไฟฟ้าเป็นฟังก์ชั่นตัวสร้างตัวเลขธรรมชาติและค่าส่งคืนเป็นฟังก์ชันตัวสร้างตัวเลขธรรมชาติ เครื่องกำเนิดไฟฟ้าแต่ละครั้งจะเรียกว่าฟังก์ชันที่ไม่ระบุชื่อจะถูกส่งกลับเป็นผลลัพธ์ ฟังก์ชั่นที่ไม่ระบุชื่อนี้จะส่งคืนหมายเลขธรรมชาติแต่ละครั้งเมื่อเรียกจริง ตัวแปร I ในเครื่องกำเนิดไฟฟ้าจะเพิ่มขึ้น 1 ทุกครั้งที่เรียกว่าฟังก์ชั่นที่ไม่ระบุชื่อนี้ซึ่งจริง ๆ แล้วเป็นการปิด มาแนะนำปิดด้านล่าง
2.3 การปิด
การปิดไม่ใช่แนวคิดใหม่และภาษาที่ใช้งานได้หลายภาษาใช้การปิด ใน JavaScript เมื่อคุณใช้ตัวแปรภายในขอบเขตของฟังก์ชั่นภายนอกในฟังก์ชั่นฝังตัวคุณจะใช้การปิด ใช้การเปรียบเทียบที่ใช้กันทั่วไปเพื่ออธิบายความสัมพันธ์ระหว่างการปิดและคลาส: คลาสคือข้อมูลที่มีฟังก์ชั่นและการปิดเป็นฟังก์ชั่นที่มีข้อมูล
ตัวแปรที่ใช้ในการปิดมีลักษณะที่พวกเขาไม่ได้รับการปล่อยตัวเมื่อฟังก์ชั่นหลักกลับมา แต่จบลงด้วยการสิ้นสุดของวงจรชีวิตปิด ตัวอย่างเช่นในตัวอย่างของเครื่องกำเนิดในส่วนก่อนหน้า Gen1 และ Gen2 ใช้ตัวแปรอิสระที่ฉันตามลำดับ (เมื่อฉันเพิ่มขึ้น 1 ของ Gen1 ฉันจะไม่ได้รับผลกระทบและในทางกลับกัน) ตราบใดที่ตัวแปรสองตัว Gen1 หรือ Gen2 ไม่ได้เก็บขยะที่รวบรวมโดยเครื่องยนต์ JavaScript ตัวแปรที่เกี่ยวข้องของพวกเขาฉันจะไม่ถูกปล่อยออกมา ในการเขียนโปรแกรม JavaScript จะใช้การปิดโดยไม่รู้ตัว คุณลักษณะของการปิดนี้ใช้งานง่าย แต่ยังนำไปสู่ปัญหาการรั่วไหลของหน่วยความจำได้อย่างง่ายดาย ตัวอย่างเช่น:
การคัดลอกรหัสมีดังนี้:
var elem = document.getElementById ('ทดสอบ');
elem.addeventListener ('คลิก', function () {
การแจ้งเตือน ('คุณคลิก' + elem.tagname);
-
วัตถุประสงค์ของรหัสนี้คือการแสดงชื่อฉลากเมื่อคลิกที่โหนด มันลงทะเบียนฟังก์ชั่นที่ไม่ระบุชื่อเป็นฟังก์ชั่นการจัดการเหตุการณ์คลิกของโหนด DOM วัตถุ DOM ถูกอ้างอิงในฟังก์ชั่นซึ่งก่อให้เกิดการปิด สิ่งนี้จะสร้างการอ้างอิงแบบวงกลมนั่นคือ: dom-> clossary-> dom-> clossary ... วัตถุ DOM จะไม่ถูกปล่อยออกมาก่อนที่การปิดจะถูกปล่อยออกมา; และการปิดมีอยู่เป็นฟังก์ชั่นการจัดการเหตุการณ์ของวัตถุ DOM ดังนั้นการปิดจะไม่ถูกปล่อยออกมาก่อนที่วัตถุ DOM จะถูกปล่อยออกมา แม้ว่าวัตถุ DOM จะถูกลบในต้นไม้ DOM เนื่องจากการมีอยู่ของการอ้างอิงแบบวงกลมนี้ทั้งวัตถุ DOM และการปิดจะถูกปล่อยออกมา การรั่วไหลของหน่วยความจำนี้สามารถหลีกเลี่ยงได้โดยใช้วิธีการต่อไปนี้:
การคัดลอกรหัสมีดังนี้:
var elem = document.getElementById ('ทดสอบ');
elem.addeventListener ('คลิก', function () {
การแจ้งเตือน ('คุณคลิก' + this.tagname); // ไม่มีการอ้างอิงตัวแปร Elem โดยตรงอีกต่อไป
-
ในรหัสข้างต้นนี้ใช้แทน Elem (ตัวชี้นี้ชี้ไปที่องค์ประกอบ DOM ในฟังก์ชั่นการจัดการเหตุการณ์ DOM) เพื่อให้ JS Runtime ไม่เชื่ออีกต่อไปว่าฟังก์ชั่นใช้ตัวแปรคลาสพาเรนต์ดังนั้นจึงไม่มีการปิดอีกต่อไป
การปิดจะนำปัญหาการรั่วไหลของหน่วยความจำที่คล้ายกันมากมาย คุณสามารถให้ความสนใจกับการปิดเมื่อเขียนโค้ดและพยายามหลีกเลี่ยงปัญหาดังกล่าว
2.4 ตัวสร้างคลาส
ฟังก์ชั่น JavaScript ยังใช้เป็นตัวสร้างคลาสดังนั้นคุณสามารถใช้คำหลักใหม่เพื่อสร้างอินสแตนซ์ของคลาสตราบใดที่คุณประกาศฟังก์ชั่น
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นบุคคล (ชื่อ) {
this.name = ชื่อ;
this.toString = function () {
กลับ 'สวัสดี' + this.name + '!';
-
-
var p = คนใหม่ ('ghosttheaven');
การแจ้งเตือน (P); // สวัสดี Ghosttheaven! ในตัวอย่างข้างต้นฟังก์ชั่นบุคคลใช้เป็นตัวสร้างคลาส ในเวลานี้ชี้ไปที่วัตถุอินสแตนซ์ที่สร้างขึ้นใหม่และสามารถเพิ่มคุณสมบัติและวิธีการลงในอินสแตนซ์ สำหรับการเขียนโปรแกรม JavaScript เชิงวัตถุโดยละเอียดโปรดดูบทความนี้ สิ่งที่ฉันต้องการจะพูดที่นี่คือปัญหาค่าส่งคืนเมื่อใช้ฟังก์ชั่น JavaScript เป็นตัวสร้างคลาส
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น myclass (ชื่อ) {
this.name = ชื่อ;
ชื่อคืน; // ค่าส่งคืนของตัวสร้าง?
-
var obj1 = myclass ใหม่ ('foo');
var obj2 = myclass ('foo');
var obj3 = myclass ใหม่ ({});
var obj4 = myclass ({});
ตัวสร้างข้างต้นค่อนข้างพิเศษพร้อมคำสั่งส่งคืนดังนั้นวัตถุอะไรที่ OBJ1 ~ OBJ4 ชี้ไปที่? ผลลัพธ์ที่แท้จริงคือสิ่งนี้:
การคัดลอกรหัสมีดังนี้:
obj1 = วัตถุ myclass
obj2 = 'foo'
obj3 = {}
obj4 = {}
เหตุผลเฉพาะถูกอธิบายในบทความนี้และฉันจะไม่ทำซ้ำในบทความนี้ เนื่องจากตัวสร้างที่มีค่าส่งคืนจะให้ผลลัพธ์ที่แปลกประหลาดอย่าเรียกคำสั่ง return ที่มีค่าส่งคืนในตัวสร้าง (สามารถส่งคืนที่ว่างเปล่าได้)
3. ฟังก์ชั่น JavaScript ระดับมอนสเตอร์
ยินดีต้อนรับสู่พื้นที่การสอนฟังก์ชั่นมอนสเตอร์ที่คุณจะได้รับวิธีการเผชิญหน้ากับสัตว์ประหลาดตัวเก่าอย่างสงบและอิสระ - -
3.1 คลาสฟังก์ชั่น
มีคลาสในตัวที่เรียกว่าฟังก์ชั่นในรันไทม์ JavaScript การประกาศฟังก์ชั่นด้วยคำหลักของฟังก์ชั่นเป็นตัวย่อสำหรับการสร้างวัตถุคลาสฟังก์ชั่น ฟังก์ชั่นทั้งหมดมีวิธีการทั้งหมดของคลาสฟังก์ชั่นเช่นการโทร, ใช้, ผูก, ผูกพัน ฯลฯ คุณสามารถตรวจสอบคำสั่งนี้ผ่านคำหลักของอินสแตนซ์ของคำหลัก
เนื่องจากฟังก์ชั่นเป็นคลาสคอนสตรัคเตอร์ของมันคือฟังก์ชั่น (มันเป็นวัตถุของคลาสฟังก์ชั่น) และควรสร้างวัตถุฟังก์ชันผ่านคำหลักใหม่ มอนสเตอร์ตัวแรกอยู่ที่นี่ซึ่งเป็นวิธีการสร้างฟังก์ชั่นโดยใช้คลาสฟังก์ชั่น ไวยากรณ์ของฟังก์ชั่นมีดังนี้:
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นใหม่ ([arg1 [, arg2 [, ... argn]],] functionbody)
โดยที่ arg1, arg2, ... argn เป็นสตริงแทนชื่อพารามิเตอร์และ functionbody ก็เป็นสตริงซึ่งเป็นตัวแทนของฟังก์ชั่น ชื่อพารามิเตอร์ก่อนหน้านี้มากหรือน้อย ตัวสร้างฟังก์ชั่นจะปฏิบัติต่อพารามิเตอร์สุดท้ายเป็นตัวถังฟังก์ชั่นและพารามิเตอร์ก่อนหน้านี้เป็นพารามิเตอร์
การคัดลอกรหัสมีดังนี้:
var func1 = ฟังก์ชั่นใหม่ ('ชื่อ', 'return "hello," + name + "!";');
func1 ('Ghosttheaven'); // สวัสดี Ghosttheaven!
วิธีการข้างต้นสร้างฟังก์ชั่นผ่านฟังก์ชั่นซึ่งเหมือนกับฟังก์ชั่นอื่น ๆ ที่ประกาศด้วยคำหลักของฟังก์ชั่น
เมื่อเห็นสิ่งนี้หลายคนอาจถามว่าทำไมสัตว์ประหลาดจึงจำเป็น? "สิ่งที่มีอยู่นั้นสมเหตุสมผล" คลาสฟังก์ชั่นมีจุดประสงค์ที่เป็นเอกลักษณ์ คุณสามารถใช้มันเพื่อสร้างตรรกะฟังก์ชั่นต่าง ๆ แบบไดนามิกหรือแทนที่ฟังก์ชั่นของฟังก์ชั่นการประเมินและป้องกันไม่ให้สภาพแวดล้อมปัจจุบันถูกมลพิษ*
3.2 ฟังก์ชั่นการอัปเดตตนเอง
ในหลายภาษาเมื่อมีการประกาศฟังก์ชั่นแล้วจะไม่สามารถประกาศฟังก์ชั่นของชื่อเดียวกันอีกครั้งมิฉะนั้นข้อผิดพลาดทางไวยากรณ์จะเกิดขึ้น ฟังก์ชั่นใน JavaScript ไม่เพียง แต่จะถูกประกาศซ้ำ ๆ แต่ยังอัปเดตตัวเองด้วย สัตว์ประหลาดที่ฉันกินอยู่ที่นี่!
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น selfupdate () {
window.selfupdate = function () {
การแจ้งเตือน ('วิ่งครั้งที่สอง!');
-
การแจ้งเตือน ('วิ่งครั้งแรก!');
-
selfupdate (); // วิ่งครั้งแรก!
selfupdate (); // วิ่งครั้งที่สอง! ฟังก์ชั่นนี้สามารถใช้สำหรับตรรกะที่ทำงานเพียงครั้งเดียวและหลังจากการเรียกใช้ครั้งแรกมันจะถูกแทนที่ด้วยตรรกะชิ้นใหม่
สรุป
ฟังก์ชั่นของ JavaScript นั้นทรงพลังมาก ในขณะที่การแก้ปัญหามากมายอย่างสวยงามพวกเขายังนำปัญหาด้านลบมากมาย ฟังก์ชั่นระดับมอนสเตอร์มักใช้กับการใช้งานที่ไม่ค่อยมีใครรู้จัก หากไม่มีความจำเป็นอย่างยิ่งมันจะทำให้เกิดปัญหาในการอ่านรหัสและส่งผลกระทบต่อประสิทธิภาพการพัฒนาของทีม
* มีการแนะนำโหมดที่เข้มงวดใน eCmascript ใหม่ ในโหมดที่เข้มงวดฟังก์ชั่นการประเมินนั้นถูก จำกัด อย่างมากและสามารถมั่นใจได้ว่าสภาพแวดล้อมไม่ได้มลพิษ
คุณเข้าใจหรือไม่มันใช้งานได้จริงมาก หากมีสถานที่ที่ขาดหายไปโปรดให้คำแนะนำแก่ฉันและดำเนินการด้วยกัน