ในการเขียนโปรแกรมเชิงวัตถุมีฟังก์ชั่นที่สนับสนุนการทำงานมากเกินไปและสามารถทำการดำเนินการที่แตกต่างกันตามตัวเลขและประเภทของพารามิเตอร์ที่แตกต่างกันที่ส่งผ่านโดยฟังก์ชั่น อย่างไรก็ตาม JS ไม่สนับสนุนดังนั้นเราจึงต้องดำเนินการเล็ก ๆ น้อย ๆ
ในบริบทการดำเนินการของฟังก์ชั่น JS มีตัวแปรที่น่าสนใจที่เรียกว่าอาร์กิวเมนต์ มันเก็บพารามิเตอร์ทั้งหมดที่ผ่านระหว่างการดำเนินการฟังก์ชั่นในรูปแบบของอาร์เรย์แม้ว่าคำจำกัดความของฟังก์ชั่นจะไม่ได้กำหนดพารามิเตอร์ที่เป็นทางการมากมาย คุณสมบัติพิเศษอีกอย่างหนึ่งคือเมื่อเทียบกับประเภทอาร์เรย์ตัวแปรอาร์กิวเมนต์มีและมีแอตทริบิวต์ความยาวเพียงหนึ่งแอตทริบิวต์ วิธีการอาร์เรย์เช่นการกดป๊อป ฯลฯ ไม่มี มันเป็นเพียง "pseudo-array": มันมีแอตทริบิวต์ความยาวและอาร์เรย์ที่เก็บไว้สามารถเข้าถึงได้โดยอักขระการเข้าถึงอาร์เรย์ [] และเป็นแบบอ่านอย่างเดียวและไม่สามารถเขียนได้
1. การโอเวอร์โหลดตัวเลขที่แตกต่างกัน
มันควรจะชัดเจนมากที่นี่ว่าคุณสามารถใช้แอตทริบิวต์ความยาวของฟังก์ชันอาร์กิวเมนต์เพื่อตัดสิน
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
ฟังก์ชั่นพูดคุย (ผงชูรส, ตัวจัดการ) {
var len = อาร์กิวเมนต์ความยาว;
// ดำเนินการเมื่อผ่านพารามิเตอร์
ถ้า (len == 1) {
การแจ้งเตือน ("ฟังก์ชั่นบอกว่า:"+ผงชูรส);
-
// ดำเนินการเมื่อผ่านพารามิเตอร์สองตัว
อื่นถ้า (len == 2) {
ตัวจัดการ (ผงชูรส);
-
-
พูดคุย ("สาธิต");
Talk ("Demo", function (w) {Alert ("Handler พูดว่า:"+w);});
</script>
2. การโอเวอร์โหลดพารามิเตอร์ประเภทต่างๆ
สำหรับภาษาที่พิมพ์แบบไดนามิกเช่น JS ลักษณะโดยพลการของการประกาศตัวแปรแสดงให้เห็นถึงความสำคัญของประเภทตัวแปรที่เข้มงวดในใจของนักพัฒนา (PS: ยังขึ้นอยู่กับระบบ ECMA ซึ่งเป็นการแนะนำประเภทการประกาศตัวแปรที่จำเป็น) ข้อบกพร่องที่ไม่คาดคิดจำนวนมากเกิดจากการแปลงอัตโนมัติของประเภทตัวแปรนี้ ในความเป็นจริง JS ให้วิธีการที่แม่นยำมากในการตรวจจับประเภทของตัวแปรอย่างเคร่งครัด ยิ่งไปกว่านั้นคือวิธีการ typeof และแอตทริบิวต์ตัวสร้าง
1. ประเภทของตัวแปรส่งคืนประเภทตัวแปร
การคัดลอกรหัสมีดังนี้:
อุณหภูมิ = "พูด"; // สตริง
อุณหภูมิ = 1; //ตัวเลข
อุณหภูมิ = ไม่ได้กำหนด; // ไม่ได้กำหนด
อุณหภูมิ = null; //วัตถุ
temp = {}; //วัตถุ
อุณหภูมิ = []; //วัตถุ
อุณหภูมิ = จริง; // บูลีน
temp = function () {} // ฟังก์ชัน
การแจ้งเตือน (typeof temp);
จากการทดสอบข้างต้นคุณจะเห็นว่าสำหรับ NULL, OBJECT และ ARRAY ประเภทวัตถุที่ส่งคืนทั้งหมดและการใช้วิธีการต่อไปนี้สามารถแก้ปัญหานี้ได้
2. แอตทริบิวต์ตัวสร้างตรวจจับประเภทตัวแปร
แต่ละวัตถุใน JS มีแอตทริบิวต์ตัวสร้างซึ่งใช้เพื่ออ้างอิงฟังก์ชั่นที่สร้างวัตถุนี้ โดยการตัดสินการอ้างอิงนี้สามารถตรวจพบประเภทตัวแปรได้
การคัดลอกรหัสมีดังนี้:
อุณหภูมิ = "พูด";
Temp.Constructor == สตริง; //จริง
temp = {};
Temp.Constructor == Object; // true
อุณหภูมิ = [];
Temp.Constructor == array; // true
ผ่านการทดสอบข้างต้นมันง่ายที่จะแยกแยะระหว่างตัวแปรอาร์เรย์และประเภทวัตถุ ลองทดสอบวัตถุที่กำหนดเองเพื่อดูว่าเกิดอะไรขึ้น
การคัดลอกรหัสมีดังนี้:
// วัตถุที่กำหนดเอง
ฟังก์ชั่นบอล () {}
// อินสแตนซ์วัตถุ
var basketball = new ball ();
บาสเก็ตบอล. constructor == บอล; //จริง
สิ่งนี้สามารถระบุได้ว่าแอตทริบิวต์ตัวสร้างยังใช้กับวัตถุที่กำหนดเอง
หลังจากทำความเข้าใจกับการประยุกต์ใช้สองวิธีข้างต้นให้กลับไปที่การจำลองฟังก์ชั่น JS มากเกินไป ตัวอย่างต่อไปนี้คือการโอเวอร์โหลดตามประเภทพารามิเตอร์
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่นพูดคุย (ผงชูรส) {
var t = typeof msg;
if (t == "String") {
การแจ้งเตือน ("มันเป็นสตริง");
-
อื่นถ้า (t == "number") {
การแจ้งเตือน ("มันเป็นตัวเลข");
-
-
พูดคุย (10); // มันเป็นสตริง
พูดคุย ("สาธิต"); // เป็นตัวเลข
แนบเป็นฟังก์ชั่นที่ฉลาดมากที่ตรวจจับประเภทและตัวเลขพารามิเตอร์อย่างเคร่งครัด:
การคัดลอกรหัสมีดังนี้:
// ตรวจสอบประเภทของรายการตัวแปรอย่างเคร่งครัดตามรายการพารามิเตอร์
ฟังก์ชั่นเข้มงวด (ประเภท, args) {
// ตรวจสอบให้แน่ใจว่าหมายเลขและพิมพ์เคอร์เนลของพารามิเตอร์ตรงกับ
if (types.length! = args.length) {
// หากความยาวไม่ตรงกันจะมีการโยนข้อยกเว้น
โยน "จำนวนอาร์กิวเมนต์ที่ไม่ถูกต้องคาดหวัง" + types.length + "ได้รับ" + args.length + "แทน";
-
// เดินทางผ่านแต่ละพารามิเตอร์และตรวจสอบประเภทฐาน
สำหรับ (var i = 0; i <args.length; i ++) {
// หาก JavaScript บางประเภทไม่ตรงกันข้อยกเว้นจะถูกโยนทิ้งไป
ถ้า (args [i] .Constructor! = ประเภท [i]) {
โยน "ประเภทอาร์กิวเมนต์ที่ไม่ถูกต้องคาดหวัง" + ประเภท [i] .name + "ได้รับ" + args [i] .constructor.name + "แทน";
-
-
-
// การใช้วิธีข้างต้น
ฟังก์ชั่น dofunction (id, ชื่อ) {
// ตรวจจับหมายเลขและประเภทของพารามิเตอร์
เข้มงวด ([หมายเลข, สตริง], อาร์กิวเมนต์);
-
-