Zig

JSON Paths

See more JSON Examples

Demonstrates using "Chilkat JSON Paths" to access parts of a JSON document, or to iterate over parts.

This example uses the following JSON document:

{
    "nestedArray" : [
			[
				[1,2,3],
				[4,5,6],
				[7,8,9,10]
			],
			[
				[11,12,13],
				[14,15,16],
				[17,18,19,20]
			],
			[
				[21,22,23],
				[24,25,26],
				[27,28,29,30],
				[31,32,33,34,35,36]
			]
		],

	"nestedObject" : {
		"aaa" : {
			"bb1" : {
				"cc1" : "c1Value",
				"cc2" : "c2Value",
				"cc3" : "c3Value"
			},
			"bb2" : {
				"dd1" : "d1Value",
				"dd2" : "d2Value",
				"dd3" : "d3Value"
			}
		}
	},

	"mixture" : {
		"arrayA" : [  
			{ "fruit": "apple", "animal": "horse", "job": "fireman", "colors": ["red","blue","green"] },
			{ "fruit": "pear", "animal": "plankton", "job": "waiter", "colors": ["yellow","orange","purple"] },
			{ "fruit": "kiwi", "animal": "echidna", "job": "astronaut", "colors": ["magenta","tan","pink"] }
			]
	},


        "name.with.dots" : { "grain" : "oats" }

	
}

Zig

const std = @import("std");
const chilkat = @import("chilkat");

pub fn main(init: std.process.Init) !void {
    const alloc = init.arena.allocator();

    const json = try chilkat.JsonObject.init();
    defer json.deinit();
    json.setEmitCompact(false);

    // Assume the file contains the data as shown above..
    json.loadFile("qa_data/json/pathSample.json") catch {
        std.debug.print("{s}\n", .{try json.getLastErrorText(alloc)});
        return;
    };

    // First, let's get the value of "cc1"
    // The path to this value is: nestedObject.aaa.bb1.cc1
    std.debug.print("{s}\n", .{try json.stringOf(alloc, "nestedObject.aaa.bb1.cc1")});

    // Now let's get number 18 from the nestedArray.
    // It is located at nestedArray[1][2][1]
    // (remember: Indexing is 0-based)
    std.debug.print("This should be 18: {d}\n", .{json.intOf("nestedArray[1][2][1]")});

    // We can do the same thing in a more roundabout way using the
    // I, J, and K properties.  (The I,J,K properties will be convenient
    // for iterating over arrays, as we'll see later.)
    json.setI(1);
    json.setJ(2);
    json.setK(1);
    std.debug.print("This should be 18: {d}\n", .{json.intOf("nestedArray[i][j][k]")});

    // Let's iterate over the array containing the numbers 17, 18, 19, 20.
    // First, use the SizeOfArray method to get the array size:
    const sz = json.sizeOfArray("nestedArray[1][2]");
    // The size should be 4.
    std.debug.print("size of array = {d} (should equal 4)\n", .{sz});

    // Now iterate...
    var i: i32 = 0;
    i = 0;
    while (i < sz) : (i += 1) {
        json.setI(i);
        std.debug.print("{d}\n", .{json.intOf("nestedArray[1][2][i]")});
    }

    // Let's use a triple-nested loop to iterate over the nestedArray:
    var j: i32 = 0;
    var k: i32 = 0;

    // szI should equal 1.
    const sz_i = json.sizeOfArray("nestedArray");
    i = 0;
    while (i < sz_i) : (i += 1) {
        json.setI(i);

        const sz_j = json.sizeOfArray("nestedArray[i]");
        j = 0;
        while (j < sz_j) : (j += 1) {
            json.setJ(j);

            const sz_k = json.sizeOfArray("nestedArray[i][j]");
            k = 0;
            while (k < sz_k) : (k += 1) {
                json.setK(k);

                std.debug.print("{d}\n", .{json.intOf("nestedArray[i][j][k]")});
            }
        }
    }

    // Now let's examine how to navigate to JSON objects contained within JSON arrays.
    // This line of code gets the value "kiwi" contained within "mixture"
    std.debug.print("{s}\n", .{try json.stringOf(alloc, "mixture.arrayA[2].fruit")});

    // This line of code gets the color "yellow"
    std.debug.print("{s}\n", .{try json.stringOf(alloc, "mixture.arrayA[1].colors[0]")});

    // Getting an object at a path:
    // This gets the 2nd object in "arrayA"

    const obj2 = try chilkat.JsonObject.init();
    defer obj2.deinit();
    json.objectOf2("mixture.arrayA[1]", obj2) catch {};

    // This object's "animal" should be "plankton"
    std.debug.print("{s}\n", .{try obj2.stringOf(alloc, "animal")});

    // Note that paths are relative to the object, not the absolute root of the JSON document.
    // Starting from obj2, "purple" is at "colors[2]"
    std.debug.print("{s}\n", .{try obj2.stringOf(alloc, "colors[2]")});

    // Getting an array at a path:
    // This gets the array containing the colors red, green, blue:

    const arr1 = try chilkat.JsonArray.init();
    defer arr1.deinit();
    json.arrayOf2("mixture.arrayA[0].colors", arr1) catch {};

    const sz_arr1 = arr1.getSize();
    i = 0;
    while (i < sz_arr1) : (i += 1) {
        std.debug.print("{d}: {s}\n", .{ i, try arr1.stringAt(alloc, i) });
    }

    // The Chilkat JSON path uses ".", "[", and "]" chars for separators.  When a name
    // contains one of these chars, use double-quotes in the path:
    std.debug.print("{s}\n", .{try json.stringOf(alloc, "\"name.with.dots\".grain")});
}