ตัวแปลง TOML เป็น JSON

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

TOML (Tom's Obvious Minimal Language) เป็นรูปแบบไฟล์กำหนดค่าที่ออกแบบมาเพื่อให้มนุษย์อ่านง่ายด้วยความหมายที่ชัดเจน มีการใช้งานใน Cargo (Rust), Poetry (Python) และเครื่องมืออื่นๆ อีกมากมาย การแปลง TOML เป็น JSON มีประโยชน์เมื่อคุณต้องการส่งการกำหนดค่าไปยังระบบที่รองรับเฉพาะ JSON, ตรวจสอบการตั้งค่าที่ซ้อนกันด้วยภาพ หรือแชร์ข้อมูลกับ web APIs ที่สื่อสารด้วย JSON

Q: ตัวแปลงนี้รองรับ arrays of tables และ inline tables หรือไม่?

ใช่ ตัวแปลงรองรับไวยากรณ์ [[array.of.tables]] อย่างเต็มรูปแบบ (แปลงเป็น JSON arrays of objects), รองรับ inline tables เช่น {a = 1, b = 2} (แปลงเป็น JSON objects), sub-tables ที่ซ้อนกัน, dotted keys และการซ้อนกันในระดับความลึกที่ต้องการ

Q: รองรับรูปแบบเอาต์พุตแบบใดบ้าง?

มี 4 รูปแบบ: แบบสวยงาม 2 ช่องว่าง (ค่าเริ่มต้น เหมาะสำหรับการอ่าน), แบบสวยงาม 4 ช่องว่าง (ตรงกับสไตล์การย่อหน้าแบบ PEP-8), แบบกระชับ (JSON บรรทัดเดียวที่มีขนาดเล็กที่สุด) และแบบเรียงลำดับคีย์ (เอาต์พุตสวยงามที่เรียงลำดับคีย์ตามตัวอักษรเพื่อให้ง่ายต่อการเปรียบเทียบความต่าง)

Q: TOML datetimes ถูกแปลงเป็น JSON อย่างไร?

JSON ไม่มีประเภทข้อมูล datetime โดยกำเนิด ดังนั้น TOML datetimes (รูปแบบ RFC 3339 เช่น 2026-04-25T12:00:00Z) จะถูกรักษาไว้ในรูปแบบสตริงในเอาต์พุต JSON ทั้งวันเวลาท้องถิ่นและ offset datetimes จะถูกเก็บไว้ตามเดิม พร้อมสำหรับการนำไปวิเคราะห์ต่อด้วยไลบรารีวันเวลาใดๆ

Q: จะเกิดอะไรขึ้นกับค่า inf และ nan ของ TOML?

มาตรฐาน JSON ไม่อนุญาตให้ใช้ค่าคงที่ Infinity หรือ NaN ดังนั้นค่า floats ที่ไม่สิ้นสุดจาก TOML (inf, -inf, nan) จะถูกแปลงเป็น null ในเอาต์พุต JSON เพื่อให้ผลลัพธ์เป็นไปตามมาตรฐาน RFC 8259 และสามารถใช้งานได้กับทุกไลบรารี JSON

Q: ข้อผิดพลาดในการประมวลผลมาจากไหนและจะแก้ไขได้อย่างไร?

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

แปลงการตั้งค่า TOML เป็น JSON ได้ทันทีด้วยเครื่องมือออนไลน์ฟรีนี้ รองรับตารางซ้อนกัน (Nested Tables), อาร์เรย์ของตาราง (Arrays of Tables), ตารางแบบบรรทัดเดียว (Inline Tables), ข้อความหลายบรรทัด และมีรูปแบบผลลัพธ์แบบสวยงาม/กะทัดรัด/เรียงลำดับ การแสดงภาพโครงสร้าง การแจ้งเตือนข้อผิดพลาดตามบรรทัด และตัวอย่างในคลิกเดียว

ตัวแปลง TOML เป็น JSON

⚡ ตัวอย่างด่วน (คลิกเพื่อโหลด)

① TOML ของคุณ 0 ตัวอักษร · 0 บรรทัด · 0 บรรทัดที่มีข้อมูล

② รูปแบบเอาต์พุต

📐 สวยงาม (2 ช่องว่าง)

เริ่มต้น — อ่านง่าย, กระชับ

📏 สวยงาม (4 ช่องว่าง)

การย่อหน้าสไตล์ PEP-8

🗜 กระชับ

ย่อขนาดเหลือบรรทัดเดียว

🔤 เรียงลำดับคีย์

ง่ายต่อการเปรียบเทียบไฟล์

Embed ตัวแปลง TOML เป็น JSON Widget

เกี่ยวกับ ตัวแปลง TOML เป็น JSON

ยินดีต้อนรับสู่ ตัวแปลง TOML เป็น JSON เครื่องมือออนไลน์ฟรีที่เปลี่ยนการกำหนดค่า TOML ให้เป็น JSON ที่สะอาดและถูกต้องในคลิกเดียว ไม่ว่าคุณกำลังย้าย Cargo.toml ไปยังไปป์ไลน์ที่ใช้ JSON, ตรวจสอบการตั้งค่าที่ซ้อนกันด้วยภาพ หรือส่งไฟล์ TOML ไปยังบริการที่รองรับเฉพาะ JSON ตัวแปลงนี้จัดการทุกโครงสร้างของ TOML ได้อย่างถูกต้อง: ทั้ง tables, sub-tables, arrays of tables, inline tables, dotted keys, multi-line strings, เลขฐานสิบหก/ฐานแปด/ฐานสอง, วันที่ และค่า floats พิเศษ เลือกรูปแบบเอาต์พุตที่เหมาะกับงานของคุณ ไม่ว่าจะเป็นแบบสวยงาม 2 ช่องว่าง, สวยงาม 4 ช่องว่าง, แบบกระชับ หรือแบบเรียงลำดับตามคีย์ และตรวจสอบผลลัพธ์ผ่านโครงสร้างแบบต้นไม้ แดชบอร์ดสถิติ และแผนภาพการแปลง

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

TOML (Tom's Obvious Minimal Language) เป็นรูปแบบการกำหนดค่าที่ถูกออกแบบมาให้ไม่มีความคลุมเครือและอ่านง่ายสำหรับมนุษย์ เป็นขุมพลังให้กับ metadata ของแพ็กเกจสำหรับ Cargo (Rust), Poetry (Python) และเครื่องมือสำหรับนักพัฒนาอื่นๆ อีกมากมาย ในขณะที่ JSON เป็นรูปแบบการแลกเปลี่ยนข้อมูลที่เป็นสากลบนเว็บ ระบบจำนวนมาก เช่น REST APIs, ฐานข้อมูลเอกสาร, localStorage ในเบราว์เซอร์ และแอป JavaScript รองรับเฉพาะ JSON เท่านั้น การแปลง TOML เป็น JSON ช่วยให้คุณเชื่อมต่อโลกทั้งสองใบนี้เข้าด้วยกันโดยไม่ต้องเขียนการกำหนดค่าใหม่

เหตุผลยอดนิยมในการแปลง TOML เป็น JSON

ส่งต่อ TOML ไปยัง API ที่รองรับเฉพาะ JSON — เช่น บริการการปรับใช้ (deployment) หรือแพลตฟอร์ม Feature-flag
ตรวจสอบการกำหนดค่าที่ซ้อนกันอย่างลึกซึ้งด้วยภาพ — โครงสร้างวงเล็บและปีกกาของ JSON ทำให้เห็นลำดับชั้นได้ชัดเจนในพริบตา
สร้างชุดการกำหนดค่าสำหรับ Front-end — เขียนไฟล์ต้นฉบับในรูปแบบ TOML แล้วส่ง JSON ไปยังเบราว์เซอร์
ใช้งานร่วมกับ Linter และ JSON Schema — ตรวจสอบโครงสร้าง TOML โดยการส่งผ่านตัวตรวจสอบ JSON Schema
เปรียบเทียบการกำหนดค่า — เปรียบเทียบ JSON ที่เรียงลำดับคีย์แล้วระหว่างสภาพแวดล้อมต่างๆ เพื่อหาจุดที่แตกต่าง
ย้ายการกำหนดค่าแบบเก่า — ค่อยๆ ทยอยย้ายไฟล์ TOML เข้าสู่บริการกำหนดค่าที่ใช้ JSON เป็นฐาน

คุณสมบัติหลักของตัวแปลงนี้

รองรับ TOML 1.0 ครบถ้วน — ทั้ง basic และ literal strings (บรรทัดเดียวและหลายบรรทัด), ตัวเลขจำนวนเต็มในฐานสิบ/สิบหก/แปด/สอง พร้อมเครื่องหมายขีดล่างคั่น, เลขทศนิยมพร้อมสัญลักษณ์ทางวิทยาศาสตร์, inf, -inf, nan, ค่าบูลีน, วันที่ และวันเวลา
โครงสร้างที่ซ้อนกัน — tables, sub-tables ([a.b.c]), arrays of tables ([[a]]), inline tables ({ a = 1, b = 2 }) และ dotted keys
รูปแบบเอาต์พุต 4 สไตล์ — สวยงาม 2 ช่องว่าง, สวยงาม 4 ช่องว่าง, แบบกระชับ (minified) และแบบเรียงลำดับคีย์เพื่อการเปรียบเทียบไฟล์ที่ง่ายขึ้น
โครงสร้างต้นไม้แบบภาพ — ดูว่าโครงสร้าง TOML กลายเป็น JSON objects และ arrays อย่างไร พร้อมป้ายระบุประเภท (table, AoT, array, string, number, bool)
แดชบอร์ดสถิติ — นับจำนวนตาราง, คีย์, อาร์เรย์, arrays of tables, ระดับความลึก พร้อมจำนวนตัวอักษรขาเข้าและขาออก
ข้อความแจ้งเตือนข้อผิดพลาดระบุบรรทัด — ทุกข้อผิดพลาดในการประมวลผลจะระบุเลขบรรทัดที่แน่นอนเพื่อให้คุณแก้ไขได้ทันที
ไลบรารีตัวอย่างในคลิกเดียว — โหลดตัวอย่างสไตล์ Cargo.toml, pyproject, การกำหนดค่าแอปพลิเคชัน, ตัวเลข หรือสตริงหลายบรรทัด
คัดลอกและดาวน์โหลด — คัดลอก JSON ไปยังคลิปบอร์ดหรือดาวน์โหลดเป็นไฟล์ .json
รองรับมือถือ — ใช้งานได้อย่างสะดวกบนโทรศัพท์ แท็บเล็ต และเดสก์ท็อป
ข้อมูลไม่หลุดออกจากเบราว์เซอร์ — TOML จะถูกประมวลผลในฝั่งเซิร์ฟเวอร์และส่งผลลัพธ์กลับมาในคำขอเดิม ไม่มีการเก็บข้อมูลไว้

การจับคู่ TOML เป็น JSON

โครงสร้างส่วนใหญ่ของ TOML สามารถแปลงเป็น JSON ได้อย่างสมบูรณ์และไม่มีการสูญเสียข้อมูล นี่คือการจับคู่ที่ตัวแปลงใช้งาน:

โครงสร้าง TOML	สิ่งที่เทียบเท่าใน JSON	หมายเหตุ
`key = "string"`	`"key": "string"`	Basic strings จะคงลำดับการหลบ (escape sequences); literal strings จะเป็นไปตามตัวอักษรจริง
`key = 42`	`"key": 42`	เลขจำนวนเต็มฐานสิบ, ฐานสิบหก (`0x`), ฐานแปด (`0o`) และฐานสอง (`0b`) ทั้งหมดจะกลายเป็นตัวเลข JSON
`key = 3.14`	`"key": 3.14`	เลขทศนิยมจะคงความแม่นยำ; `inf`/`nan` จะกลายเป็น `null` เพื่อให้เป็น JSON ที่ถูกต้อง
`key = true`	`"key": true`	ค่าบูลีนจะจับคู่กันโดยตรง
`key = 2026-04-25T12:00:00Z`	`"key": "2026-04-25T12:00:00Z"`	JSON ไม่มีประเภทข้อมูล datetime ดังนั้นสตริง RFC 3339 จะถูกรักษาไว้
`key = [1, 2, 3]`	`"key": [1, 2, 3]`	Arrays จะกลายเป็น JSON arrays
`[table] k = 1`	`"table": { "k": 1 }`	Tables จะกลายเป็น objects
`[a.b.c] k = 1`	`"a": { "b": { "c": { "k": 1 } } }`	Sub-tables จะซ้อนกันโดยนัย
`[[items]] k = 1`	`"items": [{ "k": 1 }]`	Array of tables จะกลายเป็น array of objects
`k = { a = 1, b = 2 }`	`"k": { "a": 1, "b": 2 }`	Inline tables เทียบเท่ากับ JSON objects
`a.b.c = 1`	`"a": { "b": { "c": 1 } }`	Dotted keys จะสร้างการซ้อนกันโดยนัย

ตัวอย่าง

TOML ขาเข้า

title = "App"
[server]
host = "localhost"
port = 8080

JSON ขาออก

{
  "title": "App",
  "server": {
    "host": "localhost",
    "port": 8080
  }
}

TOML ขาเข้า (array of tables)

[[user]]
name = "Alice"
admin = true

[[user]]
name = "Bob"
admin = false

JSON ขาออก

{
  "user": [
    { "name": "Alice", "admin": true },
    { "name": "Bob",   "admin": false }
  ]
}

TOML ขาเข้า (dotted keys + inline)

db.host = "10.0.0.1"
db.port = 5432
db.options = { ssl = true, pool = 20 }

JSON ขาออก

{
  "db": {
    "host": "10.0.0.1",
    "port": 5432,
    "options": { "ssl": true, "pool": 20 }
  }
}

วิธีใช้งานตัวแปลง TOML เป็น JSON

วาง TOML ของคุณ ลงในกล่องข้อมูลขาเข้า หรือคลิกที่ปุ่มตัวอย่างด่วนเพื่อโหลดการกำหนดค่าทั่วไป
เลือกรูปแบบเอาต์พุต — แบบสวยงาม 2 ช่องว่าง (ค่าเริ่มต้น), สวยงาม 4 ช่องว่าง, แบบกระชับ หรือแบบเรียงลำดับคีย์
คลิก Convert to JSON เครื่องมือจะประมวลผล TOML และแสดงผลลัพธ์ JSON พร้อมสถิติและโครงสร้างต้นไม้
ตรวจสอบผลลัพธ์ — ดูแดชบอร์ดสถิติเพื่อสรุปข้อมูลในพริบตา ขยายโครงสร้างต้นไม้เพื่อดูลำดับชั้น และดูแผนภาพการแปลงเพื่อทำความเข้าใจการจับคู่ข้อมูล
คัดลอกหรือดาวน์โหลด JSON ปุ่ม Copy จะเก็บข้อมูลไว้ในคลิปบอร์ด ปุ่ม Download จะบันทึกเป็นไฟล์ converted.json

คุณสมบัติ TOML ที่รองรับ

สตริง (Strings)

Basic strings ใช้เครื่องหมายอัญประกาศคู่และรองรับ escape sequences: \n, \t, \r, \", \\, \uXXXX, \UXXXXXXXX
Literal strings ใช้เครื่องหมายอัญประกาศเดี่ยวและเก็บตัวอักษรตามจริงโดยไม่มีการ escape
Multi-line basic strings ใช้เครื่องหมายอัญประกาศคู่ 3 อัน (""") และรองรับ backslash ท้ายบรรทัดเพื่อตัดช่องว่าง
Multi-line literal strings ใช้เครื่องหมายอัญประกาศเดี่ยว 3 อัน (''') และรักษาทุกอย่างไว้ตามต้นฉบับ

ตัวเลข (Numbers)

เลขจำนวนเต็มฐานสิบ พร้อมตัวเลือกเครื่องหมายขีดล่างคั่น: 1_000_000
เลขจำนวนเต็มฐานสิบหก/แปด/สอง: 0xDEADBEEF, 0o755, 0b1010
เลขทศนิยม พร้อมตัวเลือกเครื่องหมาย, จุดทศนิยม และเลขยกกำลัง: 3.14, -2e-3, 6.022e23
เลขทศนิยมพิเศษ: inf, -inf, nan (แปลงเป็น null ใน JSON)

ตารางและอาร์เรย์ (Tables and Arrays)

Tables: [name] เพื่อเปิดตารางใหม่
Sub-tables: [a.b.c] เพื่อสร้างตารางซ้อนกัน
Arrays of tables: [[name]] เพื่อเพิ่มตารางใหม่เข้าไปในอาร์เรย์
Inline tables: { a = 1, b = 2 }
Arrays: [1, 2, 3] สามารถเขียนได้หลายบรรทัดและมีประเภทข้อมูลผสมกันได้

การเลือกรูปแบบเอาต์พุตที่เหมาะสม

สวยงาม 2 ช่องว่าง (Pretty 2-space) — ค่าเริ่มต้น กระชับแต่อ่านง่าย เหมาะสำหรับการใช้งานส่วนใหญ่ รวมถึงไฟล์กำหนดค่าที่เก็บใน git
สวยงาม 4 ช่องว่าง (Pretty 4-space) — ตรงกับสไตล์การย่อหน้าแบบ PEP-8 เป็นที่นิยมในทีมพัฒนา Python และ Java
แบบกระชับ (Compact/minified) — บรรทัดเดียว ไม่มีช่องว่างส่วนเกิน มีขนาดข้อมูลเล็กที่สุดสำหรับการส่งผ่านเครือข่าย
แบบเรียงลำดับคีย์ (Sorted keys) — เอาต์พุตสวยงามที่เรียงลำดับคีย์ตามตัวอักษร ดีเยี่ยมสำหรับการเปรียบเทียบความต่าง (diff) เพราะการกำหนดค่าที่เหมือนกันจะให้ผลลัพธ์ที่ตรงกันทุกไบต์เสมอ

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

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

TOML เป็นรูปแบบการกำหนดค่าที่ออกแบบมาให้ชัดเจนและเรียบง่าย การแปลงเป็น JSON ช่วยให้คุณนำการกำหนดค่าไปใช้กับระบบที่รองรับเฉพาะ JSON, ตรวจสอบโครงสร้างที่ซ้อนกันด้วยภาพ, แชร์กับ web APIs และรวมเข้ากับโค้ด JavaScript ที่รอรับ JSON ได้

ตัวแปลงนี้รองรับ arrays of tables และ inline tables หรือไม่?

ใช่ ตัวแปลงรองรับไวยากรณ์ [[array.of.tables]] (แปลงเป็น JSON arrays of objects), inline tables เช่น { a = 1, b = 2 } (แปลงเป็น JSON objects), sub-tables ที่ซ้อนกัน, dotted keys และการซ้อนกันไม่จำกัดระดับ

รองรับรูปแบบเอาต์พุตแบบใดบ้าง?

มี 4 สไตล์: แบบสวยงาม 2 ช่องว่าง (ค่าเริ่มต้น เหมาะสำหรับการอ่าน), แบบสวยงาม 4 ช่องว่าง (สไตล์ PEP-8), แบบกระชับ (JSON บรรทัดเดียวขนาดเล็กที่สุด) และแบบเรียงลำดับคีย์ (เหมาะสำหรับการเปรียบเทียบความต่างของไฟล์)

TOML datetimes ถูกแปลงเป็น JSON อย่างไร?

JSON ไม่มีประเภทข้อมูล datetime ดังนั้น TOML datetimes (รูปแบบ RFC 3339 เช่น 2026-04-25T12:00:00Z) จะถูกเก็บเป็นสตริงในเอาต์พุต JSON ข้อมูลวันเวลาทั้งหมดจะถูกรักษาไว้ตามเดิมเพื่อให้ไลบรารีอื่นนำไปใช้งานต่อได้

จะเกิดอะไรขึ้นกับค่า inf และ nan ของ TOML?

มาตรฐาน JSON ไม่อนุญาตให้ใช้ Infinity หรือ NaN ดังนั้นค่าเหล่านี้จาก TOML (inf, -inf, nan) จะถูกแปลงเป็น null ในเอาต์พุต JSON เพื่อให้เป็นไปตามมาตรฐาน RFC 8259

ข้อผิดพลาดในการประมวลผลมาจากไหนและจะแก้ไขได้อย่างไร?

ตัวแปลงจะแจ้งบรรทัดที่เกิดปัญหาพร้อมคำอธิบาย (เช่น สตริงไม่ปิด, คีย์ซ้ำ, ลืมเครื่องหมายเท่ากับ ฯลฯ) สาเหตุส่วนใหญ่มักเกิดจากการลืมปิดเครื่องหมายคำพูดหรือวงเล็บ หรือการนิยามตารางซ้ำ

มีจำกัดขนาดไฟล์หรือไม่?

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

ข้อมูล TOML ของฉันถูกส่งไปที่ไหนหรือถูกเก็บไว้หรือไม่?

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

ฉันสามารถแปลง JSON กลับเป็น TOML ได้หรือไม่?

เครื่องมือนี้ทำงานแบบทางเดียว (TOML → JSON) สำหรับการแปลงย้อนกลับ โปรดใช้ตัวแปลง JSON-to-TOML หรือไลบรารีในภาษาโปรแกรมต่างๆ เช่น tomli_w (Python), @iarna/toml (JavaScript) หรือ toml crate (Rust)

เคล็ดลับสำหรับการแปลงข้อมูลที่สะอาด

ใช้เอาต์พุตแบบเรียงลำดับคีย์สำหรับการเปรียบเทียบไฟล์ — เพื่อให้ JSON ในระบบควบคุมเวอร์ชัน (version control) มีความเสถียรเสมอ
เลือกใช้สตริงหลายบรรทัด (""" หรือ ''') สำหรับข้อความยาวๆ แทนการต่อสตริงด้วย \n
จัดกลุ่มคีย์ที่เกี่ยวข้องด้วยตาราง (tables) — จะช่วยให้อ่านง่ายกว่าการใช้ dotted keys ยาวๆ
ระวังการนิยามตารางซ้ำซ้อน — TOML ไม่อนุญาตให้กำหนดตารางเดิมสองครั้ง ซึ่งตัวแปลงจะแจ้งเตือนข้อผิดพลาดนี้อย่างชัดเจน
ใช้วันเวลาในรูปแบบ RFC 3339 — เพื่อให้สามารถนำไปใช้งานต่อในระบบ JSON อื่นๆ ได้อย่างไร้รอยต่อ