แต่ละฟังก์ชัน JavaScript สามารถเข้าถึงตัวแปรพิเศษ - อาร์กิวเมนต์ภายในขอบเขต ตัวแปรนี้มีรายการของพารามิเตอร์ทั้งหมดที่ส่งผ่านไปยังฟังก์ชัน
วัตถุอาร์กิวเมนต์ไม่ใช่อาร์เรย์ ถึงแม้ว่าจะมีสถานที่เดียวกันกับอาร์เรย์เช่นมันมีคุณสมบัติความยาว แต่มันไม่ได้สืบทอดมาจาก array.prototype อันที่จริงมันเป็นวัตถุ
ดังนั้นเราจึงไม่สามารถใช้วิธีการอาร์เรย์ได้โดยตรงสำหรับอาร์กิวเมนต์เช่นการกดป๊อปหรือชิ้น ฯลฯ ดังนั้นเพื่อใช้วิธีการเหล่านี้เราจำเป็นต้องแปลงเป็นอาร์เรย์จริง
แปลงเป็นอาร์เรย์
รหัสต่อไปนี้จะส่งคืนอาร์เรย์ที่มีองค์ประกอบทั้งหมดของวัตถุอาร์กิวเมนต์
array.prototype.slice.call (อาร์กิวเมนต์);
เนื่องจากความเร็วในการแปลงช้ามากจึงไม่แนะนำในโปรแกรมที่มีข้อกำหนดด้านประสิทธิภาพที่เข้มงวด
ผ่านพารามิเตอร์
นี่คือวิธีที่แนะนำเพิ่มเติมในการส่งอาร์กิวเมนต์วัตถุจากฟังก์ชันหนึ่งไปยังอีกฟังก์ชัน
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น foo () {
bar.apply (null, อาร์กิวเมนต์);
-
แถบฟังก์ชัน (A, B, C) {
// ทำสิ่งที่นี่
-
มีวิธีการที่ชาญฉลาดอีกวิธีหนึ่งซึ่งก็คือการสร้างวิธีการที่แยกออกจากกันอย่างรวดเร็วโดยใช้การโทรและใช้ในเวลาเดียวกัน
การคัดลอกรหัสมีดังนี้:
function foo () {}
foo.prototype.method = ฟังก์ชั่น (a, b, c) {
console.log (นี่, a, b, c);
-
// สร้าง "วิธี" เวอร์ชันที่ไม่ได้ผูกไว้
// ต้องใช้พารามิเตอร์: นี่, arg1, arg2 ... argn
foo.method = function () {
// ผลลัพธ์: foo.prototype.method.call (this, arg1, arg2 ... argn)
function.call.apply (foo.prototype.method, อาร์กิวเมนต์);
-
ความสัมพันธ์ระหว่างพารามิเตอร์ฟังก์ชันและแอตทริบิวต์อาร์กิวเมนต์
วัตถุอาร์กิวเมนต์สร้างวิธีการ getter และ setter สำหรับทั้งคุณสมบัติและพารามิเตอร์ฟังก์ชันของตัวเอง
ดังนั้นการปรับเปลี่ยนพารามิเตอร์อย่างเป็นทางการของฟังก์ชันจะส่งผลกระทบต่อค่าคุณสมบัติของวัตถุอาร์กิวเมนต์ที่เกี่ยวข้องและในทางกลับกัน
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น foo (a, b, c) {
อาร์กิวเมนต์ [0] = 2;
a; // 2
b = 4;
ข้อโต้แย้ง [1]; // 4
var d = c;
d = 9;
C; // 3
-
foo (1, 2, 3);
ปัญหาด้านประสิทธิภาพ
อาร์กิวเมนต์จะไม่ถูกสร้างขึ้นในสองกรณีจะถูกประกาศว่าเป็นตัวแปรท้องถิ่นภายในฟังก์ชั่นและอีกกรณีหนึ่งถูกใช้เป็นพารามิเตอร์ที่เป็นทางการของฟังก์ชัน ในกรณีอื่น ๆ วัตถุอาร์กิวเมนต์จะถูกสร้างขึ้นเสมอ
เนื่องจากวิธีการของ Getter และ Setter ถูกสร้างขึ้นเสมอด้วยการสร้างวัตถุอาร์กิวเมนต์การใช้อาร์กิวเมนต์มีผลเพียงเล็กน้อยต่อประสิทธิภาพของตัวเอง
อย่างไรก็ตามมีสถานการณ์ที่ส่งผลกระทบอย่างจริงจังต่อประสิทธิภาพของ JavaScript ซึ่งก็คือการใช้อาร์กิวเมนต์
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น foo () {
ข้อโต้แย้ง. callee; // ทำอะไรกับวัตถุฟังก์ชันนี้
อาร์กิวเมนต์. callee.caller; // และวัตถุฟังก์ชันการโทร
-
ฟังก์ชั่น bigloop () {
สำหรับ (var i = 0; i <100000; i ++) {
foo (); // ปกติจะถูก inlined ...
-
-
ในรหัสข้างต้นฟังก์ชั่น FOO ไม่ได้เป็นส่วนขยายแบบอินไลน์ที่เรียบง่ายอีกต่อไปเพราะจำเป็นต้องรู้ตัวเองและผู้โทร สิ่งนี้ไม่เพียง แต่ชดเชยการปรับปรุงประสิทธิภาพที่เกิดจากส่วนขยายแบบอินไลน์ แต่ยังทำลายการห่อหุ้มของฟังก์ชั่นเนื่องจากฟังก์ชั่นเองอาจต้องพึ่งพาพื้นหลังการโทรเฉพาะ
ดังนั้นขอแนะนำให้คุณพยายามที่จะไม่ใช้อาร์กิวเมนต์ callee
ข้างต้นคือทั้งหมดเกี่ยวกับวัตถุอาร์กิวเมนต์ JavaScript คุณรู้หรือไม่? เพียงแค่ใส่
อาร์กิวเมนต์อ้างถึงวัตถุพารามิเตอร์ของฟังก์ชัน (หมายถึงพารามิเตอร์ที่ผ่านจริง)
อาร์กิวเมนต์ความยาวหมายถึงความยาวของวัตถุพารามิเตอร์ของฟังก์ชัน
อาร์กิวเมนต์ [i] หมายถึงค่าของพารามิเตอร์ i-th (อันแรกคือ 0)