JavaScript im Studio

Einführung

JavaScript kann nur in Skripten verwendet werden, die als Projektkomponente erstellt wurden (nicht in Skripten, die innerhalb einer Transformation verwendet werden). Diese Seite bietet Informationen zur JavaScript-Unterstützung in Harmony sowie einige Beispiele, um Ihnen den Einstieg zu erleichtern. Siehe auch verwandte Seiten zum Erstellen eines Skripts, Verwenden des Skripteditors und Testen eines Skripts.

JavaScript-Unterstützung in Harmony

Die JavaScript-Engine von Harmony unterstützt den ECMA-262 v5.1 Standard, wie er von ECMA International festgelegt ist. Diese Version von JavaScript bietet native Unterstützung für JSON sowie die Definition und Verwendung von Funktionen innerhalb von Skripten. Jitterbit's JavaScript entspricht der Standard-JavaScript-Objektmanipulation und -verhalten.

Einfache Datentypen, Arrays und JSON-Objekte werden vollständig unterstützt. Jitterbit-Karten werden auch innerhalb von JavaScript unterstützt. JavaScript behandelt Jitterbit-Karten als JSON-Objekte, und Jitterbit-Skripte behandeln JSON-Objekte als Jitterbit-Karten. JSON-Eigenschaften werden mit Kartenschlüsseln zugegriffen.

Zum Beispiel, gegeben dieses JSON-Objekt, das in JavaScript definiert ist:

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

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

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

Nachdem Sie ein neues JavaScript im Studio erstellt haben, können Sie das Skript direkt im Skripteditor eingeben. In JavaScripts, die im Studio verwendet werden, müssen Skripte innerhalb eines <javascript>-Öffnungstags und eines </javascript>-Schlussstags eingeschlossen sein.

Schleifeniterationen

Die maximale Anzahl an Schleifeniterationen, die in Harmony erlaubt ist, beträgt 50.000. Die maximale Anzahl an Schleifeniterationen in JavaScript gilt pro Skript, nicht pro Schleife.

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

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

Für weitere Informationen zur Erhöhung der maximalen Anzahl an erlaubten Schleifen siehe [Settings] unter Bearbeiten der Konfigurationsdatei (jitterbit.conf).

Für ein Beispiel einer Schleife siehe JavaScript-Schleife weiter unten auf dieser Seite unter Beispiele.

Komponentenpalette

Die Skriptkomponentenpalette bietet Zugriff auf verschiedene Komponenten, die innerhalb eines Skripts verwendet werden können. Sie können Komponenten innerhalb eines Skripts verwenden, indem Sie sie aus der Komponentenpalette ziehen oder doppelklicken, die Autovervollständigungsfunktion nutzen oder die korrekte Syntax manuell eingeben oder einfügen.

Sie können die Skriptkomponentenpalette auf der rechten Seite des Projektdesigners und des Skripteditors aufrufen:

Einige der in der Skriptkomponentenpalette angezeigten Registerkarten zeigen Komponenten, die in einem in JavaScript geschriebenen Skript nicht verwendet werden können. Insbesondere wird das Referenzieren von Plugins, Operationen, Benachrichtigungen und anderen Skripten in einem in JavaScript geschriebenen Skript nicht unterstützt. Die Registerkarten, die Funktionen oder Komponenten enthalten, die in einem in JavaScript geschriebenen Skript verwendbar sind, werden im Folgenden beschrieben.

Funktionen

Die Funktionen-Registerkarte bietet eine Liste von Funktionen, die in einem Skript verwendet werden können.

Innerhalb eines Skripts können Funktionen durch Einfügen der Funktionssyntax verwendet werden.

Um die Funktionssyntax in ein Skript (Jitterbit-Skript oder JavaScript) einzufügen, verwenden Sie eine dieser Methoden:

• Ziehen Sie die Funktion aus der Palette in das Skript, um die Funktionssyntax einzufügen.
• Doppelklicken Sie auf die Funktion in der Palette, um die Funktionssyntax an der Position des Cursors im Skript einzufügen. Beim Einfügen der Funktionssyntax wird das erste Funktionsargument hervorgehoben und der Cursor wird ans Ende des Arguments verschoben.
• Beginnen Sie, den Funktionsnamen einzugeben, und drücken Sie dann Control+Space, um eine Liste von Autovervollständigungsvorschlägen anzuzeigen. Wählen Sie eine Funktion aus, um die Funktionssyntax einzufügen.
• Geben Sie die Funktionssyntax manuell ein.

Die in einem JavaScript verfügbaren Funktionen sind in vier Kategorien unterteilt: Jitterbit, Keywords, Allgemeine Funktionen und Mathematik. Für detaillierte Informationen zu jeder in JavaScript in Harmony verfügbaren Funktion verweisen Sie auf diese Seiten:

• JavaScript Jitterbit und allgemeine Funktionen
• JavaScript Standard-Eigenschaften und -Funktionen

Variablen

Die Variablen-Registerkarte bietet Zugriff auf Variablen, die global in einem Projekt referenziert werden können, einschließlich globaler Variablen, Projektvariablen und Jitterbit-Variablen.

Innerhalb eines Skripts können Variablen durch Einfügen der Variablen-Syntax verwendet werden (siehe die Dokumentation für jeden Variablentyp unter Variablen).

Um die Variablen-Syntax in ein Skript (Jitterbit Script oder JavaScript) einzufügen, verwenden Sie eine dieser Methoden:

• Ziehen Sie die Variable aus der Palette in das Skript, um die Variablen-Syntax einzufügen.
• Doppelklicken Sie auf die Variable in der Palette, um die Variablen-Syntax an der Position des Cursors im Skript einzufügen.
• Beginnen Sie, den Variablennamen einzugeben, und drücken Sie dann Control+Space, um eine Liste von Autocomplete-Vorschlägen anzuzeigen. Wählen Sie eine Variable aus, um die Variablen-Syntax einzufügen.
• Geben Sie die Variablen-Syntax manuell ein.

Lokale Variablen werden nicht aufgelistet, da sie nicht global verfügbar sind; Sie können sie jedoch weiterhin lokal innerhalb eines Skripts verwenden.

Globale Variablen

Alle Jitterbit globalen Variablen können aus einem JavaScript zugegriffen und aktualisiert werden. Alle neu definierten JavaScript globalen Variablen werden zu Jitterbit globalen Variablen.

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

Setzen einer globalen Variablen

• Namen ohne Punkte (empfohlen): Eine globale Variable, die keine Punkte in ihrem Namen enthält, kann zunächst erstellt oder mit dem Befehl var $ aktualisiert werden, oder sie kann mit einem Dollarzeichen $ ohne var aktualisiert werden.

  • var $: Mit var und beginnend mit einem Dollarzeichen $ erstellt oder aktualisiert das Codebeispiel var $serverURL="https://www.example.com" eine globale Variable namens serverURL mit dem Wert https://www.example.com. Neue globale Variablen, die initialisiert werden, müssen dem $ mit var vorangestellt werden.
  • $: 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 bereits initialisierte globale Variablen.

• Namen mit Punkten (nicht empfohlen): Eine globale Variable, die Punkte in ihrem Namen enthält, kann zunächst erstellt oder nur mit der Funktion Jitterbit.SetVar 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 Zeichenfolge behandelt wird. Beachten Sie, dass das Dollarzeichen $ muss innerhalb des Variablennamens enthalten sein, da die Variable sonst nicht global im Harmony-System ist.

Abrufen einer globalen Variablen

• Namen ohne Punkte: Der Wert einer globalen Variable, die keine Punkte in ihrem Namen enthält, kann abgerufen werden, indem man mit einem Dollarzeichen $ voranstellt.

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

• Namen mit Punkten: Der Wert einer globalen Variable, die Punkte in ihrem Namen enthält, kann nur mit der Funktion Jitterbit.GetVar abgerufen werden.

  • Jitterbit.GetVar: Mit Jitterbit.GetVar gibt das Codebeispiel Jitterbit.GetVar("$server.URL") den Stringwert der globalen Variablen server.URL zurück. Beachten Sie, dass das Dollarzeichen $ muss innerhalb des Variablennamens enthalten sein, um den globalen Wert aus dem Harmony-System zu lesen.

Projektvariablen

Projektvariablen werden zunächst als Projektkomponente innerhalb von Studio erstellt. Sobald eine Projektvariable erstellt wurde, können Sie Werte über Studio, die Management-Konsole oder Citizen Integrator festlegen. Erfahren Sie mehr über das Erstellen und Aktualisieren von Projektvariablen unter Projektvariablen.

In Jitterbit JavaScript hängt die Syntax, die zum Abrufen des Wertes einer Projektvariablen verwendet wird, davon ab, ob der Name der Projektvariablen einen Punkt enthält.

• Namen ohne Punkte: Der Wert einer Projektvariablen, die keinen Punkt in ihrem Namen enthält, kann abgerufen werden, indem mit einem Dollarzeichen $ begonnen wird.

  • $: Mit einem Dollarzeichen $ vorangestellt, ruft das Codebeispiel $org_netsuite_auth_username den Wert der Projektvariablen org_netsuite_auth_username ab.

• Namen mit Punkten: Der Wert einer Projektvariablen, die Punkte in ihrem Namen enthält, kann nur mit der Funktion Jitterbit.GetVar abgerufen werden.

  • Jitterbit.GetVar: Mit Jitterbit.GetVar gibt das Codebeispiel Jitterbit.GetVar("$server.URL") den Wert der Projektvariablen server.URL zurück. Beachten Sie, dass das Dollarzeichen $ muss innerhalb des Variablennamens enthalten sein.

Jitterbit-Variablen

Das Harmony-System definiert bestimmte globale Variablen, die in einem Projekt immer verfügbar sind, bekannt als Jitterbit-Variablen (oder als vordefinierte globale Variablen bekannt). Diese können verwendet werden, um globale Informationen wie den Namen der aktuellen Quelldatei oder den Namen der aktuellen Operation abzurufen. Erfahren Sie mehr unter Jitterbit-Variablen.

In Jitterbit JavaScript sind die von Harmony vordefinierten 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 $ unbedingt im Variablennamen enthalten sein muss.

Endpunkte

Der Endpunkte-Tab bietet eine Liste von Endpunkten im Projekt, die in einem Skript referenziert werden können.

Innerhalb eines Skripts können Sie Endpunkte als Argument für Funktionen referenzieren, indem Sie den Verbindungs- oder Aktivitätsreferenzpfad einfügen.

Um einen Verbindungs- oder Aktivitätsreferenzpfad in ein Skript (Jitterbit-Skript oder JavaScript) einzufügen, verwenden Sie eine dieser Methoden:

• Ziehen Sie die Verbindung oder Aktivität aus der Palette in das Skript, um die entsprechende Referenz einzufügen.
• Doppelklicken Sie auf die Verbindung oder Aktivität in der Palette, um die entsprechende Referenz an der Position des Cursors im Skript einzufügen.
• Beginnen Sie, den Namen der Verbindung oder Aktivität einzugeben, und drücken Sie dann Control+Space, um eine Liste von Autovervollständigungsvorschlägen anzuzeigen. Wählen Sie eine Verbindung oder Aktivität aus, um die entsprechende Referenz einzufügen.
• Geben Sie die Verbindungs- oder Aktivitätsreferenz manuell ein.

Die Arten von Endpunkten, die innerhalb von Skripten verwendet werden können, hängen davon ab, ob es Funktionen gibt, die das spezifische Typ der Verbindungs- oder Aktivitätsreferenz als Argument unterstützen. Die Endpunktreferenzen müssen in Verbindung mit diesen Funktionen verwendet werden, um im Skript gültig zu sein.

Verbindungen und Aktivitäten, die im Skript verwendet werden können, erscheinen innerhalb von Kategorien, die die Anzahl jedes verfügbaren Elements unter jeder Kategorie auflisten. Aktivitätsnamen werden von eckigen Klammern begleitet, die den Typ der Interaktion mit der Datenressource enthalten, der spezifisch für den Aktivitätstyp ist (zum Beispiel: Lesen, Schreiben, Abfragen, Upsert, GET, POST usw.). Um hier angezeigt zu werden, müssen Verbindungen und Aktivitäten bereits im Projekt konfiguriert sein. Wenn es beispielsweise eine einzige konfigurierte HTTP-Verbindung im Projekt gibt, mit zwei Aktivitäten, die diese Verbindung verwenden, erscheinen sie gruppiert wie folgt:

Verbindungsreferenzen sind in den <TAG> und </TAG> Tags enthalten und bestehen aus dem Typ der Projektkomponente (connection), gefolgt von einem Doppelpunkt (:), gefolgt vom Typ der Verbindung, gefolgt vom vom Benutzer bereitgestellten Verbindungsnamen.

Aktivitätsreferenzen sind länger, da die Verbindungsreferenz, mit der sie verbunden sind, ebenfalls im Pfad enthalten sein muss. Aktivitätsreferenzen sind in den <TAG> und </TAG> Tags enthalten und bestehen aus dem Typ der Projektkomponente (activity), gefolgt von einem Doppelpunkt (:), gefolgt vom Typ der Verbindung, gefolgt vom Typ der Aktivität, gefolgt vom vom Benutzer bereitgestellten Aktivitätsnamen.

Je nach spezifischem Verbindungs- oder Aktivitätstyp, wie unten aufgeführt, können Funktionen aus dem Functions Tab verwendet werden, die eine Connector-Referenz als Argument annehmen. Die unten beschriebenen Funktionen können mit den aufgeführten Verbindungen und Aktivitäten verwendet werden.

Engine-Debug-Protokolle

Setzen Sie $javascript.debug auf true in einem Jitterbit-Skript vor jeglichem JavaScript, um die Ausführungszeiten und Größen der an die Verarbeitungseinheiten gesendeten Daten zu protokollieren. 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

Diese JavaScript-Beispiele werden zur Referenz bereitgestellt.

JavaScript-Dateifunktionen

<javascript>
// This script:
// * Generates some random numbers
// * Writes them to a target file
// * Then reads them back in
// * Writes 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>activity:tempstorage/Temporary Storage Endpoint/tempstorage_write/tmpdata</TAG>", mystring);

// Read the data back in from the file
var filedata = Jitterbit.ReadFile("<TAG>activity:tempstorage/Temporary Storage Endpoint/tempstorage_read/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>

JavaScript-Mathematikfunktionen

<javascript>
// 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>

JavaScript-Schleife

<javascript>
// Create 100 random numbers

var $output = "";

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

SetScriptResult($output);
</javascript>

JavaScript-JSON-Beispiel 1

<javascript>
WriteToOperationLog("\n\n Parsing JSON...");

var jsonData = Jitterbit.ReadFile("<TAG>activity:tempstorage/Temporary Storage Endpoint/tempstorage_read/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>

JavaScript-JSON-Beispiel 2

<javascript>
WriteToOperationLog("\n\n Parsing JSON...");

var jsonData = Jitterbit.ReadFile("<TAG>activity:tempstorage/Temporary Storage Endpoint/tempstorage_read/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 are 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>

JavaScript-JSON-Beispiel 3

<javascript>
// 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>activity:http/HTTP Endpoint/http_post/Example HTTP POST</TAG>", $outputJSON);
WriteToOperationLog($outputJSON);
SetScriptResult($outputJSON);

</javascript>