คำถามติดแท็ก configuration

ฉันใช้ไฟล์JSONเพื่อกำหนดค่าแอปพลิเคชันของฉันเสมอ ฉันเริ่มใช้พวกเขาตั้งแต่ตอนที่ฉันเขียนโค้ด Java จำนวนมากและตอนนี้ฉันทำงานเป็นหลักเกี่ยวกับการพัฒนา Python ด้านเซิร์ฟเวอร์และวิทยาศาสตร์ข้อมูลและฉันไม่แน่ใจว่าJSONเป็นวิธีที่เหมาะสมที่จะไปอีกต่อไป ฉันเห็น Celery ใช้ไฟล์ Python ที่แท้จริงเพื่อกำหนดค่า ตอนแรกฉันสงสัยเกี่ยวกับมัน แต่แนวคิดของการใช้โครงสร้างข้อมูล Python ง่าย ๆ สำหรับการกำหนดค่าเริ่มที่จะเพิ่มขึ้น ข้อดีบางประการ: โครงสร้างข้อมูลจะเหมือนกับที่ฉันเขียนตามปกติดังนั้นฉันไม่จำเป็นต้องเปลี่ยนกรอบความคิด IDE ของฉัน (PyCharm) เข้าใจการเชื่อมต่อระหว่างการกำหนดค่าและรหัส Ctrl+ Bทำให้สามารถข้ามไปมาระหว่างการกำหนดค่าและรหัสได้อย่างง่ายดาย ฉันไม่ต้องการที่จะทำงานกับที่ไม่จำเป็น IMO เข้มงวดJSON ฉันกำลังดูคุณสองคำพูดไม่มีเครื่องหมายจุลภาคต่อท้ายและไม่มีความคิดเห็น ฉันสามารถเขียนการกำหนดค่าการทดสอบในแอปพลิเคชันที่ฉันกำลังทำงานอยู่จากนั้นจึงย้ายพวกเขาไปยังไฟล์กำหนดค่าโดยไม่ต้องทำการแปลงใด ๆ และการแยกวิเคราะห์ JSON เป็นไปได้ที่จะทำสคริปต์ง่าย ๆ ในไฟล์กำหนดค่าถ้าจำเป็นจริงๆ (แม้ว่าสิ่งนี้ควรมี จำกัด มาก) ดังนั้นคำถามของฉันคือถ้าฉันสลับฉันจะยิงตัวเองในเท้าได้อย่างไร ไม่มีผู้ใช้ที่ไม่มีทักษะจะใช้ไฟล์กำหนดค่า การเปลี่ยนแปลงใด ๆ ที่เกิดขึ้นกับไฟล์การกำหนดค่าปัจจุบันมีความมุ่งมั่นที่จะใช้ Git และถูกนำไปใช้กับเซิร์ฟเวอร์ของเราซึ่งเป็นส่วนหนึ่งของการปรับใช้อย่างต่อเนื่อง ไม่มีการเปลี่ยนแปลงการกำหนดค่าด้วยตนเองเว้นแต่จะมีเหตุฉุกเฉินหรืออยู่ระหว่างการพัฒนา (ฉันเคยพิจารณาYAMLแต่มีบางอย่างเกี่ยวกับมันทำให้ฉันรำคาญดังนั้นสำหรับตอนนี้มันอยู่นอกโต๊ะอเมริกัน)

72 python  json  configuration  configuration-management  python-3.x 

สมมติว่าคุณเขียนแอปพลิเคชันที่ผู้ใช้สามารถกำหนดค่าได้ สำหรับการจัดเก็บ "ข้อมูลการกำหนดค่า" นี้ลงในฐานข้อมูลมักใช้สองรูปแบบ ตารางแถวเดียว CompanyName | StartFullScreen | RefreshSeconds | ... ---------------+-------------------+------------------+-------- ACME Inc. | true | 20 | ... ค่าชื่อคู่โต๊ะ ConfigOption | Value -----------------+------------- CompanyName | ACME Inc. StartFullScreen | true (or 1, or Y, ...) RefreshSeconds | 20 ... | ... ฉันเคยเห็นตัวเลือกทั้งสองในป่าและทั้งสองมีข้อดีและข้อเสียที่เห็นได้ชัดเช่น: ตารางแถวเดี่ยว จำกัด จำนวนตัวเลือกการกำหนดค่าที่คุณสามารถมีได้ (เนื่องจากจำนวนคอลัมน์ในแถวนั้น จำกัด …

64 database-design  data-structures  configuration 

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

43 configuration 

ฉันเพิ่งได้อ่านThe Pragmatic Programmerซึ่งระบุว่า: รายละเอียดทำให้รหัสเดิมของเรายุ่งเหยิงโดยเฉพาะอย่างยิ่งหากมีการเปลี่ยนแปลงบ่อยครั้ง ทุกครั้งที่เราต้องเข้าไปและเปลี่ยนรหัสเพื่อรองรับการเปลี่ยนแปลงบางอย่างในตรรกะทางธุรกิจหรือในกฎหมายหรือในรสนิยมส่วนตัวของผู้บริหารของวันที่เราจะเสี่ยงต่อการทำลายระบบ - การแนะนำข้อผิดพลาดใหม่ ล่าแอนดรู; โทมัสเดวิด (1999-10-20) โปรแกรมเมอร์ในทางปฏิบัติ: จาก Journeyman ถึง Master (จุดติดตั้ง 2651-2653) การศึกษาของเพียร์สัน (สหรัฐอเมริกา) จุด Edition. ขณะนี้ฉันกำลังเขียนโปรแกรมเว็บแอปที่มีบางรุ่นที่มีคุณสมบัติที่สามารถมาจากชุดของค่าเท่านั้นเช่น (ไม่ใช่ตัวอย่างจริงเนื่องจากข้อมูลแอปบนเว็บเป็นความลับ): light-> type = sphere / cube / cylinder ประเภทไฟสามารถเป็นค่าสามค่าข้างต้นเท่านั้น แต่ตาม TPP ฉันควรเขียนโค้ดราวกับว่าพวกเขาสามารถเปลี่ยนและวางค่าของพวกเขาในไฟล์ปรับแต่งได้ เนื่องจากมีหลายเหตุการณ์ในแอปนี้คำถามของฉันคือ: ฉันควรเก็บค่าเหล่านี้ไว้ใน: ไฟล์ปรับแต่ง: 'light-types' => array(sphere, cube, cylinder), 'other-type' => value, 'etc' => etc-value ตารางเดียวในฐานข้อมูลที่มีหนึ่งบรรทัดสำหรับแต่ละรายการกำหนดค่า …

41 design  database  configuration 

นี้โพสต์โดย Rob Conery (หมายเหตุกระสุน) กล่าวว่าสภาพแวดล้อมการพัฒนาที่ควรจะเรียกใช้ภายในเครื่องเสมือน ฉันเห็นสิ่งที่เขาพูดและมีแนวโน้มที่จะเห็นด้วย แต่ก็ยังรู้สึกไม่สบายใจเล็กน้อย ตอนนี้การทำเวอร์ชวลไลเซชันนั้นครบกำหนดแล้วแม้กระทั่งระบบการผลิตที่ใช้ความเร็วของ VM ก็ค่อนข้างจะไม่ใช่ปัญหา แต่อย่างที่ฉันพูดไป การทำเวอร์ชวลไลเซชันบนเครื่องของคุณเป็นอย่างไร คุณทำไปแล้วเหรอ? ถ้าคุณทำผิดพลาดหรือ gotchas ไปตามถนน?

41 productivity  configuration  development-environment  virtualization 

ส่วนใหญ่ฉันเก็บการกำหนดค่าแอปพลิเคชันการพัฒนาในไดเรกทอรีรากของโครงการเช่นนี้ app |-- config.json แต่นั่นไม่ได้เป็นวิธีที่ดีที่สุดเนื่องจากการกำหนดค่านี้จะถูกเก็บไว้ในระบบควบคุมเวอร์ชัน - อาจส่งผลให้เกิดการรั่วไหลของชื่อผู้ใช้รหัสผ่านและข้อมูลที่ละเอียดอ่อนอื่น ๆ คู่มือแนะนำแอพ 12 Factorแนะนำให้วางไฟล์กำหนดค่าโดยรวมและใช้ตัวแปรสภาพแวดล้อมสำหรับการตั้งค่า: ... เก็บ config ในตัวแปรสภาพแวดล้อม Env vars สามารถเปลี่ยนแปลงได้ง่ายระหว่าง Deploys โดยไม่ต้องเปลี่ยนรหัสใด ๆ ต่างจากไฟล์ปรับแต่งมีโอกาสน้อยที่จะถูกตรวจสอบลงในรหัสซื้อคืนโดยไม่ได้ตั้งใจ และแตกต่างจากไฟล์ปรับแต่งที่กำหนดเองหรือกลไกการกำหนดค่าอื่น ๆ เช่นคุณสมบัติระบบ Java พวกเขาเป็นมาตรฐานภาษาและระบบปฏิบัติการไม่เชื่อเรื่องพระเจ้า ฟังดูดีสำหรับฉันจริง ๆ แต่ร้านใดร้านหนึ่งพูดว่าตัวแปรสภาพแวดล้อมโดยไม่ตรวจสอบสิ่งเหล่านั้นลงในการควบคุมแหล่งที่มา? และเครื่องมือใดที่ฉันสามารถใช้เพื่อส่งตัวแปรเหล่านั้นไปยังแอป สามารถมีตัวเลือกการกำหนดค่าได้หลายสิบตัวและพิมพ์ด้วยมือทุกครั้งที่คุณเปิดแอปไม่ดี - ดังนั้นจึงต้องเก็บไว้ในไฟล์บางประเภท ไฟล์ดังกล่าวจะจบลงในการควบคุมแหล่งและเรากลับไปที่ที่เราเริ่ม มีวิธีจัดการตัวเลือกการกำหนดค่าที่ยอมรับกันโดยทั่วไปหรือไม่ซึ่งไม่มีความเสี่ยงในการจัดเก็บการกำหนดค่าท้องถิ่นในการควบคุมแหล่งที่มา?

38 architecture  configuration  configuration-management 

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

20 configuration 

ลองนึกภาพระบบที่มีเซิร์ฟเวอร์จำนวนมาก แต่ละรายการมีการตั้งค่าจำนวนมาก: บางอย่างเฉพาะกับเซิร์ฟเวอร์ เฉพาะบางภูมิภาค บางคนพบเห็นได้ทั่วทุกคน บางทีคุณอาจมีการจัดกลุ่มแบบกำหนดเองบางอย่างเช่นกลุ่มเซิร์ฟเวอร์นี้มีไว้สำหรับอ่านเท่านั้น เป็นต้น การปฏิบัติปัจจุบันที่ฉันมีอยู่ในใจเป็นโครงสร้างที่เรียบง่ายพร้อมความสามารถที่เหนือกว่า ให้ใช้เซิร์ฟเวอร์ของ Google เพื่อเป็นตัวอย่าง แต่ละรายการมีรายการการตั้งค่าที่จะโหลด ตัวอย่างเช่นเซิร์ฟเวอร์ลอนดอนอาจมี: rootsettings.properties, europesettings.properties, londonsettings.properties, searchengine.propertiesฯลฯ ที่แต่ละไฟล์มีชุดของคุณสมบัติและลำดับการโหลดช่วยให้คุณสามารถแทนที่คุณสมบัติได้ยิ่งคุณไปได้ไกลเท่าไหร่ ตัวอย่างเช่น: rootsettings.propertiesอาจมีaccessible=falseค่าเริ่มต้น แต่อยู่เหนือsearchengine.propertiesด้วยaccessible=true ปัญหาที่ฉันมีกับโครงสร้างนี้คือมันง่ายมากที่จะออกจากการควบคุม มันไม่ได้มีโครงสร้างเลยหมายความว่าคุณสามารถกำหนดคุณสมบัติใด ๆ ได้ทุกระดับและหลายรายการอาจล้าสมัย นอกจากนี้การเปลี่ยนระดับกลางจะเป็นไปไม่ได้เมื่อเครือข่ายโตขึ้นเนื่องจากตอนนี้คุณส่งผลกระทบต่อเซิร์ฟเวอร์จำนวนมาก ท้ายสุด แต่ไม่ท้ายสุดแต่ละอินสแตนซ์แต่ละรายการอาจต้องการคุณสมบัติพิเศษ 1 รายการซึ่งหมายความว่าแผนผังของคุณจะจบลงด้วยการกำหนดค่าสำหรับเซิร์ฟเวอร์แต่ละเครื่องอย่างไรก็ตามมันจึงไม่ใช่โซลูชันที่ดีที่สุด ฉันจะขอขอบคุณอย่างมากหากคุณมีข้อเสนอแนะ / แนวคิดเกี่ยวกับสถาปัตยกรรมการจัดการการกำหนดค่าที่ดีขึ้น

15 configuration  configuration-management  properties 

ฉันกำลังเขียนเชลล์สคริปต์ด้วยตัวแปรบางตัวที่ควรกำหนดค่าโดยผู้ใช้ จะมีโปรแกรมติดตั้งสำหรับดาวน์โหลดและกำหนดค่าสคริปต์โดยอาจถามคำถามหลายข้อ สคริปต์ที่เป็นปัญหานั้นมุ่งเป้าไปที่ผู้พัฒนารายอื่น สิ่งนี้สามารถนำไปใช้ได้หลายวิธี: ใช้ตัวยึดตำแหน่งในสคริปต์และใช้sedเพื่อแทนที่ในระหว่างการติดตั้ง (สิ่งนี้: /programming/415677/how-to-replace-placeholders-in-a-text-file ) ข้อดี: คำจำกัดความของตัวแปรทั้งหมดมีอยู่ในสคริปต์ ง่ายในการดาวน์โหลดสคริปต์ด้วยตนเองและกำหนดค่าตัวแปรสำหรับผู้ใช้ที่ต้องการตัวแก้ไขมากกว่าตัวติดตั้ง ข้อด้อย: มันยากที่จะกำหนดค่าตัวแปรใหม่ผ่านตัวติดตั้งเมื่อมีอยู่ นอกจากว่าฉันจะสร้าง regexp ที่ซับซ้อนมากขึ้นซึ่งจะมีแนวโน้มที่จะเกิดข้อผิดพลาด ใช้ไฟล์ configโดยทั่วไปแล้วเชลล์สคริปต์อื่นที่มีการมอบหมายและใช้sourceเพื่อรวมไฟล์นั้น (และอาจวางไว้ใน~/.scriptname? สคริปต์หลักถูกคัดลอกไปยัง/usr/local/bin) ข้อดี: ง่ายต่อการกำหนดค่าสคริปต์ใหม่ สามารถเพิ่มพารามิเตอร์สำหรับการทำเช่นนั้นได้จากสคริปต์หลัก (อาจเป็นไปได้ในโซลูชันแรกเช่นกัน แต่การแก้ไขสคริปต์จากตัวเองไม่ได้ฟังดูเหมือนเป็นความคิดที่ดีมาก) ข้อด้อย: สคริปต์นี้ขึ้นอยู่กับสองไฟล์และผู้ใช้จำเป็นต้องเรียกใช้โปรแกรมติดตั้งสำหรับไฟล์การกำหนดค่าที่จะสร้าง สิ่งนี้สามารถแก้ไขได้โดยการสร้างไฟล์ปรับแต่งอัตโนมัติหากไม่มีอยู่ แต่การค้นหาไฟล์กำหนดค่าภายนอกจะยังคงเป็นเรื่องยุ่งยากสำหรับผู้ใช้ที่ต้องการดาวน์โหลดสคริปต์แก้ไขและดำเนินการกับมัน นอกจากนี้ยังมีตัวเลือกเล็กน้อยเกี่ยวกับวิธีการจัดการการกำหนดค่าโดยผู้ใช้หลังการติดตั้ง: คอมไพล์เช่น $ myscript config server.host example.org $ myscript config server.proxypath / home / johndoe / proxy $ myscript config server.httppath …

13 configuration  configuration-management  shell  bash 

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

12 development-process  management  configuration 

เรากำลังใช้อัลกอริทึมมากมายซึ่งโดยทั่วไปจะมีพารามิเตอร์ที่แชร์สาธารณะรู้จักและความปลอดภัย ปัจจุบันเราใช้คลาสที่เก็บพารามิเตอร์ทั้งหมดและวัตถุโกลบอลที่กำหนดไว้ล่วงหน้าสองรายการ: class PublicParams(object): p = q = 0 def __init__(self, p, q): self.p = p self.q = q # used for tests publicParams_test = PublicParams(15,7) # Some 2048 bit numbers for example publicParams_secure = PublicParams(128378947298374928374,128378947298374928374) จากนั้นอัลกอริธึมนำPublicParamsวัตถุเป็นอาร์กิวเมนต์ที่เป็นค่าเริ่มต้นไปยังการผลิตpublicParams_secure def AlgoOne(n, publicParams = publicParams_secure): # do stuff with publicParams.p # ... AlgoTwo(x, …

11 python  unit-testing  configuration 

CMS สาธารณะเกือบทุกตัวในนั้นใช้ไฟล์. php สำหรับการตั้งค่าฐานข้อมูลและอื่น ๆ ตัวอย่างเช่น WordPress สร้างไฟล์. php config โดยอัตโนมัติเมื่อคุณติดตั้ง ทำไมพวกเขาไม่เพียงแค่ใช้ไฟล์. ini PHP มีparse_ini_file ()อยู่แล้วและฉันแน่ใจว่าภาษาอื่นมีฟังก์ชั่นที่คล้ายกัน

10 php  cms  configuration 

ลองพิจารณาสองตัวอย่างนี้: ส่งผ่านวัตถุไปยังตัวสร้าง class ExampleA { private $config; public function __construct($config) { $this->config = $config; } } $config = new Config; $exampleA = new ExampleA($config); ยกระดับชั้นเรียน class ExampleB { private $config; public function __construct() { $this->config = new Config; } } $exampleA = new ExampleA(); วิธีใดที่ถูกต้องในการจัดการการเพิ่มวัตถุเป็นคุณสมบัติ เมื่อใดที่ฉันควรใช้อีกอันหนึ่ง? การทดสอบหน่วยมีผลต่อสิ่งที่ฉันควรใช้หรือไม่

10 object-oriented  unit-testing  configuration 

หากคุณเพิ่มตัวเลือกการกำหนดค่าใหม่ให้กับโปรแกรมมันมักจะมีเอฟเฟ็กต์ระลอกคลื่นจำนวนมากในแง่ของการรับตัวเลือกไปยังตำแหน่งที่จำเป็นต้องดำเนินการ มีสามวิธีพื้นฐานในการจัดการกับสิ่งนี้ที่ฉันรู้: ส่งการตั้งค่าทั้งหมดไปยังส่วนต่าง ๆ ของโปรแกรมของคุณที่ต้องการการตั้งค่าพื้นฐาน นี่คือวิธีที่ชัดเจนที่สุดและวิธีที่แยกสิ่งต่าง ๆ ออกมามากที่สุด ข้อเสียคือว่านี่เป็นทั้ง verbose และเปราะ ทำให้การตั้งค่าการกำหนดค่าที่ใช้บ่อยที่สุดคือ global / static นี่เป็นวิธีที่ง่ายที่สุด แต่แนะนำให้ดำเนินการในระยะไกลเป็นอุปสรรคต่อการทดสอบและถือว่าการกำหนดค่านั้นเป็นระดับโลกอย่างแท้จริง (ซึ่งคุณต้องการเพียงหนึ่งการกำหนดค่าในเวลาที่กำหนด) สร้างคลาสการกำหนดค่า / โครงสร้างที่มีตัวเลือกการกำหนดค่าทั้งหมดสำหรับโปรแกรมทั้งหมดหรือสำหรับข้อกังวลหลัก ๆ ภายในโปรแกรมจากนั้นส่งผ่านสิ่งนี้อย่างชัดเจน สิ่งนี้ชัดเจนน้อยกว่า (1) แต่ชัดเจนกว่า (2) หากคุณต้องการเปลี่ยนการตั้งค่าสำหรับการเรียกใช้ฟังก์ชั่นเดียวคุณสามารถโคลนวัตถุกำหนดค่าและเปลี่ยนค่านี้ได้ สิ่งนี้มีประโยชน์ทั้งในการทดสอบและในทางปฏิบัติ อย่างไรก็ตามคุณยังคงสามารถส่งข้อมูลจำนวนมากไปยังฟังก์ชั่นที่ไม่ต้องการและเปลี่ยนค่าในคลาส / โครงสร้าง config ยังสามารถทำให้เกิดการกระทำที่ระยะไกล คุณจะพิจารณา (3) รูปแบบหรือรูปแบบการต่อต้านหรือไม่? หากเป็นรูปแบบการต่อต้านคุณจะทำอย่างไรแทน

10 design  testing  configuration  object 

เรามีวิธีต่าง ๆ ในการจัดเก็บข้อมูลโปรแกรม (บันทึกไฟล์ในเกมฐานข้อมูลพนักงานการกำหนดค่าโปรแกรม ฯลฯ ): ข้อความล้วน (คิด.iniและ.conf) XML ฐานข้อมูล (MySQL, SQLite ... ) .zip และที่คล้ายกันมีหลายไฟล์ (ที่มีรูปแบบที่แตกต่างกัน) ไฟล์ไบนารี (คิดว่า.docเป็นต้นเช่นสร้างโดยเครื่องมือการทำให้เป็นอนุกรม) กรณีการใช้งานที่แตกต่างกันสำหรับรูปแบบที่ระบุไว้ข้างต้นคืออะไรและข้อได้เปรียบของพวกเขาคือข้อเสียอะไรบ้าง (คิดว่าความเร็วความยืดหยุ่นขนาดไฟล์ใช้งานง่าย ... )? วิธีการตัดสินใจระหว่างพวกเขาสำหรับงานที่แตกต่างกันอย่างไร เกี่ยวกับรูปแบบการซิป:นี่ใช้สำหรับบรรจุไฟล์อื่นเท่านั้น มันอาจเป็นรูปแบบการบีบอัดอื่นเช่นกัน สิ่งนี้ทำให้โครงสร้างของหลาย ๆ ไฟล์รวมถึงไฟล์รูปภาพไฟล์เสียงและไฟล์ข้อความ ตัวอย่างเช่นสมมติว่าคุณมีรูปแบบการจัดเก็บข้อมูลสำหรับข้อความซึ่งอาจมีไฟล์ คุณสามารถมีไฟล์ต่อไปนี้ในไฟล์ซิป: message.txt (containing the message) attachments (folder containing attachments) audio.wav picture.jpg

10 database  xml  data  configuration  storage