การคัดลอกเนื้อหาใน JavaScript โดยใช้ StructuredClone

ตอนนี้แพลตฟอร์มมาพร้อมกับ structuredClone() ซึ่งเป็นฟังก์ชันในตัวสำหรับการคัดลอกแบบลึก

เป็นเวลานานแล้วที่คุณต้องใช้วิธีแก้ปัญหาชั่วคราวและไลบรารีเพื่อสร้างสำเนาเชิงลึกของค่า JavaScript ตอนนี้แพลตฟอร์มมาพร้อมกับ structuredClone() ซึ่งเป็นฟังก์ชันในตัวสำหรับการคัดลอกแบบลึก

Browser Support

  • Chrome: 98.
  • Edge: 98.
  • Firefox: 94.
  • Safari: 15.4.

Source

สำเนาแบบตื้น

การคัดลอกค่าใน 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() แล้ว ไชโย