Chinese (Simplified Han script) (Boost Json Translation - en to zh_Hans translation catalogue (106 entries)

en: = `value` JSON documents are represented in memory as instances of <<ref_value>>: a {req_Regular} type which satisfies {req_DefaultConstructible}, {req_CopyConstructible}, {req_CopyAssignable}, {req_MoveConstructible}, {req_MoveAssignable}, and many of the requirements of allocator-aware containers. It is implemented as a https://en.wikipedia.org/wiki/Tagged_union[__variant__] internally, and can dynamically store any of the six defined JSON value types:
zh_Hans: = `value` JSON文档在内存中表示为&lt;<ref_value>&gt;的实例：一种{req_Regular}类型，满足{req_DefaultConstructible}、{req_CopyConstructible}、{req_CopyAssignable}、{req_MoveConstructible}、{req_MoveAssignable}以及许多分配器感知容器的要求。它在内部实现为一个https://en.wikipedia.org/wiki/Tagged_union[__variant__]（变体），并且可以动态存储六种已定义的JSON值类型中的任意一种：</ref_value>

en: **null**: A
zh_Hans: **空值**：一种

en: https://en.cppreference.com/w/cpp/utility/variant/monostate[__monostate__] value, equivalent to `nullptr`.
zh_Hans: https://en.cppreference.com/w/cpp/utility/variant/monostate[__monostate__]（单态）值，等同于`nullptr`。

en: **boolean**: A boolean: either `true` or `false`.
zh_Hans: **布尔值**：布尔类型，取值为`true`或`false`。

en: **number**: An integral or floating point value.
zh_Hans: **数值**：整型或浮点型值。

en: **string**: A sequence of zero or more Unicode characters,
zh_Hans: **字符串**：由零个或多个Unicode字符组成的序列，

en: similar to {std_string}.
zh_Hans: 类似于{std_string}。

en: **array**: An ordered list of values, like {std_vector}.
zh_Hans: **数组**：值的有序列表，类似于{std_vector}。

en: **object**: A collection of name/value pairs, also known as an
zh_Hans: **对象**：名称/值对的集合，也称为

en: https://en.wikipedia.org/wiki/Associative_array[__associative array__].
zh_Hans: https://en.wikipedia.org/wiki/Associative_array[__关联数组__]。

en: Working With Values
zh_Hans: 处理值

en: A <<ref_value>> constructed from `nullptr` or default constructed represents a null JSON element:
zh_Hans: 从`nullptr`构造或默认构造的 &lt;<ref_value>&gt; 表示一个空的JSON元素：</ref_value>

en: The member function <<ref_value_kind,`value::kind`>> may be used to query the kind stored in the value. Alternatively, member functions like <<ref_value_is_object,`value::is_object`>> <<ref_value_is_number,`value::is_number`>> may be used to check whether or not the value is a particular kind:
zh_Hans: 成员函数&lt;<ref_value_kind,`value::kind`>&gt;可用于查询值中存储的种类。或者，也可以使用诸如&lt;<ref_value_is_object,`value::is_object`>&gt;、&lt;<ref_value_is_number,`value::is_number`>&gt; 等成员函数来检查值是否为特定种类：</ref_value_is_number,`value::is_number`></ref_value_is_object,`value::is_object`></ref_value_kind,`value::kind`>

en: Functions like <<ref_value_if_object,`value::if_object`>> actually return a pointer to the object if the value is an object, otherwise they return null. This allows them to be used both in boolean contexts as above, and in assignments or conditional expressions to capture the value of the pointer:
zh_Hans: 诸如 &lt;<ref_value_if_object,`value::if_object`>&gt; 的函数在值为对象时返回指向该对象的指针，否则返回空指针。这使得它们既可用于上述的布尔上下文，也可用于赋值或条件表达式中，以捕获指针的值：</ref_value_if_object,`value::if_object`>

en: After a <<ref_value>> is constructed, its kind can change depending on what is assigned to it, or by calling functions such as <<ref_value_emplace_array,`value::emplace_array`>> or <<ref_value_emplace_bool,`value::emplace_bool`>>. If the assignment is successful, in other words it completes without any exceptions then the value is replaced. Otherwise, the value is unchanged. All operations which can fail to modify a value offer the strong exception safety guarantee.
zh_Hans: &lt;<ref_value>&gt; 构造之后，其类型可根据赋值内容或通过调用&lt;<ref_value_emplace_array,`value::emplace_array`>&gt; 或 &lt;<ref_value_emplace_bool,`value::emplace_bool`>&gt; 等函数来改变。如果赋值成功，即未引发任何异常，则该值将被替换。否则，原值保持不变。所有可能修改值失败的操作均提供强异常安全保证。</ref_value_emplace_bool,`value::emplace_bool`></ref_value_emplace_array,`value::emplace_array`></ref_value>

en: The following table shows all of the ways to determine and access the contents of a <<ref_value>>:
zh_Hans: 下表列出了所有用于判断和访问 &lt;<ref_value>&gt; 内容的方法：</ref_value>

en: .<<ref_value>> Accessors [%autowidth,cols=8] |=== |Kind |Representation |Emplacement |Kind Test |Pointer Access |`result` Access |Checked Access |Unchecked Access
zh_Hans: .&lt;<ref_value>&gt;访问器 [%autowidth, cols=8] |=== |种类 |表示形式 |置入 |种类测试 |指针访问 |`result`访问 |受检访问 |非受检访问</ref_value>

[ctx: :95]
en: <<ref_kind,`kind::array`>>
zh_Hans: &lt;<ref_kind,`kind::array`>&gt;</ref_kind,`kind::array`>

[ctx: :95]
en: <<ref_array>>
zh_Hans: &lt;<ref_array>&gt;</ref_array>

en: <<ref_value_emplace_array>>
zh_Hans: &lt;<ref_value_emplace_array>&gt;</ref_value_emplace_array>

en: <<ref_value_is_array>>
zh_Hans: &lt;<ref_value_is_array>&gt;</ref_value_is_array>

en: <<ref_value_if_array>>
zh_Hans: &lt;<ref_value_if_array>&gt;</ref_value_if_array>

en: <<ref_value_try_as_array>>
zh_Hans: &lt;<ref_value_try_as_array>&gt;</ref_value_try_as_array>

en: <<ref_value_as_array>>
zh_Hans: &lt;<ref_value_as_array>&gt;</ref_value_as_array>

en: <<ref_value_get_array>>
zh_Hans: &lt;<ref_value_get_array>&gt;</ref_value_get_array>

[ctx: :95]
en: <<ref_kind,`kind::object`>>
zh_Hans: &lt;<ref_kind,`kind::object`>&gt;</ref_kind,`kind::object`>

[ctx: :95]
en: <<ref_object>>
zh_Hans: &lt;<ref_object>&gt;</ref_object>

en: <<ref_value_emplace_object>>
zh_Hans: &lt;<ref_value_emplace_object>&gt;</ref_value_emplace_object>

en: <<ref_value_is_object>>
zh_Hans: &lt;<ref_value_is_object>&gt;</ref_value_is_object>

en: <<ref_value_if_object>>
zh_Hans: &lt;<ref_value_if_object>&gt;</ref_value_if_object>

en: <<ref_value_try_as_object>>
zh_Hans: &lt;<ref_value_try_as_object>&gt;</ref_value_try_as_object>

en: <<ref_value_as_object>>
zh_Hans: &lt;<ref_value_as_object>&gt;</ref_value_as_object>

en: <<ref_value_get_object>>
zh_Hans: &lt;<ref_value_get_object>&gt;</ref_value_get_object>

[ctx: :95]
en: <<ref_kind,`kind::string`>>
zh_Hans: &lt;<ref_kind,`kind::string`>&gt;</ref_kind,`kind::string`>

[ctx: :95]
en: <<ref_string>>
zh_Hans: &lt;<ref_string>&gt;</ref_string>

en: <<ref_value_emplace_string>>
zh_Hans: &lt;<ref_value_emplace_string>&gt;</ref_value_emplace_string>

en: <<ref_value_is_string>>
zh_Hans: &lt;<ref_value_is_string>&gt;</ref_value_is_string>

en: <<ref_value_if_string>>
zh_Hans: &lt;<ref_value_if_string>&gt;</ref_value_if_string>

en: <<ref_value_try_as_string>>
zh_Hans: &lt;<ref_value_try_as_string>&gt;</ref_value_try_as_string>

en: <<ref_value_as_string>>
zh_Hans: &lt;<ref_value_as_string>&gt;</ref_value_as_string>

en: <<ref_value_get_string>>
zh_Hans: &lt;<ref_value_get_string>&gt;</ref_value_get_string>

[ctx: :95]
en: <<ref_kind,`kind::int64`>>
zh_Hans: &lt;<ref_kind,`kind::int64`>&gt;</ref_kind,`kind::int64`>

en: <<ref_value_emplace_int64>>
zh_Hans: &lt;<ref_value_emplace_int64>&gt;</ref_value_emplace_int64>

en: <<ref_value_is_int64>>
zh_Hans: &lt;<ref_value_is_int64>&gt;</ref_value_is_int64>

en: <<ref_value_if_int64>>
zh_Hans: &lt;<ref_value_if_int64>&gt;</ref_value_if_int64>

en: <<ref_value_try_as_int64>>
zh_Hans: &lt;<ref_value_try_as_int64>&gt;</ref_value_try_as_int64>

en: <<ref_value_as_int64>>
zh_Hans: &lt;<ref_value_as_int64>&gt;</ref_value_as_int64>

en: <<ref_value_get_int64>>
zh_Hans: &lt;<ref_value_get_int64>&gt;</ref_value_get_int64>

[ctx: :95]
en: <<ref_kind,`kind::uint64`>>
zh_Hans: &lt;<ref_kind,`kind::uint64`>&gt;</ref_kind,`kind::uint64`>

en: <<ref_value_emplace_uint64>>
zh_Hans: &lt;<ref_value_emplace_uint64>&gt;</ref_value_emplace_uint64>

en: <<ref_value_is_uint64>>
zh_Hans: &lt;<ref_value_is_uint64>&gt;</ref_value_is_uint64>

en: <<ref_value_if_uint64>>
zh_Hans: &lt;<ref_value_if_uint64>&gt;</ref_value_if_uint64>

en: <<ref_value_try_as_uint64>>
zh_Hans: &lt;<ref_value_try_as_uint64>&gt;</ref_value_try_as_uint64>

en: <<ref_value_as_uint64>>
zh_Hans: &lt;<ref_value_as_uint64>&gt;</ref_value_as_uint64>

en: <<ref_value_get_uint64>>
zh_Hans: &lt;<ref_value_get_uint64>&gt;</ref_value_get_uint64>

[ctx: :95]
en: <<ref_kind,`kind::double_`>>
zh_Hans: &lt;<ref_kind,`kind::double_`>&gt;</ref_kind,`kind::double_`>

en: <<ref_value_emplace_double>>
zh_Hans: &lt;<ref_value_emplace_double>&gt;</ref_value_emplace_double>

en: <<ref_value_is_double>>
zh_Hans: &lt;<ref_value_is_double>&gt;</ref_value_is_double>

en: <<ref_value_if_double>>
zh_Hans: &lt;<ref_value_if_double>&gt;</ref_value_if_double>

en: <<ref_value_try_as_double>>
zh_Hans: &lt;<ref_value_try_as_double>&gt;</ref_value_try_as_double>

en: <<ref_value_as_double>>
zh_Hans: &lt;<ref_value_as_double>&gt;</ref_value_as_double>

en: <<ref_value_get_double>>
zh_Hans: &lt;<ref_value_get_double>&gt;</ref_value_get_double>

[ctx: :95]
en: <<ref_kind,`kind::bool_`>>
zh_Hans: &lt;<ref_kind,`kind::bool_`>&gt;</ref_kind,`kind::bool_`>

en: <<ref_value_emplace_bool>>
zh_Hans: &lt;<ref_value_emplace_bool>&gt;</ref_value_emplace_bool>

en: <<ref_value_is_bool>>
zh_Hans: &lt;<ref_value_is_bool>&gt;</ref_value_is_bool>

en: <<ref_value_if_bool>>
zh_Hans: &lt;<ref_value_if_bool>&gt;</ref_value_if_bool>

en: <<ref_value_try_as_bool>>
zh_Hans: &lt;<ref_value_try_as_bool>&gt;</ref_value_try_as_bool>

en: <<ref_value_as_bool>>
zh_Hans: &lt;<ref_value_as_bool>&gt;</ref_value_as_bool>

en: <<ref_value_get_bool>>
zh_Hans: &lt;<ref_value_get_bool>&gt;</ref_value_get_bool>

[ctx: :95]
en: <<ref_kind,`kind::null`>>
zh_Hans: &lt;<ref_kind,`kind::null`>&gt;</ref_kind,`kind::null`>

en: <<ref_value_emplace_null>>
zh_Hans: &lt;<ref_value_emplace_null>&gt;</ref_value_emplace_null>

en: <<ref_value_is_null>>
zh_Hans: &lt;<ref_value_is_null>&gt;</ref_value_is_null>

en: ^|&mdash; |<<ref_value_try_as_null>> ^|&mdash; ^|&mdash;
zh_Hans: ^|— |&lt;<ref_value_try_as_null>&gt; ^|— ^|—</ref_value_try_as_null>

en: The emplace members of <<ref_value>> return a typed reference to the underlying representation. For example, the call to <<ref_value_emplace_string,`value::emplace_string`>> in the previous example returns a <<ref_string,`string&`>>. This table shows the underlying type for each kind:
zh_Hans: &lt;<ref_value>&gt; 的置入成员函数返回对底层表示形式的类型化引用。例如，前例中对 &lt;<ref_value_emplace_string,`value::emplace_string`>&gt; 的调用返回一个 &lt;<ref_string,`string&`>&gt; 。下表列出了每种 kind 对应的底层类型：</ref_string,`string&`></ref_value_emplace_string,`value::emplace_string`></ref_value>

en: Kind
zh_Hans: 种类

en: Type
zh_Hans: 类型

en: Description
zh_Hans: 描述

[ctx: :175]
en: <<ref_kind,`kind::object`>>
zh_Hans: &lt;<ref_kind,`kind::object`>&gt;</ref_kind,`kind::object`>

[ctx: :175]
en: <<ref_object>>
zh_Hans: &lt;<ref_object>&gt;</ref_object>

en: An associative array of string keys mapping to <<ref_value>> elements with an
zh_Hans: 一个关联数组，其键为字符串，值为 &lt;<ref_value>&gt; 元素，接口</ref_value>

en: interface similar to {std_unordered_map}, that remembers insertion order.
zh_Hans: 类似于 {std_unordered_map}，并保留插入顺序

[ctx: :183]
en: <<ref_kind,`kind::array`>>
zh_Hans: &lt;<ref_kind,`kind::array`>&gt;</ref_kind,`kind::array`>

[ctx: :183]
en: <<ref_array>>
zh_Hans: &lt;<ref_array>&gt;</ref_array>

en: An ordered list of <<ref_value>> elements with an interface similar to
zh_Hans: 一个&lt;<ref_value>&gt;元素的有序列表，其接口类似于</ref_value>

en: {std_vector}.
zh_Hans: {std_vector}。

[ctx: :188]
en: <<ref_kind,`kind::string`>>
zh_Hans: &lt;<ref_kind,`kind::string`>&gt;</ref_kind,`kind::string`>

[ctx: :188]
en: <<ref_string>>
zh_Hans: &lt;<ref_string>&gt;</ref_string>

en: A https://en.wikipedia.org/wiki/UTF-8[__UTF-8__] encoded
zh_Hans: 一个采用https://en.wikipedia.org/wiki/UTF-8[__UTF-8__]编码的

en: https://en.wikipedia.org/wiki/Unicode[Unicode] https://en.wikipedia.org/wiki/String_(computer_science)[string] of characters with an interface similar to {std_string}.
zh_Hans: https://en.wikipedia.org/wiki/Unicode[Unicode]字符https://en.wikipedia.org/wiki/String_(computer_science)[字符串]，其接口类似于{std_string}。

[ctx: :195]
en: <<ref_kind,`kind::int64`>>
zh_Hans: &lt;<ref_kind,`kind::int64`>&gt;</ref_kind,`kind::int64`>

en: A 64 bit signed integer.
zh_Hans: 64位有符号整数。

[ctx: :195]
en: <<ref_kind,`kind::uint64`>>
zh_Hans: &lt;<ref_kind,`kind::uint64`>&gt;</ref_kind,`kind::uint64`>

en: A 64 bit unsigned integer.
zh_Hans: 64位无符号整数。

[ctx: :195]
en: <<ref_kind,`kind::double_`>>
zh_Hans: &lt;<ref_kind,`kind::double_`>&gt;</ref_kind,`kind::double_`>

en: A `double` holding a floating-point value.
zh_Hans: 一个`double`，用于保存浮点型值。

[ctx: :195]
en: <<ref_kind,`kind::bool_`>>
zh_Hans: &lt;<ref_kind,`kind::bool_`>&gt;</ref_kind,`kind::bool_`>

en: A `bool` holding `true` or `false`.
zh_Hans: 一个`bool`，用于保存`true`或`false`。

[ctx: :195]
en: <<ref_kind,`kind::null`>>
zh_Hans: &lt;<ref_kind,`kind::null`>&gt;</ref_kind,`kind::null`>

en: ^| &mdash; | A monostate value representing null. |===
zh_Hans: ^| — | 一个表示空值的monostate值。 |===

en: The return value from emplace can be used to perform assignment or to capture a reference to the underlying element for later inspection or modification:
zh_Hans: 置入操作的返回值可用于执行赋值，或捕获对底层元素的引用以供后续检查或修改：

en: If the <<ref_kind>> of a <<ref_value>> is known, functions such as <<ref_value_as_bool,`value::as_bool`>> or <<ref_value_as_string,`value::as_string`>> may be used to obtain a reference to the underlying representation without changing the existing value:
zh_Hans: 如果已知 &lt;<ref_value>&gt; 的 &lt;<ref_kind>&gt;，可使用诸如 &lt;<ref_value_as_bool,`value::as_bool`>&gt; 或 &lt;<ref_value_as_string,`value::as_string`>&gt; 等函数，在不改变现有值的情况下获取对底层表示的引用：</ref_value_as_string,`value::as_string`></ref_value_as_bool,`value::as_bool`></ref_kind></ref_value>

en: However, as shown above these functions throw an exception if the kind in the <<ref_value>> does not match the kind denoted by the function signature. This can be used as a concise form of validation: access values as if they were the right type, but handle the resulting exception indicating if the schema of the JSON is not valid.
zh_Hans: 然而，如上所示，如果 &lt;<ref_value>&gt; 中的实际类型与函数签名所指定的类型不匹配，这些函数会抛出异常。这一行为可作为一种简洁的验证形式：以预期类型直接访问值，若 JSON 结构无效，则通过捕获异常进行处理。</ref_value>

en: We can query a value for its underlying representation of a particular kind in a way that does not throw exceptions by requesting a pointer which may be null, instead of a reference. Here we use <<ref_value_if_string,`value::if_string`>> to conditionally perform an assignment without using exceptions:
zh_Hans: 我们可以通过请求一个可能为空的指针（而非引用）来查询值中特定种类的底层表示形式，而不会抛出异常。这里我们使用 &lt;<ref_value_if_string,`value::if_string`>&gt; 来条件执行赋值操作，而无需使用异常：</ref_value_if_string,`value::if_string`>

en: Functions returning {ref_result} allow you to use both approaches:
zh_Hans: 返回 {ref_result} 的函数允许您同时使用上述两种方式：

en: Formatted Output
zh_Hans: 格式化输出

en: When a <<ref_value>> is formatted to a {std_ostream}, the result is serialized JSON as if by calling <<ref_serialize>>.
zh_Hans: 当将 &lt;<ref_value>&gt; 输出到 {std_ostream} 时，其结果等同于调用 &lt;<ref_serialize>&gt; 所生成的序列化 JSON。</ref_serialize></ref_value>
