Pascal (Lazarus/Delphi)

Call a JavaScript Function Passing an Array Argument

See more JavaScript Examples

Demonstrates how to call a JavaScript function with an argument that is an array. 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.Js,
  Chilkat.StringBuilder,
  Chilkat.JsonArray,
  Chilkat.JsonObject;

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

procedure RunDemo;
var
  success: Boolean;
  sbScript: TStringBuilder;
  js: TJs;
  result: TJsonObject;
  funcCall: TJsonObject;
  argsArray: TJsonArray;
  arg: TJsonArray;
  sbOut: TStringBuilder;

begin
  success := False;

  //  This is the JavaScript function we'll call:

  //  function calculateTotal(numbers) {
  //    console.log(numbers);
  //    let total = 0;
  //    
  //    // Loop through every number in the array
  //    for (const num of numbers) {
  //      console.log(num);
  //      total += num;
  //    }
  //    
  //    return total;
  //  }

  sbScript := TStringBuilder.Create;
  success := sbScript.LoadFile('js_function_array_arg.js','utf-8');
  if (success = False) then
    begin
      WriteLn(sbScript.LastErrorText);
      Exit;
    end;

  js := TJs.Create;

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

  //  Call Eval to add the function to the context's global object
  success := js.Eval(sbScript,result);
  if (success = False) then
    begin
      //  Examine the result for an exception.
      WriteLn(result.Emit());

      //  Also examine the LastErrorText.
      WriteLn(js.LastErrorText);
      Exit;
    end;

  //  ------------------------------------------------------------------------------
  //  Call the function calculateTotal(numbers)

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

  //  Create JSON specifying the function name and arguments
  //  In this case, there is only 1 argument, and it is an array.

  funcCall.UpdateString('name','calculateTotal');

  //  Create the arguments array.
  argsArray := TJsonArray.Create;

  //  The 1st argument in the arguments array is itself an array.
  //  Passing -1 indicates to append to the array.
  arg := TJsonArray.Create;
  argsArray.AddArrayAt2(-1,arg);

  //  Fill in the values for the 1st argument.
  arg.AddNumberAt(-1,'10.50');
  arg.AddNumberAt(-1,'20.00');
  arg.AddNumberAt(-1,'5.25');

  //  Add the "args" array to the funcCall.
  funcCall.AppendArrayCopy('args',argsArray);

  WriteLn(funcCall.Emit());

  //  The funcCall is as follows.  Notice that the 1st (and only) argument is an array.

  //  {
  //    "name": "calculateTotal",
  //    "args": [
  //      [
  //        10.50,
  //        20.00,
  //        5.25
  //      ]
  //    ]
  //  }

  success := js.CallFunction(funcCall,result);
  if (success = False) then
    begin
      //  Examine the result for an exception.
      WriteLn(result.Emit());

      //  Also examine the LastErrorText.
      WriteLn(js.LastErrorText);
      Exit;
    end;

  WriteLn(result.Emit());

  //  Result:
  //  {
  //    "type": "double",
  //    "value": 35.75
  //  }

  //  The function also emitted text to the console.

  sbOut := TStringBuilder.Create;
  js.ConsoleOutputSb(sbOut);
  WriteLn(sbOut.GetAsString());

  //  Output:
  //  10.5,20,5.25
  //  10.5
  //  20
  //  5.25

  //  -----------------------------------------------------------
  //  Note: If the array argument is simple, this is an alternative
  //  and simpler way of creating the funcCall:

  funcCall.Clear();
  funcCall.UpdateString('name','calculateTotal');
  funcCall.UpdateNumber('args[0][0]','10.50');
  funcCall.UpdateNumber('args[0][1]','20.00');
  funcCall.UpdateNumber('args[0][2]','5.25');
  WriteLn(funcCall.Emit());


  sbScript.Free;
  js.Free;
  result.Free;
  funcCall.Free;
  argsArray.Free;
  arg.Free;
  sbOut.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.