json
version 3.11.3
json จากตัวอักษร JSONมีไลบรารี JSON มากมาย และแต่ละไลบรารีก็อาจมีเหตุผลในการดำรงอยู่ด้วยซ้ำ ชั้นเรียนของเรามีเป้าหมายการออกแบบดังนี้:
ไวยากรณ์ที่ใช้งานง่าย ในภาษาต่างๆ เช่น Python นั้น JSON ให้ความรู้สึกเหมือนเป็นประเภทข้อมูลชั้นหนึ่ง เราใช้เวทย์มนตร์โอเปอเรเตอร์ทั้งหมดของ C++ สมัยใหม่เพื่อให้ได้ความรู้สึกแบบเดียวกันในโค้ดของคุณ ลองดูตัวอย่างด้านล่างแล้วคุณจะรู้ว่าฉันหมายถึงอะไร
การบูรณาการเล็กน้อย โค้ดทั้งหมดของเราประกอบด้วยไฟล์ส่วนหัวเดียว json.hpp แค่นั้นแหละ. ไม่มีไลบรารี่ ไม่มีโปรเจ็กต์ย่อย ไม่มีการพึ่งพา ไม่มีระบบการสร้างที่ซับซ้อน ชั้นเรียนเขียนด้วยภาษาวานิลลา C++11 โดยรวมแล้ว ทุกสิ่งไม่ควรต้องมีการปรับเปลี่ยนแฟล็กคอมไพเลอร์หรือการตั้งค่าโปรเจ็กต์ของคุณ
การทดสอบที่จริงจัง โค้ดของเราได้รับการทดสอบหน่วยอย่างหนักและครอบคลุมโค้ด 100% รวมถึงพฤติกรรมพิเศษทั้งหมดด้วย นอกจากนี้เรายังตรวจสอบกับ Valgrind และ Clang Sanitizers ว่าไม่มีหน่วยความจำรั่ว นอกจากนี้ Google OSS-Fuzz ยังทำการทดสอบแบบคลุมเครือกับโปรแกรมแยกวิเคราะห์ทั้งหมดทุกวันตลอด 24 ชั่วโมง ซึ่งดำเนินการทดสอบนับพันล้านครั้งอย่างมีประสิทธิภาพจนถึงขณะนี้ เพื่อรักษาคุณภาพสูง โครงการจึงปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดของ Core Infrastructure Initiative (CII)
ด้านอื่นๆ ไม่สำคัญสำหรับเรามากนัก:
ประสิทธิภาพของหน่วยความจำ ออบเจ็กต์ JSON แต่ละรายการมีค่าใช้จ่ายของหนึ่งพอยน์เตอร์ (ขนาดสูงสุดของสหภาพ) และองค์ประกอบการแจงนับหนึ่งรายการ (1 ไบต์) การวางนัยทั่วไปตามค่าเริ่มต้นจะใช้ประเภทข้อมูล C++ ต่อไปนี้: std::string สำหรับสตริง, int64_t , uint64_t หรือ double สำหรับตัวเลข, std::map สำหรับอ็อบเจ็กต์, std::vector สำหรับอาร์เรย์ และ bool สำหรับบูลีน อย่างไรก็ตาม คุณสามารถเทมเพลตคลาสทั่วไป basic_json ตามความต้องการของคุณได้
ความเร็ว . มีไลบรารี JSON ที่เร็วกว่านี้อย่างแน่นอน อย่างไรก็ตาม หากเป้าหมายของคุณคือการเร่งการพัฒนาโดยเพิ่มการรองรับ JSON ด้วยส่วนหัวเดียว ไลบรารีนี้ก็ใช่เลย หากคุณรู้วิธีใช้ std::vector หรือ std::map คุณตั้งค่าไว้แล้ว
ดูหลักเกณฑ์การบริจาคสำหรับข้อมูลเพิ่มเติม
คุณสามารถสนับสนุนห้องสมุดนี้ได้ที่ GitHub Sponsors
ขอบคุณทุกคน!
❓ หากคุณมี คำถาม โปรดตรวจสอบว่ามีคำตอบแล้วใน ส่วนคำถามที่พบบ่อย หรือส่วน ถามตอบ ถ้าไม่ โปรด ถามคำถามใหม่ ที่นั่น
หากคุณต้องการ เรียนรู้เพิ่มเติม เกี่ยวกับวิธีใช้ไลบรารี โปรดดูส่วนที่เหลือของ README ดู ตัวอย่างโค้ด หรือเรียกดู หน้าช่วยเหลือ
- หากคุณต้องการทำความเข้าใจ API ให้ดีขึ้น โปรดดูที่ API Reference
- หากคุณพบ ข้อบกพร่อง โปรดตรวจสอบ คำถามที่ พบบ่อยว่าเป็นปัญหาที่ทราบหรือเป็นผลจากการตัดสินใจในการออกแบบ โปรดดู รายการปัญหา ก่อนที่คุณ จะสร้างปัญหาใหม่ โปรดให้ข้อมูลมากที่สุดเท่าที่จะเป็นไปได้เพื่อช่วยให้เราเข้าใจและทำให้เกิดปัญหาของคุณอีกครั้ง
นอกจากนี้ยังมี ชุดเอกสาร สำหรับเบราว์เซอร์เอกสาร Dash, Velocity และ Zeal ที่มีเอกสารประกอบฉบับเต็มเป็นทรัพยากรออฟไลน์
ต่อไปนี้เป็นตัวอย่างบางส่วนเพื่อให้คุณมีแนวคิดในการใช้ชั้นเรียน
นอกเหนือจากตัวอย่างด้านล่าง คุณอาจต้องการ:
→ ตรวจสอบเอกสาร
→ เรียกดูไฟล์ตัวอย่างแบบสแตนด์อโลน
ฟังก์ชัน API ทุกฟังก์ชัน (บันทึกไว้ในเอกสารประกอบ API) มีไฟล์ตัวอย่างแบบสแตนด์อโลนที่สอดคล้องกัน ตัวอย่างเช่น ฟังก์ชัน emplace() มีไฟล์ตัวอย่าง emplace.cpp ที่ตรงกัน
คลาส json จัดเตรียม API สำหรับจัดการค่า JSON หากต้องการสร้างวัตถุ json โดยการอ่านไฟล์ JSON ให้ทำดังนี้
# include < fstream >
# include < nlohmann/json.hpp >
using json = nlohmann::json;
// ...
std::ifstream f ( " example.json " );
json data = json::parse(f);json จากตัวอักษร JSON สมมติว่าคุณต้องการสร้างฮาร์ดโค้ดค่า JSON ตามตัวอักษรนี้ในไฟล์เป็นออบเจ็กต์ json :
{
"pi" : 3.141 ,
"happy" : true
}มีตัวเลือกต่างๆ:
// Using (raw) string literals and json::parse
json ex1 = json::parse( R"(
{
"pi": 3.141,
"happy": true
}
)" );
// Using user-defined (raw) string literals
using namespace nlohmann ::literals ;
json ex2 = R"(
{
"pi": 3.141,
"happy": true
}
)" _json;
// Using initializer lists
json ex3 = {
{ " happy " , true },
{ " pi " , 3.141 },
};ต่อไปนี้เป็นตัวอย่างบางส่วนเพื่อให้คุณมีแนวคิดในการใช้ชั้นเรียน
สมมติว่าคุณต้องการสร้างออบเจ็กต์ JSON
{
"pi" : 3.141 ,
"happy" : true ,
"name" : " Niels " ,
"nothing" : null ,
"answer" : {
"everything" : 42
},
"list" : [ 1 , 0 , 2 ],
"object" : {
"currency" : " USD " ,
"value" : 42.99
}
}ด้วยไลบรารีนี้ คุณสามารถเขียน:
// create an empty structure (null)
json j;
// add a number that is stored as double (note the implicit conversion of j to an object)
j[ " pi " ] = 3.141 ;
// add a Boolean that is stored as bool
j[ " happy " ] = true ;
// add a string that is stored as std::string
j[ " name " ] = " Niels " ;
// add another null object by passing nullptr
j[ " nothing " ] = nullptr ;
// add an object inside the object
j[ " answer " ][ " everything " ] = 42 ;
// add an array that is stored as std::vector (using an initializer list)
j[ " list " ] = { 1 , 0 , 2 };
// add another object (using an initializer list of pairs)
j[ " object " ] = { { " currency " , " USD " }, { " value " , 42.99 } };
// instead, you could also write (which looks very similar to the JSON above)
json j2 = {
{ " pi " , 3.141 },
{ " happy " , true },
{ " name " , " Niels " },
{ " nothing " , nullptr },
{ " answer " , {
{ " everything " , 42 }
}},
{ " list " , { 1 , 0 , 2 }},
{ " object " , {
{ " currency " , " USD " },
{ " value " , 42.99 }
}}
}; โปรดทราบว่าในทุกกรณี คุณไม่จำเป็นต้อง "บอก" คอมไพลเลอร์ว่าต้องการใช้ค่า JSON ประเภทใด หากคุณต้องการให้ชัดเจนหรือแสดงกรณีขอบบางกรณี ฟังก์ชัน json::array() และ json::object() จะช่วย:
// a way to express the empty array []
json empty_array_explicit = json::array();
// ways to express the empty object {}
json empty_object_implicit = json({});
json empty_object_explicit = json::object();
// a way to express an _array_ of key/value pairs [["currency", "USD"], ["value", 42.99]]
json array_not_object = json::array({ { " currency " , " USD " }, { " value " , 42.99 } }); คุณสามารถสร้างค่า JSON (ดีซีเรียลไลเซชัน) ได้โดยการต่อท้าย _json เข้ากับสตริงตามตัวอักษร:
// create object from string literal
json j = " { " happy " : true, " pi " : 3.141 } " _json;
// or even nicer with a raw string literal
auto j2 = R"(
{
"happy": true,
"pi": 3.141
}
)" _json; โปรดทราบว่าหากไม่ต่อท้ายส่วนต่อท้าย _json สตริงลิเทอรัลที่ส่งผ่านจะไม่ถูกแยกวิเคราะห์ แต่จะใช้เป็นค่าสตริง JSON เท่านั้น นั่นคือ json j = "{ "happy": true, "pi": 3.141 }" จะเก็บสตริง "{ "happy": true, "pi": 3.141 }" แทนที่จะแยกวิเคราะห์ข้อมูลจริง วัตถุ.
ควรนำสตริงตัวอักษรเข้าสู่ขอบเขตโดย using namespace nlohmann::literals; (ดู json::parse() )
ตัวอย่างข้างต้นสามารถแสดงได้อย่างชัดเจนโดยใช้ json::parse() :
// parse explicitly
auto j3 = json::parse( R"( {"happy": true, "pi": 3.141} )" );คุณยังสามารถรับการแสดงสตริงของค่า JSON (ทำให้เป็นอนุกรม):
// explicit conversion to string
std::string s = j.dump(); // {"happy":true,"pi":3.141}
// serialization with pretty printing
// pass in the amount of spaces to indent
std::cout << j.dump( 4 ) << std::endl;
// {
// "happy": true,
// "pi": 3.141
// }สังเกตความแตกต่างระหว่างการทำให้เป็นอนุกรมและการกำหนด:
// store a string in a JSON value
json j_string = " this is a string " ;
// retrieve the string value
auto cpp_string = j_string. template get<std::string>();
// retrieve the string value (alternative when a variable already exists)
std::string cpp_string2;
j_string.get_to(cpp_string2);
// retrieve the serialized value (explicit JSON serialization)
std::string serialized_string = j_string.dump();
// output of original string
std::cout << cpp_string << " == " << cpp_string2 << " == " << j_string. template get<std::string>() << ' n ' ;
// output of serialized value
std::cout << j_string << " == " << serialized_string << std::endl; .dump() ส่งกลับค่าสตริงที่เก็บไว้เดิม
โปรดทราบว่าไลบรารีรองรับเฉพาะ UTF-8 เท่านั้น เมื่อคุณจัดเก็บสตริงที่มีการเข้ารหัสที่แตกต่างกันในไลบรารี การเรียก dump() อาจทำให้เกิดข้อยกเว้น เว้นแต่ว่า json::error_handler_t::replace หรือ json::error_handler_t::ignore ถูกใช้เป็นตัวจัดการข้อผิดพลาด
คุณยังสามารถใช้สตรีมเพื่อทำให้ซีเรียลไลซ์และดีซีเรียลไลซ์ได้:
// deserialize from standard input
json j;
std::cin >> j;
// serialize to standard output
std::cout << j;
// the setw manipulator was overloaded to set the indentation for pretty printing
std::cout << std::setw( 4 ) << j << std::endl; โอเปอเรเตอร์เหล่านี้ใช้ได้กับคลาสย่อยของ std::istream หรือ std::ostream นี่คือตัวอย่างเดียวกันกับไฟล์:
// read a JSON file
std::ifstream i ( " file.json " );
json j;
i >> j;
// write prettified JSON to another file
std::ofstream o ( " pretty.json " );
o << std::setw( 4 ) << j << std::endl; โปรดทราบว่าการตั้งค่าบิตข้อยกเว้นสำหรับ failbit นั้นไม่เหมาะสมสำหรับกรณีการใช้งานนี้ มันจะส่งผลให้โปรแกรมยุติลงเนื่องจากมีการใช้งานตัวระบุ noexcept
คุณยังสามารถแยกวิเคราะห์ JSON จากช่วงตัววนซ้ำได้ นั่นคือจากคอนเทนเนอร์ใดๆ ที่สามารถเข้าถึงได้โดยตัววนซ้ำซึ่ง value_type เป็นประเภทอินทิกรัลขนาด 1, 2 หรือ 4 ไบต์ ซึ่งจะถูกตีความว่าเป็น UTF-8, UTF-16 และ UTF-32 ตามลำดับ ตัวอย่างเช่น a std::vector<std::uint8_t> หรือ std::list<std::uint16_t> :
std::vector<std:: uint8_t > v = { ' t ' , ' r ' , ' u ' , ' e ' };
json j = json::parse(v.begin(), v.end());คุณสามารถปล่อยให้ตัววนซ้ำอยู่ในช่วง [เริ่มต้น, สิ้นสุด):
std::vector<std:: uint8_t > v = { ' t ' , ' r ' , ' u ' , ' e ' };
json j = json::parse(v); เนื่องจากฟังก์ชันแยกวิเคราะห์ยอมรับช่วงตัววนซ้ำที่กำหนดเอง คุณจึงสามารถจัดเตรียมแหล่งข้อมูลของคุณเองได้โดยใช้แนวคิด LegacyInputIterator
struct MyContainer {
void advance ();
const char & get_current ();
};
struct MyIterator {
using difference_type = std:: ptrdiff_t ;
using value_type = char ;
using pointer = const char *;
using reference = const char &;
using iterator_category = std::input_iterator_tag;
MyIterator& operator ++() {
target-> advance ();
return * this ;
}
bool operator !=( const MyIterator& rhs) const {
return rhs. target != target;
}
reference operator *() const {
return target-> get_current ();
}
MyContainer* target = nullptr ;
};
MyIterator begin (MyContainer& tgt) {
return MyIterator{&tgt};
}
MyIterator end ( const MyContainer&) {
return {};
}
void foo () {
MyContainer c;
json j = json::parse (c);
}ไลบรารีใช้อินเทอร์เฟซคล้าย SAX พร้อมฟังก์ชันต่อไปนี้:
// called when null is parsed
bool null ();
// called when a boolean is parsed; value is passed
bool boolean ( bool val);
// called when a signed or unsigned integer number is parsed; value is passed
bool number_integer ( number_integer_t val);
bool number_unsigned ( number_unsigned_t val);
// called when a floating-point number is parsed; value and original string is passed
bool number_float ( number_float_t val, const string_t & s);
// called when a string is parsed; value is passed and can be safely moved away
bool string ( string_t & val);
// called when a binary value is parsed; value is passed and can be safely moved away
bool binary ( binary_t & val);
// called when an object or array begins or ends, resp. The number of elements is passed (or -1 if not known)
bool start_object (std:: size_t elements);
bool end_object ();
bool start_array (std:: size_t elements);
bool end_array ();
// called when an object key is parsed; value is passed and can be safely moved away
bool key ( string_t & val);
// called when a parse error occurs; byte position, the last token, and an exception is passed
bool parse_error (std:: size_t position, const std::string& last_token, const detail:: exception & ex);ค่าที่ส่งคืนของแต่ละฟังก์ชันจะกำหนดว่าควรแยกวิเคราะห์ต่อไปหรือไม่
หากต้องการใช้ตัวจัดการ SAX ของคุณเอง ให้ดำเนินการดังนี้:
nlohmann::json_sax<json> เป็นคลาสพื้นฐานได้ แต่คุณยังสามารถใช้คลาสใดก็ได้ที่มีการปรับใช้ฟังก์ชันที่อธิบายไว้ข้างต้นและเป็นสาธารณะmy_saxbool json::sax_parse(input, &my_sax) ; โดยที่พารามิเตอร์แรกสามารถเป็นอินพุตใดๆ เช่น สตริงหรืออินพุตสตรีม และพารามิเตอร์ตัวที่สองคือตัวชี้ไปยังอินเทอร์เฟซ SAX ของคุณ โปรดทราบว่าฟังก์ชัน sax_parse จะส่งคืน bool ที่ระบุผลลัพธ์ของเหตุการณ์ SAX ที่ดำเนินการครั้งล่าสุดเท่านั้น จะไม่ส่งคืนค่า json - ขึ้นอยู่กับคุณที่จะตัดสินใจว่าจะทำอย่างไรกับเหตุการณ์ SAX นอกจากนี้ จะไม่มีข้อยกเว้นเกิดขึ้นในกรณีที่เกิดข้อผิดพลาดในการแยกวิเคราะห์ - ขึ้นอยู่กับคุณว่าจะทำอย่างไรกับออบเจ็กต์ข้อยกเว้นที่ส่งไปยังการใช้งาน parse_error ของคุณ ภายใน อินเทอร์เฟซ SAX ใช้สำหรับตัวแยกวิเคราะห์ DOM (คลาส json_sax_dom_parser ) เช่นเดียวกับตัวรับ ( json_sax_acceptor ) ดูไฟล์ json_sax.hpp
เราออกแบบคลาส JSON ให้ทำงานเหมือนกับคอนเทนเนอร์ STL ที่จริงแล้ว มันเป็นไปตามข้อกำหนด ReversibleContainer
// create an array using push_back
json j;
j.push_back( " foo " );
j.push_back( 1 );
j.push_back( true );
// also use emplace_back
j.emplace_back( 1.78 );
// iterate the array
for (json::iterator it = j.begin(); it != j.end(); ++it) {
std::cout << *it << ' n ' ;
}
// range-based for
for ( auto & element : j) {
std::cout << element << ' n ' ;
}
// getter/setter
const auto tmp = j[ 0 ]. template get<std::string>();
j[ 1 ] = 42 ;
bool foo = j.at( 2 );
// comparison
j == R"( ["foo", 1, true, 1.78] )" _json; // true
// other stuff
j.size(); // 4 entries
j.empty(); // false
j.type(); // json::value_t::array
j.clear(); // the array is empty again
// convenience type checkers
j.is_null();
j.is_boolean();
j.is_number();
j.is_object();
j.is_array();
j.is_string();
// create an object
json o;
o[ " foo " ] = 23 ;
o[ " bar " ] = false ;
o[ " baz " ] = 3.141 ;
// also use emplace
o.emplace( " weather " , " sunny " );
// special iterator member functions for objects
for (json::iterator it = o.begin(); it != o.end(); ++it) {
std::cout << it. key () << " : " << it. value () << " n " ;
}
// the same code as range for
for ( auto & el : o.items()) {
std::cout << el. key () << " : " << el. value () << " n " ;
}
// even easier with structured bindings (C++17)
for ( auto & [key, value] : o.items()) {
std::cout << key << " : " << value << " n " ;
}
// find an entry
if (o.contains( " foo " )) {
// there is an entry with key "foo"
}
// or via find and an iterator
if (o.find( " foo " ) != o.end()) {
// there is an entry with key "foo"
}
// or simpler using count()
int foo_present = o.count( " foo " ); // 1
int fob_present = o.count( " fob " ); // 0
// delete an entry
o.erase( " foo " ); คอนเทนเนอร์ลำดับใด ๆ ( std::array , std::vector , std::deque , std::forward_list , std::list ) ซึ่งค่าที่สามารถใช้ในการสร้างค่า JSON (เช่น จำนวนเต็ม ตัวเลขทศนิยม บูลีน สตริง ประเภทหรือคอนเทนเนอร์ STL อีกครั้งที่อธิบายไว้ในส่วนนี้) สามารถใช้เพื่อสร้างอาร์เรย์ JSON ได้ สิ่งเดียวกันนี้มีไว้สำหรับคอนเทนเนอร์ที่เชื่อมโยงที่คล้ายกัน ( std::set , std::multiset , std::unordered_set , std::unordered_multiset ) แต่ในกรณีเหล่านี้ ลำดับขององค์ประกอบของอาร์เรย์ขึ้นอยู่กับวิธีการเรียงลำดับองค์ประกอบใน คอนเทนเนอร์ STL ตามลำดับ
std::vector< int > c_vector { 1 , 2 , 3 , 4 };
json j_vec (c_vector);
// [1, 2, 3, 4]
std::deque< double > c_deque { 1.2 , 2.3 , 3.4 , 5.6 };
json j_deque (c_deque);
// [1.2, 2.3, 3.4, 5.6]
std::list< bool > c_list { true , true , false , true };
json j_list (c_list);
// [true, true, false, true]
std::forward_list< int64_t > c_flist { 12345678909876 , 23456789098765 , 34567890987654 , 45678909876543 };
json j_flist (c_flist);
// [12345678909876, 23456789098765, 34567890987654, 45678909876543]
std::array< unsigned long , 4 > c_array {{ 1 , 2 , 3 , 4 }};
json j_array (c_array);
// [1, 2, 3, 4]
std::set<std::string> c_set { " one " , " two " , " three " , " four " , " one " };
json j_set (c_set); // only one entry for "one" is used
// ["four", "one", "three", "two"]
std::unordered_set<std::string> c_uset { " one " , " two " , " three " , " four " , " one " };
json j_uset (c_uset); // only one entry for "one" is used
// maybe ["two", "three", "four", "one"]
std::multiset<std::string> c_mset { " one " , " two " , " one " , " four " };
json j_mset (c_mset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]
std::unordered_multiset<std::string> c_umset { " one " , " two " , " one " , " four " };
json j_umset (c_umset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"] ในทำนองเดียวกัน คอนเทนเนอร์คีย์-ค่าที่เชื่อมโยงใด ๆ ( std::map , std::multimap , std::unordered_map , std::unordered_multimap ) ซึ่งคีย์สามารถสร้าง std::string และค่าที่สามารถใช้ในการสร้างค่า JSON (ดู ตัวอย่างข้างต้น) สามารถใช้เพื่อสร้างวัตถุ JSON โปรดทราบว่าในกรณีของมัลติแมป จะใช้เพียงคีย์เดียวในออบเจ็กต์ JSON และค่าจะขึ้นอยู่กับลำดับภายในของคอนเทนเนอร์ STL
std::map<std::string, int > c_map { { " one " , 1 }, { " two " , 2 }, { " three " , 3 } };
json j_map (c_map);
// {"one": 1, "three": 3, "two": 2 }
std::unordered_map< const char *, double > c_umap { { " one " , 1.2 }, { " two " , 2.3 }, { " three " , 3.4 } };
json j_umap (c_umap);
// {"one": 1.2, "two": 2.3, "three": 3.4}
std::multimap<std::string, bool > c_mmap { { " one " , true }, { " two " , true }, { " three " , false }, { " three " , true } };
json j_mmap (c_mmap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}
std::unordered_multimap<std::string, bool > c_ummap { { " one " , true }, { " two " , true }, { " three " , false }, { " three " , true } };
json j_ummap (c_ummap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}ไลบรารีรองรับ JSON Pointer (RFC 6901) เป็นทางเลือกอื่นในการจัดการกับค่าที่มีโครงสร้าง ยิ่งไปกว่านั้น JSON Patch (RFC 6902) ยังอนุญาตให้อธิบายความแตกต่างระหว่างค่า JSON สองค่า - ช่วยให้สามารถดำเนินการ patch และ diff ที่รู้จักจาก Unix ได้อย่างมีประสิทธิภาพ
// a JSON value
json j_original = R"( {
"baz": ["one", "two", "three"],
"foo": "bar"
} )" _json;
// access members with a JSON pointer (RFC 6901)
j_original[ " /baz/1 " _json_pointer];
// "two"
// a JSON patch (RFC 6902)
json j_patch = R"( [
{ "op": "replace", "path": "/baz", "value": "boo" },
{ "op": "add", "path": "/hello", "value": ["world"] },
{ "op": "remove", "path": "/foo"}
] )" _json;
// apply the patch
json j_result = j_original.patch(j_patch);
// {
// "baz": "boo",
// "hello": ["world"]
// }
// calculate a JSON patch from two JSON values
json::diff (j_result, j_original);
// [
// { "op":" replace", "path": "/baz", "value": ["one", "two", "three"] },
// { "op": "remove","path": "/hello" },
// { "op": "add", "path": "/foo", "value": "bar" }
// ]ไลบรารีรองรับ JSON Merge Patch (RFC 7386) เป็นรูปแบบแพตช์ แทนที่จะใช้ตัวชี้ JSON (ดูด้านบน) เพื่อระบุค่าที่จะจัดการ ตัวชี้จะอธิบายการเปลี่ยนแปลงโดยใช้ไวยากรณ์ที่เลียนแบบเอกสารที่กำลังแก้ไขอย่างใกล้ชิด
// a JSON value
json j_document = R"( {
"a": "b",
"c": {
"d": "e",
"f": "g"
}
} )" _json;
// a patch
json j_patch = R"( {
"a":"z",
"c": {
"f": null
}
} )" _json;
// apply the patch
j_document.merge_patch(j_patch);
// {
// "a": "z",
// "c": {
// "d": "e"
// }
// }ประเภทที่รองรับสามารถแปลงเป็นค่า JSON โดยปริยายได้
ไม่แนะนำให้ใช้ การแปลงโดยนัย จาก ค่า JSON คุณสามารถดูรายละเอียดเพิ่มเติมเกี่ยวกับคำแนะนำนี้ได้ที่นี่ คุณสามารถปิดการแปลงโดยนัยได้โดยกำหนด JSON_USE_IMPLICIT_CONVERSIONS เป็น 0 ก่อนที่จะรวมส่วนหัว json.hpp เมื่อใช้ CMake คุณสามารถทำได้โดยการตั้งค่าตัวเลือก JSON_ImplicitConversions เป็น OFF
// strings
std::string s1 = " Hello, world! " ;
json js = s1;
auto s2 = js. template get<std::string>();
// NOT RECOMMENDED
std::string s3 = js;
std::string s4;
s4 = js;
// Booleans
bool b1 = true ;
json jb = b1;
auto b2 = jb. template get< bool >();
// NOT RECOMMENDED
bool b3 = jb;
bool b4;
b4 = jb;
// numbers
int i = 42
