คำอธิบายโดยละเอียดเกี่ยวกับการแมปที่อ่อนแอของ JavaScript และความรู้ในการรวบรวมที่อ่อนแอ

พูดง่ายๆ ก็คือ หากตัวแปรหรืออ็อบเจ็กต์ "ไม่สามารถเข้าถึงได้" ก็ไม่จำเป็นต้องให้ตัวแปรหรืออ็อบเจ็กต์นั้นถูกจัดเก็บไว้ในหน่วยความจำต่อไป และควรนำกลับมาใช้ใหม่

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

ให้ xiaoming = {name:'xiaoming'}//สร้างวัตถุและใช้ตัวแปร xiaoming เพื่ออ้างอิง xiaoming = null //ทำให้ตัวแปร xiaoming ว่างเปล่า ทำให้วัตถุ {name:'xiaoming'} ไม่สามารถเข้าถึงได้//{ name:'xiaoming'} วัตถุถูกรีไซเคิล

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

วัตถุในอาร์เรย์:

ให้ xiaoming = {name:'xiaoming'}
ให้ arr = [เสี่ยวหมิง]
xiaoming = null //ทำให้ตัวแปร xiaoming ว่างเปล่า //วัตถุ {name:'xiaoming'} จะไม่ถูกปล่อยออกมาเนื่องจากมีอยู่ในอาร์เรย์

ในทำนองเดียวกัน หากเราใช้วัตถุเป็นคีย์ของ Map ถ้ามี Map อยู่ แล้ววัตถุนั้นจะไม่ถูกนำกลับมาใช้ใหม่โดยเครื่องยนต์

วัตถุหลักใน Map :

ให้ xiaoming = {name:'xiaoming'}
ให้ map = new Map()
map.set (เสี่ยวหมิง 'เด็กชาย')
xiaoming = null //ทำให้ตัวแปร xiaoming ว่างเปล่า //วัตถุ {name:'xiaoming'} จะไม่ถูกปล่อยออกมาเนื่องจากเป็นคีย์ของแผนที่

โดยพื้นฐานแล้ว WeapMap จะแตกต่างจาก Map ในการประมวลผลของการปล่อยวัตถุหลัก เพียง , , WeapMap จะไม่ป้องกันการรวบรวมขยะเนื่องจากวัตถุเป็นกุญแจ

WeakMap

ความแตกต่างระหว่าง WeakMap และ Map สามารถแบ่งออกได้เป็น 3 ด้าน คือ

1. WeakMap สามารถใช้วัตถุเป็นคีย์ได้เท่านั้น

ให้weakMap = new WeakMap()
ให้ obj = {ชื่อ:'obj'}
อ่อนแอMap.set(obj,'obj เป็นกุญแจ')
อ่อนแอMap.set('str','str as the key')//

ผลการดำเนินการโค้ดข้อผิดพลาดเป็นดังนี้:

จะเห็นได้ว่าเมื่อเราใช้ strings เป็น key โปรแกรมจะไม่สามารถทำงานได้ตามปกติ

2. ไม่ได้ป้องกันเครื่องยนต์จากการรีไซเคิลคีย์ (วัตถุ)

กล่าวอีกนัยหนึ่งถ้าวัตถุไม่มีการอ้างอิงอื่น ๆ ยกเว้นการอ้างอิง WeakMap จากนั้นระบบจะรีไซเคิลวัตถุนั้น

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

ให้อ่อนแอMap = ใหม่ WeakMap()
ให้ obj = {ชื่อ:'obj'}
อ่อนแอMap.set(obj,'obj เป็นกุญแจ')
obj = null //ทำให้ตัวแปร obj ว่างเปล่า //ในขณะนี้ วัตถุ {name:'obj'} จะถูกรีไซเคิล

3. WeakMap รองรับวิธีการที่จำกัด

• WeakMap ไม่รองรับการวนซ้ำ
• WeakMap ไม่รองรับ keys()
• WeakMap ไม่รองรับ values()
• WeakMap ไม่รองรับ entires()

ดังนั้นเราจึงไม่มีทางรับคู่คีย์-ค่าทั้งหมดได้

WeakMap สามารถใช้วิธีการต่อไปนี้เท่านั้น:

• weakMap.get(key) รับคู่คีย์-ค่า
• weakMap.set(key,val) ตั้งค่าคู่คีย์-ค่า
• weakMap.delete(key) ลบคู่คีย์-ค่า
• weakMap.has(key) ตรวจสอบว่ามี

อยู่จริงหรือไม่ ต้องจำกัดวิธีการเข้าถึงข้อมูลของ WeakMap เนื่องจากไม่สามารถกำหนดเวลาของเอ็นจิ้น JavaScript ที่ปล่อยออบเจ็กต์ได้

เมื่อวัตถุสูญเสียการอ้างอิงทั้งหมด กลไก JavaScript อาจปล่อยพื้นที่ที่วัตถุครอบครองทันที หรืออาจรอสักครู่

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

กรณีการใช้งาน WeakMap

สถานการณ์การใช้งานของ WeakMap มักจะเก็บข้อมูลที่ "เป็น" ของวัตถุ เมื่อมีข้อมูล "ที่เป็น" ของออบเจ็กต์นี้ควรได้รับการเผยแพร่ด้วย

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

หากเราอธิบายเรื่องราวนี้ด้วยโค้ด JavaScript เราควรใช้ WeakMap :

ให้weakMap = new WeakMap()
ให้กระต่าย = {ชื่อ:'rabbit'} // กระต่ายเจ้าเล่ห์ ให้ runDog = {ชื่อ: 'runDog'} // สุนัขวิ่ง ให้ flyBird = {ชื่อ: 'flyBird'} // นกบิน ให้ goodBow = {ชื่อ :'goodBow'} //เหลียงกงweakMap.set(rabbit,runDog)
อ่อนแอMap.set(flyBird,goodBow)

rabbit = null //กระต่ายเจ้าเล่ห์ตาย flyBird = null //นกจากไปแล้ว//อีกไม่นานลูกน้องและธนูที่ดีจะออกอาจจะไม่ทันที // เรื่องนี้บอกเราว่าการเป็น a ไม่มีจุดจบที่ดี ขี้ข้าอาจจะไม่ถูกฆ่าโดยทันที แต่จะถูกฆ่าไม่ช้าก็เร็ว

WeakSet

Set WeakSet แตกต่างดังต่อไปนี้:

1. WeakSet สามารถเพิ่มองค์ประกอบอ็อบเจ็กต์ได้เท่านั้น
2. WeakSet add()
3. WeakSet ป้องกันระบบจากการรีไซเคิลองค์ประกอบ
4. add() , has() , delete()
5. WeakSet ไม่รองรับแอตทริบิวต์ size และเมธอด keys()

เราสามารถใช้ WeakMap เพื่อตรวจสอบข้อมูลที่มีอยู่บางส่วน หรือตรวจสอบสถานะ เช่น "ใช่/ไม่ใช่" ตัวอย่างเช่น เราสามารถใช้ WeakMap เพื่อตรวจสอบว่าผู้ใช้ออนไลน์อยู่หรือไม่:

ให้ onlineUser = new WeakMap()
ให้ zhangSan = {ชื่อ:'Zhang San'}
ให้ ลีซี่ = {ชื่อ:'李思'}
ให้ wangEr = {ชื่อ:'王二'}
ให้ maZi = {ชื่อ:'Mazi'}

ฟังก์ชั่นเข้าสู่ระบบ (ผู้ใช้) {
    -
    onlineUser.add(ผู้ใช้)
-

//ตรวจสอบว่าผู้ใช้ออนไลน์อยู่หรือไม่ ฟังก์ชัน isOnline(user){
    ส่งคืน onlineUser.has (ผู้ใช้)
}

ข้อจำกัดของ WeakMap และ WeakSet คือไม่สามารถวนซ้ำและรับองค์ประกอบทั้งหมดในคราวเดียว ซึ่งไม่ส่งผลกระทบต่อบทบาทที่สำคัญในตำแหน่งที่สำคัญมาก

สรุป

1. WeakMap สามารถใช้วัตถุเป็นคีย์เท่านั้น เมื่อการอ้างอิงภายนอกทั้งหมดไปยังคีย์หายไป (ไม่มีตัวแปรอื่น ๆ ยกเว้น WeakMap อ้างถึงวัตถุคีย์) WeakMap จะไม่ป้องกันกลไกจากการรีไซเคิลค่าคีย์ เมื่อรีไซเคิลแล้ว องค์ประกอบที่เกี่ยวข้องของ WeakMap จะไม่มีอยู่อีกต่อไป
2. WeakSet สามารถจัดเก็บได้เฉพาะวัตถุเท่านั้น เมื่อองค์ประกอบวัตถุสูญเสียการอ้างอิงภายนอกทั้งหมด (ยกเว้น WeakSet จะไม่มีตัวแปรอื่นอ้างอิงถึงวัตถุองค์ประกอบ) WeakSet จะไม่ป้องกันกลไกจากการรีไซเคิลองค์ประกอบ เมื่อรีไซเคิลแล้ว องค์ประกอบที่เกี่ยวข้องใน WeakSet จะหายไป
3. ข้อได้เปรียบทั่วไปคือสามารถลดขนาดหน่วยความจำของอ็อบเจ็กต์ในสถานการณ์ที่เหมาะสมได้
4. ไม่รองรับวิธีการเช่น clear() , size , keys() values()

WeakMap และ WeakSet มักจะใช้เพื่อจัดเก็บโครงสร้างข้อมูลที่เกี่ยวข้องกับวัตถุ "main" เมื่อวัตถุ "main" สูญเสียความหมายไป โครงสร้างข้อมูลที่เกี่ยวข้องจะถูกลบออกตามธรรมชาติ