跳转到内容
标准库Zig 0.17.0官方原文
源码std/json.zig

第 1 行

符合 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。

std.json.AllocWhen

别名

第 76 行

别名目标 std.json.Scanner.AllocWhen

std.json.Array

别名

第 64 行

别名目标 std.json.dynamic.Array

std.json.ArrayHashMap

别名

第 67 行

别名目标 std.json.hashmap.ArrayHashMap

std.json.builtin

常量

第 12 行

std.json.default_buffer_size

别名

第 72 行

别名目标 std.json.Scanner.default_buffer_size

std.json.default_max_value_len

别名

第 77 行

别名目标 std.json.Scanner.default_max_value_len

std.json.Diagnostics

别名

第 75 行

别名目标 std.json.Scanner.Diagnostics

std.json.Error

别名

第 71 行

别名目标 std.json.Scanner.Error

std.json.fmt

函数

第 97 行

返回使用 stringify 格式化给定值的格式化器。

pub fn fmt(value: anytype, options: Stringify.Options) Formatter(@TypeOf(value))

参数

options: Stringify.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 },
    }, .{})});
}

std.json.Formatter

类型函数

第 120 行

使用 stringify 格式化给定值。

pub fn Formatter(comptime T: type) type

参数

T: type

字段

value: T
options: Stringify.Options

std.json.Formatter.format

函数

第 125 行

pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void

参数

self: @This()
writer: *std.Io.Writer

错误

WriteFailed

详细诊断信息见 Writer 实现。

std.json.innerParse

别名

第 87 行

别名目标 std.json.static.innerParse

std.json.innerParseFromValue

别名

第 90 行

别名目标 std.json.static.innerParseFromValue

std.json.isNumberFormattedLikeAnInteger

别名

第 79 行

别名目标 std.json.Scanner.isNumberFormattedLikeAnInteger

std.json.ObjectMap

别名

第 63 行

别名目标 std.json.dynamic.ObjectMap

std.json.Parsed

别名

第 82 行

别名目标 std.json.static.Parsed

std.json.ParseError

别名

第 91 行

别名目标 std.json.static.ParseError

std.json.parseFromSlice

别名

第 83 行

别名目标 std.json.static.parseFromSlice

std.json.parseFromSliceLeaky

别名

第 84 行

别名目标 std.json.static.parseFromSliceLeaky

std.json.parseFromTokenSource

别名

第 85 行

别名目标 std.json.static.parseFromTokenSource

std.json.parseFromTokenSourceLeaky

别名

第 86 行

别名目标 std.json.static.parseFromTokenSourceLeaky

std.json.parseFromValue

别名

第 88 行

别名目标 std.json.static.parseFromValue

std.json.ParseFromValueError

别名

第 92 行

别名目标 std.json.static.ParseFromValueError

std.json.parseFromValueLeaky

别名

第 89 行

别名目标 std.json.static.parseFromValueLeaky

std.json.ParseOptions

别名

第 81 行

别名目标 std.json.static.ParseOptions

std.json.Reader

别名

第 78 行

别名目标 std.json.Scanner.Reader

std.json.Scanner

别名

第 69 行

别名目标 std.json.Scanner

std.json.std

别名

第 13 行

别名目标 std

std.json.Stringify

别名

第 94 行

别名目标 std.json.Stringify

std.json.testing

别名

第 14 行

别名目标 std.testing

std.json.Token

别名

第 73 行

别名目标 std.json.Scanner.Token

std.json.TokenType

别名

第 74 行

别名目标 std.json.Scanner.TokenType

std.json.validate

别名

第 70 行

别名目标 std.json.Scanner.validate

std.json.Value

别名

第 65 行

别名目标 std.json.dynamic.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");
}