เข้าใจพารามิเตอร์ฟังก์ชัน JavaScript อย่างลึกซึ้ง (แนะนำ)

คำก่อนหน้านี้

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

ข้อโต้แย้ง

คำจำกัดความของฟังก์ชั่นใน JavaScript ไม่ได้ระบุประเภทของพารามิเตอร์ฟังก์ชันและการเรียกใช้ฟังก์ชันไม่ได้ทำการตรวจสอบประเภทใด ๆ ในค่าพารามิเตอร์ที่ผ่าน ในความเป็นจริงการเรียกใช้ฟังก์ชัน JavaScript ไม่ได้ตรวจสอบจำนวนพารามิเตอร์ที่เป็นทางการที่เข้ามา

 ฟังก์ชั่นเพิ่ม (x) {return x+1;} console.log (เพิ่ม (1)); // 2console.log (เพิ่ม ('1')); // '11'console.log (เพิ่ม ()); // nanconsole.log (เพิ่ม (1,2));

พารามิเตอร์อย่างเป็นทางการของชื่อเดียวกัน

ในโหมดที่ไม่ใช่ Strict พารามิเตอร์ที่เป็นทางการของชื่อเดียวกันสามารถปรากฏในฟังก์ชั่นและเฉพาะพารามิเตอร์ที่เป็นทางการสุดท้ายของชื่อที่ปรากฏสามารถเข้าถึงได้

 ฟังก์ชั่นเพิ่ม (x, x, x) {return x;} console.log (เพิ่ม (1,2,3)); // 3

ในโหมดที่เข้มงวดข้อผิดพลาดทางไวยากรณ์จะเกิดขึ้นเมื่อชื่อเดียวกันเกี่ยวข้องกับข้อผิดพลาดทางไวยากรณ์

 ฟังก์ชั่นเพิ่ม (x, x, x) {'ใช้อย่างเข้มงวด'; return x;} console.log (เพิ่ม (1,2,3)); // syntaxError: ชื่อพารามิเตอร์ที่ซ้ำกันไม่อนุญาตในบริบทนี้

จำนวนพารามิเตอร์

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

 ฟังก์ชั่นเพิ่ม (x, y) {console.log (x, y); // 1 undefined} เพิ่ม (1);

ใช้ตรรกะหรือตัวดำเนินการบ่อยครั้งเพื่อตั้งค่าเริ่มต้นที่สมเหตุสมผลสำหรับพารามิเตอร์ที่ละเว้น

 ฟังก์ชั่นเพิ่ม (x, y) {y = y || 2; console.log (x, y); // 1 2} เพิ่ม (1);

[หมายเหตุ] ที่จริงแล้วการใช้ y || 2 ไม่เข้มงวดการตั้งค่าเท็จอย่างชัดเจน (ไม่ได้กำหนด, null, false, 0, -0, '', nan) จะได้รับผลลัพธ์เดียวกัน ดังนั้นจึงควรตั้งค่าตามเงื่อนไขที่สมเหตุสมผลตามสถานการณ์จริง

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

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

 ฟังก์ชั่นเพิ่ม (x) {console.log (อาร์กิวเมนต์ [0], อาร์กิวเมนต์ [1], อาร์กิวเมนต์ [2]) // 1 2 3 กลับ x+1;} เพิ่ม (1,2,3);

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

 ฟังก์ชั่นเพิ่ม (x, y) {console.log (arguments.length) // 3Return x+1;} เพิ่ม (1,2,3); console.log (add.length); // 2

พารามิเตอร์ที่เป็นทางการนั้นสะดวกเท่านั้น แต่ไม่จำเป็น

 ฟังก์ชันเพิ่ม () {return arguments [0] + อาร์กิวเมนต์ [1];} console.log (เพิ่ม (1,2)); // 3

พารามิเตอร์วัตถุ

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

 ฟังก์ชั่น arraycopy (/*array*/จาก,/*ดัชนี*/form_start,/*array*/to,/*ดัชนี*/to_start,/*จำนวนเต็ม*/ความยาว) {// toDo}

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

 ฟังก์ชั่น easycopy (args) {arraycopy (args.from, args.form_start || 0, args.to, args.to_start || 0, args.length);} var a = [1,2,3,4], b = []; easycopy

ซิงโครนัส

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

 การทดสอบฟังก์ชั่น (NUM1, NUM2) {console.log (num1, อาร์กิวเมนต์ [0]); // 1 1arguments [0] = 2; console.log (num1, อาร์กิวเมนต์ [0]); // 2 2num1 = 10; console.log (num1, อาร์กิวเมนต์ [0]); // 10 10} ทดสอบ (1);

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

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

 การทดสอบฟังก์ชั่น (num1, num2) {'ใช้เข้มงวด'; console.log (num1, อาร์กิวเมนต์ [0]); // 1 1arguments [0] = 2; console.log (num1, อาร์กิวเมนต์ [0]); // 1 2num1 = 10; console.log (num1, ข้อโต้แย้ง [0]); // 10 2};

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

 การทดสอบฟังก์ชั่น (num1, num2) {console.log (num1, อาร์กิวเมนต์ [0]); // undefined, undefinedNum1 = 10; อาร์กิวเมนต์ [0] = 5; console.log (num1, อาร์กิวเมนต์ [0]); // 10,5} การทดสอบ ();

คุณสมบัติภายใน

【 Callee 】

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

ด้านล่างเป็นฟังก์ชั่นแฟคทอเรียลคลาสสิก

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

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

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

แต่ในโหมดเข้ม

 ฟังก์ชั่นแฟคทอเรียล (num) {'ใช้อย่างเข้มงวด'; ถ้า (num <= 1) {return 1;} else {return num* arguments.callee (num-1);}} // typeError: 'ผู้โทร', 'callee' และ 'อาร์กิวเมนต์' อาจไม่สามารถเข้าถึงได้

ในเวลานี้สามารถใช้นิพจน์ฟังก์ชันที่มีชื่อได้

 var factorial = function fn (num) {ถ้า (num <= 1) {return 1;} else {return num*fn (num-1);}}; console.log (แฟคทอเรียล (5)); // 120

【ผู้โทร】

มีสองแอตทริบิวต์ผู้โทร

【 1 】ผู้โทรฟังก์ชั่น

คุณสมบัติผู้โทรของฟังก์ชั่นมีการอ้างอิงถึงฟังก์ชั่นที่เรียกฟังก์ชันปัจจุบัน หากฟังก์ชั่นปัจจุบันถูกเรียกในขอบเขตทั่วโลกค่าของมันจะเป็นโมฆะ

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

ในโหมดเข้ม

 ฟังก์ชั่น inner () {'ใช้อย่างเข้มงวด'; // typeError: 'ผู้โทร' และ 'อาร์กิวเมนต์' เป็นคุณสมบัติของฟังก์ชั่นที่ จำกัด และไม่สามารถเข้าถึงได้ในบริบทนี้

【 2 】อาร์กิวเมนต์อาร์กิวเมนต์ผู้โทร

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

 ฟังก์ชั่นด้านใน (x) {console.log (arguments.caller); // undefined} inner (1);

ในทำนองเดียวกันในโหมดเข้ม

 ฟังก์ชั่น Inner (x) {'ใช้อย่างเข้มงวด'; // typeError: 'ผู้โทร' และ 'อาร์กิวเมนต์' เป็นคุณสมบัติของฟังก์ชันที่ จำกัด และไม่สามารถเข้าถึงได้ในบริบทนี้ล็อก (อาร์กิวเมนต์อาร์กิวเมนต์);} ภายใน (1);

ฟังก์ชั่นมากเกินไป

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

ฟังก์ชั่น JavaScript ไม่มีลายเซ็นเนื่องจากพารามิเตอร์ของมันจะถูกแทนด้วยอาร์เรย์ที่มีค่า 0 หรือมากกว่า หากไม่มีลายเซ็นฟังก์ชั่นการโอเวอร์โหลดจริงเป็นไปไม่ได้

 // การประกาศที่ตามมาจะแทนที่ฟังก์ชันการประกาศก่อนหน้านี้ addsomenumber (num) {return num + 100;} ฟังก์ชัน addsomenumber (num) {return num + 200;} var result = addsomenumber (100); // 300

การใช้วิธีการมากเกินไปสามารถจำลองได้โดยการตรวจสอบประเภทและปริมาณของพารามิเตอร์ในฟังก์ชันที่ผ่านและทำปฏิกิริยาที่แตกต่างกัน

 ฟังก์ชั่น doadd () {ถ้า (arguments.length == 1) {แจ้งเตือน (อาร์กิวเมนต์ [0] + 10);} อื่นถ้า (อาร์กิวเมนต์. length == 2) {แจ้งเตือน (อาร์กิวเมนต์ [0] + อาร์กิวเมนต์ [1]);}} doadd (10); // 20doadd (30,20);

พารามิเตอร์ผ่าน

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

【 1 】ค่าประเภทพื้นฐาน

เมื่อผ่านค่าของประเภทดั้งเดิมไปยังพารามิเตอร์ค่าที่ผ่านจะถูกคัดลอกไปยังตัวแปรท้องถิ่น (องค์ประกอบของพารามิเตอร์ชื่อหรือวัตถุอาร์กิวเมนต์)

 ฟังก์ชั่น addten (num) {num += 10; return num;} var count = 20; var result = addten (count); console.log (count); // 20, ไม่มีการเปลี่ยนแปลง console.log (ผลลัพธ์); // 30

【 2 】ค่าประเภทการอ้างอิง

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

 ฟังก์ชั่น setName (obj) {obj.name = 'test';} var person = new Object (); setName (บุคคล); console.log (person.name); // 'ทดสอบ'

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

 ฟังก์ชั่น setName (obj) {obj.name = 'test'; console.log (person.name); // 'test'obj = วัตถุใหม่ (); obj.name =' White '; console.log (person.name); //' test '

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