ตอนนี้แพลตฟอร์มมาพร้อมกับ structuredClone() ซึ่งเป็นฟังก์ชันในตัวสำหรับการคัดลอกแบบลึก
เป็นเวลานานแล้วที่คุณต้องใช้วิธีแก้ปัญหาชั่วคราวและไลบรารีเพื่อสร้างสำเนาเชิงลึกของค่า JavaScript ตอนนี้แพลตฟอร์มมาพร้อมกับ structuredClone() ซึ่งเป็นฟังก์ชันในตัวสำหรับการคัดลอกแบบลึก
สำเนาแบบตื้น
การคัดลอกค่าใน JavaScript มักจะเป็นแบบตื้นเสมอ ซึ่งตรงข้ามกับแบบลึก ซึ่งหมายความว่าการเปลี่ยนแปลงค่าที่ฝังลึกจะปรากฏในสำเนาและต้นฉบับด้วย
วิธีหนึ่งในการสร้างสำเนาแบบตื้นใน JavaScript โดยใช้โอเปอเรเตอร์สเปรดออบเจ็กต์ ...:
const myOriginal = {
someProp: "with a string value",
anotherProp: {
withAnotherProp: 1,
andAnotherProp: true
}
};
const myShallowCopy = {...myOriginal};
การเพิ่มหรือเปลี่ยนพร็อพเพอร์ตี้ในสำเนาแบบตื้นโดยตรงจะส่งผลต่อสำเนาเท่านั้น ไม่ใช่ต้นฉบับ
myShallowCopy.aNewProp = "a new value";
console.log(myOriginal.aNewProp)
// ^ logs `undefined`
อย่างไรก็ตาม การเพิ่มหรือเปลี่ยนแปลงพร็อพเพอร์ตี้ที่ซ้อนกันหลายชั้นจะส่งผลต่อทั้งสำเนาและต้นฉบับ ดังนี้
myShallowCopy.anotherProp.aNewProp = "a new value";
console.log(myOriginal.anotherProp.aNewProp)
// ^ logs `a new value`
นิพจน์ {...myOriginal} จะทำซ้ำพร็อพเพอร์ตี้ (ที่แจกแจงได้) ของ myOriginal โดยใช้ Spread Operator โดยจะใช้ชื่อและค่าพร็อพเพอร์ตี้ แล้วกำหนดค่าเหล่านั้นทีละรายการให้กับออบเจ็กต์ว่างที่สร้างขึ้นใหม่ ดังนั้น ออบเจ็กต์ที่ได้จึงมีรูปร่างเหมือนกัน แต่มีสำเนารายการพร็อพเพอร์ตี้และค่าของตัวเอง ระบบจะคัดลอกค่าด้วย แต่ค่าที่เรียกว่าค่าพื้นฐานจะได้รับการจัดการโดยค่า JavaScript แตกต่างจากค่าที่ไม่ใช่ค่าพื้นฐาน หากต้องการอ้างอิง MDN ให้ทำดังนี้
ใน JavaScript ข้อมูลพื้นฐาน (ค่าพื้นฐาน ประเภทข้อมูลพื้นฐาน) คือข้อมูลที่ไม่ใช่ออบเจ็กต์และไม่มีเมธอด ข้อมูลพื้นฐานมี 7 ประเภท ได้แก่ สตริง, ตัวเลข, BigInt, บูลีน, ไม่ได้กำหนด, สัญลักษณ์ และ Null
MDN — Primitive
ระบบจะจัดการค่าที่ไม่ใช่ค่าพื้นฐานเป็นการอ้างอิง ซึ่งหมายความว่าการคัดลอกค่าเป็นเพียงการคัดลอกการอ้างอิงไปยังออบเจ็กต์พื้นฐานเดียวกัน ซึ่งส่งผลให้เกิดลักษณะการทำงานของการคัดลอกแบบตื้น
สำเนาแบบ Deep Copy
การคัดลอกแบบตื้นจะตรงข้ามกับการคัดลอกแบบลึก อัลกอริทึมการคัดลอกแบบลึกจะคัดลอกพร็อพเพอร์ตี้ของออบเจ็กต์ทีละรายการด้วย แต่จะเรียกใช้ตัวเองซ้ำเมื่อพบการอ้างอิงไปยังออบเจ็กต์อื่น ซึ่งจะสร้างสำเนาของออบเจ็กต์นั้นด้วย ซึ่งอาจมีความสำคัญอย่างยิ่งในการตรวจสอบว่าโค้ด 2 ส่วนไม่ได้แชร์ออบเจ็กต์โดยไม่ตั้งใจและจัดการสถานะของกันและกันโดยไม่รู้ตัว
ก่อนหน้านี้ไม่มีวิธีที่ง่ายหรือดีในการสร้างสำเนาเชิงลึกของค่าใน JavaScript หลายคนใช้ไลบรารีของบุคคลที่สาม เช่น ฟังก์ชัน cloneDeep() ของ Lodash วิธีแก้ปัญหาที่พบบ่อยที่สุดสำหรับปัญหานี้คือการแฮ็กที่ใช้ JSON ดังนี้
const myDeepCopy = JSON.parse(JSON.stringify(myOriginal));
อันที่จริง วิธีแก้ปัญหานี้ได้รับความนิยมมากจน V8 ได้เพิ่มประสิทธิภาพ JSON.parse() และรูปแบบข้างต้นอย่างจริงจังเพื่อให้ทำงานได้เร็วที่สุด แม้ว่าวิธีนี้จะรวดเร็ว แต่ก็มีข้อเสียและข้อควรระวังบางประการ ดังนี้
- โครงสร้างข้อมูลแบบเรียกซ้ำ:
JSON.stringify()จะแสดงข้อผิดพลาดเมื่อคุณให้โครงสร้างข้อมูลแบบเรียกซ้ำ ซึ่งอาจเกิดขึ้นได้ง่ายเมื่อทำงานกับรายการหรือโครงสร้างแบบต้นไม้ที่ลิงก์กัน - ประเภทในตัว:
JSON.stringify()จะแสดงข้อผิดพลาดหากค่ามี JS ในตัวอื่นๆ เช่นMap,Set,Date,RegExpหรือArrayBuffer - ฟังก์ชัน:
JSON.stringify()จะทิ้งฟังก์ชันโดยไม่แจ้งให้ทราบ
การโคลนแบบมีโครงสร้าง
แพลตฟอร์มจำเป็นต้องมีความสามารถในการสร้างสำเนาเชิงลึกของค่า JavaScript ในบางตำแหน่งอยู่แล้ว เช่น การจัดเก็บค่า JS ใน IndexedDB ต้องใช้การทำให้เป็นอนุกรมบางรูปแบบเพื่อให้จัดเก็บในดิสก์ได้ และทำการดีซีเรียลไลซ์ในภายหลังเพื่อกู้คืนค่า JS ในทำนองเดียวกัน การส่งข้อความไปยัง WebWorker ผ่าน postMessage() ต้องมีการโอนค่า JS จากขอบเขต JS หนึ่งไปยังอีกขอบเขตหนึ่ง อัลกอริทึมที่ใช้สำหรับกรณีนี้เรียกว่า "Structured Clone" และจนกระทั่งเมื่อไม่นานมานี้ นักพัฒนาซอฟต์แวร์ยังเข้าถึงได้ไม่ง่ายนัก
แต่ตอนนี้ได้เปลี่ยนไปแล้ว ข้อกำหนด HTML ได้รับการแก้ไขเพื่อแสดงฟังก์ชันที่ชื่อว่า structuredClone() ซึ่งเรียกใช้อัลกอริทึมดังกล่าวเพื่อให้นักพัฒนาซอฟต์แวร์สร้างสำเนาเชิงลึกของค่า JavaScript ได้อย่างง่ายดาย
const myDeepCopy = structuredClone(myOriginal);
เท่านี้ก็เรียบร้อย นั่นคือ API ทั้งหมด หากต้องการเจาะลึกรายละเอียดเพิ่มเติม โปรดดูบทความ MDN
ฟีเจอร์และข้อจำกัด
การโคลนแบบมีโครงสร้างช่วยแก้ข้อบกพร่องหลายอย่าง (แต่ไม่ใช่ทั้งหมด) ของเทคนิค JSON.stringify() การโคลนแบบมีโครงสร้างสามารถจัดการโครงสร้างข้อมูลแบบวนซ้ำ รองรับประเภทข้อมูลในตัวหลายประเภท และโดยทั่วไปแล้วจะมีประสิทธิภาพมากกว่าและมักจะเร็วกว่า
อย่างไรก็ตาม ฟีเจอร์นี้ยังมีข้อจำกัดบางอย่างที่คุณอาจไม่ทันตั้งตัว ดังนี้
- ต้นแบบ: หากใช้
structuredClone()กับอินสแตนซ์คลาส คุณจะได้รับออบเจ็กต์ธรรมดาเป็นค่าที่แสดงผล เนื่องจากโคลนที่มีโครงสร้างจะทิ้งเชนต้นแบบของออบเจ็กต์ - ฟังก์ชัน: หากออบเจ็กต์มีฟังก์ชัน
structuredClone()จะแสดงข้อยกเว้นDataCloneError - โคลนไม่ได้: ค่าบางค่าไม่สามารถโคลนแบบมีโครงสร้างได้ โดยเฉพาะ
Errorและโหนด DOM ซึ่งจะทำให้structuredClone()แสดงข้อผิดพลาด
หากข้อจำกัดเหล่านี้เป็นอุปสรรคต่อกรณีการใช้งานของคุณ ไลบรารีอย่าง Lodash ยังคงมีการใช้งานอัลกอริทึมการโคลนเชิงลึกอื่นๆ ที่กำหนดเองซึ่งอาจเหมาะหรือไม่เหมาะกับกรณีการใช้งานของคุณ
ประสิทธิภาพ
แม้ว่าฉันจะไม่ได้ทำการเปรียบเทียบไมโครเบนช์มาร์กใหม่ แต่ฉันได้ทำการเปรียบเทียบในช่วงต้นปี 2018 ก่อนที่จะมีการเปิดเผย structuredClone() ในตอนนั้น JSON.parse() เป็นตัวเลือกที่เร็วที่สุดสำหรับวัตถุขนาดเล็กมาก เราคาดว่าสถานการณ์จะยังคงเป็นเช่นนี้ต่อไป เทคนิคที่อาศัยการโคลนแบบมีโครงสร้างจะเร็วกว่า (อย่างมาก) สำหรับออบเจ็กต์ขนาดใหญ่ เมื่อพิจารณาว่า structuredClone() ใหม่มาโดยไม่มีค่าใช้จ่ายเพิ่มเติมในการละเมิด API อื่นๆ และมีประสิทธิภาพมากกว่า JSON.parse() เราขอแนะนำให้คุณใช้เป็นแนวทางเริ่มต้นในการสร้างสำเนาแบบ Deep Copy
บทสรุป
หากต้องการสร้างสำเนาเชิงลึกของค่าใน JS (อาจเป็นเพราะคุณใช้โครงสร้างข้อมูลที่เปลี่ยนแปลงไม่ได้หรือต้องการตรวจสอบว่าฟังก์ชันสามารถจัดการออบเจ็กต์ได้โดยไม่ส่งผลกระทบต่อออบเจ็กต์เดิม) คุณไม่จำเป็นต้องใช้วิธีแก้ปัญหาชั่วคราวหรือไลบรารีอีกต่อไป ตอนนี้ระบบนิเวศ JS มี structuredClone() แล้ว ไชโย