(PowerBuilder) 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 ActiveX Downloads ActiveX for 32-bit and 64-bit Windows

integer li_rc
oleobject loo_Json
integer li_Success
integer li_Sz
integer i
integer j
integer k
integer li_SzI
integer li_SzJ
integer li_SzK
oleobject loo_Obj2
oleobject loo_Arr1
integer li_SzArr1

loo_Json = create oleobject
// Use "Chilkat_9_5_0.JsonObject" for versions of Chilkat < 10.0.0
li_rc = loo_Json.ConnectToNewObject("Chilkat.JsonObject")
if li_rc < 0 then
    destroy loo_Json
    MessageBox("Error","Connecting to COM object failed")
    return
end if
loo_Json.EmitCompact = 0

// Assume the file contains the data as shown above..
li_Success = loo_Json.LoadFile("qa_data/json/pathSample.json")
if li_Success <> 1 then
    Write-Debug loo_Json.LastErrorText
    destroy loo_Json
    return
end if

// First, let's get the value of "cc1"
// The path to this value is: nestedObject.aaa.bb1.cc1
Write-Debug loo_Json.StringOf("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)
Write-Debug "This should be 18: " + string(loo_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.)
loo_Json.I = 1
loo_Json.J = 2
loo_Json.K = 1
Write-Debug "This should be 18: " + string(loo_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:
li_Sz = loo_Json.SizeOfArray("nestedArray[1][2]")
// The size should be 4.
Write-Debug "size of array = " + string(li_Sz) + " (should equal 4)"

// Now iterate...

for i = 0 to li_Sz - 1
    loo_Json.I = i
    Write-Debug string(loo_Json.IntOf("nestedArray[1][2][i]"))
next

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

// szI should equal 1.
li_SzI = loo_Json.SizeOfArray("nestedArray")
for i = 0 to li_SzI - 1
    loo_Json.I = i

    li_SzJ = loo_Json.SizeOfArray("nestedArray[i]")
    for j = 0 to li_SzJ - 1
        loo_Json.J = j

        li_SzK = loo_Json.SizeOfArray("nestedArray[i][j]")
        for k = 0 to li_SzK - 1
            loo_Json.K = k

            Write-Debug string(loo_Json.IntOf("nestedArray[i][j][k]"))
        next
    next
next

// 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"
Write-Debug loo_Json.StringOf("mixture.arrayA[2].fruit")

// This line of code gets the color "yellow"
Write-Debug loo_Json.StringOf("mixture.arrayA[1].colors[0]")

// Getting an object at a path:
// This gets the 2nd object in "arrayA"
loo_Obj2 = loo_Json.ObjectOf("mixture.arrayA[1]")
// This object's "animal" should be "plankton"
Write-Debug loo_Obj2.StringOf("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]"
Write-Debug loo_Obj2.StringOf("colors[2]")

destroy loo_Obj2

// Getting an array at a path:
// This gets the array containing the colors red, green, blue:
loo_Arr1 = loo_Json.ArrayOf("mixture.arrayA[0].colors")
li_SzArr1 = loo_Arr1.Size
for i = 0 to li_SzArr1 - 1
    Write-Debug string(i) + ": " + loo_Arr1.StringAt(i)
next
destroy loo_Arr1

// The Chilkat JSON path uses ".", "[", and "]" chars for separators.  When a name
// contains one of these chars, use double-quotes in the path:
Write-Debug loo_Json.StringOf("~"name.with.dots~".grain")


destroy loo_Json