คำอธิบายโดยละเอียดเกี่ยวกับประเภทสัญลักษณ์ของ JavaScript คุณลักษณะที่ซ่อนอยู่ และการลงทะเบียนส่วนกลาง

รู้เบื้องต้นเกี่ยวกับสัญลักษณ์

ประเภท Symbol เป็นประเภทพิเศษใน JavaScript โดยเฉพาะค่าประเภท Symbol ทั้งหมดจะแตกต่างกัน เราสามารถใช้ "Symbol" เพื่อแสดงค่าที่ไม่ซ้ำใครได้ ต่อไปนี้เป็นตัวอย่างของการสร้างอ็อบเจ็กต์ Symbol :

ให้ id = Symbol();

ด้วยวิธีนี้ เราสร้างค่าประเภท Symbol และเก็บค่านี้ไว้ในตัวแปร id

คำอธิบายประเภทสัญลักษณ์

เมื่อเราสร้างตัวแปรประเภท Symbol เราสามารถส่งผ่านสตริงบางตัวพร้อมกับแอตทริบิวต์วินาทีในพารามิเตอร์เพื่ออธิบายข้อมูลวัตถุประสงค์ของตัวแปรนี้ได้
ตัวอย่างเช่น:

ให้ id1 = Symbol('Id ของเสี่ยวหมิงผู้บ้าคลั่งและเท่');
la id2 = Symbol('รหัสของ Tingting แบบคีย์ต่ำ หรูหรา และมีความหมายแฝง');

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

ให้ id1 = สัญลักษณ์('id');
ให้ id2 = สัญลักษณ์('id');
console.log(id1==id2);//

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

สัญลักษณ์ไม่ได้แปลงเป็นสตริงโดยปริยาย

ประเภทส่วนใหญ่ใน JavaScript สามารถแปลงเป็นประเภทสตริงได้โดยตรงสำหรับเอาต์พุต ดังนั้นเราจึงไม่สามารถเห็นค่าของมันได้โดยสัญชาตญาณ ตัวอย่างเช่น เราสามารถใช้ alert(123) เพื่อแปลงตัวเลข 123 ได้โดยตรง แปลงเป็นป๊อปอัปสตริง
อย่างไรก็ตาม ประเภท Symbol เป็นประเภทพิเศษและไม่สามารถแปลงได้โดยตรง เช่น

ให้ id = Symbol();
alert(id);//รายงานข้อผิดพลาด ประเภทสัญลักษณ์ไม่สามารถแปลง

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

ลองนึกภาพว่าหาก Symbol สามารถแปลงเป็นสตริงได้ ก็จะกลายเป็นฟังก์ชันที่สร้างสตริงเฉพาะ และไม่จำเป็นต้องมีชนิดข้อมูลอิสระ

หากเราต้องการทราบค่าของตัวแปร Symbol จริงๆ เราสามารถใช้เมธอด .toString() ได้ดังนี้:

ให้ id = Symbol('this is Identification');
console.log(id.toString());//Symbol(นี่คือการระบุตัวตน);

หรือใช้แอตทริบิวต์ .description เพื่อรับข้อมูลคำอธิบาย:

ให้ id = Symbol('เอาน่า ให้ฉัน Oli');
console.log(id.description);//Come on, Ollie”

Symbol คล้ายกับคีย์คุณสมบัติของอ็อบเจ็กต์

ตามข้อกำหนด JavaScript มีเพียงสองค่าเท่านั้นที่สามารถใช้เป็นคีย์คุณสมบัติของอ็อบเจ็กต์ได้:

1. สัญลักษณ์
2. สตริง

If มีการใช้ประเภทอื่น โดยจะถูกแปลงเป็นประเภทสตริงโดยปริยาย คีย์ของออบเจ็กต์จะถูกแนะนำโดยละเอียดในบทที่แล้ว และจะไม่ถูกทำซ้ำที่นี่

มีสอง Symbol

ในการสร้างคีย์สัญลักษณ์

ตัวอย่างที่ 1:

ให้ id = Symbol('id');
ให้ผู้ใช้ = {};
user[id] = 'id value';//เพิ่มคีย์สัญลักษณ์ console.log(user[id]);//id value

ตัวอย่างที่ 2:

ให้ id = Symbol('id');
ให้ผู้ใช้ = {
	[id]:'id value',//สังเกตวงเล็บเหลี่ยมที่นี่	
-
console.log(user[id]);

สองกรณีข้างต้นแสดงการใช้การแทรกประเภท Symbol เป็นคีย์ในวัตถุ ควรสังเกตว่าเมื่อเข้าถึงแอตทริบิวต์คุณต้องใช้ obj[id] แทน obj.id เพราะ obj.id แสดงถึง obj['id']

จะเกิดอะไรขึ้นหากเราใช้ Symbol เป็นกุญแจของวัตถุ?

ที่ถูกข้าม

Symbol for...in คือถ้าวัตถุใช้ Symbol เป็นคีย์ คุณสมบัติประเภท Symbol จะไม่สามารถเข้าถึงได้โดยใช้คำสั่ง for…in

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

ให้ id = Symbol('id');
ให้ผู้ใช้ = {
	ชื่อ'เสี่ยวหมิง'
	[id] : 'id',
-
สำหรับ (ให้ป้อนผู้ใช้) console.log(user[key]);

ดำเนินการโค้ดด้านบนและรับผลลัพธ์ต่อไปนี้:

> Xiaoming

จะพบว่าค่าของวัตถุ [id] ไม่ได้ถูกพิมพ์ออกมา ซึ่งบ่งชี้ว่าในวัตถุ รายการแอตทริบิวต์ ใช้ for … in จะละเว้นคีย์ประเภท Symbol โดยอัตโนมัติ

ในทำนองเดียวกัน Object.keys(user) จะละเว้นคีย์ประเภท Symbol ทั้งหมด

คุณลักษณะนี้สามารถให้ผลที่เป็นประโยชน์มากได้ เช่น เราสามารถสร้างคุณสมบัติที่มีเพียงเราเท่านั้นที่สามารถใช้ได้

แม้ว่าเราจะไม่มีทางรับคีย์ Symbol โดยตรง แต่เมธอด Object.assign สามารถคัดลอกคุณสมบัติทั้งหมดได้:

ให้ id = Symbol();
ให้ obj = {
    [id] : '123'
-

ให้ obj2 = Object.assign({},obj);
console.log(obj2[id]);

สิ่งนี้ไม่ส่งผลกระทบต่อคุณสมบัติที่ซ่อนอยู่ของ Symbol เนื่องจากวัตถุที่คัดลอกยังคงไม่สามารถรับคีย์ Symbol ได้

การซ่อนแอตทริบิวต์ที่กำหนดเอง

เนื่องจาก Symbol ไม่สามารถแปลงเป็นสตริงได้โดยตรง เราจึงไม่มีวิธีรับค่าของมันโดยสัญชาตญาณ และเราไม่สามารถรับแอตทริบิวต์ Symbol ของออบเจ็กต์ผ่านทาง for … in ได้ กล่าวอีกนัยหนึ่ง หากไม่มีตัวแปร Symbol เอง เราไม่มีทางรับคุณสมบัติที่เกี่ยวข้องภายในวัตถุได้

ดังนั้นด้วยค่าคีย์ของประเภท Symbol เราสามารถซ่อนคุณสมบัติเหล่านี้ได้เพียงตัวเราเองเท่านั้น และไม่มีใครสามารถเห็นคุณสมบัติของเราได้

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

ในระหว่างกระบวนการพัฒนา เราจำเป็นต้องร่วมมือกับเพื่อนร่วมงานของเรา "จางซาน" และจางซานคนนี้ได้สร้าง Tool ที่ใช้งานง่ายมาก Tool เป็นประเภทวัตถุ เราต้องการใช้ Tool ของจางซานฟรี และเพิ่มคุณสมบัติของคุณเองตามสิ่งนี้

เราสามารถเพิ่มคีย์ประเภท Symbol ได้:

Let tool = {//Tool เขียนโดย Zhang San
    การใช้งาน: "สามารถทำอะไรก็ได้",
-

ให้ชื่อ = สัญลักษณ์ ("เครื่องมือของฉัน obj");
tool[name] = "นี่คือเครื่องมือของฉัน";
console.log(tool[name]);

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

เหตุผลมีดังนี้

1. Object tool เป็นโค้ดที่เขียนโดยผู้อื่น โดยหลักการแล้ว เราไม่ควรแก้ไขโค้ดของผู้อื่น เนื่องจากจะทำให้เกิดความเสี่ยง
2. เพื่อหลีกเลี่ยงความขัดแย้งในการตั้งชื่อ หากเราใช้สตริงโดยตรง ก็มีแนวโน้มที่จะขัดแย้งกับโค้ดอื่นๆ

นั้น

1. แตก
2. Symbol Symbol
3. ผู้อื่นไม่สามารถเข้าถึงคีย์ประเภท Symbol ซึ่งหมายความว่าจะไม่ขัดแย้งกับรหัสของบุคคลอื่น

หากเราไม่ใช้ประเภท Symbol สถานการณ์ต่อไปนี้น่าจะเกิดขึ้น:

ให้ tool = {//Tool เขียนโดย Zhang San
    การใช้งาน: "สามารถทำอะไรก็ได้",
-

tool.usage = "บูมบูม";
console.log(tool.usage);

โค้ดด้านบนนำ "การใช้งาน" มาใช้ซ้ำ และเขียนแอตทริบิวต์ดั้งเดิมใหม่ ซึ่งจะทำให้ฟังก์ชันดั้งเดิมของอ็อบเจ็กต์ผิดปกติ

Symbol Global Registry

ตัวแปร Symbol ทั้งหมดจะแตกต่างกัน แม้ว่าจะมีป้ายกำกับเดียวกัน (คำอธิบาย)
บางครั้งเราต้องการเข้าถึงวัตถุ Symbol เดียวกันผ่านชื่อสตริง (ป้ายกำกับ) ตัวอย่างเช่น เราเข้าถึง Symbol เดียวกันในตำแหน่งที่แตกต่างกันในโค้ด

JavaScript รักษารีจิสทรี Symbol ทั่วโลก เราสามารถเข้าถึงวัตถุได้โดยการแทรกวัตถุ Symbol ลงในรีจิสทรีและตั้งชื่อสตริงให้กับวัตถุ

หากต้องการแทรกหรืออ่านวัตถุ Symbol ลงในรีจิสทรี คุณต้องใช้วิธี Symbol.for(key) หากมีวัตถุชื่อ key ในรีจิสทรี วัตถุนั้นจะถูกส่งกลับ มิฉะนั้น วัตถุใหม่จะถูกแทรกและ กลับมา

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

ให้ id1 = Symbol.for('id');//ไม่มีสัญลักษณ์ชื่อ id ในรีจิสทรี, สร้างและส่งกลับ ให้ id2 = Symbol.for('id');//มีสัญลักษณ์ชื่ออยู่แล้ว id ในรีจิสทรี สำหรับสัญลักษณ์ที่มี id ให้ส่งคืน console.log(id1===id2);//true โดยตรง

เราสามารถใช้วัตถุ Symbol เป็น Symbol.for(key) ส่วนกลางและใช้สตริงเพื่อ ทำเครื่องหมายชื่อของวัตถุ

ในทางตรงกันข้าม เรายังสามารถใช้ Symbol.keyFor(Symbol) เพื่อรับชื่อจากอ็อบเจ็กต์แบบย้อนกลับได้

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

la id = Symbol.for('id');//ไม่มีสัญลักษณ์ชื่อ id ในรีจิสทรี ให้สร้างและส่งกลับ la name = Symbol.keyFor(id);
console.log(name);//id

Symbol.keyFor() ฟังก์ชันสามารถใช้ได้กับวัตถุ Symbol ส่วนกลางเท่านั้น (วัตถุที่แทรกโดยใช้ Symbol.for ) หากใช้กับวัตถุที่ไม่ใช่ส่วนกลาง มันจะส่งคืน undefined

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

ให้ id = Symbol('id');//local Symbol
ให้ชื่อ = Symbol.keyFor(id);
console.log(name);//unknown

system Symbol

JavaScript มี Symbol ระบบมากมาย เช่น:

• Symbol.hasInstance
• Symbol.iterator
• Symbol.toPrimitive

พวกมันมีการใช้งานของตัวเอง เราจะค่อยๆ แนะนำตัวแปรเฉพาะเหล่านี้ในภายหลัง

สรุป

1. ค่าของวัตถุ Symbol นั้นไม่ซ้ำกัน
2. Symbol สามารถเพิ่มป้ายกำกับและสอบถามเอนทิตีของวัตถุในการลงทะเบียนส่วนกลางผ่านป้ายกำกับ
3. สัญลักษณ์
4. Symbol ไม่สามารถตรวจพบคีย์ของวัตถุ for … in ;
5. การลงทะเบียนส่วนกลางผ่าน Symbol วัตถุ Global Symbol

อย่างไรก็ตาม Symbol ไม่ได้ถูกซ่อนไว้อย่างสมบูรณ์ เราสามารถรับ Symbol ทั้งหมดของวัตถุผ่าน Object.getOwnPropertySymbols(obj) หรือรับคีย์ทั้งหมดของวัตถุผ่าน Reflect.ownKeys(obj) .