JSON เป็น TOML

คลิกเพื่อแปลง JSON เป็น TOML

เครื่องมือฟรีนี้ช่วยแปลง JSON object เป็นไฟล์คอนฟิก TOML v1.0 ได้อย่างรวดเร็ว รองรับการสร้างตารางซ้อน ([section]), ตารางย่อย ([a.b]) และอาเรย์ของตาราง ([[items]]) อัตโนมัติ จึงเหมาะสำหรับเตรียม Cargo.toml หรือ pyproject.toml และทุกขั้นตอนทำงานแบบโลคอลในเบราว์เซอร์

คำแนะนำที่เกี่ยวข้อง

JSON → YAML

ซ่อมแซม JSON

ตัวตรวจสอบ JSON Schema

เรียง JSON

จัดรูปแบบ JSON

JSON เป็น TypeScript

TOML คืออะไร และทำไมต้องแปลง JSON เป็น TOML

TOML ย่อมาจาก Tom's Obvious, Minimal Language (ภาษาที่ชัดเจนและเรียบง่ายของทอม) เป็นรูปแบบไฟล์คอนฟิกที่เผยแพร่ในปี 2013 โดย Tom Preston-Werner ผู้ร่วมก่อตั้ง GitHub เป้าหมายการออกแบบคือ: ไวยากรณ์ที่ชัดเจน (obvious), เรียบง่าย (minimal), อ่านง่ายสำหรับมนุษย์, ชัดเจนไม่คลุมเครือ TOML 1.0 กลายเป็นเวอร์ชันเสถียรในปี 2021 (toml-lang/toml) ปัจจุบันกลายเป็นรูปแบบคอนฟิกเริ่มต้นของเครื่องมือมากมาย รวมถึง Cargo ในระบบนิเวศ Rust, PEP 621 ของ Python (pyproject.toml), Hugo, Prettier, Deno, Taplo

TOML มีข้อได้เปรียบที่ชัดเจนหลายประการเหนือ JSON และ YAML ในสถานการณ์ไฟล์คอนฟิก: ①ไม่มีกับดักการเยื้องของ YAML — YAML ใช้การเยื้องแสดงลำดับชั้น ข้อผิดพลาดในการเยื้องจะเปลี่ยนความหมายของคอนฟิกอย่างสิ้นเชิง (เช่น list กลายเป็น string) TOML ใช้ [table] ประกาศลำดับชั้นอย่างชัดเจน ไม่มีความคลุมเครือ; ②เหมาะกับคอนฟิกมากกว่า JSON — เครื่องหมายคำพูดและวงเล็บปีกกาของ JSON จะเยอะมากในคอนฟิกที่ซับซ้อน การเขียน key = value ของ TOML สะอาดกว่า รองรับคอมเมนต์โดยธรรมชาติ; ③ระบบประเภทชัดเจน — TOML แยกประเภท integer/float/string/boolean/datetime/array/table เจ็ดประเภท ไม่มีความคลุมเครือของ JSON ที่ว่า "ตัวเลขเป็นจำนวนเต็มหรือทศนิยม" และไม่มีปัญหา Norway ของ YAML 1.1 (NO ถูกแยกวิเคราะห์เป็นบูลีน false)

โครงสร้างหลักของ TOML ประกอบด้วยสี่องค์ประกอบ: ①คู่คีย์-ค่า (key = value) แสดงรายการคอนฟิกพื้นฐาน; ②ตาราง (Table) ใช้ [name] แสดงกลุ่มที่มีชื่อ รองรับการซ้อน ([a.b.c]); ③อาเรย์ของตาราง (Array of Tables) ใช้ [[name]] แสดงรายการออบเจ็กต์ที่เป็นเนื้อเดียวกัน มักใช้สำหรับคอนฟิกหลายสภาพแวดล้อม รายการปลั๊กอิน รายการการพึ่งพา; ④อาเรย์ (Array) รองรับอินไลน์ประเภทพื้นฐาน ([1, 2, 3]) และการเขียนหลายบรรทัดสองแบบ เครื่องมือนี้จะจดจำโครงสร้าง JSON อย่างชาญฉลาดระหว่างการแปลง เลือกไวยากรณ์ TOML ที่เหมาะสมที่สุดโดยอัตโนมัติ

แรงจูงใจทั่วไปในการแปลง JSON เป็น TOML มีหลายประการ: ①โปรเจกต์ย้ายจากระบบนิเวศ Node.js ไปยังระบบนิเวศ Rust/Python ใหม่ รูปแบบคอนฟิกจำเป็นต้องรวมเป็นหนึ่งเดียวเป็น TOML; ②ทีมตัดสินใจรวมคอนฟิก JSON ที่กระจัดกระจายจัดการใน TOML ใช้ลำดับชั้น [section] ของ TOML เพื่อหลีกเลี่ยงภาระการอ่านจากการซ้อนลึกของ JSON; ③ใช้ TOML แทน YAML เพื่อขจัดบั๊กแปลกๆ ที่เกิดจากการเยื้อง; ④แปลงเมทาดาต้า JSON ที่ส่งลงมาจากต้นทางใน CI/CD เป็น TOML เพื่อฉีดเข้าเครื่องมือปลายทาง เครื่องมือนี้ครอบคลุมความต้องการการแปลงของทุกสถานการณ์เหล่านี้

กระบวนการแปลงโดยพื้นฐานคือการแมปแผนผังไวยากรณ์: JSON.parse() แยกวิเคราะห์ข้อความเป็นออบเจ็กต์ JavaScript (AST) แล้วเรียกซ้ำผ่านแต่ละโหนด — สตริง ตัวเลข บูลีน null ถูกแมปเป็นสเกลาร์ TOML ที่สอดคล้องกัน; อาเรย์ถูกแบ่งเป็นอาเรย์อินไลน์หรืออาเรย์ของตารางตามประเภทองค์ประกอบ; ออบเจ็กต์ซ้อนถูกแมปเป็นตารางหรือตารางย่อย สุดท้ายส่งออกข้อความตามข้อกำหนด TOML การแมปโครงสร้างนี้รับประกันว่าผลลัพธ์ที่แปลงนั้นถูกต้องตามหลักไวยากรณ์ 100% ไม่มีข้อผิดพลาดของรูปแบบ

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

เมื่ออยากร่าง Cargo.toml สำหรับโปรเจกต์ Rust ได้อย่างรวดเร็ว
เมื่อต้องย้ายการตั้งค่าโปรเจกต์ Python ไปไว้ใน pyproject.toml
เมื่อต้องแปลงคอนฟิก Hugo, Deno หรือ Prettier จาก JSON ไปเป็น TOML
เมื่อทีมต้องการทำมาตรฐานคอนฟิก CI/CD หรือ DevOps ด้วย TOML
เมื่ออยากเปรียบเทียบ JSON เดิมกับ TOML เพื่อเลือกฟอร์แมตที่อ่านง่ายกว่า
เมื่อกำลังเรียนรู้ไวยากรณ์ TOML จากตัวอย่างตารางซ้อนและอาเรย์ของตาราง

วิธีการใช้งาน

วาง JSON ลงในตัวแก้ไขด้านซ้ายหรืออัปโหลดไฟล์ .json / .txt และถ้าต้องการสามารถเปิดตัวอย่างได้ทันที
เครื่องมือจะพาร์สข้อมูลและสร้างผลลัพธ์ TOML v1.0 ให้ในแผงด้านขวาแบบเรียลไทม์
ถ้ามี error ด้านไวยากรณ์ ให้ตรวจข้อความแจ้งเตือนและแก้ JSON ก่อนแปลงใหม่
คัดลอกผลลัพธ์หรือดาวน์โหลดเป็น config.toml เพื่อนำไปใช้ต่อในโปรเจกต์

คุณสมบัติ

สร้างผลลัพธ์ตามสเปก TOML v1.0 และนำไปใช้ต่อกับ Cargo, Poetry, Hugo, Prettier หรือเครื่องมือที่รองรับ TOML ได้ทันที
แปลง JSON หลายชั้นให้เป็นตาราง TOML แบบ [a] และ [a.b.c] โดยอัตโนมัติ ทำให้โครงสร้างอ่านง่ายขึ้น
เปลี่ยนอาเรย์ของออบเจ็กต์ให้เป็นอาเรย์ของตาราง [[items]] เหมาะกับรายการ host, dependency หรือหลาย environment
จัดการ escape สำหรับเครื่องหมายคำพูด แบ็กสแลช ขึ้นบรรทัดใหม่ และแท็บตามกฎของ TOML
แม็ป string, number, boolean และ null ไปเป็นชนิดข้อมูล TOML ที่เหมาะสม โดย null จะกลายเป็นสตริงว่าง ""
วาง JSON ทางซ้ายแล้วดูผล TOML ทางขวาได้แบบเรียลไทม์ทันที
มีตัวอย่างครบทั้งออบเจ็กต์ซ้อน อาเรย์ และอาเรย์ของตารางให้ทดลองได้ในคลิกเดียว
รองรับการนำเข้าไฟล์ .json / .txt และดาวน์โหลดผลลัพธ์เป็น config.toml
บนเดสก์ท็อปสามารถลากปรับความกว้างของแผงได้ และระบบจะเก็บประวัติ 200 รายการล่าสุดให้เอง
หลังแปลงเสร็จสามารถไปต่อที่เครื่องมือจัดรูปแบบ JSON เพื่อเช็กหรือจัดระเบียบข้อมูลต้นทางได้
ทุกอย่างทำงานแบบโลคอลใน JavaScript ของเบราว์เซอร์ จึงไม่ส่งค่าคอนฟิกที่อ่อนไหวไปยังเซิร์ฟเวอร์

คำถามที่พบบ่อย

จะแปลง JSON เป็นไฟล์คอนฟิก TOML ได้อย่างไร

วางเนื้อหา JSON ลงในกล่องอินพุตทางซ้าย เครื่องมือจะแยกวิเคราะห์ JSON Object และแปลงเป็นรูปแบบคอนฟิกตามข้อกำหนด TOML v1.0 โดยอัตโนมัติ คู่คีย์-ค่าจะกลายเป็น key = value, ออบเจ็กต์ซ้อนจะกลายเป็นตาราง TOML ([section]) และตารางย่อย ([a.b]), อาเรย์จะถูกแบ่งเป็นอาเรย์อินไลน์หรืออาเรย์ของตาราง ([[items]]) ตามเนื้อหาโดยอัตโนมัติ คลิกปุ่มตัวอย่างเพื่อโหลดตัวอย่างซ้อนเพื่อดูผลลัพธ์ ผลลัพธ์ที่แปลงสามารถดาวน์โหลดเป็นไฟล์ config.toml สำหรับคอนฟิกโปรเจกต์ได้โดยตรง

TOML, YAML และ JSON เหมาะกับสถานการณ์ใด

JSON เหมาะสำหรับการแลกเปลี่ยนข้อมูล API และการส่งข้อมูลระหว่างหน้า-หลัง เป็นมาตรฐานโดยพฤตินัยของ REST API; YAML เหมาะสำหรับโครงสร้างข้อมูลที่ซับซ้อนและคอนฟิก CI/CD (GitHub Actions, Ansible, Kubernetes) อ่านง่าย รองรับคอมเมนต์และหลายเอกสาร; TOML เหมาะสำหรับสถานการณ์คอนฟิกที่ชัดเจน (Rust/Cargo, Python pyproject, Hugo, Prettier) ไวยากรณ์กระชับ คลุมเครือน้อย ไม่มีกับดักการเยื้อง ทั้งสามไม่มีข้อดี-ข้อเสียแบบสัมบูรณ์ สิ่งสำคัญคือการจับคู่กับสถานการณ์ — ไฟล์คอนฟิกแนะนำ TOML, คอนฟิก CI/CD แนะนำ YAML, ข้อมูล API ใช้ JSON

ออบเจ็กต์ซ้อนใน JSON แสดงใน TOML อย่างไร

TOML ใช้ตาราง (Table) เพื่อแสดงโครงสร้างซ้อน การซ้อนหนึ่งชั้น เช่น {"database": {"host": "localhost"}} จะแปลงเป็น [database] host = "localhost"; การซ้อนหลายชั้น เช่น {"server": {"ssl": {"enabled": true}}} จะแปลงเป็น [server.ssl] enabled = true เครื่องมือนี้จะจดจำระดับการซ้อนและสร้างเส้นทางส่วนหัวตารางที่สอดคล้องกันโดยอัตโนมัติ ไม่จำเป็นต้องปรับด้วยตนเอง

อาเรย์ JSON ถูกแปลงใน TOML อย่างไร

TOML แยกไวยากรณ์อาเรย์สองแบบ: ①อาเรย์ประเภทพื้นฐาน (เช่น ["a", "b", 1, 2]) จะถูกแปลงเป็นอาเรย์อินไลน์ key = ["a", "b", 1, 2] ห่อด้วยวงเล็บเหลี่ยมคั่นด้วยจุลภาค; ②อาเรย์ของออบเจ็กต์ (เช่น [{"name": "primary"}, {"name": "replica"}]) จะถูกแปลงเป็นอาเรย์ของตาราง [[items]] แต่ละออบเจ็กต์มีส่วนหัว [[items]] อยู่ด้านหน้า ฟิลด์เรียงต่อกันด้านล่าง เครื่องมือนี้จะตัดสินประเภทอาเรย์และเลือกไวยากรณ์ TOML ที่เหมาะสมที่สุดโดยอัตโนมัติ

TOML ที่สร้างสามารถใช้กับ Cargo.toml ได้โดยตรงหรือไม่

ได้ เครื่องมือปฏิบัติตามข้อกำหนดอย่างเป็นทางการของ TOML v1.0 (github.com/toml-lang/toml) อย่างเคร่งครัด TOML ที่ส่งออกสามารถใช้กับ Cargo (ตัวจัดการแพ็กเกจ Rust), Poetry/pyproject (ตัวจัดการแพ็กเกจ Python), Hugo (สถิตไซต์), Prettier, Deno, Taplo และเครื่องมือที่รองรับรูปแบบ TOML อื่นๆ ได้โดยตรง หมายเหตุ: หากคุณต้องการส่วน [package] / [dependencies] เฉพาะของ Cargo.toml กรุณาเพิ่มฟิลด์ที่เกี่ยวข้องตามข้อกำหนดของ Cargo (name, version, edition, ตารางการพึ่งพา crate ฯลฯ)

ค่า null ใน JSON จะถูกแปลงเป็นอะไร

TOML ไม่มีประเภท null ดังนั้น null ของ JSON จะถูกแปลงเป็นสตริงว่าง "" (การแสดงที่เทียบเท่ากันบ่อยที่สุด) หากผู้บริโภค TOML ของคุณมีข้อกำหนดพิเศษสำหรับฟิลด์ null (เช่น ฟิลด์ optional ของ crate ใน [dependencies]) กรุณาปรับบรรทัดที่เกี่ยวข้องด้วยตนเองหลังการแปลง

เครื่องหมายคำพูดคู่และการขึ้นบรรทัดใหม่ในสตริงจัดการอย่างไร

สตริง TOML ต้องห่อด้วยเครื่องหมายคำพูดคู่ เครื่องหมายคำพูดคู่ภายใน แบ็กสแลช ขึ้นบรรทัดใหม่ (\n), ขึ้นบรรทัดเก่า (\r), แท็บ (\t) ต้องถูกหลบหนีตามกฎ TOML เครื่องมือนี้จะจัดการการหลบหนีเหล่านี้โดยอัตโนมัติ เช่น He said "Hello" ใน JSON จะกลายเป็น He said \"Hello\" ใน TOML การขึ้นบรรทัดใหม่ในสตริงหลายบรรทัดจะกลายเป็น \n ไม่จำเป็นต้องหลบหนีด้วยตนเอง ผลลัพธ์ที่ส่งออกสามารถอ่านได้อย่างถูกต้องโดยตัวแยกวิเคราะห์ TOML

TOML ที่สร้างรองรับประเภทวันที่-เวลาหรือไม่

เครื่องมือนี้รับเฉพาะข้อความ JSON เป็นอินพุต และมาตรฐาน JSON ไม่มีประเภทวันที่-เวลาโดยธรรมชาติ (แนวปฏิบัติทั่วไปคือสตริง ISO 8601 เช่น "2026-01-01T00:00:00Z") หลังการแปลง TOML จะเก็บค่าเหล่านี้เป็นสตริง (key = "2026-01-01T00:00:00Z") หากคุณต้องการประเภท local datetime/offset datetime ดั้งเดิมของ TOML กรุณาเปลี่ยนสตริงเป็นตัวอักษรวันที่ TOML แบบเปลือยด้วยตนเอง (เช่น 2026-01-01T00:00:00)

การแปลงในเบราว์เซอร์ในเครื่องจะอัปโหลดข้อมูลคอนฟิกหรือไม่

ไม่ การแยกวิเคราะห์ JSON, การสร้าง TOML และการหลบหนีสตริงทั้งหมดเสร็จสิ้นในเอนจิน JavaScript ของเบราว์เซอร์ของคุณในเครื่อง จะไม่ถูกส่งผ่านเครือข่ายไปยังเซิร์ฟเวอร์ใดๆ ใช้งานได้แม้ไม่มีอินเทอร์เน็ต JSON ที่มีข้อมูลคอนฟิกที่ละเอียดอ่อน เช่น รหัสผ่านฐานข้อมูล คีย์ API ที่อยู่อินทราเน็ต สามารถแปลงได้อย่างสบายใจ

การแก้ไขปัญหา

JSON รายงาน "Unexpected token" แก้ไขอย่างไร

นี่คือข้อผิดพลาดทางไวยากรณ์ JSON สาเหตุทั่วไป: ①จุลภาคเกินที่ท้าย (trailing comma) เช่น {"a":1,}; ②ใช้เครื่องหมายคำพูดเดี่ยวห่อสตริง เช่น {'a':1} (JSON ต้องใช้เครื่องหมายคำพูดคู่); ③ชื่อคีย์ไม่มีเครื่องหมายคำพูด เช่น {a:1}; ④คอมเมนต์ // หรือ /* */ (มาตรฐาน JSON ไม่รองรับ) สามารถใช้เครื่องมือซ่อมแซม JSON ของเว็บไซต์นี้เพื่อซ่อมข้อผิดพลาดทั่วไปเหล่านี้โดยอัตโนมัติด้วยคลิกเดียว แล้ววางลงในเครื่องมือนี้เพื่อแปลงอีกครั้ง

TOML ที่แปลงแล้วรายงาน "invalid TOML" ใน Cargo

มักเกิดจากการชนกันของชื่อฟิลด์หรือฟิลด์บังคับที่ขาดหายไป ตัวแยกวิเคราะห์ TOML เข้มงวดมากกับเส้นทางส่วนหัวตาราง ชื่อคีย์ซ้ำ และการหลบหนีอักขระ กรุณาตรวจสอบ: ①มีชื่อคีย์ซ้ำในขอบเขตเดียวกันหรือไม่; ②อักขระพิเศษในสตริงถูกหลบหนีอย่างถูกต้องหรือไม่ (เครื่องหมายคำพูดคู่ แบ็กสแลช ขึ้นบรรทัดใหม่); ③ลำดับชั้นซ้อนลึกเกินไปหรือไม่ (TOML 1.0 แนะนำไม่เกิน 5 ชั้น); ④ขาดส่วนบังคับของ Cargo เช่น [package] หรือไม่ ไวยากรณ์ที่ส่งออกจากเครื่องมือนี้ถูกต้องตามกฎหมาย 100% ปัญหามักอยู่ที่ฝั่งผู้ใช้ (เช่น ชื่อฟิลด์เป็นไปตามข้อกำหนดของ Cargo หรือไม่)

อาเรย์ของออบเจ็กต์ถูกแปลงเป็นอาเรย์อินไลน์แทนที่จะเป็นอาเรย์ของตาราง

อาเรย์ JSON จะถูกแปลงเป็นอาเรย์อินไลน์ ["a","b"] ก็ต่อเมื่อองค์ประกอบทั้งหมดเป็นประเภทพื้นฐาน (สตริง/ตัวเลข/บูลีน/null) เท่านั้น อาเรย์ของออบเจ็กต์ (เช่น [{"name":"x"}]) จะถูกแปลงเป็นอาเรย์ของตาราง [[items]] หากอาเรย์ของออบเจ็กต์ของคุณถูกระบุผิดเป็นอาเรย์อินไลน์ แสดงว่ามีองค์ประกอบที่ไม่ใช่ออบเจ็กต์ปะปนอยู่ กรุณาตรวจสอบข้อมูล: ①มีสตริงหรือตัวเลขปะปนในอาเรย์หรือไม่; ②ลำดับชั้นซ้อนถูกทำลายหรือไม่

ชื่อคีย์บางตัวมีเครื่องหมายคำพูดหลังแปลง จะลบออกได้อย่างไร

TOML กำหนดว่าชื่อคีย์สามารถมีได้เฉพาะตัวอักษร ตัวเลข ขีดล่าง และขีดกลาง ([A-Za-z0-9_-]) หากชื่อคีย์ JSON มีอักขระพิเศษ (เช่น ช่องว่าง จุด ภาษาจีน อิโมจิ คำสงวน) เครื่องมือจะห่อด้วยเครื่องหมายคำพูดคู่โดยอัตโนมัติเพื่อให้ TOML ถูกกฎหมาย เช่น {"my key": 1} จะถูกแปลงเป็น "my key" = 1 หากเครื่องมือปลายทางของคุณไม่ยอมรับชื่อคีย์ที่มีเครื่องหมายคำพูด กรุณาเปลี่ยนชื่อคีย์ JSON เป็นอักขระที่ถูกกฎหมาย (A-Z a-z 0-9 _ -) ก่อนแปลง

เบราว์เซอร์ค้างเมื่อแปลงไฟล์ขนาดใหญ่ ทำอย่างไร

เครื่องมือมีการเพิ่มประสิทธิภาพการแปลงแบบเรียลไทม์ (แปลงทันทีที่ป้อนข้อมูล) แต่ไฟล์ขนาดใหญ่มาก (>1MB, หลายแสนบรรทัด) อาจยังมีความกดดัน คำแนะนำ: ①ใช้เครื่องมือจัดรูปแบบ JSON เพื่อตรวจสอบว่า JSON ถูกกฎหมายหรือไม่ก่อน; ②แปลงเป็นชุดๆ (เช่น แยกตามคีย์ระดับบนสุด); ③ยืนยันว่าเบราว์เซอร์มีหน่วยความจำเพียงพอ; ④ไฟล์คอนฟิกขนาดใหญ่มาก (10MB+) แนะนำให้ใช้เครื่องมือบรรทัดคำสั่ง เช่น taplo, tomlq เครื่องมือนี้ออกแบบมาสำหรับสถานการณ์คอนฟิกรายวัน (ระดับ KB ถึงหลายร้อย KB)

อภิธานศัพท์

TOML: Tom's Obvious, Minimal Language ภาษารูปแบบที่ออกแบบมาสำหรับไฟล์คอนฟิก ไวยากรณ์กระชับไม่คลุมเครือ เป็นรูปแบบคอนฟิกเริ่มต้นของ Rust Cargo / Python pyproject / Hugo
Table (ตาราง): กลุ่มที่มีชื่อใน TOML ที่ประกาศด้วย [name] เทียบเท่ากับออบเจ็กต์ใน JSON รองรับการซ้อนด้วยจุด เช่น [server.ssl]
Array of Tables (อาเรย์ของตาราง): รายการออบเจ็กต์ที่เป็นเนื้อเดียวกันที่ประกาศด้วย [[name]] ใน TOML แต่ละส่วน [[name]] มีฟิลด์ทั้งหมดของออบเจ็กต์ เทียบเท่ากับอาเรย์ของออบเจ็กต์ใน JSON
Inline Table (ตารางอินไลน์): ไวยากรณ์ที่รองรับใน TOML 1.0 ใช้ { key = value, key = value } ประกาศออบเจ็กต์อย่างง่ายในบรรทัดเดียว เหมาะสำหรับออบเจ็กต์แบนที่ไม่ต้องการตั้งชื่อ
Cargo.toml: ไฟล์คอนฟิกมาตรฐานของโปรเจกต์ Rust กำหนดเมทาดาต้าของแพ็กเกจ, dependencies, dev-dependencies, features ฯลฯ ในรูปแบบ TOML
pyproject.toml: ไฟล์คอนฟิกมาตรฐานของโปรเจกต์ Python (PEP 621) กำหนด build-system, เมทาดาต้าของโปรเจกต์, dependencies, คอนฟิกเครื่องมือ (black/pytest/mypy ฯลฯ)
TOML v1.0: TOML 1.0 เป็นเวอร์ชันเสถียรที่เผยแพร่อย่างเป็นทางการในปี 2021 เครื่องมือนี้ปฏิบัติตามข้อกำหนดนี้อย่างเคร่งครัด (github.com/toml-lang/toml/blob/main/toml.md)
ออบเจ็กต์ซ้อน JSON: ออบเจ็กต์ที่มีออบเจ็กต์อื่นอยู่ภายในใน JSON สอดคล้องกับ Table ([section]) หรือตารางย่อย ([a.b.c]) ของ TOML
การหลบหนี TOML: อักขระพิเศษเช่นเครื่องหมายคำพูดคู่ แบ็กสแลช ขึ้นบรรทัดใหม่ในสตริง TOML ต้องถูกหลบหนีด้วยแบ็กสแลช (\", \\, \n) เครื่องมือนี้จัดการให้อัตโนมัติ
ไฟล์คอนฟิก (Config File): ไฟล์การตั้งค่าที่แอปพลิเคชันอ่านเมื่อเริ่มต้น แยกออกจากโค้ดเพื่อให้แก้ไขได้ง่าย TOML เป็นหนึ่งในมาตรฐานโดยพฤตินัยของไฟล์คอนฟิก

ตารางแมปประเภท JSON กับ TOML

เครื่องมือนี้แปลงประเภท JSON เป็นประเภท TOML ตามกฎต่อไปนี้:

ประเภท JSON	ประเภท TOML	ไวยากรณ์ TOML	คำอธิบาย
string	string	`key = "value"`	สตริง TOML ต้องห่อด้วยเครื่องหมายคำพูดคู่
integer	integer	`key = 8080`	จำนวนเต็มไม่มีจุดทศนิยม
float	float	`key = 3.14`	ทศนิยมต้องมีจุดทศนิยม
boolean	boolean	`key = true`	TOML ใช้ true / false ตัวพิมพ์เล็กเท่านั้น
null	string (ว่าง)	`key = ""`	TOML ไม่มีประเภท null จะถูกแปลงเป็นสตริงว่าง
array[primitive]	array	`key = ["a", "b"]`	อาเรย์ประเภทพื้นฐานใช้วงเล็บเหลี่ยมอินไลน์
array[object]	array of tables	`[[items]]\nkey = value`	อาเรย์ของออบเจ็กต์ใช้อาเรย์ของตาราง [[name]]
object	table	`[name]\nkey = value`	ออบเจ็กต์ใช้การประกาศตาราง [name]

ตารางเปรียบเทียบการหลบหนีสตริง TOML

อักขระพิเศษที่ต้องหลบหนีในสตริง TOML:

อักขระดั้งเดิม	หลังหลบหนี TOML	ชื่อ	สถานการณ์ตัวอย่าง
`"`	`\"`	เครื่องหมายคำพูดคู่	ซ้อนเครื่องหมายคำพูดคู่ในสตริง
`\`	`\\`	แบ็กสแลช	พาธ Windows C:\Users
`ขึ้นบรรทัดใหม่`	`\n`	Newline	บีบอัดสตริงหลายบรรทัด
`แท็บ`	`\t`	Tab	ฟิลด์แท็บ
`ขึ้นบรรทัดเก่า`	`\r`	Carriage Return	ขึ้นบรรทัดใหม่ Windows CRLF
`\b`	`\b`	Backspace	อักขระถอยกลับ
`\f`	`\f`	Form Feed	อักขระป้อนกระดาษ
`U+0000`	`\u0000`	Unicode 0	อักขระควบคุมต้องใช้ \u หลบหนี

ตารางเปรียบเทียบตัวอย่าง JSON เป็น TOML

อินพุต JSON ที่มีโครงสร้างซับซ้อนและเอาต์พุต TOML ที่สอดคล้องกัน:

โครงสร้าง	ตัวอย่าง
อินพุต JSON	`{ "name": "app", "port": 8080 }`
เอาต์พุต TOML	`name = "app" port = 8080`
อินพุต JSON	`{ "server": { "host": "0.0.0.0", "port": 443 } }`
เอาต์พุต TOML	`[server] host = "0.0.0.0" port = 443`
อินพุต JSON	`{ "hosts": [{"ip":"10.0.0.1"},{"ip":"10.0.0.2"}] }`
เอาต์พุต TOML	`[[hosts]] ip = "10.0.0.1" [[hosts]] ip = "10.0.0.2"`

Privacy & Security

การพาร์ส JSON, การสร้าง TOML, การ escape สตริง และการอ่านไฟล์ทั้งหมดทำงานแบบโลคอลภายใน JavaScript ของเบราว์เซอร์คุณ JSON ที่ป้อนเข้าและ TOML ที่สร้างขึ้นจะไม่ถูกส่งไปยังเซิร์ฟเวอร์หรือเก็บไว้เพื่อวิเคราะห์ จึงเหมาะกับข้อมูลคอนฟิกที่มีความอ่อนไหว เช่น รหัสผ่านฐานข้อมูล, API key หรือที่อยู่เครือข่ายภายใน ประวัติในเครื่องจะเก็บไว้เฉพาะใน localStorage ของเบราว์เซอร์และลบได้ด้วยการล้างแคช

Authoritative References

toml-langข้อกำหนดอย่างเป็นทางการของ TOML v1.0
GitHubที่เก็บ GitHub ของ TOML
WikipediaTOML - วิกิพีเดีย
Rust อย่างเป็นทางการข้อมูลอ้างอิงฟิลด์ Cargo.toml