(Tcl) JSON Paths

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" }

	
}

Chilkat Tcl Extension Downloads Chilkat Tcl Extension Downloads

load ./chilkat.dll

set json [new_CkJsonObject]

CkJsonObject_put_EmitCompact $json 0

# Assume the file contains the data as shown above..
set success [CkJsonObject_LoadFile $json "qa_data/json/pathSample.json"]
if {$success != 1} then {
    puts [CkJsonObject_lastErrorText $json]
    delete_CkJsonObject $json
    exit
}

# First, let's get the value of "cc1"
# The path to this value is: nestedObject.aaa.bb1.cc1
puts [CkJsonObject_stringOf $json 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)
puts "This should be 18: [CkJsonObject_IntOf $json {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.)
CkJsonObject_put_I $json 1
CkJsonObject_put_J $json 2
CkJsonObject_put_K $json 1
puts "This should be 18: [CkJsonObject_IntOf $json {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:
set sz [CkJsonObject_SizeOfArray $json "nestedArray[1][2]"]
# The size should be 4.
puts "size of array = $sz (should equal 4)"

# Now iterate...

for {set i 0} {$i <= [expr $sz - 1]} {incr i} {
    CkJsonObject_put_I $json $i
    puts [CkJsonObject_IntOf $json {nestedArray[1][2][i]}]
}

# Let's use a triple-nested loop to iterate over the nestedArray:

# szI should equal 1.
set szI [CkJsonObject_SizeOfArray $json "nestedArray"]
for {set i 0} {$i <= [expr $szI - 1]} {incr i} {
    CkJsonObject_put_I $json $i

    set szJ [CkJsonObject_SizeOfArray $json "nestedArray[i]"]
    for {set j 0} {$j <= [expr $szJ - 1]} {incr j} {
        CkJsonObject_put_J $json $j

        set szK [CkJsonObject_SizeOfArray $json "nestedArray[i][j]"]
        for {set k 0} {$k <= [expr $szK - 1]} {incr k} {
            CkJsonObject_put_K $json $k

            puts [CkJsonObject_IntOf $json {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"
puts [CkJsonObject_stringOf $json {mixture.arrayA[2].fruit}]

# This line of code gets the color "yellow"
puts [CkJsonObject_stringOf $json {mixture.arrayA[1].colors[0]}]

# Getting an object at a path:
# This gets the 2nd object in "arrayA"
# obj2 is a CkJsonObject
set obj2 [CkJsonObject_ObjectOf $json "mixture.arrayA[1]"]
# This object's "animal" should be "plankton"
puts [CkJsonObject_stringOf $obj2 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]"
puts [CkJsonObject_stringOf $obj2 {colors[2]}]

delete_CkJsonObject $obj2

# Getting an array at a path:
# This gets the array containing the colors red, green, blue:
# arr1 is a CkJsonArray
set arr1 [CkJsonObject_ArrayOf $json "mixture.arrayA[0].colors"]
set szArr1 [CkJsonArray_get_Size $arr1]
for {set i 0} {$i <= [expr $szArr1 - 1]} {incr i} {
    puts "$i: [CkJsonArray_stringAt $arr1 $i]"
}
delete_CkJsonArray $arr1

# The Chilkat JSON path uses ".", "[", and "]" chars for separators.  When a name
# contains one of these chars, use double-quotes in the path:
puts [CkJsonObject_stringOf $json \"name.with.dots\".grain]

delete_CkJsonObject $json