JavaScript รู้ได้อย่างไรว่าประเภทพื้นฐานมีคุณสมบัติและวิธีการเช่นวัตถุ

[คำแนะนำที่เกี่ยวข้อง: วิดีโอสอน JavaScript, ส่วนหน้าของเว็บ]

"วิธีการระบุแอตทริบิวต์" ของประเภทพื้นฐาน

บทความนี้จะสำรวจแนวคิดที่น่าสนใจอย่างมาก กล่าวคือ วิธีการระบุแอตทริบิวต์ของประเภทพื้นฐาน เป็นไงบ้าง สับสนนิดหน่อยเหรอ? ให้ฉันบอกคุณช้าๆ ~

คำนำ

ในภาษาการเขียนโปรแกรมเชิงวัตถุอื่นๆ เช่น Java และ C++ คุณลักษณะเป็นแนวคิดเฉพาะของวัตถุ และประเภทพื้นฐานคือประเภทพื้นฐาน ไม่มีแนวคิดของวิธีการแอตทริบิวต์

ใช่ มันเป็นความคิดที่ไม่ดีอีกประการหนึ่งของ JavaScript เอ็นจิ้นของมันช่วยให้เราใช้วิธีการคุณสมบัติเพื่อจัดการข้อมูลประเภทพื้นฐานเช่นวัตถุ

ก่อนที่จะอธิบายคุณลักษณะแปลก ๆ นี้ เราต้องชี้แจงก่อนว่าอะไรคือความแตกต่างระหว่างประเภทพื้นฐานและประเภทวัตถุ?

1. • { }
2. พื้นฐานคือ
   • อะไร JavaScript
   • JavaScript มี 7 ประเภท ได้แก่: String , Number , Boolean , BigInt , Symbol , null และ undefined ;
3. • { } สร้างและสามารถจัดเก็บค่าได้หลายค่า
   • JavaScript ยังมีวัตถุประเภทอื่น ๆ เช่นฟังก์ชัน

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

ตัวอย่างเช่น:

ให้ผู้ใช้ = {
    ชื่อ: "เสี่ยวหมิง",
    สวัสดี() {
        console.log(`สวัสดี ฉันชื่อ ${this.name}`);
    }}user.hello();

เราสรุปคุณลักษณะและเมธอดของ user อ็อบเจ็กต์ลงในอ็อบเจ็กต์ เพื่อให้ใช้งานง่ายมาก เราจำเป็นต้องใช้ obj.attr เพื่อเรียกเมธอดหรือแอททริบิวต์เท่านั้น

อย่างไรก็ตาม การทำเช่นนั้นเกี่ยวข้องกับค่าใช้จ่ายเพิ่มเติม (เชิงวัตถุมีค่าใช้จ่ายเพิ่มเติม) ซึ่งเป็นจุดที่ภาษาเชิงวัตถุ C++ ช้ากว่า C

ปัญหาที่เผชิญ

เมื่อใช้ประเภทพื้นฐาน

เป็นวัตถุ มีปัญหาสองประการที่ยากต่อการกระทบยอดเมื่อใช้ประเภทพื้นฐานเป็นวัตถุ:

1. เราหวังว่าการดำเนินการกับประเภทพื้นฐานจะเหมือนกับการใช้วัตถุ เช่น "abc".toUpperCase() ;
2. ออบเจ็กต์มีค่าใช้จ่ายเพิ่มเติม เรายังหวังว่าจะรักษาลักษณะที่เรียบง่ายและมีประสิทธิภาพของประเภทพื้นฐานไว้

วิธีแก้ปัญหาคือ

JavaScript แก้ปัญหาข้างต้นด้วยวิธีที่ "ง่าย" มาก:

1. ประเภทพื้นฐานคือประเภทพื้นฐาน โดยให้อิสระ ค่าเดียว
2. อนุญาตให้เข้าถึงวิธีการ String , Number , Boolean และ Symbol และคุณสมบัติของประเภทนั้น
3. เพื่อให้มั่นใจในความสมบูรณ์ของทฤษฎีเมื่อใช้วิธีการและคุณสมบัติของประเภทพื้นฐาน พวกเขาจะถูกบรรจุลงในวัตถุก่อนแล้วจึงถูกทำลาย

1. ต้น

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

ตัวอย่าง

ของเหตุการณ์เบื้องหลัง

la name = "Trump";console.log(name.toUpperCase());//วิธีการเข้าถึงประเภทพื้นฐาน

ผลการดำเนินการของโค้ดข้างต้นมีดังนี้:

ดูเหมือนว่าจะไม่มีปัญหาใหญ่ แต่มีหลายอย่างเกิดขึ้น และเราจำเป็นต้องรู้ประเด็นต่อไปนี้:

1. name เป็นประเภทสตริงพื้นฐาน และไม่มีอะไรพิเศษเกี่ยวกับมัน
2. เมื่อเข้าถึงเมธอดแอตทริบิวต์ name ไฟล์ที่มี วัตถุพิเศษที่มีค่าสตริง วัตถุนี้มีวิธี toUpperCase
3. การเรียกวิธีการของวัตถุพิเศษ toUpperCase ส่งคืนสตริง ใหม่
4. วัตถุพิเศษจะถูกทำลายเมื่อใช้จน

หมด

ผลลัพธ์ของการประนีประนอม

แม้ว่าการแก้ปัญหาจะเต็มไปด้วยการประนีประนอม (ความคิดที่ไม่ดี) แต่ผลลัพธ์ก็ยังดีและความสำเร็จที่ทำได้มีดังนี้:

1. ประเภทพื้นฐานยังคงความเรียบง่ายและมีประสิทธิภาพ
2. ประเภทพื้นฐานมีคุณสมบัติและวิธีการผ่านวัตถุพิเศษ ;
3. ตามทฤษฎีแล้ว มีเพียงออบเจ็กต์เท่านั้นที่มีคุณสมบัติและวิธีการ

แม้ว่านี่จะเป็นความจริงตามทฤษฎี แต่ในความเป็นจริงแล้ว เอ็นจิ้น JavaScript ได้รับการปรับให้เหมาะสมที่สุดสำหรับกระบวนการนี้ และฉันสงสัยว่ามันไม่ได้สร้างออบเจ็กต์เพิ่มเติมเลย เขาแค่พูดด้วยวาจาว่าเขาปฏิบัติตามกฎราวกับว่าเขามีวัตถุชั่วคราวจริงๆ

ตัวอย่างของวิธีการที่ใช้กันทั่วไป

บทความนี้จะแนะนำแนวคิดของวิธีการประเภทพื้นฐานเพียงสั้นๆ เท่านั้น และไม่ได้อธิบายวิธีการต่างๆ มากมาย เนื่องจากบทช่วยสอนยังคงเข้มข้นขึ้น จึงจะมีการค่อยๆ เข้ามามีส่วนร่วมกับวิธีการจำนวนมาก ในที่นี้เราจะแสดงรายการวิธีการและคุณสมบัติของประเภทพื้นฐานที่ใช้กันทั่วไปโดยย่อเท่านั้น

ประเภทพื้นฐานที่แตกต่างกันมีวิธีแอตทริบิวต์ที่แตกต่างกันซึ่งแสดงอยู่ในประเภทต่อไปนี้:

สตริง

1. length คืนความยาวสตริง

   console.log("abc".length);

   ผลลัพธ์ของโค้ดข้างต้นมีดังนี้:

   

2. วิธีการindexOf(ch)ส่งคืน

   ตัว

   indexOf(ch) ของอักขระตัวแรก ch ในสตริง

   console.log("abc".indexOf('b'));console.log("abc".indexOf('d'));

   ผลลัพธ์การรันโค้ดมีดังนี้:

   

   เมื่อมีอักขระอยู่ในสตริง ดัชนี (นับจาก 0 ) จะถูกส่งกลับ หากไม่พบ จะส่งกลับ -1

3. วิธี concat(str) ประกบสองสายเข้าด้วยกัน

   ให้ str1 = "hello ";let str2 = "world!";console.log(str1.concat(str2));console.log(str1);console.log(str2 );

   ผลลัพธ์การรันโค้ดมีดังนี้:

   

4. replace(str1,str2) วิธีการใช้ str2 เพื่อแทนที่ str1

   ให้ str = "javascript";console.log(str.replace('java','996'));

   console.log

   (str);

   ดังต่อไปนี้:

   

Number

1. toFixed(num) ปัดเศษทศนิยมตามที่ระบุ

   console.log(9.3333333.toFixed(3)); console.log(9.3333333.toFixed(0))

   ผลลัพธ์การเรียกใช้โค้ดมีดังนี้:

   

2. วิธี toString() แปลงตัวเลขเป็นสตริง

   3.14.toString();//แปลงเป็น '3.14'console.log((8).toString(2));//แปลงเป็นไบนารี่ '1000'console.log((( 9).toString(2));//แปลงเป็นไบนารี '1001'console.log((996).toString(16));//แปลงเป็นสตริงเลขฐานสิบหก '3e4'

   ผลการเรียกใช้โค้ดมีดังนี้:

   

3. วิธี toExponential() แปลงเป็นวิธีนับเลขชี้กำลัง

   console.log(3.1415926.toExponential()); console.log(3.1415926.toExponential(2)); console.log(

   3.1415926.toExponential

   (3));

   ดังต่อไปนี้:

   

วิธีการเพิ่มเติมจะแสดงในบทต่อๆ ไป ดังนั้นฉันจะไม่ลงรายละเอียดที่นี่

ตัวสร้างประเภทพื้นฐาน (คุณสมบัติที่เลิกใช้แล้ว)

เช่นเดียวกับ Java JavaScript สามารถสร้าง "ตัวห่อวัตถุ" สำหรับประเภทพื้นฐานได้อย่างชัดเจนผ่านตัวดำเนินการ new ไม่แนะนำอย่างยิ่ง วิธีการนี้กล่าวถึงในที่นี้เพียงเพื่อความรู้เรื่องความสมบูรณ์

มีปัญหาเกี่ยวกับวิธีการนี้ ตัวอย่างเช่น:

ให้ num = new Number(0);console.log(typeof num);console.log(typeof 0);

ผลลัพธ์การเรียกใช้โค้ดจะเป็นดังนี้:

หรืออาจมีความสับสนในการตัดสิน:

ให้ศูนย์ = new Number(0);if (ศูนย์) { // ศูนย์เป็นจริงเนื่องจากเป็นวัตถุ console.log('true');}

ผลการเรียกใช้โค้ดจะเป็นดังนี้ ดังต่อไปนี้:

ในเวลาเดียวกัน อย่าลืมว่าฟังก์ชัน String/Number/Boolean ที่ไม่มี new (คำหลัก) สามารถแปลงค่าเป็นประเภทที่สอดคล้องกันได้: เป็นสตริง ตัวเลข หรือค่าบูลีน (ประเภทดั้งเดิม)

ตัวอย่างเช่น:

console.log(typeof Number('123'));

หมายเหตุ:

ทั้งสองประเภท null และ undefined ไม่มีวิธีการใด ๆ

ในส่วนนี้

1. ประเภทพื้นฐานอื่นที่ไม่ใช่ null และ undefined จะมีวิธีการที่มีประโยชน์

2. JavaScript วิธีการปรับใช้ที่ถูกบุกรุก แต่ได้รับผลลัพธ์ที่น่าพึงพอใจ โดยตระหนักถึงคุณลักษณะและการเรียกเมธอดของประเภทพื้นฐานด้วยต้นทุนที่ต่ำกว่า

[คำแนะนำที่เกี่ยวข้อง: วิดีโอสอน JavaScript, ส่วนหน้าของเว็บ]

ข้างต้นคือวิธีที่ JavaScript ตระหนักดีว่าประเภทพื้นฐานมีความเหมือนกัน คุณลักษณะและวัตถุเป็นวัตถุ สำหรับรายละเอียดของวิธีการโปรดใส่ใจกับบทความอื่น ๆ ที่เกี่ยวข้องในเครือข่ายรหัสที่มาสำหรับข้อมูลเพิ่มเติม!