Javascript¶

Introducción¶

JavaScript está disponible para su uso únicamente en secuencias de comandos creadas como componente del proyecto (no en secuencias de comandos utilizadas dentro de una transformación). Esta página proporciona información sobre la compatibilidad con JavaScript en Harmony, así como algunos ejemplos para ayudarle a comenzar. Consulte también las páginas relacionadas para crear un secuencia de comandos, usando el editor de secuencia de comandos y probando un secuencia de comandos.

Soporte de JavaScript en Harmony¶

El motor JavaScript de Harmony es compatible con ECMA-262 v5.1 estándar como se especifica en ECMA International. Esta versión de JavaScript tiene soporte nativo de JSON y la definición y uso de funciones dentro de secuencias de comandos. El JavaScript de Jitterbit se ajusta a la manipulación y el comportamiento estándar de objetos de JavaScript.

Se admiten tipos de datos simples, matrices y objetos JSON. Los mapas Jitterbit también son compatibles con JavaScript. JavaScript trata los mapas de Jitterbit como objetos JSON y los Secuencias de Comandos de Jitterbit tratan los objetos JSON como mapas de Jitterbit. Se accede a las propiedades JSON mediante claves de mapa.

Por ejemplo, dado este objeto JSON definido en JavaScript:

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

En un Jitterbit Script, se accedería al objeto mediante un mapa. Acceder al "car3" propiedad como esta:

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

Después de haber creado un nuevo JavaScript en Cloud Studio, puede ingresar el secuencia de comandos directamente en el editor de secuencia de comandos. En los JavaScript utilizados en Cloud Studio, los secuencias de comandos deben estar encerrados dentro de un <javascript> etiqueta de apertura y </javascript> etiqueta de cierre.

Iteraciones de Bucle¶

El número máximo de iteraciones de bucle permitidas en Harmony es 50.000. El número máximo de iteraciones de bucle en JavaScript es por secuencia de comandos, no por bucle.

Por ejemplo, un secuencia de comandos JavaScript que contiene tres bucles, donde cada bucle ejecuta 25 000 iteraciones, sería un total de 75 000 iteraciones ejecutándose dentro de un secuencia de comandos.

Para aumentar el número máximo de iteraciones permitidas en cualquier secuencia de comandos JavaScript, agregue manualmente JavaScriptMaxIterations=X dónde X es mayor que 50000.

Para obtener más información sobre cómo aumentar el número máximo de bucles permitidos, consulte [Settings] en Editar el archivo de configuración (jitterbit.conf).

Para ver un ejemplo de bucle, consulte JavaScript Loop más adelante en esta página en Ejemplos.

Paleta de Componentes¶

La paleta de componentes de secuencias de comandos proporciona acceso a varios componentes que se pueden utilizar dentro de un secuencia de comandos. Puede usar componentes dentro de una secuencia de comandos arrastrándolos o haciendo doble clic en ellos desde la paleta de componentes, usando la función de autocompletar o escribiendo o pegando manualmente la sintaxis correcta.

Puede acceder a la paleta de componentes de secuencias de comandos en el lado derecho del diseñador de proyectos y del editor de secuencia de comandos:

Algunas de las pestañas que se muestran en la paleta de componentes de secuencias de comandos muestran componentes que no se pueden usar en un secuencia de comandos escrito en JavaScript. Específicamente, no se admite hacer referencia a complementos, operaciones, notificaciones y otros secuencias de comandos en un secuencia de comandos escrito en JavaScript. Las pestañas que contienen funciones o componentes que se pueden utilizar en un secuencia de comandos escrito en JavaScript se describen a continuación.

Funciones¶

La pestaña Funciones proporciona una lista de funciones disponibles para usar en un secuencia de comandos:

Dentro de un secuencia de comandos, puede utilizar funciones insertando la sintaxis de la función.

Para agregar la sintaxis de la función a un secuencia de comandos (Jitterbit Script o JavaScript), utilice uno de estos métodos:

• Arrastre la función desde la paleta al secuencia de comandos para insertar la sintaxis de la función.
• Haga doble clic en la función en la paleta para insertar la sintaxis de la función en la ubicación del cursor dentro del secuencia de comandos. Al insertar la sintaxis de la función, el primer argumento de la función se resalta y el cursor se mueve al final del argumento.
• Comience a escribir el nombre de la función y luego presione Control+Space para mostrar una lista de sugerencias de autocompletar. Seleccione una función para insertar la sintaxis de la función.
• Introduzca manualmente la sintaxis de la función.

Las funciones disponibles para usar en JavaScript están disponibles en cuatro categorías: Jitterbit, Palabras clave, Funciones comunes y Matemáticas. Para obtener información detallada sobre cada función disponible en JavaScript en Harmony, consulte estas páginas:

• JavaScript Jitterbit y funciones comunes
• Propiedades y funciones estándar de JavaScript

Variables¶

La pestaña Variables proporciona acceso a variables que están disponibles para hacer referencia globalmente en todo un proyecto, incluidas variables globales, variables del proyecto, y variables de Jitterbit:

Dentro de un secuencia de comandos, puede usar variables insertando la sintaxis de la variable (consulte la documentación para cada tipo de variable en Variables).

Para agregar la sintaxis de la variable a un secuencia de comandos (Jitterbit Script o JavaScript), utilice uno de estos métodos:

• Arrastre la variable desde la paleta al secuencia de comandos para insertar la sintaxis de la variable.
• Haga doble clic en la variable en la paleta para insertar la sintaxis de la variable en la ubicación del cursor dentro del secuencia de comandos.
• Comience a escribir el nombre de la variable y luego presione Control+Space para mostrar una lista de sugerencias de autocompletar. Seleccione una variable para insertar la sintaxis de la variable.
• Introduzca manualmente la sintaxis de la variable.

Variables locales no aparecen en la lista porque no están disponibles globalmente; sin embargo, aún puedes usarlos localmente dentro de un secuencia de comandos.

Variables Globales¶

Se puede acceder y actualizar todas las variables globales de Jitterbit desde JavaScript. Cualquier variable global de JavaScript recién definida se convierte en variable global de Jitterbit.

La sintaxis utilizada para configurar y recuperar una variable global depende de si el nombre de la variable global contiene un punto.

Establecer una Variable Global¶

• Nombres sin puntos (recomendado): Una variable global que no contiene puntos en su nombre se puede crear inicialmente o actualizar usando el comando var $, o actualizado usando un signo de dólar $ sin var.

  • var $: Usando var y comenzando con un signo de dólar$, el ejemplo de código var $serverURL="https://www.example.com" crea o actualiza una variable global llamada serverURL con un valor de https://www.example.com. Las nuevas variables globales que se están inicializando deben preceder a la $ con var.
  • $: Con el prefijo de un signo de dólar $, el ejemplo de código $serverURL="https://www.example.com" actualiza la misma variable global llamada serverURL con la misma URL. Esto funciona sólo para variables globales que ya están inicializadas.

• Nombres con puntos (no recomendado): Una variable global que contiene puntos en su nombre se puede crear inicialmente o actualizar solo con el Jitterbit.SetVar función.

  • Jitterbit.SetVar: Usando Jitterbit.SetVar, el ejemplo de código Jitterbit.SetVar("$server.URL", "https://www.example.com") crea o actualiza una variable global llamada server.URL con un valor de https://www.example.com que se trata como una cadena. Tenga en cuenta que el signo del dólar $ debe incluirse dentro del nombre de la variable, o la variable no será global para el sistema Harmony.

Obtener una Variable Global¶

• Nombres sin puntos: El valor de una variable global que no contiene ningún punto en su nombre se puede recuperar anteponiendo un signo de dólar. $.

  • $: Con el prefijo de un signo de dólar $, el ejemplo de código $serverURL recupera el valor de la variable global serverURL.

• Nombres con puntos: El valor de una variable global que contiene puntos en su nombre se puede recuperar solo con el Jitterbit.GetVar función.

  • Jitterbit.GetVar: Usando Jitterbit.GetVar, el ejemplo de código Jitterbit.GetVar("$server.URL") devuelve el valor de cadena de la variable global llamada server.URL. Tenga en cuenta que el signo del dólar $ debe incluirse dentro del nombre de la variable para leer el valor global del sistema Harmony.

Variables del Proyecto¶

Las variables del proyecto se crean primero como un componente del proyecto dentro de Cloud Studio. Una vez creada una variable de proyecto, puede establecer valores para ella a través de Cloud Studio, el Management Console o Citizen Integrator. Obtenga más información sobre cómo crear y actualizar variables de proyecto en Variables de proyecto.

En Jitterbit JavaScript, la sintaxis utilizada para recuperar el valor de una variable del proyecto depende de si el nombre de la variable del proyecto contiene un punto.

• Nombres sin puntos: El valor de una variable de proyecto que no contiene ningún punto en su nombre se puede recuperar comenzando con un signo de dólar. $.

  • $: Con el prefijo de un signo de dólar $, el ejemplo de código $org_netsuite_auth_username recupera el valor de la variable del proyecto llamada org_netsuite_auth_username.

• Nombres con puntos: El valor de una variable de proyecto que contiene puntos en su nombre se puede recuperar solo con el Jitterbit.GetVar función.

  • Jitterbit.GetVar: Usando Jitterbit.GetVar, el ejemplo de código Jitterbit.GetVar("$server.URL") devuelve el valor de la variable del proyecto llamada server.URL. Tenga en cuenta que el signo del dólar $ debe incluirse dentro del nombre de la variable.

Variables de Jitterbit¶

El sistema Harmony define ciertas variables globales que siempre están disponibles a lo largo de un proyecto, conocidas como variables Jitterbit (o conocidas como variables globales predefinidas). Estos se pueden utilizar para obtener información global como el nombre del archivo fuente actual o el nombre de la operación actual. Obtenga más información en Variables de Jitterbit.

En Jitterbit JavaScript, las variables Jitterbit predefinidas por Harmony solo son accesibles con el Jitterbit.GetVar función. Esto se debe a que todas las variables de Jitterbit predefinidas por Jitterbit contienen puntos dentro del nombre de la variable.

• Jitterbit.GetVar: Usando Jitterbit.GetVar, el ejemplo de código Jitterbit.GetVar("$jitterbit.operation.error") recupera el valor de la variable Jitterbit jitterbit.operation.error. Tenga en cuenta que el signo del dólar $ debe incluirse dentro del nombre de la variable.

Extremos¶

La pestaña Extremos proporciona una lista de extremos en el proyecto que están disponibles para hacer referencia en un secuencia de comandos:

Dentro de un secuencia de comandos, puede hacer referencia a extremos como argumento para funciones insertando la ruta de referencia de conexión o actividad.

Para agregar una ruta de conexión o referencia de actividad a un secuencia de comandos (Jitterbit Script o JavaScript), utilice uno de estos métodos:

• Arrastre la conexión o actividad desde la paleta al secuencia de comandos para insertar la referencia adecuada.
• Haga doble clic en la conexión o actividad en la paleta para insertar la referencia adecuada en la ubicación del cursor dentro del secuencia de comandos.
• Comience a escribir el nombre de la conexión o actividad y luego presione Control+Space para mostrar una lista de sugerencias de autocompletar. Seleccione una conexión o actividad para insertar la referencia adecuada.
• Introducir manualmente la referencia de conexión o actividad.

Los tipos de extremos que se pueden usar dentro de los secuencias de comandos dependen de si hay funciones que admitan tomar el tipo específico de conexión o referencia de actividad como argumento. Las referencias de extremo deben usarse junto con esas funciones para que sean válidas en el secuencia de comandos.

Las conexiones y actividades que se pueden utilizar en el secuencia de comandos aparecen dentro de categorías que enumeran el número de cada elemento disponible en cada categoría. Los nombres de las actividades están precedidos por corchetes que contienen el tipo de interacción con el recurso de datos que es específico del tipo de actividad (por ejemplo, lectura, escritura, consulta, inserción, GET, POST, etc.). Para aparecer aquí, las conexiones y actividades ya deben estar configuradas dentro del proyecto. Por ejemplo, si hay una única conexión HTTP configurada en el proyecto, con dos actividades configuradas usando esa conexión, aparecen agrupadas de la siguiente manera:

Las referencias de conexión están contenidas en <TAG> y </TAG> etiquetas y se construyen a partir del tipo de componente del proyecto (connection), seguido de dos puntos (:), seguido del tipo de conexión, seguido del nombre de la conexión proporcionado por el usuario.

Las referencias de actividades son más largas, ya que en la ruta también se debe incluir la referencia de conexión desde la que están asociadas. Las referencias de actividades están contenidas en <TAG> y </TAG> etiquetas y se construyen a partir del tipo de componente del proyecto (activity), seguido de dos puntos (:), seguido del tipo de conexión, seguido del tipo de actividad, seguido del nombre de la actividad proporcionado por el usuario.

Dependiendo de la conexión específica o el tipo de actividad que se detalla a continuación, puede usar funciones de la pestaña Funciones que toman una referencia de conector como argumento. Las funciones que se describen a continuación están disponibles para usarse con las conexiones y actividades enumeradas.

Ejemplos¶

Estos ejemplos de JavaScript se proporcionan como referencia.

Funciones de Archivos JavaScript¶

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

Funciones Matemáticas de JavaScript¶

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

Bucle de JavaScript¶

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

Ejemplo 1 de JavaScript JSON¶

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

Ejemplo 2 de JavaScript JSON¶

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

Ejemplo 3 de JavaScript JSON¶

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