JavaScript in Jitterbit Design Studio

JavaScript ist ab Version 8.24.2 für Skripte verfügbar, die als Teil einer Operation erstellt werden (d. h. als Projektelement). Derzeit ist JavaScript nicht für die Verwendung in Transformationszuordnungen oder im Skript-Pad verfügbar. Unter Skript erstellen finden Sie Anweisungen zum Erstellen eines neuen JavaScript und zur Verwendung des Skript-Builders in Jitterbit.

JavaScript-Unterstützung in Jitterbit

Jitterbits JavaScript-Engine unterstützt den Standard ECMA-262 v5.1 wie von ECMA International spezifiziert. Diese JavaScript-Version bietet native Unterstützung für JSON und die Definition und Verwendung von Funktionen in Skripten. Jitterbits JavaScript entspricht der standardmäßigen JavaScript-Objektmanipulation und dem Verhalten.

Einfache Datentypen, Arrays und JSON-Objekte werden vollständig unterstützt. Jitterbit-Maps werden auch in JavaScript unterstützt. JavaScript behandelt Jitterbit-Maps als JSON-Objekte, und Jitterbit Scripts behandeln JSON-Objekte als Jitterbit-Maps. Auf JSON-Eigenschaften wird über Map-Schlüssel zugegriffen.

Beispiel: Gegeben ist dieses in JavaScript definierte JSON-Objekt:

var $myObj = {
 "name":"John",
 "age":30,
 "cars": {
   "car1":"Ford",
   "car2":"BMW",
   "car3":"Fiat"
   }
 };

In einem Jitterbit Script wird auf das Objekt über eine Map zugegriffen. Greifen Sie auf die Eigenschaft "car3" wie folgt zu:

$mycar = $myObj["cars"]["car3"];

Neues JavaScript erstellen

Innerhalb Ihres Projekts in Jitterbit Studio gibt es mehrere Möglichkeiten, ein neues JavaScript als Projektelement zu erstellen:

• Klicken Sie in der Baumstruktur auf der linken Seite mit der rechten Maustaste auf den Bereich Scripts und wählen Sie New JavaScript.

• Klicken Sie in einer vorhandenen Operation mit der rechten Maustaste auf einen beliebigen Einfügungspunkt und wählen Sie Insert > Script. Oder klicken Sie mit der rechten Maustaste auf eine Quelle oder ein Ziel und wählen Sie Insert Before This > Script oder Insert After This > Script. Ein Skript-Symbol wird im Operationsgraph angezeigt. Führen Sie dann einen der folgenden Schritte aus:

  • Klicken Sie mit der rechten Maustaste auf das Skript-Symbol und wählen Sie Create New JavaScript.

  • Doppelklicken Sie auf das Skript-Symbol und klicken Sie auf die Schaltfläche Create New JavaScript.

Skript-Builder verwenden

Nachdem Sie ein neues JavaScript in Jitterbit erstellt haben, können Sie Ihr JavaScript direkt im Skriptbereich eingeben.

Funktionen

Die verfügbaren Funktionen in einem JavaScript sind in vier Kategorien verfügbar.

Jitterbit

Diese Kategorie enthält eine Liste von Funktionen, die spezifisch für Jitterbit sind. Diese umfassen eine begrenzte Anzahl von Standard-Jitterbit-Funktionen sowie eine Reihe von JavaScript-Funktionen, die spezifisch für Jitterbit sind.

Derzeit ist eine begrenzte Anzahl der Jitterbit Script-Funktionen zur Verwendung in JavaScript verfügbar. Um eine dieser Jitterbit-Funktionen in Ihrem JavaScript zu verwenden, stellen Sie der Funktion "jitterbit." voran. Diese Jitterbit-Funktionen sind zur Verwendung in JavaScript in Jitterbit verfügbar:

• Jitterbit.ReadFile(string source_id[, string file_name])
  Liest eine Datei aus der angegebenen Quelle, wie in Formula Builder Dateifunktionen beschrieben. Der zurückgegebene Wert ist eine Zeichenkette. Beispiel: In JavaScript mit dieser Jitterbit-Funktion eine Datei lesen:

  var MyData = Jitterbit.ReadFile("<TAG>Sources/myfile</TAG>");
  

• Jitterbit.WriteFile(string target_id, type file_contents[, string file_name])
  Schreibt in eine Datei und leert diese automatisch. Es wird kein Wert zurückgegeben. Siehe WriteFile unter Formula Builder Dateifunktionen.

• Jitterbit.DbExecute(string database_id, string sql_str, ...)
  Führt eine SQL-Anweisung in einer Datenbank aus und gibt die Ergebnisse zurück. Der zurückgegebene Wert ist eine Zeichenkette. Siehe DBExecute unter Formula Builder Datenbankfunktionen.

• Jitterbit.DbLookup(string database_id, string sql_str)
  Führt eine SQL-Anweisung in einer Datenbank aus und gibt das erste Ergebnis zurück, das den angegebenen Kriterien entspricht. Der zurückgegebene Wert ist eine Zeichenkette. Siehe DBLookup unter Formula Builder Datenbankfunktionen.

• Jitterbit.GetVar(string name) und Jitterbit.SetVar(string name, string value)

  Warnung

  Die Funktionen Jitterbit.GetVar und Jitterbit.SetVar ermöglichen die Verwendung von Variablen, die Punkte im Variablennamen enthalten. Die Verwendung von Punkten in einem Variablennamen wird jedoch nicht empfohlen. Da der Wert beim Setzen der Variablen in eine Zeichenkette konvertiert wird, können diese Funktionen nicht mit komplexen Datentypen wie Arrays, Dictionaries oder JSON-Objekten verwendet werden. Es wird empfohlen, globale Variablen ohne Punkte zu erstellen und stattdessen Unterstriche anstelle von Punkten zu verwenden sowie die Standard-Dollar-Syntax $ wie unter Globale Variablen beschrieben zu nutzen.

  Die Funktion Jitterbit.GetVar ruft eine zuvor zugewiesene Jitterbit-Globalvariable ab (eine Variable mit dem Präfix "Jitterbit"). Der zurückgegebene Wert ist der entsprechende Datentyp.

  Die Funktion Jitterbit.SetVar weist einen Wert einer Jitterbit-Globalvariablen zu (eine Variable mit dem Präfix "Jitterbit"). Der zurückgegebene Wert ist eine Zeichenkette. Dieses Beispiel verwendet eine benutzerdefinierte API, die einen Vorgang mit JavaScript ausführt, der Jitterbit.GetVar und Jitterbit.SetVar verwendet:

  var response="Hello World";
  
  response += "\r\nOperation Name: " + Jitterbit.GetVar("$jitterbit.operation.name");
  response += "\r\ntest_var: " + Jitterbit.GetVar("$jitterbit.api.request.parameters.test_var");
  
  Jitterbit.SetVar("$jitterbit.api.response.headers.content_type","text/plain");
  Jitterbit.SetVar("$jitterbit.api.response.headers.test_header", "This is a header test");
  Jitterbit.SetVar("$jitterbit.api.response",response);
  

In dieser Kategorie sind mehrere Funktionen enthalten, die für die Verwendung mit JavaScript in Jitterbit angepasst wurden. Diese Funktionen haben nicht das Präfix "Jitterbit.".

• WriteToOperationLog
  Sendet Ausgaben an das aktuelle Jitterbit-Operationsprotokoll. Wurde für die Verwendung mit JavaScript in Jitterbit entwickelt und funktioniert ähnlich wie die Jitterbit-Funktion, die in Formula Builder Protokollierungs- und Fehlerfunktionen beschrieben ist.

• SetScriptOutput und SetScriptResult
  Legt die Ausgabe für das Skript fest. Diese beiden Funktionen sind Aliase und können je nach Vorliebe verwendet werden. Im Gegensatz zu Jitterbit-Skripten, die automatisch den Wert der letzten Zeile zurückgeben, geben Jitterbit-JavaScripts nicht automatisch einen Wert zurück. Mit einer dieser Funktionen kann das Skriptergebnis in JavaScript zurückgegeben werden. Beispiel:

  var MyVariable = "Hello World";
  WriteToOperationLog(MyVariable);
  SetScriptResult(MyVariable);
  

Schlüsselwörter

Diese Kategorie enthält eine Liste von JavaScript-Schlüsselwörtern im ECMAScript 5.1-Standard und wird hier zur Referenz aufgeführt.

Häufig verwendete Funktionen

Diese Kategorie enthält eine Liste von JavaScript-Funktionen im ECMAScript 5.1-Standard, die für Jitterbit-Benutzer relevant sein können. Diese Kategorie ist nicht umfassend – Sie können auch andere JavaScript-Funktionen verwenden, die hier nicht aufgeführt sind, wie z. B. JavaScript Array-, Date- und String-Objekte und ihre zugehörigen Funktionen.

Math

Diese Kategorie enthält Funktionseigenschaften, die für das JavaScript math-Objekt gemäß dem ECMAScript 5.1-Standard verfügbar sind. Diese Kategorie wird zur einfachen Referenzierung bereitgestellt. Die umfassende Dokumentation finden Sie im ECMAScript 5.1-Standard.

Projektelemente

In JavaScript können Sie auf Projektelemente wie Quellen und Ziele zugreifen, genau wie in einem Jitterbit Script. Obwohl Jitterbit Scripts Jitterbit JavaScripts aufrufen können, ist das Gegenteil derzeit nicht möglich. Jitterbit JavaScripts können keine anderen Scripts oder Operationen aufrufen.

Datenelemente

Dieser Tab bietet Zugriff auf Datenelemente, die global in Ihrem Projekt verfügbar sind, einschließlich Globale Variablen, Variablen und Jitterbit-Variablen.

Globale Variablen

Alle Jitterbit-Variablen können über Ihr JavaScript aufgerufen und aktualisiert werden. Alle neu definierten globalen JavaScript-Variablen werden zu globalen Jitterbit-Variablen.

Die Syntax zum Festlegen und Abrufen einer globalen Variablen hängt davon ab, ob der Name der globalen Variablen einen Punkt enthält.

Globale Variable festlegen

• Namen ohne Punkte (empfohlen): Eine globale Variable ohne Punkte im Namen kann mit dem Befehl var $ erstellt oder aktualisiert werden, oder mit einem Dollarzeichen $ ohne var aktualisiert werden.

  • var $: Mit var und einem Dollarzeichen $ am Anfang erstellt das Codebeispiel var $serverURL="https://www.example.com" eine globale Variable namens "serverURL" mit dem Wert "https://www.example.com" oder aktualisiert diese. Neue globale Variablen, die initialisiert werden, müssen dem $ mit var vorangestellt sein.
  • $: Mit einem Dollarzeichen $ vorangestellt aktualisiert das Codebeispiel $serverURL="https://www.example.com" dieselbe globale Variable namens "serverURL" mit derselben URL. Dies funktioniert nur für globale Variablen, die bereits initialisiert sind.

• Namen mit Punkten (nicht empfohlen): Eine globale Variable mit Punkten im Namen kann nur mit der Funktion Jitterbit.SetVar erstellt oder aktualisiert werden.

• Jitterbit.SetVar: Mit Jitterbit.SetVar erstellt oder aktualisiert das Codebeispiel Jitterbit.SetVar("$server.URL", "https://www.example.com") eine globale Variable namens "server.URL" mit dem Wert "https://www.example.com", die als String behandelt wird. Beachten Sie, dass das Dollarzeichen $ muss im Variablennamen enthalten sein, sonst wird die Variable nicht global für das Jitterbit-System.

Eine globale Variable abrufen

• Namen ohne Punkte: Der Wert einer globalen Variable ohne Punkte im Namen lässt sich durch Voranstellen eines Dollarzeichens $ abrufen.

  • $: Mit einem Dollarzeichen $ vorangestellt ruft das Codebeispiel $serverURL den Wert der globalen Variable "serverURL" ab.

• Namen mit Punkten: Der Wert einer globalen Variable mit Punkten im Namen lässt sich nur mit der Funktion Jitterbit.GetVar abrufen.

  • Jitterbit.GetVar: Mit Jitterbit.GetVar gibt das Codebeispiel Jitterbit.GetVar("$server.URL") den String-Wert der globalen Variable namens "server.URL" zurück. Beachten Sie, dass das Dollarzeichen $ muss im Variablennamen enthalten sein, um den globalen Wert aus dem Jitterbit-System zu lesen.

Projektvariablen

Projektvariablen werden zunächst als Projektelement in Design Studio erstellt. Nach der Erstellung einer Projektvariable können Sie Werte dafür über Design Studio, die Management Console oder Citizen Integrator festlegen. Weitere Informationen zum Erstellen und Aktualisieren von Projektvariablen finden Sie unter Projektvariablen.

In Jitterbit JavaScript hängt die Syntax zum Abrufen des Werts einer Projektvariable davon ab, ob der Name der Projektvariable einen Punkt enthält.

• Namen ohne Punkte: Der Wert einer Projektvariable ohne Punkte im Namen lässt sich durch ein vorangestelltes Dollarzeichen $ abrufen.

  • $: Mit einem Dollarzeichen $ vorangestellt ruft das Codebeispiel $org_netsuite_auth_username den Wert der Projektvariable namens "org_netsuite_auth_username" ab.

• Namen mit Punkten: Der Wert einer Projektvariable mit Punkten im Namen lässt sich nur mit der Funktion Jitterbit.GetVar abrufen.

  • Jitterbit.GetVar: Mit Jitterbit.GetVar gibt das Codebeispiel Jitterbit.GetVar("$server.URL") den Wert der Projektvariable namens "server.URL" zurück. Beachten Sie, dass das Dollarzeichen $ muss im Variablennamen enthalten sein.

Jitterbit-Variablen

Das Jitterbit-System definiert bestimmte globale Variablen, die in Ihrem Projekt immer verfügbar sind und als Jitterbit-Variablen bekannt sind (auch als vordefinierte globale Variablen bekannt). Diese können verwendet werden, um globale Informationen wie den Namen der aktuellen Quelldatei oder den Namen des aktuellen Vorgangs abzurufen. Diese sind einzeln im Abschnitt Jitterbit-Variablen dokumentiert.

In Jitterbit JavaScript sind von Jitterbit vordefinierte Jitterbit-Variablen nur mit der Funktion Jitterbit.GetVar zugänglich. Dies liegt daran, dass alle von Jitterbit vordefinierten Jitterbit-Variablen Punkte im Variablennamen enthalten.

• Jitterbit.GetVar: Mit Jitterbit.GetVar ruft das Codebeispiel Jitterbit.GetVar("$jitterbit.operation.error") den Wert der Jitterbit-Variable "jitterbit.operation.error" ab. Beachten Sie, dass das Dollarzeichen $ muss im Variablennamen enthalten sein.

Plugins

Die Verwendung von Plugins in JavaScript wird derzeit nicht unterstützt. Verwenden Sie stattdessen ein Jitterbit Script und rufen Sie sowohl das Plugin als auch Ihr JavaScript daraus auf.

Testen und Debuggen

In einem JavaScript können Sie Variablenwerte genauso anzeigen und validieren wie in einem Jitterbit Script. Die Option Breakpoints deaktivieren ist jedoch nicht anwendbar, da Debugging in JavaScript nicht verfügbar ist. Beim Testen werden die Ergebnisse des Scripts (wie durch die Funktionen SetScriptOutput oder SetScriptResult festgelegt) im Feld „Result" der Registerkarte „Test" von Design Studio angezeigt.

Engine-Debug-Protokolle

Setzen Sie $javascript.debug auf true in einem Jitterbit-Skript vor einem beliebigen JavaScript, um die Ausführungsdauern und Datengrößen zu protokollieren, die an die Verarbeitungs-Engines gesendet werden. Dieses Protokoll wird in $javascript.debugoutput gespeichert:

Javascript Debug Log
--------------------------------------------------------------------
/// Timer started: Total Execution
# variables to Javascript: 10
Approx. Size: 112
/// Timer started: JavaScript Run
@@@ 10 ms for: JavaScript Run

# variables to JB Engine: 12
Approx. Size: 115
@@@ 69 ms for: Total Execution

Total Script Elapsed Time: 50498ms

Beispiele

Die folgenden JavaScript-Beispiele werden als Referenz bereitgestellt.

JavaScript-Dateifunktionen

// This script will:
// * Generate some random numbers
// * Write them to a target file
// * Then read them back in
// * Write output to the Operation Log
//

// Get 200 random numbers between 1 and 10000
var mystring = getRandomNumbers(200,1,10000);

// Write the data to a file
Jitterbit.WriteFile("<TAG>Targets/tmpdata</TAG>", mystring);

// Read the data back in from the file
var filedata = Jitterbit.ReadFile("<TAG>Sources/tmpdata</TAG>");

// Output to the Operation Log
WriteToOperationLog("Read file, output: " + filedata);

// Displays the data in the result of the Studio test script tab
SetScriptResult(filedata);

/////////////////

function getRandomNumbers(howMany,min,max) {
  var output = "";

  for (var i=0; i<howMany; i++) {
    output = output + getRandomNumber(min,max) + " \n";
  }

  return output;
}

function getRandomNumber(min,max) {
  return Math.floor((Math.random() * max) + min);
}

/////////////////

JavaScript-Mathematikfunktionen

// Create 200 random numbers
var $output = getRandomNumbers(200);

WriteToOperationLog($output);
SetScriptResult($output);

/////////////////

function getRandomNumbers(howMany) {
  var output = "";

  for (var i=0; i<howMany; i++) {
    output = output + Math.floor((Math.random() * 10000) + 1) + " \n";
  }

  return output;
}

/////////////////

JavaScript-Schleife

// Create 100 random numbers

var $output = "";

for (var i=0; i<100; i++) {
  $output = $output + Math.floor((Math.random() * 10000) + 1) + " \n";
}

SetScriptResult($output);

Die maximale Anzahl von Schleifeniterationen in Harmony beträgt 50.000. Die maximale Anzahl von Schleifeniterationen in JavaScript gilt pro Skript, nicht pro Schleife.

Beispielsweise würde ein JavaScript-Skript mit drei Schleifen, bei dem jede Schleife 25.000 Iterationen ausführt, insgesamt 75.000 Iterationen innerhalb des einen Skripts ausführen.

Um die maximale Anzahl der in einem JavaScript-Skript zulässigen Iterationen zu erhöhen, fügen Sie manuell JavaScriptMaxIterations=X hinzu, wobei X größer als 50000 ist.

Weitere Informationen finden Sie unter Konfigurationsdatei bearbeiten (jitterbit.conf).

JavaScript-JSON-Beispiel 1

WriteToOperationLog("\n\n Parsing JSON...");

var jsonData = Jitterbit.ReadFile("<TAG>Sources/JSON_Data</TAG>");
var $jsonObj = JSON.parse(jsonData);

WriteToOperationLog("Value of 'status' is: " + $jsonObj.status);
WriteToOperationLog("Value of 'operation' is: " + $jsonObj.operation);
WriteToOperationLog("Value of 'serverUrl' is: " + $jsonObj.serverUrl);

var $firstOrg = $jsonObj.orgAttrs[0];

WriteToOperationLog("First Org ID is: " + $firstOrg.orgId);
WriteToOperationLog("First Org Name is: " + $firstOrg.orgName);

JavaScript-JSON-Beispiel 2

WriteToOperationLog("\n\n Parsing JSON...");

var jsonData = Jitterbit.ReadFile("<TAG>Sources/JSON_Data</TAG>");
var $jsonObj = JSON.parse(jsonData);

WriteToOperationLog("Status: " + $jsonObj.status);
WriteToOperationLog("Operation: " + $jsonObj.operation);

var orgs = "";
var needComma = false;

for (var i=0; i<$jsonObj.orgAttrs.length; i++) {
  if (needComma) orgs = orgs + ",";
  orgs = orgs + $jsonObj.orgAttrs[i].orgId;
  needComma = true;
}

WriteToOperationLog("Org IDs: " + orgs);

// You can modify existing JSON values
// Any changes will be reflected in the Jitterbit system as a map variable
// Here we'll insert a random number as an authentication token
var randomNumber = Math.floor((Math.random() * 10000) + 1);
$jsonObj.authenticationToken = randomNumber;

JavaScript-JSON-Beispiel 3

// This script uses JSON stringify
// to create a property value structure
// and then pushes it to an API

var $complexAPI = {
  "properties": [
    {
      "property": "email",
      "value": $email
    },
    {
      "property": "firstname",
      "value": $firstname
    },
    {
      "property": "lastname",
      "value": $lastname
    },
    {
      "property": "website",
      "value": $website
    },
    {
      "property": "phone",
      "value": $phone
    }
  ]
}

var $outputJSON = JSON.stringify($complexAPI);
Jitterbit.WriteFile("<TAG>Targets/Example HTTP Post</TAG>", $outputJSON);
WriteToOperationLog($outputJSON);
SetScriptResult($outputJSON);