ในการคำนวณ การทำให้เป็นอนุกรม (หรือserialisationซึ่งเรียกอีกอย่างว่าpicklingในPython ) คือกระบวนการแปลงโครงสร้างข้อมูลหรือ สถานะ ของวัตถุให้เป็นรูปแบบที่สามารถจัดเก็บ (เช่นไฟล์ในอุปกรณ์จัดเก็บข้อมูลรองบัฟเฟอร์ข้อมูลในอุปกรณ์จัดเก็บข้อมูลหลัก) หรือส่งผ่าน (เช่นสตรีมข้อมูลผ่านเครือข่ายคอมพิวเตอร์ ) และสร้างขึ้นใหม่ในภายหลัง (อาจอยู่ในสภาพแวดล้อมคอมพิวเตอร์ที่แตกต่างกัน) ^{[ 1 ]}เมื่ออ่านชุดบิตที่ได้ใหม่ตามรูปแบบการทำให้เป็นอนุกรมแล้ว ก็สามารถใช้สร้างโคลนที่มีความหมายเหมือนกันของวัตถุเดิมได้ สำหรับวัตถุที่ซับซ้อนหลายอย่าง เช่น วัตถุที่ใช้การอ้างอิง อย่างกว้างขวาง กระบวนการนี้ไม่ใช่เรื่องง่าย การทำให้เป็นอนุกรมของวัตถุ จะไม่รวม เมธอดที่เกี่ยวข้องใดๆที่เคยเชื่อมโยงไว้ก่อนหน้านี้

กระบวนการแปลงวัตถุเป็นอนุกรมนี้บางครั้ง ก็เรียกว่า marshalling ^{[ 2 ] [ 3 ] [ 4 ]}การดำเนินการตรงกันข้าม คือการดึงโครงสร้างข้อมูลจากชุดไบต์ เรียก ว่า deserialization (เรียกอีกอย่างว่าunserializationหรือunmarshalling )

ในฮาร์ดแวร์อุปกรณ์เครือข่าย ส่วนที่ทำหน้าที่แปลงข้อมูลเป็นรูปแบบอนุกรมและแปลงกลับเป็นรูปแบบอนุกรมนั้น โดยทั่วไปเรียกว่า SerDes

การใช้งานการจัดเรียงข้อมูลเป็นลำดับ (Serialization) ได้แก่:

• การถ่ายโอนข้อมูลผ่านสายไฟและเครือข่าย ( การส่งข้อความ )
• การจัดเก็บข้อมูล (ในฐานข้อมูลในฮาร์ดดิสก์ไดรฟ์ )
• การเรียกใช้ฟังก์ชันระยะไกลเช่น ในรูปแบบSOAP
• การกระจายวัตถุ โดยเฉพาะอย่างยิ่งในวิศวกรรมซอฟต์แวร์แบบใช้ส่วนประกอบเช่นCOM , CORBAเป็นต้น
• การตรวจจับการเปลี่ยนแปลงในข้อมูลที่เปลี่ยนแปลงตามเวลา

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

โดยพื้นฐานแล้ว รูปแบบการจัดเรียงข้อมูลใดๆ ก็ตามนั้น เนื่องจากการเข้ารหัสข้อมูลเป็นแบบอนุกรมตามนิยาม การดึงส่วนใดส่วนหนึ่งของโครงสร้างข้อมูลแบบอนุกรมจึงจำเป็นต้องอ่านวัตถุทั้งหมดตั้งแต่ต้นจนจบและสร้างขึ้นใหม่ ในหลายแอปพลิเคชัน ความเป็นเชิงเส้นนี้เป็นข้อดี เพราะช่วยให้สามารถใช้อินเทอร์เฟซ I/O ทั่วไปที่เรียบง่ายในการจัดเก็บและส่งต่อสถานะของวัตถุได้ ในแอปพลิเคชันที่ประสิทธิภาพสูงเป็นสิ่งสำคัญ การลงทุนความพยายามมากขึ้นในการจัดการกับโครงสร้างการจัดเก็บข้อมูลที่ซับซ้อนและไม่เป็นเชิงเส้นอาจเป็นเรื่องที่สมเหตุสมผล

แม้แต่ในเครื่องเดียว วัตถุ พอยเตอร์ แบบดั้งเดิม ก็เปราะบางเกินกว่าจะบันทึกได้ เพราะวัตถุที่พอยเตอร์ชี้ไปอาจถูกโหลดไปยังตำแหน่งอื่นในหน่วยความจำ เพื่อแก้ไขปัญหานี้ กระบวนการซีเรียลไลเซชันจึงมีขั้นตอนที่เรียกว่าการแปลงกลับ (unswizzling)หรือ การแปลงพอยเตอร์กลับ (pointer unswizzling ) ซึ่งการอ้างอิงพอยเตอร์โดยตรงจะถูกแปลงเป็นการอ้างอิงตามชื่อหรือตำแหน่ง กระบวนการดีซีเรียลไลเซชันมีขั้นตอนตรงกันข้ามที่เรียกว่าการแปลงพอยเตอร์ (pointer swizzling )

เนื่องจากทั้งการแปลงเป็นรูปแบบอนุกรม (serialization) และการแปลงกลับเป็นรูปแบบอนุกรม (deserialization) สามารถทำงานได้จากโค้ดส่วนกลาง (เช่น ฟังก์ชัน SerializeในMicrosoft Foundation Classes ) จึงเป็นไปได้ที่โค้ดส่วนกลางจะทำทั้งสองอย่างพร้อมกัน นั่นคือ 1) ตรวจจับความแตกต่างระหว่างวัตถุที่กำลังถูกแปลงเป็นรูปแบบอนุกรมกับสำเนาเดิม และ 2) ให้ข้อมูลสำหรับการตรวจจับครั้งต่อไป ไม่จำเป็นต้องสร้างสำเนาเดิมขึ้นมาจริง ๆ เพราะสามารถตรวจจับความแตกต่างได้แบบเรียลไทม์ ซึ่งเป็นเทคนิคที่เรียกว่า การประมวลผลแบบดิฟเฟอเรนเชียล (differential execution) เทคนิคนี้มีประโยชน์ในการเขียนโปรแกรมส่วนติดต่อผู้ใช้ที่มีเนื้อหาเปลี่ยนแปลงตามเวลา เช่น สามารถสร้าง ลบ แก้ไข หรือจัดการเหตุการณ์อินพุตให้กับวัตถุกราฟิกได้โดยไม่จำเป็นต้องเขียนโค้ดแยกต่างหากเพื่อทำสิ่งเหล่านั้น

การทำให้เป็นอนุกรมจะทำลายความทึบแสงของชนิดข้อมูลนามธรรมโดยอาจเปิดเผยรายละเอียดการใช้งานส่วนตัว การใช้งานแบบง่ายๆ ที่ทำให้สมาชิกข้อมูลทั้งหมดเป็นอนุกรมอาจละเมิดการห่อหุ้ม^{[ 5 ]}

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

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

เทคโนโลยีXerox Network Systems Courier ในช่วงต้นทศวรรษ 1980 มีอิทธิพลต่อมาตรฐานที่ได้รับการยอมรับอย่างกว้างขวางเป็นครั้งแรกSun Microsystemsได้เผยแพร่External Data Representation (XDR) ในปี 1987 ^{[ 6 ]} XDR เป็นรูปแบบเปิดและได้รับการกำหนดมาตรฐานเป็นSTD 67 (RFC 4506) โดย IETF

ในช่วงปลายทศวรรษ 1990 ความพยายามที่จะหาทางเลือกอื่นนอกเหนือจากโปรโตคอลการจัดเรียงข้อมูลแบบมาตรฐานได้เริ่มต้นขึ้น: XMLซึ่ง เป็นส่วนย่อยของ SGML ถูกนำมาใช้เพื่อสร้าง การเข้ารหัสแบบข้อความ ที่ มนุษย์อ่านได้การเข้ารหัสแบบนี้มีประโยชน์สำหรับวัตถุถาวรที่มนุษย์สามารถอ่านและเข้าใจได้ หรือสื่อสารไปยังระบบอื่น ๆ โดยไม่ขึ้นอยู่กับภาษาโปรแกรม ข้อเสียคือการสูญเสียความกะทัดรัดของการเข้ารหัสแบบสตรีมไบต์ แต่ในขณะนั้นความจุในการจัดเก็บและการส่งข้อมูลที่มากขึ้นทำให้ขนาดไฟล์ไม่ใช่ปัญหาใหญ่เหมือนในยุคแรก ๆ ของการคำนวณ ในช่วงทศวรรษ 2000 XML มักถูกใช้สำหรับการถ่ายโอนข้อมูลที่มีโครงสร้างแบบอะซิงโครนัสระหว่างไคลเอนต์และเซิร์ฟเวอร์ใน แอปพลิเคชันเว็บ Ajax XML เป็นรูปแบบเปิดและได้รับการกำหนดมาตรฐานตามคำแนะนำของ W3C

JSONเป็นรูปแบบข้อมูลข้อความธรรมดาที่มีน้ำหนักเบา เป็นทางเลือกแทน XML และนิยมใช้สำหรับการสื่อสารระหว่างไคลเอ็นต์และเซิร์ฟเวอร์ในแอปพลิเคชันเว็บ JSON มีพื้นฐานมาจากไวยากรณ์ของ JavaScriptแต่เป็นอิสระจาก JavaScript และได้รับการสนับสนุนในภาษาโปรแกรมอื่นๆ อีกมากมาย JSON ได้รับการกำหนดมาตรฐานเป็นSTD 90 ( RFC  8259 ), ECMA-404และISO/IEC 21778: 2017

YAMLเป็นส่วนขยายที่เข้มงวดของ JSON และมีคุณสมบัติเพิ่มเติม เช่น แท็กประเภทข้อมูล การรองรับโครงสร้างข้อมูลแบบวนซ้ำ ไวยากรณ์ที่คำนึงถึงการเว้นวรรค และรูปแบบการอ้างอิงข้อมูลแบบสเกลาร์หลายรูปแบบ YAML เป็นรูปแบบเปิด

รายการคุณสมบัติ (Property list)ถูกใช้สำหรับการแปลงข้อมูลเป็นรูปแบบที่สามารถอ่านได้โดยเฟรมเวิร์กNeXTSTEP , GNUstep , macOSและiOS รายการคุณสมบัติหรือ เรียกสั้น ๆ ว่า p-listไม่ได้หมายถึงรูปแบบการแปลงข้อมูลเพียงรูปแบบเดียว แต่หมายถึงรูปแบบที่แตกต่างกันหลายแบบ บางรูปแบบสามารถอ่านได้โดยมนุษย์ และบางรูปแบบเป็นข้อมูลไบนารี

สำหรับชุดข้อมูลทางวิทยาศาสตร์ที่มีปริมาณมาก เช่น ข้อมูลจากดาวเทียมและผลลัพธ์จากแบบจำลองสภาพภูมิอากาศ สภาพอากาศ หรือมหาสมุทรเชิงตัวเลข ได้มีการพัฒนามาตรฐานการแปลงข้อมูลเป็นไบนารีเฉพาะขึ้น เช่นHDF , netCDFและGRIBซึ่ง เป็นมาตรฐานเก่ากว่า

ภาษา โปรแกรมเชิงวัตถุหลายภาษาสนับสนุนการจัดเก็บข้อมูลวัตถุ (หรือการเก็บรักษาวัตถุ ) โดยตรง ไม่ว่าจะผ่าน ทางไวยากรณ์ที่ช่วยให้เขียน โปรแกรมได้ง่ายขึ้นหรือการจัดเตรียมอินเทอร์ เฟซมาตรฐาน สำหรับการทำเช่นนั้น ภาษาที่รองรับฟังก์ชันนี้ ได้แก่Ruby , Smalltalk , Python , PHP , Objective-C , Delphi , Javaและ ตระกูลภาษา . NETนอกจากนี้ยังมีไลบรารีที่เพิ่มการสนับสนุนการจัดเก็บข้อมูลวัตถุให้กับภาษาที่ไม่มีการรองรับโดยตรงอีกด้วย

ภาษา CและC++ไม่ได้จัดเตรียมการทำให้เป็นอนุกรม (serialization) เป็นโครงสร้างระดับสูงใดๆ แต่ทั้งสองภาษาสนับสนุนการเขียนประเภทข้อมูล ในตัวใดๆ รวมถึงโครงสร้างข้อมูลแบบเก่าๆ ให้เป็นข้อมูลไบนารี ดังนั้น การเขียนฟังก์ชันการทำให้เป็นอนุกรมแบบกำหนดเองจึงมักทำได้ง่าย นอกจากนี้ โซลูชันที่ใช้คอมไพเลอร์ เช่น ระบบ ODB ORMสำหรับ C++ และ ชุดเครื่องมือ gSOAPสำหรับ C และ C++ สามารถสร้างโค้ดการทำให้เป็นอนุกรมโดยอัตโนมัติโดยแทบไม่ต้องแก้ไขการประกาศคลาสเลย เฟรมเวิร์กการทำให้เป็นอนุกรมยอดนิยมอื่นๆ ได้แก่ Boost.Serialization ^{[ 7 ]}จากBoost Framework , เฟรมเวิร์ก S11n ^{[ 8 ]}และ Cereal ^{[ 9 ]}เฟรมเวิร์ก MFC (Microsoft) ยังมีวิธีการทำให้เป็นอนุกรมเป็นส่วนหนึ่งของสถาปัตยกรรม Document-View อีกด้วย

ด้วยการนำการเขียนโปรแกรมแบบสะท้อนกลับมาใช้ในC++26 การทำให้เป็นอนุกรมจึงง่ายขึ้นอย่างมาก การสะท้อนกลับช่วยให้สามารถแปลง JSONเป็นอนุกรมในเวลาคอมไพล์ได้ เช่นเป็นstructโครงสร้างที่สอดคล้องกัน^{[ 10 ]}

CFMLอนุญาตให้แปลงโครงสร้างข้อมูลเป็นWDDXโดยใช้<cfwddx>แท็ก และเป็นJSONโดยใช้ฟังก์ชัน SerializeJSON()

Delphiมีกลไกในตัวสำหรับการบันทึกข้อมูลส่วนประกอบ (หรือเรียกว่าอ็อบเจ็กต์ถาวร) ซึ่งผสานรวมเข้ากับIDE อย่างสมบูรณ์ เนื้อหาของส่วนประกอบจะถูกบันทึกไว้ในไฟล์ DFM และโหลดกลับมาใช้งานได้ทันที

Goรองรับการแปลงข้อมูลJSONและXML ได้โดยตรง ^{[ 11 ]}นอกจากนี้ยังมีโมดูลของบุคคลที่สามที่รองรับYAML ^{[ 12 ]}และProtocol Buffers [ ^{13 ] Go}ยังรองรับGobs อีก ด้วย ^{[ 14 ]}

ใน Haskell การทำให้เป็นอนุกรมได้รับการสนับสนุนสำหรับประเภทที่เป็นสมาชิกของคลาสประเภท Read และ Show ทุกประเภทที่เป็นสมาชิกของReadคลาสประเภทจะกำหนดฟังก์ชันที่จะดึงข้อมูลจากสตริงที่แสดงข้อมูลที่ถูกดัมพ์Showคลาสประเภทนั้นเองก็มีshowฟังก์ชันที่สามารถสร้างสตริงที่แสดงวัตถุได้ โปรแกรมเมอร์ไม่จำเป็นต้องกำหนดฟังก์ชันอย่างชัดเจน เพียงแค่ประกาศประเภทให้สืบทอดจาก Read หรือสืบทอดจาก Show หรือทั้งสองอย่าง ก็สามารถทำให้คอมไพเลอร์สร้างฟังก์ชันที่เหมาะสมสำหรับหลายกรณี (แต่ไม่ใช่ทั้งหมด: ตัวอย่างเช่น ประเภทฟังก์ชันไม่สามารถสืบทอดจาก Show หรือ Read ได้โดยอัตโนมัติ) อินสแตนซ์ที่สร้างขึ้นโดยอัตโนมัติสำหรับ Show ยังสร้างซอร์สโค้ดที่ถูกต้อง ดังนั้นค่า Haskell เดียวกันจึงสามารถสร้างได้โดยการรันโค้ดที่สร้างโดย show ในตัวอย่างเช่น ล่าม Haskell ^{[ 15 ]}สำหรับการทำให้เป็นอนุกรมที่มีประสิทธิภาพมากขึ้น มีไลบรารี Haskell ที่อนุญาตให้ทำการทำให้เป็นอนุกรมด้วยความเร็วสูงในรูปแบบไบนารีเช่น binary

Java มีกลไกการซีเรียลไลซ์อัตโนมัติซึ่งกำหนดให้ต้องมี การทำเครื่องหมายวัตถุโดยการใช้งาน อินเท java.io.Serializableอร์เฟซ การใช้งานอินเทอร์เฟซจะทำเครื่องหมายคลาสว่า "สามารถซีเรียลไลซ์ได้" และ Java จะจัดการการซีเรียลไลซ์ภายในเอง ไม่มีเมธอดซีเรียลไลซ์ใด ๆ ที่กำหนดไว้ในSerializableอินเทอร์เฟซ แต่คลาสที่สามารถซีเรียลไลซ์ได้สามารถกำหนดเมธอดที่มีชื่อและลายเซ็นพิเศษบางอย่างได้ ซึ่งหากกำหนดไว้ เมธอดเหล่านั้นจะถูกเรียกใช้เป็นส่วนหนึ่งของกระบวนการซีเรียลไลซ์/ดีซีเรียลไลซ์ ภาษายังอนุญาตให้นักพัฒนาสามารถเขียนทับกระบวนการซีเรียลไลซ์ได้อย่างละเอียดมากขึ้นโดยการใช้งานอินเทอร์เฟซอื่นExternalizableซึ่งก็คืออินเทอร์เฟซ ซึ่งมีเมธอดพิเศษสองเมธอดที่ใช้ในการบันทึกและกู้คืนสถานะของวัตถุมีเหตุผลหลักสามประการที่ทำให้วัตถุไม่สามารถซีเรียลไลซ์ได้โดยค่าเริ่มต้นและต้องใช้งานSerializableอินเทอร์เฟซเพื่อเข้าถึงกลไกการซีเรียลไลซ์ของ Java ประการแรก วัตถุบางอย่างไม่ได้เก็บความหมายที่มีประโยชน์ในสถานะซีเรียลไลซ์ ตัวอย่างเช่น วัตถุจะผูกติดกับสถานะของ JVMThreadปัจจุบันไม่มีบริบทใดที่วัตถุที่ถูกดีซีเรียลไลซ์จะยังคงรักษาความหมายที่มีประโยชน์ไว้ได้ประการที่สอง สถานะซีเรียลไลซ์ของวัตถุเป็นส่วนหนึ่งของสัญญาความเข้ากันได้ของคลาส การรักษาความเข้ากันได้ระหว่างเวอร์ชันของคลาสที่สามารถทำให้เป็นอนุกรมได้นั้นต้องใช้ความพยายามและการพิจารณาเพิ่มเติม ดังนั้น การทำให้คลาสสามารถทำให้เป็นอนุกรมได้จึงต้องเป็นการตัดสินใจออกแบบโดยตั้งใจ ไม่ใช่เงื่อนไขเริ่มต้นสุดท้าย การทำให้เป็นอนุกรมช่วยให้สามารถเข้าถึงสมาชิกส่วนตัวที่ไม่ใช่แบบชั่วคราวของคลาสที่ไม่สามารถเข้าถึงได้ในกรณีอื่น คลาสที่มีข้อมูลที่ละเอียดอ่อน (เช่น รหัสผ่าน) ไม่ควรทำให้เป็นอนุกรมหรือทำให้เป็นภายนอกได้^{[ 16 ] : 339–345} วิธีการเข้ารหัสมาตรฐานใช้การแปลแบบกราฟแบบเรียกซ้ำของตัวอธิบายคลาสของวัตถุและฟิลด์ที่สามารถทำให้เป็นอนุกรมได้เป็นสตรีมไบต์ พรีมิทีฟรวมถึงวัตถุอ้างอิงที่ไม่ใช่แบบชั่วคราวและไม่ใช่แบบคงที่จะถูกเข้ารหัสลงในสตรีม วัตถุแต่ละชิ้นที่ถูกอ้างอิงโดยวัตถุที่ทำให้เป็นอนุกรมผ่านฟิลด์ที่ไม่ได้ทำเครื่องหมายไว้จะต้องถูกทำให้เป็นอนุกรมด้วย และหากวัตถุใด ๆ ในกราฟที่สมบูรณ์ของการอ้างอิงวัตถุที่ไม่ใช่แบบชั่วคราวไม่สามารถทำให้เป็นอนุกรมได้ การทำให้เป็นอนุกรมจะล้มเหลว นักพัฒนาสามารถมีอิทธิพลต่อพฤติกรรมนี้ได้โดยการทำเครื่องหมายวัตถุเป็นแบบชั่วคราว หรือโดยการกำหนดนิยามใหม่ของการทำให้เป็นอนุกรมสำหรับวัตถุเพื่อให้ส่วนใดส่วนหนึ่งของกราฟอ้างอิงถูกตัดทอนและไม่ถูกทำให้เป็นอนุกรมJava ไม่ใช้คอนสตรัคเตอร์เพื่อทำให้วัตถุเป็นอนุกรม เป็นไปได้ที่จะทำให้วัตถุ Java เป็นอนุกรมผ่านJDBCและจัดเก็บลงในฐานข้อมูล^{[ 17 ]}ในขณะที่SwingThreadtransientถึงแม้คอมโพเนนต์จะใช้งานอินเทอร์เฟซ Serializable แต่ก็ไม่รับประกันว่าจะสามารถใช้งานได้บน Java Virtual Machine เวอร์ชันต่างๆ ดังนั้น คอมโพเนนต์ Swing หรือคอมโพเนนต์ใดๆ ที่สืบทอดมาจาก Swing อาจจะถูกแปลงเป็นสตรีมไบต์ได้ แต่ก็ไม่รับประกันว่าจะสามารถสร้างใหม่ได้บนเครื่องอื่น

ตั้งแต่ ECMAScript 5.1 ^{[ 18 ]} JavaScriptได้รวมออบเจ็กต์ในตัวJSONและเมธอดต่างๆ ไว้JSON.parse()ด้วยJSON.stringify()แม้ว่า JSON จะอิงตามชุดย่อยของ JavaScript เป็นหลัก^{[ 19 ]}แต่ก็มีกรณีขอบเขตที่ JSON ไม่ใช่ JavaScript ที่ถูกต้อง โดยเฉพาะอย่างยิ่ง JSON อนุญาตให้ตัวจบบรรทัด Unicode U+2028 LINE SEPARATORและU+2029 PARAGRAPH SEPARATORปรากฏโดยไม่ต้องหลีกเลี่ยงในสตริงที่อยู่ในเครื่องหมายคำพูด ในขณะที่ ECMAScript 2018 และเวอร์ชันเก่ากว่าไม่อนุญาต^{[ 20 ] [ 21 ]}ดูบทความหลักเกี่ยวกับ JSON

Juliaใช้ โมดูล serialize()/ ในการทำซีเรียลไลเซ deserialize()ชัน^{[ 22 ]}ซึ่งออกแบบมาเพื่อใช้งานภายใน Julia เวอร์ชันเดียวกัน และ/หรืออินสแตนซ์ของอิมเมจระบบเดียวกัน^{[ 23 ]} แพ็กเกจ นี้HDF5.jlเสนอทางเลือกที่เสถียรกว่า โดยใช้รูปแบบที่มีเอกสารประกอบและไลบรารีทั่วไปที่มีตัวห่อสำหรับภาษาต่างๆ^{[ 24 ]}ในขณะที่รูปแบบซีเรียลไลเซชันเริ่มต้นนั้นได้รับการออกแบบโดยคำนึงถึงประสิทธิภาพสูงสุดสำหรับการสื่อสารผ่านเครือข่ายเป็นหลัก^{[ 25 ]}

โดยทั่วไป โครงสร้างข้อมูล ของ Lispสามารถแปลงเป็นรูปแบบอนุกรมได้ด้วยฟังก์ชัน " read" และ " print" ตัวอย่างเช่น ตัวแปร foo ที่เก็บรายการของอาร์เรย์จะถูกพิมพ์โดย(print foo)" " ในทำนองเดียวกัน อ็อบเจ็กต์สามารถอ่านได้จากสตรีมชื่อ s โดย(read s)" " สองส่วนนี้ของการใช้งาน Lisp เรียกว่า ตัวพิมพ์ (Printer) และ ตัวอ่าน (Reader)" ผลลัพธ์ของprint" " สามารถอ่านได้โดยมนุษย์ โดยใช้รายการที่คั่นด้วยวงเล็บ ตัวอย่างเช่น: ใน Lisp หลายประเภท รวมถึงCommon Lispตัวพิมพ์ไม่สามารถแสดงข้อมูลทุกประเภทได้ เนื่องจากไม่ชัดเจนว่าจะทำอย่างไร ใน Common Lisp ตัวพิมพ์ไม่สามารถพิมพ์อ็อบเจ็กต์ CLOS ได้ โปรแกรมเมอร์อาจเขียนเมธอดในฟังก์ชันทั่วไปซึ่งจะถูกเรียกใช้เมื่อพิมพ์อ็อบเจ็กต์ วิธีนี้ค่อนข้างคล้ายกับวิธีที่ใช้ใน Ruby โค้ด Lisp เองเขียนด้วยไวยากรณ์ของตัวอ่าน เรียกว่า ไวยากรณ์การอ่าน ภาษาโปรแกรมส่วนใหญ่ใช้ตัวแยกวิเคราะห์ที่แยกจากกันเพื่อจัดการกับโค้ดและข้อมูล แต่ Lisp ใช้เพียงตัวเดียว ไฟล์ที่มีโค้ด Lisp อาจถูกอ่านเข้าสู่หน่วยความจำในรูปแบบโครงสร้างข้อมูล แปลงโดยโปรแกรมอื่น จากนั้นอาจถูกประมวลผลหรือเขียนออกไป เช่น ในลูปอ่าน-ประเมิน-พิมพ์อย่างไรก็ตาม โปรแกรมอ่าน/เขียนข้อมูลบางตัวอาจไม่รองรับโครงสร้างแบบวนซ้ำ แบบเรียกซ้ำ หรือแบบใช้ร่วมกัน (42.9"x"y)print-object

.NETมีซีเรียลไลเซอร์หลายตัวที่ออกแบบโดยMicrosoftนอกจากนี้ยังมีซีเรียลไลเซอร์จากบุคคลที่สามอีกมากมาย ซีเรียลไลเซอร์มากกว่าสิบตัวได้รับการกล่าวถึงและทดสอบที่นี่เก็บถาวรเมื่อวันที่ 8 พฤษภาคม 2015 ที่Wayback Machine [ ^{26 ] และ}ที่นี่^{[ 27 ]}

ไลบรารีมาตรฐานของOCamlMarshal ให้การจัดเรียงข้อมูลผ่าน โมดูล^{[ 3 ]}และฟังก์ชัน Pervasives output_valueและinput_value. ในขณะที่การเขียนโปรแกรม OCaml มีการตรวจสอบประเภทแบบคงที่ การใช้Marshalโมดูลอาจทำให้การรับประกันประเภทเสียหายได้ เนื่องจากไม่มีวิธีตรวจสอบว่าสตรีมที่ไม่ได้จัดเรียงข้อมูลแสดงถึงวัตถุประเภทที่คาดหวังหรือไม่ ใน OCaml การจัดเรียงฟังก์ชันหรือโครงสร้างข้อมูลที่มีฟังก์ชันอยู่ภายใน (เช่น วัตถุที่มีเมธอดอยู่ภายใน) ทำได้ยาก เนื่องจากโค้ดที่สามารถเรียกใช้งานได้ในฟังก์ชันไม่สามารถส่งผ่านระหว่างโปรแกรมต่างๆ ได้ (มีแฟล็กสำหรับจัดเรียงตำแหน่งโค้ดของฟังก์ชัน แต่สามารถยกเลิกการจัดเรียงได้เฉพาะในโปรแกรมเดียวกันเท่านั้น) ฟังก์ชันการจัดเรียงข้อมูลมาตรฐานสามารถรักษาการแบ่งปันและจัดการข้อมูลแบบวนซ้ำ ซึ่งสามารถกำหนดค่าได้โดยใช้แฟล็ก

โมดูลPerlหลายตัว ที่มีอยู่ใน CPANมีกลไกการซีเรียลไลซ์ รวมถึง `serialize`, ` Storableserialize` JSON::XSและFreezeThaw`deserialize` Storable มีฟังก์ชันสำหรับซีเรียลไลซ์และดีซีเรียลไลซ์โครงสร้างข้อมูล Perl ไปและกลับจากไฟล์หรือค่าสเกลาร์ของ Perl นอกจากการซีเรียลไลซ์โดยตรงไปยังไฟล์ แล้ว Storableยังมีfreezeฟังก์ชันสำหรับส่งคืนสำเนาข้อมูลที่ซีเรียลไลซ์แล้วบรรจุลงในค่าสเกลาร์ และthawดีซีเรียลไลซ์ค่าสเกลาร์ดังกล่าว สิ่งนี้มีประโยชน์สำหรับการส่งโครงสร้างข้อมูลที่ซับซ้อนผ่านซ็อกเก็ตเครือข่ายหรือการจัดเก็บในฐานข้อมูล เมื่อซีเรียลไลซ์โครงสร้างด้วยStorable`serialize` จะมีฟังก์ชันที่ปลอดภัยต่อเครือข่ายซึ่งจะจัดเก็บข้อมูลในรูปแบบที่อ่านได้บนคอมพิวเตอร์ทุกเครื่องโดยแลกกับความเร็วเพียงเล็กน้อย ฟังก์ชันเหล่านี้มีชื่อว่า `deserialize` nstore, nfreeze`deserialize`, เป็นต้น ไม่มีฟังก์ชัน `deserialize` สำหรับโครงสร้างเหล่านี้ — ฟังก์ชัน `serialize` thawและretrieve`deserialize` ปกติจะดีซีเรียลไลซ์โครงสร้างที่ซีเรียลไลซ์ด้วยnฟังก์ชัน `serialize` และฟังก์ชันที่เทียบเท่าเฉพาะเครื่อง

เดิมที PHP ใช้การทำให้เป็นอนุกรมผ่าน ฟังก์ชันserialize()ในตัว^{[ 28 ]} PHP สามารถทำให้ข้อมูลประเภทใดก็ได้เป็นอนุกรม ยกเว้นทรัพยากร (ตัวชี้ไฟล์ ซ็อกเก็ต ฯลฯ) ฟังก์ชันในตัวมักเป็นอันตรายเมื่อใช้กับข้อมูลที่ไม่น่าเชื่อถือโดยสิ้นเชิง^{[ 29 ]}สำหรับอ็อบเจ็กต์ มี " เมธอดวิเศษ " สองเมธอดที่สามารถนำไปใช้ภายในคลาสได้ — และ — ซึ่งจะถูกเรียกจากภายในและตามลำดับ ซึ่งสามารถทำความสะอาดและกู้คืนอ็อบเจ็กต์ได้ ตัวอย่างเช่น อาจเป็นที่ต้องการที่จะปิดการเชื่อมต่อฐานข้อมูลเมื่อทำการทำให้เป็นอนุกรมและกู้คืนการเชื่อมต่อเมื่อทำการดีซีเรียลไลซ์ ฟังก์ชันนี้จะถูกจัดการในเมธอดวิเศษสองเมธอดนี้ นอกจากนี้ยังอนุญาตให้อ็อบเจ็กต์เลือกคุณสมบัติที่จะถูกทำให้เป็นอนุกรมได้ ตั้งแต่ PHP 5.1 เป็นต้นมา มีกลไกการทำให้เป็นอนุกรมเชิงวัตถุสำหรับอ็อบเจ็กต์ นั่นคืออินเทอร์เฟซ^{[ 30 ]}unserialize()unserialize()__sleep()__wakeup()serialize()unserialize()Serializable

โครงสร้าง เทอมของPrologซึ่งเป็นโครงสร้างข้อมูลเดียวของภาษา สามารถแปลงเป็นอนุกรมได้โดยใช้เพรดิเคตในตัวwrite_term/3และแปลงเป็นอนุกรมได้โดยใช้เพรดิเคตในตัวread/1และ สตรีม read_term/2ที่ได้จะเป็นข้อความที่ไม่ได้บีบอัด (ในรูปแบบการเข้ารหัสบางอย่างที่กำหนดโดยการกำหนดค่าของสตรีมเป้าหมาย) โดยตัวแปรอิสระใดๆ ในเทอมจะถูกแทนด้วยชื่อตัวแปรตัวยึดตำแหน่ง เพรดิเคตนี้ได้write_term/3รับการกำหนดมาตรฐานไว้ในข้อกำหนด ISO สำหรับ Prolog (ISO/IEC 13211-1) ในหน้า 59 เป็นต้นไป ("การเขียนเทอม § 7.10.5") ดังนั้นจึงคาดว่าเทอมที่แปลงเป็นอนุกรมออกมาโดยการใช้งานหนึ่งจะสามารถแปลงเป็นอนุกรมเข้ามาโดยการใช้งานอื่นได้โดยไม่มีความคลุมเครือหรือความประหลาดใจ ในทางปฏิบัติ ส่วนขยายเฉพาะการใช้งาน (เช่น พจนานุกรมของ SWI-Prolog) อาจใช้โครงสร้างเทอมที่ไม่เป็นมาตรฐาน ดังนั้นความสามารถในการทำงานร่วมกันอาจหยุดชะงักในกรณีพิเศษ ตัวอย่างเช่น ดูหน้าคู่มือที่เกี่ยวข้องสำหรับ SWI-Prolog, ^{[ 31 ]} SICStus Prolog, ^{[ 32 ]} GNU Prolog ^{[ 33 ]}การตรวจสอบเงื่อนไขที่ได้รับผ่านเครือข่ายเทียบกับข้อกำหนด (หลังจากการแปลงกลับจากสตรีมอักขระ) ขึ้นอยู่กับการใช้งานของผู้ใช้งานไวยากรณ์ประโยค กำหนดในตัวของ Prolog สามารถนำมาใช้ในขั้นตอนนี้ ได้

กลไกการซีเรียลไลเซชันทั่วไปหลักคือ โมดูล pickleไลบรารีมาตรฐานซึ่งอ้างอิงถึงคำศัพท์ในระบบฐานข้อมูลที่เรียกว่าpickling ^{[ 34 ] [ 35 ] [ 36 ]}เพื่ออธิบายการซีเรียลไลเซชันข้อมูล ( unpicklingสำหรับการดีซีเรียลไลเซชัน ) Pickle ใช้เครื่องเสมือนแบบstack ที่เรียบง่ายซึ่งบันทึกคำสั่งที่ใช้ในการสร้างวัตถุขึ้นใหม่ เป็นรูปแบบการซีเรียลไลเซชัน ที่ปรับแต่งได้ข้ามเวอร์ชันแต่ไม่ปลอดภัย (ไม่ปลอดภัยจากข้อมูลที่ผิดพลาดหรือเป็นอันตราย) ข้อมูลที่ผิดรูปแบบหรือสร้างขึ้นอย่างเป็นอันตรายอาจทำให้ดีซีเรียลไลเซอร์นำเข้าโมดูลตามอำเภอใจและสร้างวัตถุใดๆ ก็ได้^{[ 37 ] [ 38 ]}ไลบรารีมาตรฐานยังรวมถึงโมดูลที่ซีเรียลไลซ์ไปยังรูปแบบข้อมูลมาตรฐาน: (พร้อมการสนับสนุนในตัวสำหรับประเภทสเกลาร์และคอลเลกชันพื้นฐานและสามารถรองรับประเภทตามอำเภอใจผ่านhook การเข้ารหัสและการถอดรหัส ) (พร้อมการสนับสนุนสำหรับรูปแบบ รายการคุณสมบัติทั้งแบบไบนารีและ XML ) (พร้อมการสนับสนุนสำหรับมาตรฐาน External Data Representation (XDR) ตามที่อธิบายไว้ใน RFC 1014) สุดท้ายนี้ ขอแนะนำให้ประเมินวัตถุในสภาพแวดล้อมที่เหมาะสม ซึ่งทำให้ตรงกับ Common Lisp โดยประมาณ ไม่ใช่วัตถุทุกประเภทที่จะสามารถจัดเก็บได้โดยอัตโนมัติ โดยเฉพาะอย่างยิ่งวัตถุที่เก็บ ทรัพยากร ของระบบปฏิบัติการเช่นตัวจัดการไฟล์แต่ผู้ใช้สามารถลงทะเบียนฟังก์ชัน "ลด" และการสร้างแบบกำหนดเองเพื่อรองรับการจัดเก็บและการยกเลิกการจัดเก็บข้อมูลของประเภทต่างๆ ได้ Pickle เดิมทีถูกนำไปใช้เป็นโมดูล Python บริสุทธิ์ แต่ในเวอร์ชันของ Python ก่อน 3.0 โมดูล (ซึ่งเป็นโมดูลในตัวเช่นกัน) ให้ประสิทธิภาพที่ดีขึ้น (เร็วขึ้นถึง 1000 เท่า^{[ 37 ]} ) ได้รับการดัดแปลงมาจาก โครงการ Unladen Swallowใน Python 3 ผู้ใช้ควรนำเข้าเวอร์ชันมาตรฐานเสมอ ซึ่งจะพยายามนำเข้าเวอร์ชันที่เร่งความเร็วและจะใช้เวอร์ชัน Python บริสุทธิ์หากไม่ได้ผล^{[ 39 ]}jsonplistlibxdrlib__repr__print-objectpicklecPicklecPickle

Rมีฟังก์ชันdputที่เขียนข้อความ ASCII ที่แสดงถึงวัตถุ R ลงในไฟล์หรือการเชื่อมต่อ สามารถอ่านการแสดงผลจากไฟล์ได้โดยใช้dget[ ^{40 ] โดย}เฉพาะอย่างยิ่ง ฟังก์ชันserializeจะแปลงวัตถุ R เป็นอนุกรมไปยังการเชื่อมต่อ โดยผลลัพธ์จะเป็นเวกเตอร์ดิบที่เข้ารหัสในรูปแบบเลขฐานสิบหกunserializeฟังก์ชันนี้อนุญาตให้อ่านวัตถุจากการเชื่อมต่อหรือเวกเตอร์ดิบได้^{[ 41 ]}

REBOLจะทำการซีเรียลไลซ์เป็นไฟล์ ( save/all) หรือเป็นstring!( mold/all) สตริงและไฟล์สามารถดีซีเรียลไลซ์ได้โดยใช้ฟังก์ชันโพลีมอร์ฟิก ให้การซีเรียลไลซ์ข้อมูลข้ามภาษาใน R โดยใช้Protocol Buffers ^{[ 42 ]}loadRProtoBuf

RubyมีโมดูลมาตรฐานMarshalที่มี 2 เมธอด `serialize` dumpและload`serialize` คล้ายกับยูทิลิตี้มาตรฐานของ Unix อย่าง `reference` dumpและrestore`reference` เมธอดเหล่านี้จะทำการ serialize ข้อมูลไปยังคลาสมาตรฐาน `class` Stringนั่นคือ ข้อมูลเหล่านั้นจะกลายเป็นลำดับของไบต์ อย่างไรก็ตาม วัตถุบางอย่างไม่สามารถ serialize ได้ (การทำเช่นนั้นจะทำให้เกิดTypeErrorข้อยกเว้น) ได้แก่ bindings, procedure objects, instances ของ class IO, singleton objects และ interfaces หากคลาสใดต้องการการ serialize แบบกำหนดเอง (เช่น ต้องการการดำเนินการทำความสะอาดบางอย่างเมื่อทำการ dump/restoration) สามารถทำได้โดยการใช้งาน 2 เมธอด `reference` _dumpและ ` reference` เมธอด `serialize` _loadสำหรับinstance_dumpควรส่งคืนStringอ็อบเจ็กต์ที่มีข้อมูลทั้งหมดที่จำเป็นในการสร้างอ็อบเจ็กต์ของคลาสนี้และอ็อบเจ็กต์ที่อ้างอิงทั้งหมดขึ้นใหม่จนถึงระดับความลึกสูงสุดที่กำหนดเป็นพารามิเตอร์จำนวนเต็ม (ค่า -1 หมายความว่าควรปิดใช้งานการตรวจสอบความลึก) เมธอด `serialize` สำหรับ class_loadควรรับ `string` Stringและส่งคืนอ็อบเจ็กต์ของคลาสนี้

Serdeเป็นไลบรารีหรือ crate ที่ใช้กันอย่างแพร่หลายที่สุดสำหรับการซีเรียลไลซ์ในRustซึ่งมี trait SerializeและDeserializetrait ต่างๆ ให้ใช้งาน

โดยทั่วไปแล้ว อ็อบเจ็กต์ที่ไม่ใช้การเรียกซ้ำและไม่ใช้ร่วมกันสามารถจัดเก็บและเรียกใช้ในรูปแบบที่มนุษย์อ่านได้โดยใช้โปรโตคอลstoreOn:`/` เมธอดนี้จะสร้างข้อความของนิพจน์ Smalltalk ซึ่งเมื่อประเมินโดยใช้`/` จะสร้างอ็อบเจ็กต์ดั้งเดิมขึ้นมาใหม่ วิธีการนี้มีความพิเศษตรงที่มันใช้คำอธิบายเชิงกระบวนการของอ็อบเจ็กต์ ไม่ใช่ข้อมูลเอง ดังนั้นจึงมีความยืดหยุ่นสูง ทำให้คลาสสามารถกำหนดการแสดงผลที่กระชับยิ่งขึ้นได้ อย่างไรก็ตาม ในรูปแบบดั้งเดิมนั้น มันไม่ได้จัดการกับโครงสร้างข้อมูลแบบวนซ้ำหรือรักษาเอกลักษณ์ของการอ้างอิงที่ใช้ร่วมกัน (เช่น การอ้างอิงสองรายการไปยังอ็อบเจ็กต์เดียวจะถูกคืนค่าเป็นการอ้างอิงไปยังสำเนาสองชุดที่เท่ากัน แต่ไม่เหมือนกัน) สำหรับเรื่องนี้ มีทางเลือกแบบพกพาและไม่พกพาได้หลายแบบ บางวิธีนั้นเฉพาะเจาะจงกับการใช้งาน Smalltalk หรือไลบรารีคลาสเฉพาะ มีหลายวิธีในSqueak Smalltalkในการทำให้เป็นอนุกรมและจัดเก็บอ็อบเจ็กต์ วิธีที่ง่ายที่สุดและใช้บ่อยที่สุดคือรูปแบบการจัดเก็บแบบไบนารีที่อิงตามตัวทำให้เป็นอนุกรม นอกจากนี้ อ็อบเจ็กต์แบบรวมกลุ่มสามารถจัดเก็บและเรียกใช้ได้โดยใช้ `/ ` ทั้งสองภาษาต่างก็มี "เฟรมเวิร์กการจัดเก็บวัตถุแบบไบนารี" ซึ่งรองรับการแปลงเป็นและการเรียกข้อมูลจากรูปแบบไบนารีที่กะทัดรัด ทั้งสองภาษาสามารถจัดการโครงสร้างแบบวนซ้ำ แบบเรียกซ้ำ และแบบใช้ร่วมกัน การจัดเก็บ/เรียกข้อมูลคลาสและเมตาคลาสและมีกลไกสำหรับการย้ายวัตถุแบบ "ทันที" (เช่น การแปลงอินสแตนซ์ที่เขียนโดยคลาสเวอร์ชันเก่าที่มีโครงสร้างวัตถุแตกต่างกัน) API มีความคล้ายคลึงกัน (storeBinary/readBinary) แต่รายละเอียดการเข้ารหัสแตกต่างกัน ทำให้รูปแบบทั้งสองนี้เข้ากันไม่ได้ อย่างไรก็ตาม โค้ด Smalltalk/X เป็นโอเพนซอร์สและฟรี และสามารถโหลดลงใน Smalltalk อื่นๆ เพื่อให้สามารถแลกเปลี่ยนวัตถุข้ามภาษาได้ การแปลงวัตถุเป็นอนุกรมไม่ได้เป็นส่วนหนึ่งของข้อกำหนด ANSI Smalltalk ดังนั้น โค้ดสำหรับแปลงวัตถุเป็นอนุกรมจึงแตกต่างกันไปตามการใช้งาน Smalltalk ข้อมูลไบนารีที่ได้ก็แตกต่างกันไปด้วย ตัวอย่างเช่น วัตถุที่แปลงเป็นอนุกรมที่สร้างใน Squeak Smalltalk ไม่สามารถกู้คืนในAmbrai Smalltalkได้ ดังนั้น แอปพลิเคชันต่างๆ ที่ทำงานบนการใช้งาน Smalltalk หลายแบบที่อาศัยการซีเรียลไลซ์วัตถุจึงไม่สามารถแชร์ข้อมูลระหว่างการใช้งานที่แตกต่างกันเหล่านี้ได้ แอปพลิเคชันเหล่านี้ได้แก่ ฐานข้อมูลวัตถุ MinneStore ^{[ 43 ]}และ แพ็กเกจ RPC บาง แพ็กเกจ วิธีแก้ปัญหานี้คือ SIXX ^{[ 44 ]}ซึ่งเป็นแพ็กเกจสำหรับ Smalltalk หลายแบบที่ใช้ รูปแบบ XMLสำหรับการซีเรียลไลซ์ readFrom:storeOn:readFrom:storeOn:/readFrom:SmartRefStreamImageSegments

ไลบรารี มาตรฐาน SwiftมีโปรโตคอลสองแบบEncodableและDecodable(ประกอบกันเป็นCodable) ซึ่งอนุญาตให้สร้างอินสแตนซ์ของประเภทที่สอดคล้องกันเป็นอนุกรมหรือแปลงอนุกรมจากJSONรายการคุณสมบัติหรือรูปแบบอื่นๆ ได้^{[ 45 ]}คอมไพเลอร์สามารถสร้างการใช้งานเริ่มต้นของโปรโตคอลเหล่านี้สำหรับประเภทที่มีคุณสมบัติที่จัดเก็บเป็นDecodableหรือ ได้Encodableเช่น กัน

PowerShellใช้ คำสั่ง cmdlet ในตัวExport-CliXML เพื่อทำการ serialize อ็อบเจ็กต์ . Export-CliXMLNET และจัดเก็บ XML ที่ได้ในไฟล์ ในการสร้างอ็อบเจ็กต์ขึ้นมาใหม่ ให้ใช้คำสั่งImport-CliXMLcmdlet ซึ่งจะสร้างอ็อบเจ็กต์ที่ deserialize แล้วจาก XML ในไฟล์ที่ส่งออก อ็อบเจ็กต์ที่ deserialize แล้ว หรือที่รู้จักกันในชื่อ "property bags" นั้นไม่ใช่อ็อบเจ็กต์ที่มีชีวิตจริง แต่เป็นภาพรวมที่มีคุณสมบัติ แต่ไม่มีเมธอด โครงสร้างข้อมูลสองมิติยังสามารถ (de)serialize ใน รูปแบบ CSV ได้ โดยใช้คำสั่ง cmdlet ในตัวImport-CSVและ ด้วยExport-CSVเช่นกัน

• การสลับการทำงาน (การวัดระยะทาง)
• การเปรียบเทียบรูปแบบการจัดเรียงข้อมูล
• รูปแบบคอนเทนเนอร์
• Hibernate (Java)
• โครงสร้าง XML
• กฎการเข้ารหัสพื้นฐาน
• บัฟเฟอร์โปรโตคอลของ Google
• วิกิเบส
• อาปาเช่ อัฟโร

• เอกสารประกอบการจัดทำ Java Object Serialization
• เอกสารประกอบการใช้ งานJava 1.4 Object Serialization
• Java ที่ทนทาน: การทำให้เป็นอนุกรม (Serialization) เก็บถาวรเมื่อวันที่ 25 พฤศจิกายน 2005 ที่Wayback Machine
• ทรัพยากรการผูกข้อมูล XML
• ดาต้าบอร์ด - การแปลงข้อมูลไบนารีเป็นอนุกรมด้วยการเข้าถึงบางส่วนและแบบสุ่ม ระบบประเภทข้อมูล RPC การปรับเปลี่ยนประเภทข้อมูล และรูปแบบข้อความ