JSON เป็น Go

โค้ด Go

ยังไม่มีเนื้อหา

พร้อม

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

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

จัดรูปแบบ JSON

ซ่อมแซม JSON

JSON เป็น TypeScript

JSON เป็น Java

JSON เป็น CSV

JSON → YAML

คิวรี JSONPath

เครื่องมือสร้าง JSON

เกี่ยวกับ JSON เป็น Go: การเปลี่ยน JSON เป็น struct ที่มีประเภทแข็งแรงของ Go

JSON เป็น Go คือกระบวนการแปลงข้อมูลในรูปแบบ JSON เป็นนิยามประเภท struct ของภาษา Go โดยอัตโนมัติ JSON เป็นรูปแบบแลกเปลี่ยนข้อมูลที่พบบ่อยที่สุดใน REST API ไฟล์คอนฟิก คิวข้อความและบันทึก ในขณะที่ Go เป็นภาษาที่มีประเภทแข็งแรง; ในระหว่างการพัฒนา โครงสร้างไดนามิกของ JSON มักจำเป็นต้องแมปกับ struct ก่อนที่จะดีซีเรียลไลซ์ด้วย encoding/json การเขียน struct ด้วยตนเอง โดยเฉพาะอ็อบเจกต์ซ้อน มักนำไปสู่การขาดฟิลด์หรือประเภทที่ผิดได้ง่าย; เครื่องมือนี้มีจุดมุ่งหมายเพื่อทำให้งานที่ซ้ำๆ เป็นอัตโนมัติ

struct ของ Go เป็นประเภทข้อมูลผสม ประกาศด้วย `type Name struct { ... }` แต่ละฟิลด์ประกอบด้วยชื่อและประเภท; ชื่อฟิลด์ต้องขึ้นต้นด้วยตัวพิมพ์ใหญ่จึงจะสามารถเข้าถึงได้จากแพ็กเกจอื่น ซึ่งเรียกว่า 'ตัวระบุที่ส่งออก' เครื่องมือจะแปลงชื่อฟิลด์ JSON เป็นชื่อฟิลด์ที่ส่งออก PascalCase โดยอัตโนมัติ ตัวอย่างเช่น `user_name` จะแมปเป็น `UserName` โดยเก็บคีย์เดิมไว้ในแท็ก json

การแปลงหลักของเครื่องมือนี้ดำเนินการโดย Web Worker jsonFormat ภายในเบราว์เซอร์ ซึ่งเรียกตัวเรนเดอร์ Go ของ quicktype-core ด้วยตัวเลือก `just-types` และ `no-comments` กระบวนการทั้งหมดไม่ขึ้นกับบริการแบ็กเอนด์: JSON ที่ป้อนจะถูกแยกวิเคราะห์ในเครื่อง อนุมานประเภท สร้างโค้ด Go และสุดท้ายนำเสนอในตัวแก้ไขด้านขวา

การอนุมานประเภทเป็นไปตามการแมป JSON ไปยัง Go ทั่วไป: สตริงแมปเป็น `string`, บูลีนเป็น `bool`, จำนวนเต็มเป็น `int64`, จำนวนทศนิยมเป็น `float64`, อาร์เรย์เป็น slice `[]T`, อ็อบเจกต์เป็น struct อิสระ, `null` เป็น `interface{}` อ็อบเจกต์ซ้อนจะถูกประมวลผลแบบเรียกซ้ำ รักษาลำดับชั้นที่ชัดเจน

เมื่อเปรียบเทียบกับการเขียนด้วยตนเอง โค้ดที่สร้างโดยเครื่องมือเป็น 'ร่างแรกที่ทำงานได้' นักพัฒนามักจะต้องปรับแต่งชื่อประเภทราก ชื่อแพ็กเกจ ความแม่นยำของประเภทฟิลด์ (เช่น int64 เป็น int) และว่าจะใช้ประเภทพอยน์เตอร์หรือไม่ ก่อนที่จะนำไปวางในโปรเจกต์ Go จริง เมื่อรวมกับการคัดลอกในคลิกเดียวและการดาวน์โหลด model.go งานที่ซ้ำๆ ในขั้นตอนการรวมและการสร้างแบบจำลองจะลดลงอย่างมาก

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

การพัฒนาแบ็กเอนด์ Go แปลง JSON การตอบกลับ REST API เป็น struct เชื่อมโยงโดยตรงกับพารามิเตอร์ตัวจัดการ Gin/Echo/Fiber ด้วย json.Unmarshal
ในระหว่างการรวมฟรอนต์เอนด์-แบ็กเอนด์ นำ JSON การตอบกลับตัวอย่างจาก Postman สร้างโมเดล Go อย่างรวดเร็วเพื่อลดการพิมพ์ฟิลด์ด้วยตนเอง
เมื่อรวมการเรียกกลับ Webhook ของบุคคลที่สาม แปลง JSON เพย์โหลดเป็น struct Go เพื่อการเข้าถึงและตรวจสอบระดับฟิลด์ที่สะดวก
แปลงไฟล์คอนฟิก JSON จาก Viper/Consul/Nacos เป็นประเภท Go แทนที่การเข้าถึง map[string]interface{} ที่มีประเภทอ่อนแอ
ทีมไมโครเซอร์วิสร่วมกันกำหนดโครงสร้างคำขอ/ตอบกลับสำหรับอินเทอร์เฟซ gRPC/HTTP แปลง JSON ตัวอย่างเป็นประเภท Go ที่ใช้ร่วมกัน
วิศวกรทดสอบแปลง JSON fixture เป็น struct Go ใช้กับ testify สำหรับการทดสอบตามการยืนยัน
DevOps วิเคราะห์บรรทัดบันทึก JSON ที่รวบรวมโดย ELK/Fluentd สร้าง struct สำหรับการวิเคราะห์เชิงโครงสร้างด้วยโปรแกรม Go
หลังจากที่โปรแกรมขูดเว็บรวบรวมข้อมูล JSON แปลงเป็น struct Go ทำงานร่วมกับ gorm/gen หรือ ent เพื่อสร้างโมเดลฐานข้อมูล
ข้อมูลเทเลเมตรี JSON ที่รายงานโดยอุปกรณ์ IoT ถูกแปลงเป็น struct Go การดีซีเรียลไลซ์และการกรองในโปรแกรมเกตเวย์ขอบ
แปลงข้อความ JSON ที่บริโภคจาก Kafka/NATS/RabbitMQ เป็นประเภท Go สำหรับการใช้งานผู้บริโภคที่ขับเคลื่อนด้วยเหตุการณ์
นักพัฒนา SDK แปลง JSON การตอบกลับตัวอย่างของเซิร์ฟเวอร์เป็น struct Go เขียนลงในแพ็กเกจ types ของไลบรารีไคลเอ็นต์เพื่อให้ผู้ใช้อ้างอิง
แปลง JSON ตัวอย่างจากเอกสาร Swagger/OpenAPI เป็น struct Go เป็นตัวอย่างโค้ดเอกสารอินเทอร์เฟซ
นักเรียนหรือผู้สอนแปลง JSON ตัวอย่างเป็น struct ในระหว่างหลักสูตร Go สาธิตระบบประเภทของ Go และการใช้แท็ก json
สคริปต์ย้ายข้อมูลแปลงบรรทัด JSON ที่ส่งออกจาก MySQL/PostgreSQL เป็น struct Go สำหรับการแมปฟิลด์และการตรวจสอบประเภท
JSON คอนฟิก CI/CD ถูกแปลงเป็น struct Go สะดวกสำหรับการอ่านคอนฟิกที่มีประเภทแข็งแรงในเครื่องมือไปป์ไลน์ที่เขียนด้วย Go
โปรเจกต์เก่ารีแฟคเตอร์โค้ดอ่าน JSON แบบไดนามิกที่อาศัย map เป็นการเข้าถึงแบบอาศัย struct ที่มีประเภทแข็งแรง

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

วางเนื้อหา JSON ในตัวแก้ไขด้านซ้าย หรือลากและวางไฟล์ .json/.txt หรือคลิก 'ตัวอย่าง' เพื่อโหลดข้อมูลในตัว
รอประมาณ 400ms เครื่องมือจะแปลงโดยอัตโนมัติและแสดงโค้ด struct Go ที่สร้างขึ้นทางด้านขวา
หาก JSON มีข้อผิดพลาด ให้คลิกปุ่ม 'ซ่อมแซม JSON' เพื่อซ่อมแซมข้อผิดพลาดรูปแบบทั่วไปโดยอัตโนมัติ จากนั้นดำเนินการสร้างต่อ
ตรวจสอบผลลัพธ์ด้านขวา คลิก 'คัดลอก' เพื่อวางลงในโปรเจกต์ Go หรือคลิก 'ดาวน์โหลด' เพื่อบันทึกเป็นไฟล์ model.go

คุณสมบัติ

สร้าง struct Go ในเครื่องเบราว์เซอร์: การแยกวิเคราะห์ JSON และการสร้างโค้ด Go เสร็จสิ้นภายในเบราว์เซอร์ ข้อมูลดิบไม่ถูกอัปโหลดไปยังเซิร์ฟเวอร์
การแปลงอัตโนมัติแบบป้องกันการสั่น 400ms: ไม่จำเป็นต้องคลิกด้วยตนเองหลังจากวางหรือแก้ไข โค้ด Go ที่คัดลอกได้จะแสดงผลแบบเรียลไทม์ทางด้านขวา
การอนุมานประเภทอัจฉริยะ: สตริงแมปเป็น string, บูลีนเป็น bool, จำนวนเต็มเป็น int64, จำนวนทศนิยมเป็น float64, อาร์เรย์เป็น slice, อ็อบเจกต์เป็น struct
ขยายอ็อบเจกต์ซ้อนโดยอัตโนมัติ: สร้างประเภท struct อิสระแบบเรียกซ้ำ รักษาลำดับชั้น JSON ที่ชัดเจน
สร้างแท็ก json โดยอัตโนมัติ: ฟิลด์มาพร้อมกับแท็ก `json:"ชื่อฟิลด์เดิม"` พร้อมใช้งานกับ encoding/json
ซ่อมแซมข้อผิดพลาด JSON ในคลิกเดียว: จัดการจุลภาคท้าย, อัญประกาศเดี่ยว, อัญประกาศที่ขาดหายไปและข้อผิดพลาดรูปแบบทั่วไปอื่นๆ โดยอัตโนมัติ ดำเนินการสร้างต่อหลังจากซ่อมแซม
รองรับการป้อนด้วยการวาง/อัปโหลด/ตัวอย่าง: ลากและวางเพื่ออัปโหลดไฟล์ .json/.txt หรือโหลดตัวอย่างในตัว
คัดลอกและดาวน์โหลดในคลิกเดียว: คัดลอกโค้ด Go ทั้งหมดไปยังคลิปบอร์ด หรือดาวน์โหลดเป็นไฟล์ model.go โดยตรงไปยังโปรเจกต์
ประวัติการป้อน localStorage: บันทึกการป้อนล่าสุดโดยอัตโนมัติ กู้คืนได้อย่างรวดเร็วหลังจากรีเฟรชหรือปิดหน้าโดยไม่ได้ตั้งใจ
ตัวแก้ไขแบบแบ่งหน้าจอที่ตอบสนอง: ความกว้างแผงซ้าย/ขวาปรับได้ ดูการป้อน/ส่งออกได้อย่างสบายบนเดสก์ท็อปและมือถือ

ตัวอย่างโค้ด

ดีซีเรียลไลซ์ JSON ด้วย struct ที่สร้างขึ้น

หลังจากคัดลอก struct ที่สร้างขึ้นไปยังโปรเจกต์ ให้ดีซีเรียลไลซ์การตอบกลับ API โดยตรงด้วย encoding/json

package main

import (
    "encoding/json"
    "fmt"
)

// 以下代码由 GeekFormat JSON 转 Go 工具生成
type User struct {
    ID      int64    `json:"id"`
    Name    string   `json:"name"`
    Tags    []string `json:"tags"`
    Address Address  `json:"address"`
}

type Address struct {
    City string `json:"city"`
}

func main() {
    data := []byte(`{
        "id": 1,
        "name": "Alice",
        "tags": ["admin", "dev"],
        "address": {"city": "Beijing"}
    }`)

    var u User
    if err := json.Unmarshal(data, &u); err != nil {
        panic(err)
    }

    fmt.Println(u.Name, u.Address.City)
}

จัดการ JSON ที่อาจมีฟิลด์ขาดหายไป

หากบางฟิลด์ API อาจไม่มีอยู่ ให้เปลี่ยนฟิลด์ที่เกี่ยวข้องเป็นประเภทพอยน์เตอร์หรือใช้กับแท็ก omitempty

package main

import "encoding/json"

// 手动将字段改为指针，缺失时值为 nil
type User struct {
    ID      *int64  `json:"id,omitempty"`
    Name    *string `json:"name,omitempty"`
    Email   *string `json:"email,omitempty"`
}

func main() {
    data := []byte(`{"id": 1, "name": "Bob"}`)
    var u User
    json.Unmarshal(data, &u)
    if u.Email == nil {
        println("Email 字段缺失")
    }
}

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

จะแปลง JSON เป็น struct Go ได้อย่างไร?

วางเนื้อหา JSON ลงในช่องป้อนด้านซ้าย เครื่องมือจะแปลงโดยอัตโนมัติภายใน 400ms และแสดง struct Go ที่สร้างขึ้นทางด้านขวา คุณยังสามารถลากและวางไฟล์ .json/.txt หรือคลิก 'ตัวอย่าง' เพื่อโหลดข้อมูลในตัว หลังจากแปลงแล้ว คัดลอกหรือดาวน์โหลดไฟล์ model.go ในคลิกเดียว

โค้ด Go ที่สร้างขึ้นมีแท็ก json หรือไม่?

มี เครื่องมือสร้างโค้ด Go ตาม quicktype-core และโดยค่าเริ่มต้นแต่ละฟิลด์ struct จะมาพร้อมกับแท็ก `json:"ชื่อฟิลด์เดิม"` สะดวกสำหรับการซีเรียลไลซ์และดีซีเรียลไลซ์โดยตรงด้วย Unmarshal/Marshal ของ encoding/json

อาร์เรย์ JSON จะถูกแปลงเป็น slice Go หรือไม่?

ใช่ อาร์เรย์ JSON จะสร้างประเภท slice ที่สอดคล้องกันตามประเภทองค์ประกอบ ตัวอย่างเช่น `["a","b"]` สร้าง `[]string`, `[1,2,3]` สร้าง `[]int64`, `[{...},{...}]` สร้างประเภทกำหนดเองเช่น `[]UserItem`

อ็อบเจกต์ซ้อนจะสร้าง struct หลายตัวหรือไม่?

ใช่ แต่ละอ็อบเจกต์ซ้อนจะสร้างประเภท struct อิสระแบบเรียกซ้ำ ตั้งชื่อตาม PascalCase ตัวอย่างเช่น อ็อบเจกต์ `address` สร้าง struct `Address` ซึ่งอ้างอิงใน struct หลักผ่านฟิลด์ `Address Address`

ค่า null จะสร้างประเภทอะไร?

ค่า null ใน JSON มักจะถูกอนุมานว่าเป็น `interface{}` ซึ่งเป็นประเภทสำรองที่ปลอดภัย หากคุณทราบประเภทที่แท้จริงของฟิลด์ คุณสามารถเพิ่มค่าตัวอย่างใน JSON สร้างใหม่ จากนั้นปรับด้วยตนเองเป็นประเภทเฉพาะ

ฉันสามารถปรับแต่งชื่อ struct รากได้หรือไม่?

ได้ เครื่องมือใช้ชื่อประเภทราก (เช่น User) ตามค่าเริ่มต้น; หลังจากแก้ไขชื่อประเภทรากในการตั้งค่า ชื่อประเภทย่อยที่เกี่ยวข้องทั้งหมดจะอัปเดตพร้อมกัน ชื่อไฟล์ที่ดาวน์โหลดก็จะเปลี่ยนตามเช่นกัน

จะทำอย่างไรหาก JSON มีข้อผิดพลาดรูปแบบ?

เครื่องมือจะตรวจจับความถูกต้องของ JSON โดยอัตโนมัติ หากมีข้อผิดพลาดทั่วไปเช่น จุลภาคท้าย อัญประกาศเดี่ยว อัญประกาศที่ขาดหายไป ปุ่ม 'ซ่อมแซม JSON' จะปรากฏขึ้น เมื่อคลิก เครื่องมือจะพยายามซ่อมแซมโดยอัตโนมัติและสร้าง struct Go ใหม่; หากซ่อมแซมไม่สำเร็จ จะระบุตำแหน่งข้อผิดพลาดที่แน่นอน

ข้อมูลจะถูกอัปโหลดไปยังเซิร์ฟเวอร์หรือไม่? เป็นส่วนตัวและปลอดภัยหรือไม่?

ไม่ การแยกวิเคราะห์ JSON การอนุมานประเภทและการสร้างโค้ด Go ทั้งหมดเสร็จสิ้นในเบราว์เซอร์ของคุณผ่าน Web Worker; เนื้อหาที่ป้อนและโค้ดที่สร้างขึ้นจะไม่ถูกอัปโหลดไปยังเซิร์ฟเวอร์ใดๆ และไม่ถูกบันทึกไปยังคลาวด์ JSON ที่ละเอียดอ่อนซึ่งมีคีย์ API โทเค็นหรือข้อมูลธุรกิจสามารถใช้งานได้อย่างปลอดภัย

โค้ดที่สร้างขึ้นสามารถวางลงในโปรเจกต์ Go โดยตรงได้หรือไม่?

ได้ โค้ดที่สร้างขึ้นเป็น struct Go มาตรฐานพร้อมแท็ก json สามารถคัดลอกโดยตรงไปยังไดเรกทอรี types/ หรือ models/ ของโปรเจกต์ เราแนะนำให้ปรับแต่งชื่อประเภทและชื่อแพ็กเกจอย่างละเอียดตามข้อกำหนดการตั้งชื่อของโปรเจกต์

เครื่องมือนี้ฟรีหรือไม่? ฉันจำเป็นต้องลงทะเบียนหรือไม่?

ฟรีทั้งหมด ไม่จำเป็นต้องลงทะเบียนหรือเข้าสู่ระบบ เปิดหน้าและใช้งานทันที ไม่มีข้อจำกัดฟีเจอร์ ลายน้ำหรือการเข้าสู่ระบบที่บังคับ

รองรับไฟล์ JSON ขนาดเท่าใด?

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

ประเภทตัวเลขจะสร้าง float64 เหมือนกันทั้งหมดหรือไม่?

ไม่ เครื่องมือจะแยกแยะจำนวนเต็มและจำนวนทศนิยม: ฟิลด์จำนวนเต็มสร้าง int64, ฟิลด์ทศนิยมสร้าง float64 หากคุณต้องการประเภทที่เฉพาะเจาะจงมากขึ้นเช่น int, uint64 ให้แทนที่ด้วยตนเองหลังจากสร้าง

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

ทางด้านขวาแสดง 'กรุณาป้อนข้อมูล JSON'

ช่องป้อนด้านซ้ายว่างเปล่าหรือมีเฉพาะอักขระช่องว่าง กรุณาวาง JSON ที่ถูกต้อง หรือคลิก 'ตัวอย่าง' เพื่อโหลดข้อมูล หรือลากและวางไฟล์ .json/.txt

แสดงข้อผิดพลาดการแยกวิเคราะห์ JSON แต่ไม่พบตำแหน่งข้อผิดพลาด

คลิกปุ่ม 'ซ่อมแซม JSON' ด้านล่างช่องป้อน; เครื่องมือจะพยายามซ่อมแซมจุลภาคท้าย อัญประกาศเดี่ยว อัญประกาศที่ขาดหายไป อ็อบเจกต์สไตล์ JS และปัญหาอื่นๆ โดยอัตโนมัติ ผลลัพธ์ที่แก้ไขจะถูกเน้นหลังจากซ่อมแซม

ชื่อฟิลด์ที่สร้างขึ้นไม่สอดคล้องกับข้อกำหนดการตั้งชื่อ Go

เครื่องมือสร้างชื่อฟิลด์ PascalCase จากคีย์ JSON หากคีย์มีภาษาจีนหรืออักขระพิเศษ อาจสร้างชื่อฟิลด์ที่มีการเอสเคป เราแนะนำให้เปลี่ยนคีย์ JSON เป็นภาษาอังกฤษตัวพิมพ์เล็กหรือ snake_case จากนั้นปรับอย่างสม่ำเสมอหลังจากสร้าง

ฟิลด์ null สร้าง interface{} ต้องการเปลี่ยนเป็นประเภทเฉพาะ

เนื่องจาก null ไม่สามารถอนุมานประเภทเฉพาะได้ เครื่องมือจึงใช้ interface{} เป็นตัวสำรอง คุณสามารถให้ค่าตัวอย่างแก่ฟิลด์นี้ (เช่น "" หรือ 0) ใน JSON ต้นทาง สร้างใหม่ จากนั้นเปลี่ยนประเภทเป็นประเภทจริงเช่น string/int64

หน้าเว็บล่าช้าหลังจากแปลง JSON ขนาดใหญ่

การแสดงผล JSON ขนาดใหญ่เกินไปและ struct จำนวนมากในเบราว์เซอร์ใช้หน่วยความจำอย่างมาก คำแนะนำ: ① เก็บเฉพาะฟิลด์สำคัญใน JSON ตัวอย่าง; ② แบ่งเป็นหลายอ็อบเจกต์และแปลงแยกกัน; ③ ปิดแท็บอื่นๆ ที่ใช้หน่วยความจำในเบราว์เซอร์

ประเภทองค์ประกอบอาร์เรย์ถูกอนุมานว่าเป็น []interface{}

เมื่ออาร์เรย์ว่างเปล่า [] หรือประเภทองค์ประกอบไม่สอดคล้องกัน เครื่องมือจะใช้ interface{} เป็นตัวสำรอง คุณสามารถเพิ่มองค์ประกอบตัวอย่างประเภทเดียวกัน หรือเปลี่ยนประเภทด้วยตนเองเป็นประเภท slice เฉพาะเช่น []string, []int64 หลังจากสร้าง

อภิธานศัพท์

struct: ประเภทข้อมูลผสมของ Go ใช้เพื่อรวมหลายฟิลด์เป็นประเภทเดียว ส่วนหลักของโค้ด Go ที่สร้างโดยเครื่องมือนี้ประกอบด้วยนิยาม struct หลายตัว
slice: ประเภทอาร์เรย์ไดนามิกของ Go ไวยากรณ์คือ []T เครื่องมือนี้แมปอาร์เรย์ JSON เป็น slice ที่สอดคล้องกัน ตัวอย่างเช่น []string, []int64, []UserItem
json tag: สตริงในอัญประกาศย้อนกลับหลังฟิลด์ struct Go ตัวอย่างเช่น `json:"user_name"` ใช้เพื่อระบุชื่อฟิลด์ในระหว่างการซีเรียลไลซ์/ดีซีเรียลไลซ์ encoding/json เครื่องมือนี้สร้างแท็กนี้โดยอัตโนมัติ
interface{}: ประเภทอินเทอร์เฟซว่างของ Go สามารถแสดงค่าใดๆ ได้ เครื่องมือนี้ใช้ interface{} เป็นตัวสำรองที่ปลอดภัยเมื่อพบ null ใน JSON หรือไม่สามารถระบุประเภทได้
PascalCase: รูปแบบการตั้งชื่อที่แต่ละคำขึ้นต้นด้วยตัวพิมพ์ใหญ่ ตัวอย่างเช่น UserName, AddressCity Go กำหนดให้ฟิลด์ที่ส่งออกต้องขึ้นต้นด้วยตัวพิมพ์ใหญ่ ดังนั้นเครื่องมือนี้จะแปลงชื่อฟิลด์ JSON เป็น PascalCase โดยอัตโนมัติ
encoding/json: แพ็กเกจการเข้ารหัส/ถอดรหัส JSON ในไลบรารีมาตรฐานของ Go หลังจากที่ struct ที่สร้างโดยเครื่องมือนี้จับคู่กับแท็ก json แล้ว json.Unmarshal และ json.Marshal สามารถใช้งานได้โดยตรง
unmarshal: กระบวนการแยกวิเคราะห์สตรีมไบต์ JSON เป็นค่า Go หลังจากสร้าง struct แล้ว การใช้งานที่พบบ่อยที่สุดคือการเรียก json.Unmarshal(data, &user)
omitempty: ตัวเลือกทั่วไปสำหรับแท็ก json ของ Go ตัวอย่างเช่น `json:"name,omitempty"` หมายถึงข้ามการส่งออกเมื่อฟิลด์เป็นค่าศูนย์ เครื่องมือนี้ไม่สร้าง omitempty ตามค่าเริ่มต้น; เพิ่มด้วยตนเองตามความจำเป็นหลังจากสร้าง

ตารางอ้างอิงด่วนการแมปประเภท JSON เป็นประเภท Go

เครื่องมือนี้อนุมานประเภท Go ที่สอดคล้องกันตามประเภทค่า JSON โดยอัตโนมัติ; การแมปทั่วไปมีดังนี้:

ตัวอย่างค่า JSON	ประเภท Go ที่สร้าง	หมายเหตุ
`"hello"`	`string`	การแมปสตริงโดยตรง
`true / false`	`bool`	ค่าบูลีน
`42`	`int64`	จำนวนที่ไม่มีจุดทศนิยม
`3.14`	`float64`	จำนวนที่มีจุดทศนิยม
`null`	`interface{}`	ตัวสำรองที่ปลอดภัยเมื่อไม่สามารถอนุมานประเภทเฉพาะได้
`["a","b"]`	`[]string`	อาร์เรย์สตริง
`[1,2,3]`	`[]int64`	อาร์เรย์จำนวนเต็ม
`[{...},{...}]`	`[]UserItem`	อาร์เรย์อ็อบเจกต์ ประเภทองค์ประกอบถูกสร้างแบบเรียกซ้ำ
`{"id":1}`	`User`	อ็อบเจกต์สร้าง struct อิสระ

คำแนะนำการเลือกประเภทตัวเลขทั่วไปใน Go

เครื่องมือใช้ int64 และ float64 ตามค่าเริ่มต้น; ปรับตามความจำเป็นในโปรเจกต์จริง:

สถานการณ์	ประเภทที่แนะนำ	เหตุผล
ID จำนวนเต็มทั่วไป ตัวนับ	`int64`	สอดคล้องกับค่าเริ่มต้นของเครื่องมือ เข้ากันได้กับจำนวน JSON ส่วนใหญ่
PK ที่เพิ่มอัตโนมัติของฐานข้อมูลที่ทราบว่าเป็นบวก	`uint64`	หลีกเลี่ยงจำนวนลบ ความหมายชัดเจนมากขึ้น
ระบบ 32 บิตหรือจำนวนเต็มช่วงเล็กที่ชัดเจน	`int32`	ลดการใช้หน่วยความจำ
ราคา พิกัด การคำนวณทางวิทยาศาสตร์	`float64`	สอดคล้องกับค่าเริ่มต้นของเครื่องมือ ความแม่นยำทศนิยมมาตรฐาน
การคำนวณสกุลเงินที่แม่นยำ	`decimal.Decimal / int`	float64 มีความเสี่ยงด้านความแม่นยำ; แนะนำ shopspring/decimal หรือ int ในหน่วยสตางค์

Privacy & Security

การประมวลผลทั้งหมดของเครื่องมือ JSON เป็น Go นี้เสร็จสิ้นในเครื่องเบราว์เซอร์ของคุณทั้งหมด: การแยกวิเคราะห์ JSON การอนุมานประเภท การสร้างโค้ด Go ดำเนินการทั้งหมดทางฝั่งไคลเอ็นต์ผ่าน Web Worker; เนื้อหา JSON ที่ป้อน ไฟล์ที่อัปโหลดและโค้ด Go ที่สร้างขึ้นจะไม่ถูกอัปโหลดไปยังเซิร์ฟเวอร์ใดๆ และไม่ถูกบันทึก แคชหรือจัดเก็บไปยังคลาวด์ หลังจากปิดหรือรีเฟรชหน้า เนื้อหาอินพุตและเอาต์พุตทั้งหมดจะถูกล้างออกจากหน่วยความจำโดยอัตโนมัติ เฉพาะ localStorage ที่เก็บประวัติการป้อนล่าสุดของคุณ (สามารถล้างได้ตลอดเวลา) เหมาะสำหรับการประมวลผล JSON ที่มีคีย์ API โทเค็น ข้อมูลธุรกิจที่ละเอียดอ่อน