Pascal (Lazarus/Delphi)

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

	
}

Pascal (Lazarus/Delphi)

program ChilkatDemo;

// Demonstrates using the Chilkat Pascal wrapper via the C bridge DLL.
// Builds as a console application under Lazarus (FPC) or Delphi.

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}
{$APPTYPE CONSOLE}

uses
  {$IFDEF UNIX}
  cthreads,
  {$ENDIF}
  SysUtils,
  CkDllLoader,
  Chilkat.JsonArray,
  Chilkat.JsonObject;

// ---------------------------------------------------------------------------

procedure RunDemo;
var
  success: Boolean;
  json: TJsonObject;
  sz: Integer;
  i: Integer;
  j: Integer;
  k: Integer;
  szI: Integer;
  szJ: Integer;
  szK: Integer;
  obj2: TJsonObject;
  arr1: TJsonArray;
  szArr1: Integer;

begin
  success := False;

  json := TJsonObject.Create;
  json.EmitCompact := False;

  //  Assume the file contains the data as shown above..
  success := json.LoadFile('qa_data/json/pathSample.json');
  if (success = False) then
    begin
      WriteLn(json.LastErrorText);
      Exit;
    end;

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

  //  Now iterate...

  for i := 0 to sz - 1 do
    begin
      json.I := i;
      WriteLn(json.IntOf('nestedArray[1][2][i]'));
    end;

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

  //  szI should equal 1.
  szI := json.SizeOfArray('nestedArray');
  for i := 0 to szI - 1 do
    begin
      json.I := i;

      szJ := json.SizeOfArray('nestedArray[i]');
      for j := 0 to szJ - 1 do
        begin
          json.J := j;

          szK := json.SizeOfArray('nestedArray[i][j]');
          for k := 0 to szK - 1 do
            begin
              json.K := k;

              WriteLn(json.IntOf('nestedArray[i][j][k]'));
            end;

        end;

    end;

  //  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"
  WriteLn(json.StringOf('mixture.arrayA[2].fruit'));

  //  This line of code gets the color "yellow"
  WriteLn(json.StringOf('mixture.arrayA[1].colors[0]'));

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

  obj2 := TJsonObject.Create;
  json.ObjectOf2('mixture.arrayA[1]',obj2);

  //  This object's "animal" should be "plankton"
  WriteLn(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]"
  WriteLn(obj2.StringOf('colors[2]'));

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

  arr1 := TJsonArray.Create;
  json.ArrayOf2('mixture.arrayA[0].colors',arr1);

  szArr1 := arr1.Size;
  for i := 0 to szArr1 - 1 do
    begin
      WriteLn(i + ': ' + arr1.StringAt(i));
    end;

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


  json.Free;
  obj2.Free;
  arr1.Free;

end;

// ---------------------------------------------------------------------------

begin

  try
    RunDemo;
  except
    on E: Exception do
      WriteLn('Unhandled exception: ', E.ClassName, ': ', E.Message);
  end;

  WriteLn;
  {$IFDEF MSWINDOWS}
  WriteLn('Press Enter to exit...');
  ReadLn;
  {$ENDIF}
end.