ก่อนที่จะกล่าวถึงแนวคิดข้างต้น ก่อนอื่นฉันต้องการพูดถึงพารามิเตอร์โดยนัยของฟังก์ชันใน JavaScript: อาร์กิวเมนต์
อาร์กิวเมนต์ ออบ
เจ็กต์นี้แสดงถึงพารามิเตอร์ของฟังก์ชันที่กำลังดำเนินการและฟังก์ชันที่เรียกใช้ฟังก์ชันนั้น
[ฟังก์ชัน]ข้อโต้แย้ง[n]
ฟังก์ชั่นพารามิเตอร์: ตัวเลือก ชื่อของวัตถุ Function ที่กำลังดำเนินการอยู่ น: ตัวเลือก ดัชนีฐาน 0 ของค่าพารามิเตอร์ที่จะส่งผ่านไปยังออบเจ็กต์ Function
คำอธิบาย
เป็นวัตถุที่ซ่อนอยู่ซึ่งสร้างขึ้นนอกเหนือจากพารามิเตอร์ที่ระบุเมื่อเรียกใช้ฟังก์ชัน อาร์กิวเมนต์เป็นอ็อบเจ็กต์ที่คล้ายกับอาร์เรย์แต่ไม่ใช่อาร์เรย์ กล่าวกันว่าคล้ายกับอาร์เรย์เนื่องจากมีคุณสมบัติและวิธีการเข้าถึงเหมือนกับอาร์เรย์ ค่าของพารามิเตอร์เดี่ยวที่สอดคล้องกันสามารถเข้าถึงได้ผ่านอาร์กิวเมนต์ n] และมีความยาวแอตทริบิวต์ความยาวอาร์เรย์ นอกจากนี้ อ็อบเจ็กต์อาร์กิวเมนต์จะเก็บพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชันจริง ซึ่งไม่จำกัดอยู่เพียงรายการพารามิเตอร์ที่กำหนดโดยการประกาศฟังก์ชัน และอ็อบเจ็กต์อาร์กิวเมนต์ไม่สามารถสร้างได้อย่างชัดเจน วัตถุอาร์กิวเมนต์จะใช้ได้เฉพาะที่จุดเริ่มต้นของฟังก์ชันเท่านั้น ตัวอย่างต่อไปนี้ให้รายละเอียดคุณสมบัติเหล่านี้:
//การใช้วัตถุอาร์กิวเมนต์
ฟังก์ชั่น ArgTest (ก, ข) {
var i, s = "ฟังก์ชัน ArgTest ที่คาดหวัง";
var numargs = arguments.length; // รับค่าของอาร์กิวเมนต์ที่ส่งผ่าน
var expargs = ArgTest.length; // รับค่าของพารามิเตอร์ที่คาดหวัง
ถ้า (ขยาย < 2)
s += expargs + " อาร์กิวเมนต์ ";
อื่น
s += expargs + " อาร์กิวเมนต์ ";
ถ้า (ตัวเลข < 2)
s += numargs + " ผ่านไปแล้ว";
อื่น
s += numargs + "ผ่านไปแล้ว";
ส += "nn"
สำหรับ (i =0; i < numargs; i++){/ // รับเนื้อหาพารามิเตอร์
s += "หาเรื่อง" + i + " = " + อาร์กิวเมนต์ [i] + "n";
-
return (s); // รายการพารามิเตอร์ส่งคืน
}
เพิ่มรหัสที่ระบุว่าอาร์กิวเมนต์ไม่ใช่อาร์เรย์ (คลาส Array):
อาร์เรย์.ต้นแบบ.selfvalue = 1;
การแจ้งเตือน (อาร์เรย์ใหม่ (). ค่าตนเอง);
ฟังก์ชั่น testAguments(){
การแจ้งเตือน (อาร์กิวเมนต์.selfvalue);
}
รันโค้ดแล้วคุณจะพบว่าการแจ้งเตือนแรกแสดง 1 ซึ่งหมายความว่าออบเจ็กต์อาร์เรย์มีแอตทริบิวต์ selfvalue ที่มีค่าเป็น 1 เมื่อคุณเรียกใช้ฟังก์ชัน testAguments คุณจะพบว่า "unknown" ปรากฏขึ้น ซึ่งบ่งชี้ว่า ไม่ใช่แอตทริบิวต์ของอาร์กิวเมนต์ นั่นคือ อาร์กิวเมนต์ไม่ใช่ออบเจ็กต์อาร์เรย์
ผู้โทร
ส่งกลับการอ้างอิงถึงฟังก์ชันที่เรียกว่าฟังก์ชันปัจจุบัน
functionName.ผู้โทร
วัตถุ functionName คือชื่อของฟังก์ชันที่ดำเนินการ
โปรดทราบว่าสำหรับฟังก์ชัน คุณลักษณะผู้เรียกจะถูกกำหนดเมื่อมีการดำเนินการฟังก์ชันเท่านั้น ถ้าฟังก์ชันถูกเรียกจากระดับบนสุด ผู้เรียกจะมีค่าว่าง หากใช้แอตทริบิวต์ผู้เรียกในบริบทสตริง ผลลัพธ์จะเหมือนกับ functionName.toString นั่นคือข้อความที่ถอดรหัสแล้วของฟังก์ชันจะปรากฏขึ้น
ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้คุณลักษณะผู้โทร:
// การสาธิตผู้โทร {
ฟังก์ชั่นผู้โทรDemo() {
ถ้า (callerDemo.caller) {
var a= callerDemo.caller.toString();
การแจ้งเตือน (ก);
} อื่น {
alert("นี่คือฟังก์ชั่นชั้นยอด");
-
-
ฟังก์ชั่น handleCaller () {
ผู้โทรสาธิต();
}
callee
ส่งคืนวัตถุ Function ที่กำลังดำเนินการ ซึ่งเป็นเนื้อความของวัตถุ Function ที่ระบุ
[ฟังก์ชั่น]อาร์กิวเมนต์.callee
พารามิเตอร์ฟังก์ชันเสริมคือชื่อของออบเจ็กต์ฟังก์ชันที่กำลังดำเนินการอยู่
โปรดทราบว่า
ค่าเริ่มต้นของแอตทริบิวต์ callee คือวัตถุ Function ที่กำลังดำเนินการ
แอ็ตทริบิวต์ callee เป็นสมาชิกของอ็อบเจ็กต์อาร์กิวเมนต์ ซึ่งแสดงถึงการอ้างอิงถึงอ็อบเจ็กต์ฟังก์ชัน ซึ่งเป็นประโยชน์ต่อการเรียกซ้ำของฟังก์ชันที่ไม่ระบุชื่อ หรือเพื่อให้แน่ใจว่ามีการห่อหุ้มฟังก์ชัน ตัวอย่างเช่น ตัวอย่างต่อไปนี้จะคำนวณผลรวมของธรรมชาติแบบวนซ้ำ ตัวเลขตั้งแต่ 1 ถึง n คุณสมบัตินี้จะใช้ได้เฉพาะเมื่อมีการดำเนินการฟังก์ชันที่เกี่ยวข้องเท่านั้น ควรสังเกตด้วยว่าผู้เรียกมีแอตทริบิวต์ความยาว ซึ่งบางครั้งก็ดีกว่าสำหรับการตรวจสอบ arguments.length คือความยาวพารามิเตอร์จริง และ arguments.callee.length คือความยาวพารามิเตอร์อย่างเป็นทางการ จากนี้ คุณสามารถกำหนดได้ว่าความยาวพารามิเตอร์อย่างเป็นทางการสอดคล้องกับความยาวพารามิเตอร์จริงในระหว่างการโทรหรือไม่
ตัวอย่าง
//ผู้รับสายสามารถพิมพ์เองได้
ฟังก์ชั่น calleeDemo() {
การแจ้งเตือน (arguments.callee);
-
//ใช้ในการตรวจสอบพารามิเตอร์
ฟังก์ชั่น calleeLengthDemo (arg1, arg2) {
ถ้า (arguments.length==arguments.callee.length) {
window.alert("ตรวจสอบว่าความยาวพารามิเตอร์ที่เป็นทางการและตามจริงนั้นถูกต้อง!");
กลับ;
} อื่น {
alert("ความยาวพารามิเตอร์จริง: " +arguments.length);
alert("ความยาวพารามิเตอร์อย่างเป็นทางการ: " +arguments.callee.length);
-
-
//การคำนวณแบบเรียกซ้ำ
ผลรวม var = ฟังก์ชั่น (n) {
ถ้า (n <= 0)
กลับ 1;
อื่น
กลับ n + arguments.callee (n - 1)
-
ฟังก์ชันเรียกซ้ำทั่วไป:
var sum = function(n){
ถ้า (1==n) ส่งกลับ 1;
มิฉะนั้นให้ส่งคืน n + sum (n-1)
เมื่อโทร: alert(sum(100));
ฟังก์ชันประกอบด้วยการอ้างอิงถึงผลรวมเอง ชื่อฟังก์ชันเป็นเพียงชื่อตัวแปร การเรียกผลรวมภายในฟังก์ชันจะเทียบเท่ากับการเรียกตัวแปรร่วม ในกรณีนี้ การใช้ผู้เรียกจะเป็น a การเปรียบเทียบ แนวทางที่ดี
Apply และ Call
คือการผูกฟังก์ชันกับอ็อบเจ็กต์อื่นเพื่อดำเนินการ ความแตกต่างเพียงอย่างเดียวคือวิธีการกำหนดพารามิเตอร์:
Apply(thisArg,argArray);
call(thisArg[,arg1,arg2...] ]) นั่น
คือตัวชี้นี้ภายในฟังก์ชันทั้งหมดจะได้รับการกำหนดค่าของ thisArg ซึ่งสามารถบรรลุวัตถุประสงค์ของการเรียกใช้ฟังก์ชันเป็นวิธีการของวัตถุอื่น
คำอธิบายของ Apply
คือถ้า argArray ไม่ใช่อาร์เรย์ที่ถูกต้องหรือไม่ใช่อาร์กิวเมนต์ วัตถุ มันจะทำให้เกิด TypeError
หากไม่มีการระบุ argArray หรือ thisArg ไว้ Global object จะถูกนำมาใช้เป็น thisArg
และไม่สามารถส่งผ่านพารามิเตอร์ได้
คำอธิบายของการโทร
วิธีการโทรเปลี่ยนบริบทวัตถุของฟังก์ชันจากบริบทเริ่มต้นเป็นวัตถุใหม่ที่ระบุโดย thisArg
หากไม่ได้ระบุพารามิเตอร์ thisArg ไว้ วัตถุ Global จะถูกใช้เป็น thisArg
เคล็ดลับที่เกี่ยวข้อง:
มีเคล็ดลับอื่นในการใช้ call and Apply นั่นคือหลังจากใช้ call และ Apply เพื่อใช้ฟังก์ชันอื่น (คลาส) ฟังก์ชันปัจจุบัน ( class) จะพร้อมใช้งาน วิธีการหรือคุณสมบัติของฟังก์ชันอื่น (คลาส) ยังสามารถเรียกว่า "การสืบทอด" ดูตัวอย่างต่อไปนี้:
// การสาธิตการสืบทอด
ฐานฟังก์ชัน() {
this.member = "dnnsun_Member";
นี้.method = ฟังก์ชั่น() {
window.alert(นี้.สมาชิก);
-
-
ฟังก์ชั่นขยาย () {
base.call(นี่);
window.alert(สมาชิก);
window.alert (this.method);
}
ดังที่เห็นได้จากตัวอย่างข้างต้น การขยายสามารถสืบทอดวิธีการและคุณสมบัติของฐานหลังจากการเรียก
อย่างไรก็ตาม Apply ถูกใช้ในต้นแบบกรอบงาน JavaScript เพื่อสร้างรูปแบบ
ที่กำหนดคลาส โค้ดการใช้งานมีดังนี้:
var Class = {
สร้าง: ฟังก์ชั่น () {
ฟังก์ชันส่งคืน () {
this.initialize.apply (สิ่งนี้ ข้อโต้แย้ง);
-
-
-
การวิเคราะห์: จากมุมมองของโค้ด ออบเจ็กต์นี้มีเพียงวิธีเดียวเท่านั้น: Create ซึ่งส่งคืนฟังก์ชัน นั่นคือ คลาส แต่นี่ก็เป็นตัวสร้างของคลาสด้วย ซึ่งเรียกว่า Initialize และเมธอดนี้เป็นฟังก์ชันการกำหนดค่าเริ่มต้นที่กำหนดเมื่อคลาสถูกสร้างขึ้น ด้วยวิธีนี้
คุณสามารถใช้ตัวอย่างโหมดการสร้างคลาสในต้นแบบ
:
var vehicle=Class.create();
ยานพาหนะ.ต้นแบบ={
เริ่มต้น: ฟังก์ชั่น (ประเภท) {
นี้.type=type;
-
showSelf: ฟังก์ชั่น () {
alert("รถคันนี้คือ "+ this.type);
-
}
var moto=รถใหม่("Moto");
moto.showSelf();
สำหรับข้อมูลโดยละเอียดเพิ่มเติมเกี่ยวกับต้นแบบ โปรดไปที่เว็บไซต์อย่างเป็นทางการ
http://www.cnblogs.com/sunwangji/archive/2006/08/21/482341.html