符合 RFC 8259 的 JSON 解析与字符串化。https://datatracker.ietf.org/doc/html/rfc8259
底层 Scanner 接口从单个输入切片或一系列连续输入切片生成 Token。
Reader 接口将 std.Io.Reader 连接到 Scanner。
高层 parseFromSlice 和 parseFromTokenSource 将 JSON 文档反序列化为 Zig 类型。
解析为动态类型的 Value,即可加载任意 JSON 值并在运行时检查。
底层 writeStream 向 std.Io.Writer 输出符合语法的 JSON 词法单元。
高层 stringify 将 Zig 类型或 Value 类型序列化为 JSON。
builtinstdtestingObjectMapArrayValueArrayHashMapScannervalidateErrordefault_buffer_sizeTokenTokenTypeDiagnosticsAllocWhendefault_max_value_lenReaderisNumberFormattedLikeAnIntegerParseOptionsParsedparseFromSliceparseFromSliceLeakyparseFromTokenSourceparseFromTokenSourceLeakyinnerParseparseFromValueparseFromValueLeakyinnerParseFromValueParseErrorParseFromValueErrorStringifyfmtFormatter
std.json.AllocWhen
别名
std.json.Array
别名
std.json.ArrayHashMap
别名
std.json.builtin
常量
std.json.default_buffer_size
别名
std.json.default_max_value_len
别名
std.json.Diagnostics
别名
std.json.Error
别名
std.json.fmt
函数
返回使用 stringify 格式化给定值的格式化器。
pub fn fmt(value: anytype, options: Stringify.Options) Formatter(@TypeOf(value))
参数
用法示例
test fmt {
const expectFmt = std.testing.expectFmt;
try expectFmt("123", "{f}", .{fmt(@as(u32, 123), .{})});
try expectFmt(
\\{"num":927,"msg":"hello","sub":{"mybool":true}}
, "{f}", .{fmt(struct {
num: u32,
msg: []const u8,
sub: struct {
mybool: bool,
},
}{
.num = 927,
.msg = "hello",
.sub = .{ .mybool = true },
}, .{})});
}
std.json.Formatter
类型函数
使用 stringify 格式化给定值。
pub fn Formatter(comptime T: type) type
参数
T: type
字段
std.json.Formatter.format
函数
pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void
参数
错误
- WriteFailed
详细诊断信息见
Writer实现。
std.json.innerParse
别名
std.json.innerParseFromValue
别名
std.json.isNumberFormattedLikeAnInteger
别名
std.json.ObjectMap
别名
std.json.Parsed
别名
std.json.ParseError
别名
std.json.parseFromSlice
别名
std.json.parseFromSliceLeaky
别名
std.json.parseFromTokenSource
别名
std.json.parseFromTokenSourceLeaky
别名
std.json.parseFromValue
别名
std.json.ParseFromValueError
别名
std.json.parseFromValueLeaky
别名
std.json.ParseOptions
别名
std.json.Reader
别名
std.json.Scanner
别名
别名目标 std.json.Scanner
std.json.std
别名
别名目标 std
std.json.Stringify
别名
别名目标 std.json.Stringify
std.json.testing
别名
别名目标 std.testing
std.json.Token
别名
std.json.TokenType
别名
std.json.validate
别名
std.json.Value
别名
源码
std/json.zig
//! 符合 RFC 8259 的 JSON 解析与字符串化。https://datatracker.ietf.org/doc/html/rfc8259
//!
//! 底层 `Scanner` 接口从单个输入切片或一系列连续输入切片生成 `Token`。
//! `Reader` 接口将 `std.Io.Reader` 连接到 `Scanner`。
//!
//! 高层 `parseFromSlice` 和 `parseFromTokenSource` 将 JSON 文档反序列化为 Zig 类型。
//! 解析为动态类型的 `Value`,即可加载任意 JSON 值并在运行时检查。
//!
//! 底层 `writeStream` 向 `std.Io.Writer` 输出符合语法的 JSON 词法单元。
//! 高层 `stringify` 将 Zig 类型或 `Value` 类型序列化为 JSON。
const builtin = @import("builtin");
const std = @import("std");
const testing = std.testing;
test Scanner {
var scanner = Scanner.initCompleteInput(testing.allocator, "{\"foo\": 123}\n");
defer scanner.deinit();
try testing.expectEqual(Token.object_begin, try scanner.next());
try testing.expectEqualSlices(u8, "foo", (try scanner.next()).string);
try testing.expectEqualSlices(u8, "123", (try scanner.next()).number);
try testing.expectEqual(Token.object_end, try scanner.next());
try testing.expectEqual(Token.end_of_document, try scanner.next());
}
test parseFromSlice {
var parsed_str = try parseFromSlice([]const u8, testing.allocator, "\"a\\u0020b\"", .{});
defer parsed_str.deinit();
try testing.expectEqualSlices(u8, "a b", parsed_str.value);
const T = struct { a: i32 = -1, b: [2]u8 };
var parsed_struct = try parseFromSlice(T, testing.allocator, "{\"b\":\"xy\"}", .{});
defer parsed_struct.deinit();
try testing.expectEqual(@as(i32, -1), parsed_struct.value.a); // 默认值
try testing.expectEqualSlices(u8, "xy", parsed_struct.value.b[0..]);
}
test Value {
var parsed = try parseFromSlice(Value, testing.allocator, "{\"anything\": \"goes\"}", .{});
defer parsed.deinit();
try testing.expectEqualSlices(u8, "goes", parsed.value.object.get("anything").?.string);
}
test Stringify {
var out: std.Io.Writer.Allocating = .init(testing.allocator);
var write_stream: Stringify = .{
.writer = &out.writer,
.options = .{ .whitespace = .indent_2 },
};
defer out.deinit();
try write_stream.beginObject();
try write_stream.objectField("foo");
try write_stream.write(123);
try write_stream.endObject();
const expected =
\\{
\\ "foo": 123
\\}
;
try testing.expectEqualSlices(u8, expected, out.written());
}
pub const ObjectMap = @import("json/dynamic.zig").ObjectMap;
pub const Array = @import("json/dynamic.zig").Array;
pub const Value = @import("json/dynamic.zig").Value;
pub const ArrayHashMap = @import("json/hashmap.zig").ArrayHashMap;
pub const Scanner = @import("json/Scanner.zig");
pub const validate = Scanner.validate;
pub const Error = Scanner.Error;
pub const default_buffer_size = Scanner.default_buffer_size;
pub const Token = Scanner.Token;
pub const TokenType = Scanner.TokenType;
pub const Diagnostics = Scanner.Diagnostics;
pub const AllocWhen = Scanner.AllocWhen;
pub const default_max_value_len = Scanner.default_max_value_len;
pub const Reader = Scanner.Reader;
pub const isNumberFormattedLikeAnInteger = Scanner.isNumberFormattedLikeAnInteger;
pub const ParseOptions = @import("json/static.zig").ParseOptions;
pub const Parsed = @import("json/static.zig").Parsed;
pub const parseFromSlice = @import("json/static.zig").parseFromSlice;
pub const parseFromSliceLeaky = @import("json/static.zig").parseFromSliceLeaky;
pub const parseFromTokenSource = @import("json/static.zig").parseFromTokenSource;
pub const parseFromTokenSourceLeaky = @import("json/static.zig").parseFromTokenSourceLeaky;
pub const innerParse = @import("json/static.zig").innerParse;
pub const parseFromValue = @import("json/static.zig").parseFromValue;
pub const parseFromValueLeaky = @import("json/static.zig").parseFromValueLeaky;
pub const innerParseFromValue = @import("json/static.zig").innerParseFromValue;
pub const ParseError = @import("json/static.zig").ParseError;
pub const ParseFromValueError = @import("json/static.zig").ParseFromValueError;
pub const Stringify = @import("json/Stringify.zig");
/// 返回使用 stringify 格式化给定值的格式化器。
pub fn fmt(value: anytype, options: Stringify.Options) Formatter(@TypeOf(value)) {
return Formatter(@TypeOf(value)){ .value = value, .options = options };
}
test fmt {
const expectFmt = std.testing.expectFmt;
try expectFmt("123", "{f}", .{fmt(@as(u32, 123), .{})});
try expectFmt(
\\{"num":927,"msg":"hello","sub":{"mybool":true}}
, "{f}", .{fmt(struct {
num: u32,
msg: []const u8,
sub: struct {
mybool: bool,
},
}{
.num = 927,
.msg = "hello",
.sub = .{ .mybool = true },
}, .{})});
}
/// 使用 stringify 格式化给定值。
pub fn Formatter(comptime T: type) type {
return struct {
value: T,
options: Stringify.Options,
pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void {
try Stringify.value(self.value, self.options, writer);
}
};
}
test {
_ = @import("json/test.zig");
_ = Scanner;
_ = @import("json/dynamic.zig");
_ = @import("json/hashmap.zig");
_ = @import("json/static.zig");
_ = Stringify;
_ = @import("json/JSONTestSuite_test.zig");
}