JSON เป็น C++

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

เกี่ยวกับ JSON เป็น C++: การเปลี่ยนข้อมูล JSON เป็นสตรัคเจอร์ C++ ที่คอมไพล์ได้

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

• การเชื่อมต่อ REST API: แปลงการตอบสนอง JSON ที่ส่งกลับจากแบ็กเอนด์เป็นสตรัคเจอร์ C++ ใช้ร่วมกับ nlohmann::json/cpr เพื่อดีซีเรียลไลซ์คำขอ HTTP แบบประเภทเข้มงวด
• นิยามอินเทอร์เฟซไมโครเซอร์วิส: แปลงตัวอย่าง JSON ของเนื้อหาคำขอบริการ gRPC/HTTP เป็นประเภท C++ รวมนิยามโมเดลฝั่งเซิร์ฟเวอร์
• ระบบฝังตัวและ IoT: แปลงข้อมูลเซ็นเซอร์ JSON ที่อุปกรณ์รายงานเป็นสตรัคเจอร์ C++ ใช้ร่วมกับ ArduinoJson หรือ ESP-IDF JSON Parser เพื่อแยกวิเคราะห์ข้อความ MQTT/HTTP
• การพัฒนาเกม: แปลง JSON คอนฟิกเลเวล คุณสมบัติตัวละครเป็นสตรัคเจอร์ C++ ช่วยให้เอ็นจิ้นเช่น Unreal Engine หรือ Cocos2d-x อ่านไฟล์ข้อมูล .json ได้ง่ายขึ้น
• การซื้อขายทางการเงินความถี่สูง: แปลงการตอบสนองอินเทอร์เฟซ JSON ของตลาดหลักทรัพย์ (เช่น ข้อมูลตลาด OKX/Binance/Xueqiu) เป็นสตรัคเจอร์ C++ ใช้ร่วมกับ rapidjson เพื่อแยกวิเคราะห์ระดับนาโนวินาที
• ไคลเอ็นต์ C++ Qt: แปลงคอนฟิก JSON เซิร์ฟเวอร์เป็นสตรัคเจอร์ C++ ใช้ร่วมกับ QJsonObject/QJsonDocument เพื่อโหลดข้อมูล GUI
• Boost.JSON/Boost.Beast: แปลงการตอบสนอง JSON ของบริการ HTTP เป็นสตรัคเจอร์ C++ ใช้ร่วมกับ Boost.JSON เพื่อดีซีเรียลไลซ์ เขียนแบ็กเอนด์เว็บ
• RTOS สำหรับระบบฝังตัว: แปลง JSON คอนฟิกระบบ FreeRTOS/Zephyr เป็นสตรัคเจอร์ C++ ใช้ร่วมกับ cJSON เพื่ออ่านพารามิเตอร์เฟิร์มแวร์
• อัลกอริทึม/การคิดเชิงปริมาณ: แปลง JSON คอนฟิกระบบแบ็กเทสต์เป็นสตรัคเจอร์ C++ ช่วยให้การจัดการคอนฟิกทดลอง A/B และการติดตามเวอร์ชันง่ายขึ้น
• การย้ายฐานข้อมูล: แปลงเอกสาร JSON ที่ส่งออกจาก MongoDB/PostgreSQL เป็นโมเดล C++ ใช้เป็นข้อมูลอ้างอิงสำหรับฟิลด์เอนทิตี cpp-httplib/libpqxx
• เสียง/วิดีโอ/มัลติมีเดีย: แปลง JSON คอนฟิก FFmpeg/GStreamer เป็นสตรัคเจอร์ C++ ช่วยให้การอ่านพารามิเตอร์ไปป์ไลน์สื่อง่ายขึ้น
• การจำลองและการสร้างแบบจำลอง: แปลง JSON คอนฟิกอินพุตของระบบจำลองเป็นสตรัคเจอร์ C++ รวมรูปแบบข้อมูลอินพุตของโมเดลย่อยต่างๆ
• การสร้างข้อมูลทดสอบ: แปลงฟิกซ์เจอร์ JSON จริงที่ส่งกลับจากแบ็กเอนด์เป็นประเภท C++ ทำการยืนยันเชิงโครงสร้างในการทดสอบหน่วย Google Test/Catch2
• การแยกวิเคราะห์บันทึกเชิงโครงสร้าง: แปลงบันทึก JSON ที่ ELK/Loki จับได้เป็นประเภท C++ ช่วยให้การสร้างกฎการกรองและการแจ้งเตือนง่ายขึ้น
• การย้ายศูนย์คอนฟิก: แปลง JSON คอนฟิก Apollo/Nacos/Consul เป็นประเภท C++ ใช้สำหรับการโหลดคอนฟิกร้อนฝั่งเซิร์ฟเวอร์
• การทำงานร่วมกันข้ามภาษา: การเชื่อมต่อแบ็กเอนด์ C++ กับฟรอนต์เอนด์ TypeScript/Java JSON เดียวกันจะถูกแปลงเป็นสตรัคเจอร์ C++ และอินเทอร์เฟซ TS/POJO Java ตามลำดับเพื่อรักษาความสอดคล้องกันของทั้งสองฝั่ง
• การเรียนการสอน: ในหลักสูตร C++ แปลงตัวอย่าง JSON เป็นสตรัคเจอร์ สาธิตกระบวนการดีซีเรียลไลซ์ nlohmann::json และแนวคิดเมตาโปรแกรมมิ่งเทมเพลต
• การแปลงชื่อฟิลด์: หลังจากแปลงการตอบสนอง API JSON ในรูปแบบ snake_case เป็นสตรัคเจอร์ C++ แล้ว ให้เพิ่ม NLOHMANN_DEFINE_TYPE_INTRUSIVE ด้วยตัวเองเพื่อทำการแมปฟิลด์

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

1. วางเนื้อหา JSON ในตัวแก้ไขทางด้านซ้าย (แนะนำให้เป็นอ็อบเจกต์ JSON) หรือคลิกปุ่มอัปโหลดเพื่อเลือกไฟล์ .json/.txt
2. เครื่องมือใช้ quicktype-core ผ่าน Web Worker เพื่อแปลงโดยอัตโนมัติภายใน 400ms โค้ดไฟล์เฮดเดอร์ C++ ที่มี std::string/std::vector<T>/คลาสซ้อนในจะแสดงทางด้านขวา
3. หากรูปแบบ JSON ไม่ถูกต้องจะมีข้อความสีแดงปรากฏขึ้น คลิกปุ่ม 'ซ่อมแซม JSON' เพื่อซ่อมแซมปัญหาทั่วไปเช่น จุลภาคท้าย คำพูดเดี่ยวโดยอัตโนมัติจากนั้นลองอีกครั้ง
4. ตรวจสอบว่าชื่อสตรัคเจอร์/คลาสและประเภทฟิลด์ที่สร้างขึ้นเป็นไปตามที่คาดหวังหรือไม่ หากต้องการปรับเปลี่ยนให้แก้ไขชื่อคีย์ใน JSON ต้นทางแล้วแปลงใหม่
5. คลิก 'คัดลอก' เพื่อวางโค้ดลงในไฟล์ .h/.hpp ใน IDE ใช้ร่วมกับ nlohmann::json หรือ rapidjson เพื่อดีซีเรียลไลซ์การตอบสนอง API จริง; หรือคลิก 'ดาวน์โหลด' เพื่อบันทึกเป็น model.h/model.hpp

คุณสมบัติ

• การแปลงในเบราว์เซอร์ในเครื่อง: การแยกวิเคราะห์ JSON และการสร้างโค้ด C++ ทั้งหมดทำในเบราว์เซอร์ผ่าน Web Worker + quicktype-core ข้อมูลดิบจะไม่ถูกส่งไปยังเซิร์ฟเวอร์ใดๆ
• เอาต์พุตสไตล์ nlohmann::json: สร้างสตรัคเจอร์ประเภท STL เช่น std::string/std::vector<T>/double/int64_t/bool โดยอัตโนมัติ สอดคล้องกับนิสัยดีซีเรียลไลซ์ nlohmann::json สามารถรวม <nlohmann/json.hpp> เพื่อแยกวิเคราะห์ได้โดยตรง
• เข้ากันได้กับ rapidjson: สตรัคเจอร์ C++ บริสุทธิ์ที่สร้างขึ้นไม่ขึ้นอยู่กับไลบรารีของบุคคลที่สามใดๆ สามารถใช้กับ rapidjson Document/GenericValue ในสถานการณ์การแยกวิเคราะห์ประสิทธิภาพสูง
• การอนุมานประเภทอัตโนมัติ: สตริง JSON แมปเป็น std::string จำนวนเต็มเป็น int64_t/long long จำนวนทศนิยมเป็น double บูลีนเป็น bool อาร์เรย์เป็น std::vector<T> อ็อบเจกต์ซ้อนในเป็นคลาส/สตรัคเจอร์อิสระ
• การแยกอ็อบเจกต์ซ้อนในอัตโนมัติ: JSON ที่ซ้อนกันจะสร้างคลาส/สตรัคเจอร์อิสระโดยอัตโนมัติ (การตั้งชื่อ PascalCase) หลีกเลี่ยงการนิยามประเภทเดียวกันซ้ำๆ
• การจัดการ std::vector และ std::optional อัตโนมัติ: อาร์เรย์ JSON จะถูกแปลงเป็น std::vector<T> ฟิลด์ที่อาจเป็น null จะถูกรองรับเป็น std::optional<T> สอดคล้องกับแนวทางปฏิบัติ C++17/C++20 สมัยใหม่
• การแปลงอัตโนมัติด้วยดีบาวน์ 400ms: หลังจากวาง JSON การแปลงจะถูกทริกเกอร์โดยอัตโนมัติ โค้ดเฮดเดอร์ C++ จะถูกแสดงตัวอย่างทางด้านขวาแบบเรียลไทม์ ลดการรอคอยและการคลิกที่ไม่จำเป็น
• ซ่อมแซมข้อผิดพลาด JSON ในคลิกเดียว: ซ่อมแซมข้อผิดพลาดรูปแบบทั่วไปโดยอัตโนมัติ เช่น จุลภาคท้าย คำพูดเดี่ยว คำพูดที่ขาดหายไป หลังจากซ่อมแซมสำเร็จจะดำเนินการสร้างโค้ดต่อไป
• ไฮไลต์ไวยากรณ์ + คัดลอกในคลิกเดียว: พื้นที่ CodeMirror ทางด้านขวาแสดงไฮไลต์ไวยากรณ์ C++ คัดลอกไฟล์เฮดเดอร์ทั้งหมดในคลิกเดียวหรือดาวน์โหลดเป็นไฟล์ .h/.hpp เพื่อใส่ในโปรเจกต์โดยตรง
• ประวัติการป้อนค่า localStorage + คอลัมน์ที่ตอบสนองได้: บันทึกการป้อนล่าสุดโดยอัตโนมัติ สามารถกู้คืนได้อย่างรวดเร็วหลังจากรีเฟรชหรือปิดหน้าโดยไม่ได้ตั้งใจ วาง JSON ทางซ้าย ดูโค้ด C++ ทางขวา รองรับการลากเพื่อปรับความกว้างแผง ปรับให้เข้ากับหน้าจอขนาดใหญ่และอุปกรณ์เคลื่อนที่
• ผลิตภัณฑ์ header-only ไร้การอ้างอิง: .h/.hpp ที่สร้างขึ้นอยู่ในรูปแบบ header-only สามารถรวมในไฟล์เดียวเข้ากับโปรเจกต์ C++ มาตรฐานใดๆ สามารถใช้กับ nlohmann::json/rapidjson/Boost.JSON ได้โดยไม่ต้องตั้งค่าการสร้างเพิ่มเติม
• การแปลง snake_case เป็น camelCase ในตัว: สามารถแปลงฟิลด์ snake_case ใน JSON เป็นชื่อฟิลด์ camelCase ที่แนะนำสำหรับ C++ โดยอัตโนมัติ ทำงานร่วมกับ NLOHMANN_DEFINE_TYPE_INTRUSIVE เพื่อรักษาการแมปซีเรียลไลซ์ snake_case

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

// model.hpp (สร้างโดยเครื่องมือนี้)
// #pragma once
// #include <cstdint>
// #include <optional>
// #include <string>
// #include <vector>
// struct Address {
//   std::string city;
//   std::string zip;
// };
// struct User {
//   int64_t id;
//   std::string name;
//   std::optional<Address> address;
//   std::vector<std::string> tags;
// };

#include <nlohmann/json.hpp>
#include "model.hpp"

using nlohmann::json;

int main() {
    std::string raw = R"({
        "id": 1,
        "name": "Alice",
        "address": { "city": "Beijing", "zip": "100000" },
        "tags": ["cpp", "nlohmann"]
    })";

    // 1) แยกวิเคราะห์สตริง JSON
    json j = json::parse(raw);

    // 2) ดีซีเรียลไลซ์ประเภทเข้มงวดไปยังสตรัคเจอร์ที่สร้างโดยเครื่องมือนี้
    User u = j.get<User>();

    // 3) เข้าถึงฟิลด์
    std::cout << u.name << " lives in "
              << (u.address ? u.address->city : "unknown")
              << std::endl;

    for (const auto& tag : u.tags) {
        std::cout << "tag: " << tag << std::endl;
    }
    return 0;
}

/*
 * การคอมไพล์ (โปรเจกต์ CMake):
 *   find_package(nlohmann_json REQUIRED)
 *   target_link_libraries(my_app PRIVATE nlohmann_json::nlohmann_json)
 * การคอมไพล์ (vcpkg):
 *   vcpkg install nlohmann-json
 * การรวมไฟล์เดียว:
 *   ดาวน์โหลด json.hpp โดยตรงจากรีลีส https://github.com/nlohmann/json/releases
 */

#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include <iostream>
#include "model.hpp"

int main() {
    const char* raw = R"({
        "id": 1,
        "name": "Alice",
        "address": { "city": "Beijing", "zip": "100000" },
        "tags": ["cpp", "rapidjson"]
    })";

    // 1) การแยกวิเคราะห์ DOM rapidjson
    rapidjson::Document doc;
    doc.Parse(raw);

    // 2) สร้างสตรัคเจอร์ที่สร้างโดยเครื่องมือนี้และเติมข้อมูลด้วยตัวเอง
    User u;
    u.id = doc["id"].GetInt64();
    u.name = doc["name"].GetString();

    if (doc.HasMember("address") && doc["address"].IsObject()) {
        Address addr;
        addr.city = doc["address"]["city"].GetString();
        addr.zip  = doc["address"]["zip"].GetString();
        u.address = addr;
    }

    for (auto& tag : doc["tags"].GetArray()) {
        u.tags.push_back(tag.GetString());
    }

    // 3) ใช้สตรัคเจอร์ที่เติมข้อมูลแล้ว
    std::cout << u.name << ", tags=" << u.tags.size() << std::endl;
    return 0;
}

/*
 * เคล็ดลับประสิทธิภาพสูง rapidjson:
 *   ① การใช้ร่วมกับ rapidjson::MemoryPoolAllocator และ StringBuffer สามารถเร่งความเร็วเพิ่มเติมได้;
 *   ② ในสถานการณ์ความถี่สูงสามารถใช้ Reader/Writer สไตล์ SAX เพื่อประมวลผลแบบสตรีมมิ่งโดยตรง;
 *   ③ การเปิดใช้งานมาโคร RAPIDJSON_SSE42/RAPIDJSON_SIMD ช่วยให้สามารถใช้คำสั่ง SIMD ของ CPU เพื่อเร่งความเร็วได้
 */

#include <nlohmann/json.hpp>
#include <string>
#include <cstdint>

// สมมติว่าเครื่องมือสร้างฟิลด์ snake_case: user_name, created_at
// เมื่อเปลี่ยนชื่อเป็น camelCase ในโปรเจกต์จริงให้เพิ่มมาโครต่อไปนี้
struct UserProfile {
    int64_t id;
    std::string userName;       // ใน JSON คือ "user_name"
    std::string emailAddress;   // ใน JSON คือ "email_address"
    std::string createdAt;      // ใน JSON คือ "created_at"
};

// ใช้ NLOHMANN_DEFINE_TYPE_INTRUSIVE เพื่อประกาศการแมปภายในคลาส
// หมายเหตุ: ต้องวางไว้ในพื้นที่ public
// 
// NLOHMANN_DEFINE_TYPE_INTRUSIVE(UserProfile, id, userName, emailAddress, createdAt)

// หรือใช้มาโครที่ไม่รุกล้ำ (หลีกเลี่ยงการแก้ไขคลาสเอง):
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(UserProfile, id, userName, emailAddress, createdAt)

// วิธีใช้งาน:
int main() {
    nlohmann::json j = {
        {"id", 1},
        {"user_name", "Alice"},
        {"email_address", "a****@***********"},
        {"created_at", "2026-07-14T10:00:00.000Z"}
    };

    UserProfile p = j.get<UserProfile>();
    // เมื่อซีเรียลไลซ์จะส่งออกด้วยชื่อฟิลด์เดิมเช่นกัน
    std::cout << j.dump(2) << std::endl;
    return 0;
}

/*
 * เคล็ดลับ:
 *   ① มาโครรุกล้ำ (NLOHMANN_DEFINE_TYPE_INTRUSIVE) ต้องวางไว้ในพื้นที่ public;
 *   ② มาโครที่ไม่รุกล้ำ (NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE) ถูกกำหนดไว้นอกคลาส;
 *   ③ ลำดับฟิลด์ต้องสอดคล้องกับพารามิเตอร์ของมาโครอย่างเคร่งครัด;
 *   ④ ฟิลด์วันที่สามารถประมวลผลด้วย adl_serializer ที่กำหนดเองของ nlohmann::json ในรูปแบบ ISO 8601
 */

Best Practices

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

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

อภิธานศัพท์

struct / class

คีย์เวิร์ดใน C++ ที่ใช้กำหนดประเภทข้อมูลผสม เครื่องมือนี้สร้าง struct เช่น struct User { int64_t id; std::string name; } ใน C++ struct และ class เกือบจะเทียบเท่ากัน (ความแตกต่างที่สิทธิ์การเข้าถึงเริ่มต้น: สมาชิก struct เป็น public โดยค่าเริ่มต้น สมาชิก class เป็น private โดยค่าเริ่มต้น) เครื่องมือสร้าง struct เป็นค่าเริ่มต้น ในสถานการณ์ดีซีเรียลไลซ์ การใช้ struct จะกระชับและเข้าใจง่ายกว่า; หากต้องการห่อหุ้มสมาชิกส่วนตัว + เมธอดตัวเข้าถึง สามารถเปลี่ยนเป็น class ด้วยตัวเองได้

std::string

ประเภทสตริงของไลบรารีมาตรฐาน C++ (สัญชาตญาณความเป็นเจ้าของ) นิยามใน <string> เครื่องมือนี้จะแมปฟิลด์สตริง JSON เป็น std::string โดยอัตโนมัติ เช่น std::string name ควรทราบว่า std::string แตกต่างจาก char*/char[] ในภาษา C: std::string จัดการหน่วยความจำโดยอัตโนมัติ รองรับการโอเวอร์โหลดตัวดำเนินการ (+, ==, <) แต่จะมีประสิทธิภาพดีที่สุดเมื่อประมวลผลสตริงความยาวเล็กถึงปานกลางเท่านั้น; สำหรับสตริงที่ยาวมาก (เช่น บันทึกทั้งบรรทัด 1KB+) แนะนำให้ใช้ std::string_view หรือบัฟเฟอร์ที่กำหนดเอง

std::vector<T>

คอนเทนเนอร์อาร์เรย์ไดนามิกของไลบรารีมาตรฐาน C++ (<vector>) เทียบเท่ากับ ArrayList ใน Java, list ใน Python, Array ใน JavaScript เครื่องมือนี้จะแมปฟิลด์อาร์เรย์ JSON เป็น std::vector<T> โดยอัตโนมัติ เช่น std::vector<std::string> tags ข้อดี: หน่วยความจำต่อเนื่อง การเข้าถึงสุ่ม O(1) การเพิ่มที่ท้าย O(1) แบบแ amortized; ข้อเสีย: การแทรกตรงกลาง O(n) เมื่อต้องการอาร์เรย์ขนาดคงที่สามารถใช้ std::array<T, N> (จัดสรรบนสแต็ก)

std::optional<T>

ประเภทห่อค่าที่เลือกได้ของไลบรารีมาตรฐานตั้งแต่ C++17 (<optional>) ระบุว่าค่าอาจไม่มีอยู่ การใช้งานทั่วไป: std::optional<std::string> nickname; if (nickname) { use(*nickname); } เครื่องมือนี้จะแมปฟิลด์ JSON ที่อาจเป็น null เป็น std::optional<T> เช่น std::optional<std::string> nickname หากโปรเจกต์ของคุณจำเป็นต้องใช้ C++11/14 สามารถแทนที่ด้วย boost::optional<T> ได้ API เกือบจะเหมือนกัน

int64_t / double

int64_t คือนามแฝงประเภทจำนวนเต็ม 64 บิตที่มีความกว้างคงที่ใน <cstdint> เทียบเท่ากับ long long รับประกัน 8 ไบต์ข้ามแพลตฟอร์ม double คือประเภททศนิยมสองเท่าของ C++ (IEEE 754 สองเท่า/binary64 ประมาณ 15-17 หลักสำคัญ) เครื่องมือนี้จะแมปจำนวนเต็ม JSON เป็น int64_t อย่างสม่ำเสมอ จำนวนทศนิยมเป็น double หลีกเลี่ยงปัญหาความแม่นยำที่เกิดจากขนาด long ไม่สอดคล้องกันข้ามแพลตฟอร์ม (long ใน Windows เป็น 32 บิต long ใน Linux เป็น 64 บิต) เมื่อต้องการทศนิยมที่แม่นยำ (การคำนวณทางการเงิน) สามารถใช้ long double หรือไลบรารี decimal ได้

nlohmann::json

หนึ่งในไลบรารี JSON ยอดนิยมที่สุดในระบบนิเวศ C++ หรือที่เรียกว่า nlohmann/json เผยแพร่โดย Niels Lohmann ชาวเยอรมนี แนวคิดหลักคือการแมปโครงสร้างข้อมูล JSON เป็นประเภทไลบรารีมาตรฐาน C++ (เช่น std::map, std::vector, std::string) เมื่อดีซีเรียลไลซ์สามารถทำได้ในบรรทัดเดียวด้วย j.get<T>() โค้ดที่สร้างโดยเครื่องมือนี้สามารถทำงานร่วมกับ nlohmann/json ได้โดยใช้มาโครเช่น NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE เพื่อใช้งานดีซีเรียลไลซ์อัตโนมัติ การอ้างอิงเฮดเดอร์เดียว เอกสารที่อุดมสมบูรณ์ API สอดคล้องกับสไตล์ STL เป็นตัวเลือกที่ต้องการสำหรับโปรเจกต์ C++ ส่วนใหญ่

rapidjson

ไลบรารี JSON ประสิทธิภาพสูงโอเพ่นซอร์สจาก Tencent (C++) ประมาณ 5k บรรทัดของโค้ด ประสิทธิภาพสูงกว่า nlohmann::json ประมาณ 3-5 เท่า รองรับสไตล์การแยกวิเคราะห์สองแบบ: SAX (สตรีมมิ่ง) และ DOM (โมเดลอ็อบเจกต์เอกสาร) มีการใช้งานการเร่งความเร็วพิเศษสำหรับคำสั่ง SIMD (เช่น SSE42) สถานการณ์ทั่วไป: การส่งข้อมูลตลาดธุรกรรมทางการเงิน การซีเรียลไลซ์อ็อบเจกต์เอ็นจิ้นเกม การบันทึกประสิทธิภาพสูงในระบบฝังตัว สตรัคเจอร์ที่สร้างโดยเครื่องมือนี้สามารถทำหน้าที่เป็นโมเดลเป้าหมายสำหรับการดีซีเรียลไลซ์ rapidjson Document/GenericValue ได้ แต่เนื่องจาก rapidjson ไม่มีการสะท้อนเทมเพลต จึงจำเป็นต้องแยกฟิลด์ด้วยตัวเองโดยใช้ GetObject/GetString

Web Worker / quicktype-core

Web Worker คือ API เธรดพื้นหลังที่เบราว์เซอร์จัดเตรียม ทำงานขนานกับเธรดหลัก ไม่สามารถเข้าถึง DOM ของเธรดหลักได้ สามารถสื่อสารผ่าน postMessage เท่านั้น quicktype-core คือไลบรารีตัวสร้างโค้ด JSON → หลายภาษาโอเพ่นซอร์ส (GitHub: quicktype/quicktype) รองรับมากกว่าสิบภาษา รวมถึง C++/Java/TypeScript/Rust/Go/Python/Swift เครื่องมือนี้ตาม quicktype-core จะเรนเดอร์โค้ดสตรัคเจอร์ header-only สำหรับ C++ ในเบราว์เซอร์ในเครื่อง ข้อมูลดิบจะไม่ถูกส่งไปยังเซิร์ฟเวอร์ใดๆ การแยกวิเคราะห์ การสร้าง และการดาวน์โหลดทั้งหมดทำในเบราว์เซอร์ Worker ที่โหลด quicktype-core จะหลีกเลี่ยงการบล็อกเธรดหลัก UI

snake_case / camelCase / PascalCase

สไตล์การตั้งชื่อฟิลด์หลักสามแบบ: snake_case (user_name เป็นที่ต้องการใน C/Python/DB), camelCase (userName เป็นที่ต้องการใน Java/JS), PascalCase (UserName เป็นที่ต้องการสำหรับฟิลด์สตรัคเจอร์ C#/Rust) เครื่องมือนี้จะรักษาชื่อฟิลด์เดิมของ JSON ไว้ตามค่าเริ่มต้น (โดยทั่วไปคือ snake_case) คุณสามารถปรับแต่งด้วยตัวเองหลังจากสร้างแล้วเพิ่มมาโคร NLOHMANN เพื่อประกาศการแมป ควรทราบว่ามาตรฐานการตั้งชื่อฟิลด์สาธารณะ C++ แนะนำ camelCase หรือ snake_case PascalCase ใช้สำหรับชื่อคลาสเป็นหลัก (Google C++ Style) ไม่แนะนำให้ใช้กับสมาชิก; snake_case เข้ากันได้กับชื่อคอลัมน์ mySQL ตามธรรมชาติ

NLOHMANN_DEFINE_TYPE_INTRUSIVE

มาโครที่ไลบรารี nlohmann/json จัดเตรียมไว้ ใช้เพื่อประกาศการแมปฟิลด์ซีเรียลไลซ์ JSON ภายในคลาส ไวยากรณ์คือ NLOHMANN_DEFINE_TYPE_INTRUSIVE(ClassName, member1, member2, ...) ต้องวางไว้ในพื้นที่ public (เพื่อให้มาโครเข้าถึงฟิลด์ส่วนตัวได้) เวอร์ชันที่ไม่รุกล้ำ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE จะวางไว้นอกคลาส ไม่ต้องแก้ไขคลาสเอง สตรัคเจอร์ที่สร้างโดยเครื่องมือนี้จะไม่เพิ่มมาโครดังกล่าวโดยอัตโนมัติ หากจำเป็นให้เพิ่มด้วยตัวเองเพื่อประกาศความสัมพันธ์ระหว่างคีย์ JSON กับสมาชิก C++ หากชื่อฟิลด์ JSON เหมือนกับสมาชิก C++ คุณสามารถข้ามมาโครนี้และใช้ j.get<T>() โดยตรงได้

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

เครื่องมือจะอนุมานประเภท C++ ที่สอดคล้องกันโดยอัตโนมัติตามประเภทของค่า JSON:

ตารางเปรียบเทียบการเลือกตัวแยกวิเคราะห์ JSON C++ ยอดนิยม

การเปรียบเทียบไลบรารีแยกวิเคราะห์ JSON หลักในระบบนิเวศ C++ เลือกตามความต้องการของโปรเจกต์:

ตารางอ้างอิงความสอดคล้องประเภทไลบรารีมาตรฐาน C++ กับ JSON อย่างรวดเร็ว

ภาพรวมของประเภทหลักในไลบรารีมาตรฐาน C++ ที่สอดคล้องกับฟิลด์ JSON สำหรับการอ้างอิงอย่างรวดเร็วของนักพัฒนา:

Privacy & Security

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

Authoritative References

• nlohmannที่เก็บ GitHub nlohmann/json (nlohmann/json)
• cppreferencecppreference - std::optional
• cppreferencecppreference - std::vector
• Tencentที่เก็บ GitHub RapidJSON (Tencent)
• Boostเอกสารอย่างเป็นทางการ Boost.JSON
• ISO C++มาตรฐาน ISO C++ อย่างเป็นทางการ - isocpp.org