ชิ้นส่วน
ประเภทวัตถุ
Object เป็นคอลเลกชันที่ไม่ได้เรียงลำดับที่สามารถจัดเก็บวัตถุทุกประเภทและวัตถุอื่น ๆ ทั้งหมดได้รับการสืบทอดจากวัตถุนี้
มีการสร้างวัตถุสองประเภทหนึ่งคือการใช้ตัวดำเนินการใหม่และอีกประเภทหนึ่งคือสัญกรณ์ตัวอักษร
1. สร้างวัตถุโดยใช้ตัวดำเนินการใหม่
var obj = วัตถุใหม่ (); // ให้ความสนใจกับตัวพิมพ์ใหญ่คุณยังสามารถเขียนมันโดยตรงเป็นวัตถุ ()
โปรดทราบว่าการสร้างวัตถุใหม่ผ่านวิธีการใหม่ () นั้นเทียบเท่ากับวิธีการตามตัวอักษร obj = {}
2. สร้างโดยใช้วิธีการตามตัวอักษร:
var obj = {ชื่อ: 'trigkit4', อายุ: 21}; // semicolon ดีที่สุดที่จะเพิ่มเมื่อประกาศวัตถุวัตถุโดยใช้ตัวอักษรวัตถุ () ตัวสร้างจะไม่ถูกเรียก (ยกเว้น FF)
Object.prototype Object
ตัวสร้างทั้งหมดมีแอตทริบิวต์ต้นแบบที่ชี้ไปที่วัตถุต้นแบบ
Object.prototype.print = function () {console.log (this)}; var obj = วัตถุใหม่ (); obj.print () // objectอินสแตนซ์ OBJ โดยตรงสืบทอดคุณสมบัติและวิธีการของ Object.prototype
1. วัตถุเป็นเพียงข้อมูลพิเศษ วัตถุมีคุณสมบัติและวิธีการ JavaScript เป็นภาษาที่มุ่งเน้นวัตถุ แต่ JavaScript ไม่ได้ใช้คลาส JavaScript ขึ้นอยู่กับ [ต้นแบบ] [1] ไม่ใช่ชั้นเรียน
2. แอตทริบิวต์: มันเป็นตัวแปรที่เกี่ยวข้องกับวัตถุเฉพาะ วิธีการ: มันเป็นฟังก์ชั่นที่สามารถเรียกได้โดยวัตถุเฉพาะ
3.JS วัตถุเป็นชุดของคุณสมบัติและวิธีการ วิธีการคือฟังก์ชั่นซึ่งเป็นสมาชิกของวัตถุ แอตทริบิวต์คือค่าหรือชุดของค่า (ในรูปแบบของอาร์เรย์หรือวัตถุ) ที่เป็นสมาชิกของวัตถุ
4.JS วัตถุขึ้นอยู่กับฟังก์ชันตัวสร้าง เมื่อใช้ฟังก์ชั่นคอนสตรัคเตอร์เพื่อสร้างวัตถุใหม่อาจกล่าวได้ว่าวัตถุใหม่เป็นอินสแตนซ์ คุณสมบัติเป็นตัวแปรภายในฟังก์ชันตัวสร้าง
วัตถุอินสแตนซ์โดยใช้ฟังก์ชั่นคอนสตรัคเตอร์:
แมว = สัตว์ใหม่ ();
JavaScript เป็นภาษาที่ใช้วัตถุและเกือบทุกอย่างที่คุณพบคือวัตถุ อย่างไรก็ตามมันไม่ใช่ภาษาการเขียนโปรแกรมเชิงวัตถุ (OOP) ที่แท้จริงเนื่องจากไม่มีคลาส (คลาส) ในไวยากรณ์
<script type = "text/javascript"> // object เป็นคอลเลกชันของคู่ชื่อ/ค่าคู่เบราว์เซอร์ = {// วัตถุเป็นชื่อที่ล้อมรอบด้วยวงเล็บปีกกา: "Firefox", เคอร์เนล: "Gecko"};วัตถุ (OBJCT) เป็นคอลเลกชันของคุณสมบัติแต่ละคุณสมบัติประกอบด้วย "คู่ชื่อ/ค่าคู่" JS ยังกำหนดวัตถุพิเศษ - อาร์เรย์ซึ่งเป็นชุดที่สั่งซื้อของค่าหมายเลข
JS ยังกำหนดวัตถุพิเศษ - ฟังก์ชั่นฟังก์ชั่นเป็นวัตถุที่มีรหัสปฏิบัติการที่เชื่อมโยงกับมัน มันดำเนินการรหัสโดยเรียกใช้ฟังก์ชันและส่งคืนผลการดำเนินการ
ไม่มีคลาสใน JS แต่ใช้ชื่อใหม่ที่เรียกว่า "วัตถุต้นแบบ" ดังนั้น "คลาส == วัตถุต้นแบบ" ดู: วิธีการเขียนคลาส JavaScript (I)
2. ความแตกต่างและการเชื่อมต่อระหว่างคลาส (วัตถุต้นแบบ) และวัตถุ (อินสแตนซ์)
1. คลาส (วัตถุต้นแบบ) เป็นนามธรรม, แนวคิด, แสดงถึงประเภทของสิ่งต่าง ๆ
2. วัตถุเป็นคอนกรีตปฏิบัติและแสดงถึงสิ่งที่เฉพาะเจาะจง
3. คลาส (วัตถุต้นแบบ) เป็นเทมเพลตสำหรับอินสแตนซ์วัตถุและอินสแตนซ์วัตถุเป็นบุคคลของคลาส
ความเข้าใจผิดทั่วไปคือค่าตัวอักษรของตัวเลขไม่ใช่วัตถุ นี่เป็นเพราะข้อผิดพลาดในตัวแยกวิเคราะห์ JavaScript ที่พยายามแยกวิเคราะห์ตัวดำเนินการจุดเป็นส่วนหนึ่งของค่าตัวเลขตัวเลขลอยตัว
มีวิธีแก้ปัญหามากมายที่จะทำให้ค่าตามตัวอักษรของตัวเลขดูเหมือนวัตถุ
2..Tostring (); // จุดที่สองสามารถแยกวิเคราะห์ได้ตามปกติ
2.tostring (); // ให้ความสนใจกับช่องว่างก่อน DOT
(2) .tostring (); // 2 คำนวณก่อน
ลบแอตทริบิวต์
วิธีเดียวที่จะลบคุณสมบัติคือการใช้ตัวดำเนินการลบ การตั้งค่าคุณสมบัติเป็น undefined หรือ null ไม่ได้ลบคุณสมบัติ แต่เพียงลบความสัมพันธ์ระหว่างคุณสมบัติและค่า
คุณสมบัติหลักสามประการของวัตถุ JavaScript
encapsulation: ไม่มีการพิจารณาการใช้งานภายในจะพิจารณาเฉพาะการใช้งานที่ใช้งานได้
มรดก: สืบทอดวัตถุใหม่จากวัตถุที่มีอยู่
Polymorphism: polymorphism ที่เรียกว่าหมายถึงหลายรัฐที่อ้างถึงในสถานการณ์ที่แตกต่างกัน
1. บรรจุภัณฑ์
การห่อหุ้มหมายถึงการจัดกลุ่ม commonalities (รวมถึงคุณลักษณะและพฤติกรรม) ของสิ่งต่าง ๆ ที่อยู่ในหมวดหมู่เดียวกันในชั้นเรียนเพื่อใช้งานง่าย ตัวอย่างเช่นสิ่งที่มนุษย์สามารถห่อหุ้มด้วยวิธีต่อไปนี้:
ประชากร{
อายุ (แอตทริบิวต์ 1)
ความสูง (แอตทริบิวต์ 2)
เพศ (แอตทริบิวต์สาม)
ทำสิ่งต่างๆ (หนึ่งในพฤติกรรม)
เดิน (พฤติกรรม 2)
การพูด (กิจการ 3)
-
ประโยชน์ของการห่อหุ้ม:
การห่อหุ้มปกป้องความสมบูรณ์ของข้อมูลภายใน
Encapsulation ทำให้การปรับเปลี่ยนวัตถุง่ายขึ้น
การมีเพศสัมพันธ์ที่อ่อนตัวลงระหว่างโมดูลและปรับปรุงความสามารถในการใช้ซ้ำของวัตถุ
ช่วยหลีกเลี่ยงความขัดแย้งของเนมสเปซ
ดูตัวอย่างต่อไปนี้:
<script type = "text/javascript"> var boy = {}; // สร้าง Object Boy.name = "Xiao Ming"; // กำหนด boy.age = 12 ตามคุณสมบัติของวัตถุต้นแบบ, var girl = {}; girl.name = "Xiaohong"; girl.age = 10; </script>นี่คือการห่อหุ้มที่ง่ายที่สุดห่อหุ้มคุณลักษณะสองอย่างในวัตถุเดียว อย่างไรก็ตามวิธีการเขียนนี้มีสองข้อเสีย หนึ่งคือถ้าคุณสร้างอินสแตนซ์มากขึ้นมันจะลำบากมากในการเขียน อีกอย่างคือไม่มีวิธีที่จะบอกได้ว่ามีการเชื่อมต่อระหว่างอินสแตนซ์และต้นแบบหรือไม่
โหมดตัวสร้าง
เพื่อแก้ปัญหาการสร้างอินสแตนซ์จากวัตถุต้นแบบ JavaScript ให้รูปแบบตัวสร้าง
"ตัวสร้าง" ที่เรียกว่าจริง ๆ แล้วเป็นฟังก์ชันธรรมดา แต่ตัวแปรนี้ใช้ภายใน การใช้ตัวดำเนินการใหม่สำหรับตัวสร้างสามารถสร้างอินสแตนซ์และตัวแปรนี้จะถูกผูกไว้กับวัตถุอินสแตนซ์
ตัวอย่างเช่นวัตถุต้นแบบของเด็กชายและเด็กหญิงสามารถเขียนได้เช่นนี้: ตอนนี้:
<script type = "text/javascript"> person function (ชื่อ, อายุ) {this.name = name; this.age = อายุ; } </script>ตอนนี้เราสามารถสร้างวัตถุอินสแตนซ์
<script type = "text/javascript"> var boy = บุคคลใหม่ ("Xiao Ming", 12); var girl = คนใหม่ ("Xiao Hong", 10); การแจ้งเตือน (boy.name); // Xiao Ming Alert (boy.age); // 12 </script>ในเวลานี้เด็กชายและเด็กหญิงจะมีแอตทริบิวต์ตัวสร้างโดยอัตโนมัติชี้ไปที่ตัวสร้างของพวกเขา
การแจ้งเตือน (boy.constructor == บุคคล); //จริง
การแจ้งเตือน (girl.constructor); // ส่งออกสตริงทั้งหมดของรหัสคอนสตรัคเตอร์ลองด้วยตัวเอง
รูปแบบต้นแบบ JavaScript กำหนดว่าแต่ละตัวสร้างมีแอตทริบิวต์ต้นแบบที่ชี้ไปยังวัตถุอื่น คุณสมบัติและวิธีการทั้งหมดของวัตถุนี้จะได้รับการสืบทอดโดยอินสแตนซ์ของตัวสร้าง
ซึ่งหมายความว่าเราสามารถกำหนดคุณสมบัติและวิธีการที่ไม่เปลี่ยนแปลงเหล่านั้นโดยตรงบนวัตถุต้นแบบ
<script type = "text/javascript"> person function (ชื่อ, อายุ) {this.name = name; this.age = age;} person.protepe.type = "human"; person.protepe.eat = function () {แจ้งเตือน ("กินข้าว");} </script>จากนั้นสร้างอินสแตนซ์:
<script type = "text/javascript"> var boy = บุคคลใหม่ ("Xiao Ming", "12"); var girl = บุคคลใหม่ ("Xiao Hong", "10"); Alert (boy.type); // human boy.eat ();ในเวลานี้วิธีการประเภทและวิธีการ EAT () ของทุกกรณีเป็นที่อยู่หน่วยความจำเดียวกันโดยชี้ไปที่วัตถุต้นแบบซึ่งจะช่วยปรับปรุงประสิทธิภาพการทำงาน
การแจ้งเตือน (boy.eat == girl.eat); //จริง
คุณสมบัติต้นแบบเป็นคุณสมบัติในตัวที่ระบุฟังก์ชันตัวสร้างที่วัตถุขยาย
รหัสต่อไปนี้เพิ่มขนาดแอตทริบิวต์ใหม่ให้กับฟังก์ชันตัวสร้างสัตว์ซึ่งเป็นแอตทริบิวต์ต้นแบบของวัตถุ CAT ด้วยการใช้คุณสมบัติต้นแบบวัตถุทั้งหมดที่ขยายฟังก์ชั่นตัวสร้างสัตว์สามารถเข้าถึงคุณสมบัติขนาดได้
CAT = สัตว์ใหม่ ("Feline", "Meow", "Walk/Run"); cat.prototype.size = "Fat";ในกรณีนี้คุณลักษณะขนาดของวัตถุสัตว์ทั้งหมดคือ "ไขมัน" ต้นแบบเริ่มต้นเป็นอินสแตนซ์ใหม่ของวัตถุ เนื่องจากมันยังคงเป็นวัตถุจึงสามารถเพิ่มแอตทริบิวต์ใหม่ลงในวัตถุได้ เช่นเดียวกับสไตล์เป็นวัตถุใน JavaScript คุณยังสามารถเพิ่มคุณสมบัติตามสไตล์ได้
<script type = "text/javascript">/*กำหนดคลาสบุคคล*/ฟังก์ชันบุคคล (_name, _age, _salary) {// แอตทริบิวต์สาธารณะของคลาสบุคคลคุณลักษณะสาธารณะของคลาสถูกกำหนดเป็น: "ชื่อนี้ // แอตทริบิวต์ส่วนตัวของคลาสบุคคลแอตทริบิวต์ส่วนตัวของคลาสถูกกำหนดเป็น: "ชื่อแอตทริบิวต์ VAR" VAR AGE = _AGE; var salary = _salary; // กำหนดวิธีการสาธารณะ (วิธีการยกเว้น) ของคลาสบุคคลวิธีการสาธารณะของคลาสถูกกำหนดเป็น: "this.functionName = function () {..... }" this.show = function () {Alert ("Age ="+Age+"/t"+"เงินเดือน ="เมื่อวัตถุมองหาคุณสมบัติบางอย่างมันจะสำรวจคุณสมบัติของตัวเองก่อน หากไม่เป็นเช่นนั้นมันจะยังคงค้นหาวัตถุที่อ้างอิงโดย [[ต้นแบบ]] ถ้าไม่มันจะยังคงค้นหาวัตถุที่อ้างอิงโดย [[ต้นแบบ]]] [[ต้นแบบ]] และต่อไปจนกระทั่ง [[[ต้นแบบ]]] …. [[ต้นแบบ]] ไม่ได้กำหนด ([[ต้นแบบ]] ไม่ได้กำหนด))
พูดง่ายๆก็คือการบันทึกการอ้างอิงไปยังวัตถุอื่นผ่าน [[ต้นแบบ] ของวัตถุ] และค้นหาแอตทริบิวต์ผ่านการอ้างอิงนี้ นี่คือห่วงโซ่ต้นแบบ
วัตถุว่าง
ฟังก์ชั่นของ JS การกำหนดค่า null ให้กับตัวแปรคือ:
การกำหนดตัวชี้โมฆะทำให้ง่ายต่อการเข้าใจว่าตัวแปรนี้พร้อมที่จะจัดเก็บวัตถุ นอกจากนี้ยังสะดวกในการปรับผิด
วัตถุหน้าต่างทั่วโลก
ฟังก์ชั่นหรือตัวแปรส่วนกลางใน JavaScript เป็นคุณสมบัติของหน้าต่าง
วัตถุตนเองนั้นเหมือนกับวัตถุหน้าต่าง ตัวเองมักจะใช้เพื่อยืนยันว่าอยู่ในรูปแบบปัจจุบัน
วัตถุหลักหลักของหน้าต่างมีดังนี้:
วัตถุเอกสาร JavaScript
วัตถุ JavaScript Frames
วัตถุประวัติ JavaScript
วัตถุตำแหน่ง JavaScript
วัตถุ JavaScript Navigator
วัตถุหน้าจอ JavaScript
วิธีการทั่วไปหลายวิธี
วิธีการ (): ส่งคืนค่าดั้งเดิมของวัตถุที่ระบุ
วิธีการแยก () แยกสตริงออกเป็นอาร์เรย์สตริงและส่งคืนอาร์เรย์นี้
เมธอดดัชนี () ส่งคืนการเกิดขึ้นครั้งแรกของค่าสตริงที่ระบุในสตริง
เมธอด substring () ใช้เพื่อแยกอักขระในสตริงระหว่างสองตัวห้อยที่ระบุ
เมธอด substr () แยกจำนวนสตริงที่ระบุเริ่มต้นจากตำแหน่ง startPOS จากสตริง
วิธีการเข้าร่วม () ใช้เพื่อวางองค์ประกอบทั้งหมดในอาร์เรย์ลงในสตริง
arrayobject.oin (คั่น)
วิธีการย้อนกลับ () ใช้เพื่อย้อนกลับลำดับขององค์ประกอบในอาร์เรย์
เมธอด slice () ส่งคืนองค์ประกอบที่เลือกจากอาร์เรย์ที่มีอยู่
วัตถุ
ตัวอักษรวัตถุเป็นกระบวนการที่ใช้ในการสร้างคุณสมบัติจำนวนมากดังนี้:
<script type = "text/javascript"> var company = {ชื่อ: "Microsoft", อายุ: 39, พนักงาน: 99000, CEO: "Nadella"}; </script>ควรสังเกตที่นี่ว่าแอตทริบิวต์และค่าแอตทริบิวต์จะถูกคั่นด้วย colons (:); แอตทริบิวต์หลายตัวจะคั่นด้วยเครื่องหมายจุลภาค (,) วัตถุที่แท้จริงยังสามารถกำหนดวิธีการ เพียงแค่เขียนฟังก์ชั่นบนแอตทริบิวต์ของวัตถุนี้ นี่เป็นฟังก์ชั่นที่ไม่ระบุชื่อ คุณจะต้องเขียนชื่อวิธี () เพื่อเรียกมัน
<script type = "text/javascript"> var dog = {ชื่อ: "husky", อายุ: 2, run: function () {return "123";}}} การแจ้งเตือน (dog.run ()); // ถ้าคุณป้อน dog.run รหัสสำหรับส่วนที่อยู่เบื้องหลังwrapper ประเภทค่าพื้นฐาน
มีห้าประเภทพื้นฐานประเภทใน js: จำนวน, สตริง, บูลีน, null และ undefined ยกเว้น null และ undefined อีกสามคนมีสิ่งที่เรียกว่าวัตถุพื้นฐาน สามารถใช้หมายเลข constructors ในตัว (), string () และ boolean () เพื่อสร้างวัตถุ wrapper
var num = หมายเลขใหม่ (10); console.log (typeof num); // object object () method object () // ส่งคืนวัตถุวัตถุเปล่า (undefined) // ส่งคืนวัตถุวัตถุเปล่า (null) // ส่งคืนวัตถุเปล่า (1) // เทียบเท่ากับหมายเลขใหม่ (1) Boolean (TRUE) Object ([]) // ส่งคืนวัตถุอาร์เรย์ดั้งเดิม ({}) // ส่งคืนวัตถุวัตถุต้นฉบับ (ฟังก์ชัน () {}) // ส่งคืนฟังก์ชันดั้งเดิมส่วนอาร์เรย์
1. วัตถุอาร์เรย์
อาร์เรย์วัตถุ: ให้การสนับสนุนสำหรับการสร้างอาร์เรย์ของประเภทข้อมูลใด ๆ
arrayobj = อาร์เรย์ใหม่ ()
arrayobj = อาร์เรย์ใหม่ ([ขนาด])
arrayobj = อาร์เรย์ใหม่ ([องค์ประกอบ 0 [, องค์ประกอบ 1 [, ... [, elementn]]]])
คำจำกัดความ: var arr = [2,3,45,6]; var arr = อาร์เรย์ใหม่ (2,4,5,7)
ไม่มีความแตกต่างในคำจำกัดความระหว่างทั้งสอง [] มีประสิทธิภาพสูงเนื่องจากรหัสสั้น
ใช้อาร์เรย์และตัวอักษรวัตถุ: var atest = []; เมื่อสร้างอาร์เรย์การใช้ตัวอักษรอาร์เรย์เป็นตัวเลือกที่ดี ในทำนองเดียวกันตัวอักษรวัตถุยังสามารถใช้เพื่อประหยัดพื้นที่ สองบรรทัดต่อไปนี้เท่ากัน แต่ใช้ตัวอักษรวัตถุที่สั้นกว่า:
var otest = วัตถุใหม่; // พยายามอย่าใช้ var otest = {}; // ตัวเลือกที่ดีที่สุดหรือ var 0test = [];Traversal เพื่อให้ได้ประสิทธิภาพที่ดีที่สุดของอาร์เรย์ Traversing ขอแนะนำให้ใช้แบบคลาสสิกสำหรับการวนรอบ
var list = [1, 2, 3, 4, 5, ...... 100000000]; สำหรับ (var i = 0, l = list.length; i <l; i ++) {console.log (รายการ [i]);}รหัสด้านบนมีการประมวลผลซึ่งคือแคชความยาวของอาร์เรย์ผ่าน l = list.length
ตัวสร้างอาร์เรย์
เนื่องจากตัวสร้างของอาเรย์ค่อนข้างคลุมเครือเล็กน้อยเมื่อพูดถึงวิธีการจัดการอาร์กิวเมนต์จึงแนะนำให้ใช้ไวยากรณ์ของอาร์เรย์ตามตัวอักษร - [] - เพื่อสร้างอาร์เรย์
ดังนั้นรหัสต่อไปนี้จะทำให้เกิดความสับสน:
อาร์เรย์ใหม่ (3, 4, 5); // ผลลัพธ์: [3, 4, 5]
อาร์เรย์ใหม่ (3) // ผลลัพธ์: [] ความยาวของอาร์เรย์นี้คือ 3
พยายามหลีกเลี่ยงการใช้ตัวสร้างอาร์เรย์เพื่อสร้างอาร์เรย์ใหม่ ขอแนะนำให้ใช้ไวยากรณ์ตัวอักษรของอาร์เรย์ พวกเขาสั้นลงและกระชับมากขึ้นซึ่งจะเป็นการเพิ่มความสามารถในการอ่านของรหัส
คุณสมบัติของอาร์เรย์อาร์เรย์
คุณสมบัติสามประการของอาร์เรย์อาร์เรย์: แอตทริบิวต์ความยาวแอตทริบิวต์ต้นแบบแอตทริบิวต์คอนสตรัคเตอร์
1. แอตทริบิวต์ความยาว
แอตทริบิวต์ความยาวแสดงถึงความยาวของอาร์เรย์นั่นคือจำนวนองค์ประกอบในนั้น เนื่องจากดัชนีของอาร์เรย์เริ่มต้นจาก 0 เสมอขีด จำกัด บนและล่างของอาร์เรย์คือ: 0 และความยาว -1 ตามลำดับ ซึ่งแตกต่างจากภาษาอื่น ๆ ส่วนใหญ่คุณสมบัติความยาวของอาร์เรย์ JavaScript นั้นไม่แน่นอนซึ่งต้องการความสนใจเป็นพิเศษ
2. แอตทริบิวต์ prototype
ส่งคืนการอ้างอิงไปยังต้นแบบประเภทวัตถุ แอตทริบิวต์ต้นแบบเป็นเรื่องปกติของวัตถุ
สำหรับวัตถุอาร์เรย์อาร์เรย์ให้ใช้ตัวอย่างต่อไปนี้เพื่อแสดงวัตถุประสงค์ของแอตทริบิวต์ต้นแบบ
เพิ่มวิธีการลงในวัตถุอาร์เรย์เพื่อส่งคืนค่าองค์ประกอบสูงสุดในอาร์เรย์ ในการทำเช่นนี้ประกาศฟังก์ชั่นเพิ่มลงใน array.prototype และใช้งาน
ฟังก์ชั่น array_max () {var i, max = this [0]; สำหรับ (i = 1; i <this.length; i ++) {ถ้า (สูงสุด <this [i]) max = this [i]; } ส่งคืนสูงสุด; } array.prototype.max = array_max; var x = อาร์เรย์ใหม่ (1,2,3,4,5,6); var y = x.max ();หลังจากดำเนินการรหัสนี้แล้ว Y จะบันทึกค่าสูงสุดในอาร์เรย์ X หรือ 6
3. แอตทริบิวต์ของตัวสร้าง
ฟังก์ชั่นที่แสดงถึงการสร้างวัตถุ คำอธิบาย: แอตทริบิวต์ตัวสร้างเป็นสมาชิกของวัตถุทั้งหมดที่มีต้นแบบ พวกเขารวมวัตถุดั้งเดิมของ JScript ยกเว้นวัตถุทั่วโลกและคณิตศาสตร์ คุณสมบัติตัวสร้างมีการอ้างอิงถึงฟังก์ชั่นที่สร้างอินสแตนซ์วัตถุเฉพาะ
ตัวอย่างเช่น:
x = สตริงใหม่ ("สวัสดี"); if (x.constructor == สตริง) // กระบวนการ (เงื่อนไขเป็นจริง) // หรือฟังก์ชั่น myfunc {// func } y = ใหม่ myfunc;ถ้า (y.constructor == myfunc) // กระบวนการ (เงื่อนไขเป็นจริง)
สำหรับอาร์เรย์:
y = new Array ();
วิธีวัตถุอาร์เรย์
เรียงลำดับ () วิธีการ
ไวยากรณ์
arrayobject.sort (sortby)
sortby เป็นทางเลือก ระบุลำดับการเรียงลำดับ ต้องเป็นฟังก์ชั่น
var arr = [11,2,28,4,5,1];
console.log (arr.sort ()); // return [1, 11, 2, 28, 4, 5]
เหตุใด 11 และ 28 ที่นี่จึงไม่จัดเรียงตามลำดับ? นี่เป็นเพราะการเรียงลำดับที่ไม่มีพารามิเตอร์ถูกเรียงลำดับในลำดับการเข้ารหัสอักขระ
แล้วถ้าเราต้องการจัดเรียงองค์ประกอบอาร์เรย์จากขนาดเล็กถึงใหญ่ล่ะ? ดูรหัสต่อไปนี้:
var arr = [11,2,28,4,5,1]; console.log (arr.sort (ฟังก์ชั่น (a, b) {return ab; // return [1, 2, 4, 5, 11, 28]}));หากคุณต้องการเรียงลำดับตามเกณฑ์อื่นคุณจะต้องจัดเตรียมฟังก์ชั่นเปรียบเทียบที่เปรียบเทียบสองค่าจากนั้นส่งคืนตัวเลขที่แสดงลำดับสัมพัทธ์ของค่าทั้งสอง ฟังก์ชั่นการเปรียบเทียบควรมีพารามิเตอร์สองตัว A และ B และค่าผลตอบแทนของมันมีดังนี้:
หาก A น้อยกว่า B ควรปรากฏก่อน B ในอาร์เรย์ที่จัดเรียงแล้วค่าที่น้อยกว่า 0 จะถูกส่งคืน
หาก A เท่ากับ B กลับ 0
หาก A มากกว่า B ค่าที่มากกว่า 0 จะถูกส่งคืน
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น