• Fácil de utilizar: ninguna programación o scripting requerido, interfaz gráfico
• Las características del scripting están disponibles para los usuarios experimentados y los programadores
• De gran alcance, versátil, confiable y comprable
• Ejecute los millares de tasks al día
• Soporte técnico oportuno y free antes y después que usted compra
• Libre del ensayo de 30 días y de las mejoras free del menor de edad
• Funcionamientos en las windowes, el Mac OSX, Linux, y otras plataformas de Unix

------------------------------------------------------------------------------------------------------------

Scripting (Automize professional y ediciones de la empresa de Automize)

• Cree los scripts complejos de la automatización que construyen sobre los tasks existentes de Automize
• Desarrolle los scripts que reducen actividades computer-related relanzadas, laboriosas.
• Agregue las funciones avanzadas a sus tasks de Automize como el email, el FTP, monitores, fichero y listas del directorio.
• Utilice la característica del script para conseguir las listas o los nombres de fichero del fichero que usted puede utilizar en copia, el FTP, tasks del zip etc….
• Usted puede leer y fijar el valor de los parámetros del task del script. Entonces ejecute el task del script. Esto reduce la complejidad del script.
• Apenas 20-50 líneas de código pueden resultar son tasks y soluciones modificados para requisitos particulares extremadamente de gran alcance.
• Proporcionamos a la ayuda free para las 20-50 líneas pequeñas script que pueden ser usables a los utilizadores.
• El código profundizado de la guía y de la muestra para conseguirle comenzó.
• Nuestro forum en línea tiene muchos ejemplos reales del código basados en applicationes del utilizador real.

Script del ejemplo:
1) El script lee la lista del fichero del sistema de ficheros
2) El script fija parámetros del task basados en nombre del archivo y carpeta
3) El script ejecuta task. El task se ejecuta después de conjunto de parámetros del task de la lectura vía el script.
4) El script lee código de la salida del task y variables del task
5) El script puede continuar el ejecutar de task en la misma secuencia 2-4 para todos los nombres de fichero

-----------------------------------------------------------------------------------------------------------------------------------------------
Guía del scripting de Automize Java

Automize utiliza BeanShell (beanshell.org) para su scripting.  BeanShell utiliza el sintaxis 100% de Java, y Automize sí mismo se escribe en Java.  Esto es una gran manera de aprender el sintaxis de Java y de conseguir comenzada en el lenguaje de programación moderno más fácil y más de gran alcance.

Para seguir a través en esta guía, copia y pegar estos ejemplos en la window del script de Automize. Entonces ejecute estos ejemplos:

Sección 1 - Fundamentos
Sección 2 - Órdenes de control
Sección 3 - Cadenas, números y Booleans
Sección 4 - Matrices y fechas
Sección 5 - Fichero y directorio
Sección 6 - Métodos

Sección 1 - Fundamentos

Ejemplo: Script introductorio

//Líneas líneas de comentario comenzando con//are

//La mayoría de los lenguajes de programación (c, Java, c++, etc… requieren () un método principal)
//Sin embargo, usted no necesita definir () un método principal mientras que scripting

//defina una cadena
¡Encadene recepción de la prueba = “al scripting de Java!!”;

//escriba al stdout del sistema
System.out.println (prueba);

Ejemplo: Usar la clase del script

//La clase del script proporciona a una conexión entre sus scripts y funciones incorporadas del Hitek Software

//las declaraciones de la importación permiten que usted utilice el Hitek Software o las funciones existente de Java
//En este ejemplo, importamos la clase del script del Hitek Software

importación com.hitek.engine.mods.script.Script;

//defina una cadena

¡Encadene recepción de la prueba = “al scripting de Java!!”;

//Visita el método de Script.out para escribir salida al fichero de diario de la salida

Script.out (prueba);

//después de que usted se ejecute/prueba este script, controla el fichero de diario de la salida (el menú de los registros en interfaz utilizador de Automize)

Ejemplo: Números enteros y cadenas

importación com.hitek.engine.mods.script.Script;

//números enteros - usted utilizará interno o deseará con frecuencia en sus scripts
largestInteger interno = Integer.MAX_VALUE;
largestLong largo = Long.MAX_VALUE;

//boleano - usted también necesitará utilizar boleano 
javaRocks boleanos = verdades;

//Cadena - usted utilizará cadenas mucho
La cadena testString cadenas de = “Java es muy útil”;

Script.out (“valor máximo = del número entero” + largestInteger);
Script.out (“valor largo máximo =” + largestLong);
Script.out (“valor de los javaRocks =” + javaRocks);
Script.out (el testString);

//inspección el registro de la salida después de usted ejecuta este script.

Ejemplo: Este ejemplo muestra a expresiones cuál trabajo con números enteros.  Controle el registro de la salida después de que usted ejecute este script.

importe com.hitek.engine.mods.script.Script;

m interno = 10;
k interna = 5;

Script.out (“valores variables…”);
Script.out (“m =” + m);
Script.out (“k =” + k);

//que usa al operador ++ del incremento
m++;
Script.out (“incrementado usando m++, nuevo valor de m =” + m);

//que usa > (mayor que) < (menos que)
si (m > k)
{
Script.out (“sí,” +m + “es más grande que” + k);
}

//que usa el >= (mayor que o igual) y el <= (menos que o igual) 
si (>= k +5 de m)
{
Script.out (“sí, m es mayor o igual k + 5”);
}

//que usa el == del operador de igualdad
si (k==5)
{
Script.out (“sí, k es igual a 5”);
}

¡//que usa no al operador de los iguales!=
¡si (k!= 5)
{
Script.out (“sí, k no es igual a 5”);
}

//el usar y y (lógico Y)
si ((== 5 de k) y y (m==10))
{
Script.out (“sí, k es igual a 5, y m es igual a 10”);
}

//el usar || (lógico O)
si ((== 5 de k) || (m==234545))
{
Script.out (“sí, o k es igual a 5, o m es igual a 10”);
}

//inspección el registro de la salida después de usted ejecuta este script.

Ejemplo: Este ejemplo muestra a operadores de manipulación del número entero básico

importación com.hitek.engine.mods.script.Script;

//este ejemplo muestra a operadores de manipulación del número entero básico
//inspección el registro de la salida después de usted ejecuta este script.

i interno = 10;
k interna = 5;

Script.out (“valores variables…”);
Script.out (“i =” + i);
Script.out (“k =” + k);

//que agrega números
Script.out (“agregando…”);
Script.out (“i + k =” + (i + k));

//que resta números
Script.out (“restando…”);
Script.out (“i - k =” + (i - k));

//que multiplica números
Script.out (“multiplicándose…”);
Script.out (“i * k =” + (i * k));

//que divide números
Script.out (“dividiéndose…”);
Script.out (“i/k =” + (i/k));

//inspección el registro de la salida después de usted ejecuta este script.

Sección 2 - Órdenes de control de nuevo a parte superior

Ejemplo: si declaraciones

importación com.hitek.engine.mods.script.Script;

temperatura interna = 100;
Tiempo = “frío” de la cadena;

//El formulario más simple del si declaración: 
si (temperatura > 80) 
{
tiempo = “caliente”;
}
Script.out (“el tiempo está hoy” + tiempo);

//(si +) declaraciones
temperatura = 60;
si (temperatura > 80)
{
tiempo = “caliente”;
}

{
tiempo = “agradable”;
}
Script.out (“el tiempo está hoy” + tiempo);

//(si + (si) +) declaraciones

temperatura = 75;
si (temperatura < 70)
{
el tiempo = “se refresca”;
}
si (>= 70 de la temperatura y y <= 80 de la temperatura)
{
el tiempo = “perfecciona”;
}

{
tiempo = “caliente”;
}
Script.out (“el tiempo está hoy” + tiempo);


//inspección el registro de la salida después de usted ejecuta este script.

Ejemplo: El usar “para” los bucles

importación com.hitek.engine.mods.script.Script;

//defina un número entero y una cadena vacía
suma interna = 0;
"" Del resultado = de la cadena;

//uso “para” el bucle entre 1 y 10, suma del incremento por 1. 
//++ que incrementa a operador
//<= es inferior o igual

para (corriente interna = 1; <= actual 10; current++) 
{
suma + corriente de la suma =;
resultado = “número = de la cresta de corriente” + corriente + “, suma =” + suma;
Script.out (resultado);
}

//después de que usted se ejecute/prueba este script, controla el registro de la salida.

Ejemplo: mientras que bucles

//mientras que la declaración ejecuta continuamente un bloque de declaraciones mientras que una condición está satisfecha
//mientras que el bucle evalúa la expresión en la parte superior del bucle

//SEA MISMO CAREFULL CON MIENTRAS QUE LOS BUCLES. 
//Cerciórese de que usted incremente un valor para salir del bucle en una cierta punta.

importe com.hitek.engine.mods.script.Script;

bucle interno = 1;
máximo interno = 7;

mientras que (bucle < máximo) 
{
//QUE ADVIERTE - si usted consigue pegado en un bucle infinito que usted tiene que RECOMENZAR el motor/el interfaz utilizador
Script.out (“esto es un bucle del rato. bucle =” + bucle);

¡//incremento el valor del bucle de otra manera esto mientras que el bucle nunca terminará!!
loop++;
}

//-mientras que el bucle evalúa la expresión en la parte inferior

//valor reajustado del bucle a 1
bucle = 1; 
 
{
//QUE ADVIERTE - si usted consigue pegado en un bucle infinito que usted tiene que RECOMENZAR el motor/el interfaz utilizador
Script.out (“éste es -mientras que bucle. bucle =” + bucle);

¡//incremento el valor del bucle de otra manera esto -mientras que el bucle nunca terminará!!
loop++;
}
mientras que (bucle < máximo);

Ejemplo:  La declaración del interruptor 

//la declaración del interruptor realiza condicional las declaraciones basadas en una expresión del número entero

importación com.hitek.engine.mods.script.Script;

dayNumber interno = 3;
Día = de la cadena ““;

cambie (dayNumber)
{
caso 1: day= " domingo "; 
rotura;
caso 2: day= " lunes "; 
rotura;
caso 3: day= " martes "; 
rotura;
caso 4: day= " miércoles "; 
rotura;
caso 5: day= " jueves "; 
rotura;
caso 6: day= " viernes "; 
rotura;
caso 7: day= " sábado "; 
rotura;
}

Script.out (“está hoy” + el día);

Ejemplo: La declaración del continuar

//la declaración del continuar permite que usted salte la iteración actual del para o mientras que bucle

importación com.hitek.engine.mods.script.Script;

máximo interno = 7;

//explote de a para el bucle
para (i=1 interno; i < 10; i++) 
{
si (i > 3 y y i < 7) 
{
continúe;
}
Script.out (“ésta es a para el bucle con continúa. iteración =” + i);
}


//continúe y explote de un infinito mientras que bucle
bucle interno = 1;
mientras que (verdad) 
{
//QUE ADVIERTE - si usted consigue pegado en un bucle infinito que usted tiene que RECOMENZAR el motor/el interfaz utilizador
¡//incremento el valor del bucle de otra manera esto mientras que nunca explotará el bucle!!
//el incremento debe ser hecho antes de la declaración del continuar
loop++;

¡//explota esto mientras que el bucle nunca terminará!!
si (bucle > máximo)
{
rotura;
}

//continúe encendido a la iteración siguiente para las iteraciones 1 y 2
si (bucle < 4)
{
continúe;
}

Script.out (“esto es un bucle del rato con el contine para las iteraciones < 3. la iteración =” + bucle);

//Usted no puede tener el incremento del bucle después del continuar. 
¡//!! bucle ++; ¡!! el bucle ++ no debe estar aquí. Debe ser situado antes del continuar.
}
Script.out (“explota de mientras que el bucle después de bucles >” + máximo);

Ejemplo: La declaración de la rotura

//la declaración de la rotura permite que usted explote de bucles. 

importación com.hitek.engine.mods.script.Script;

máximo interno = 7;

//explote de a para el bucle
para (i=1 interno; i < 10; i++) 
{
//QUE ADVIERTE - si usted consigue pegado en un bucle infinito que usted tiene que RECOMENZAR el motor/el interfaz utilizador
Script.out (“ésta es a para el bucle. bucle =” + i);
si (máximo del >= de i) 
{
rotura;
}
}

Script.out (“explota para de bucle después de bucles >” + el máximo);

//explota de un infinito mientras que el bucle
bucle interno = 1;
mientras que (verdad) 
{
//QUE ADVIERTE - si usted consigue pegado en un bucle infinito que usted tiene que RECOMENZAR el motor/el interfaz utilizador
Script.out (“esto es un bucle del rato. bucle =” + bucle);

¡//incremento el valor del bucle de otra manera esto mientras que el bucle nunca terminará!!
loop++;

¡//explota esto mientras que el bucle nunca terminará!!
si (bucle > máximo)
{
rotura;
}
}
Script.out (“explota de mientras que el bucle después de bucles >” + máximo);

Sección 3 - Cadenas, números y Booleans de nuevo a parte superior 

Ejemplo: Funciones de la clase de la cadena de Java

//La clase de la cadena de Java permite que usted consiga la información, búsqueda, manipula, convierte, y hace salir cadenas

importación com.hitek.engine.mods.script.Script;

//defina una cadena
Cadena mi nombre del str = “es Juan. Mi nombre pasado es gama.”;

//imprímalos hacia fuera
Script.out (“la cadena de la prueba es: ” + str);

//consiga la longitud de la cadena
Script.out (“la longitud del str de la cadena es: ” + str.length ());

//consiga el carácter en el índice 8
Script.out (“el carácter en el índice 9 es: ” + str.charAt (9));

//hallazgo la primera ocurrencia de una secuencia en la cadena e imprime el índice
Script.out (“la secuencia “nombre” primero fue encontrada en el índice:” + str.indexOf (“nombre”));

//si la secuencia no se encuentra, el índice de vuelta es - 1
//las búsquedas de cadena de Java y otras operaciones son caso sensible por valor por defecto
Script.out (“la secuencia “NOMBRE” fue encontrada en el índice:” + str.indexOf (“NOMBRE”));

//hallazgo la primera ocurrencia de una secuencia en la cadena, comenzando la búsqueda en el índice 15
Script.out (“la secuencia “nombre” también fue encontrada en el índice:” + str.indexOf (“nombre”, 15));

//hallazgo la ocurrencia pasada de una secuencia en la cadena e imprime el índice
Script.out (“la secuencia “nombre” era pasada encontrada en el índice:” + str.lastIndexOf (“nombre”));

//inspección si la cadena comienza con cierta secuencia.
//el método del startsWith vuelve un boleano verdad si la cadena comienza con la secuencia incorporada.
si == (de str.startsWith (“mi”) verdad)
{
Script.out (“sí. la cadena de la prueba comienza con “mi””);
}

//inspección si la cadena termina con cierta secuencia.
//el método del startsWith vuelve un boleano verdad si la cadena termina con la secuencia incorporada.
si (str.endsWith (“gama.” ) == verdad)
{
Script.out (“sí. los extremos de la cadena de la prueba con la “gama.” “);
}

//inspección si la cadena iguala otra cadena
La cadena anotherString mi nombre de = “es Juan. Mi nombre pasado es gama.”;
Script.out (“= anotherString” + anotherString);
si (str.equals (el anotherString))
{
Script.out (“sí. la cadena dos es igual”);
}

//inspección si la cadena iguala otra cadena que no hace caso del caso
La cadena lowerCaseString mi nombre de = “es Juan. mi nombre pasado es gama.”;
Script.out (“= lowerCaseString” + lowerCaseString);
si (str.equalsIgnoreCase (el lowerCaseString))
{
Script.out (“sí. la cadena dos es igual no haciendo caso del caso”);
}

Ejemplo:  Manipulación de cadena

//Ejemplos de la manipulación de cadena

importación com.hitek.engine.mods.script.Script;

//defina algunas cadenas
Cadena mi nombre del str = “es Juan. Mi nombre pasado es gama.”;
La cadena str2 = “tengo gusto de la torta.”;

//impresión él hacia fuera
Script.out (“la cadena de la prueba es: ” + str);

//concatene (añada al final del fichero) otra cadena a esta cadena
Encadene str3 = str.concat (str2);
Script.out (“concatenando str2 a str1. Resultado: ” + str3);

//substituya la primera ocurrencia de una cadena (o del modelo regular de la expresión) por otra cadena
str3 = str.replaceFirst (“es”, “era”);
Script.out (“substituir la primera ocurrencia de “está” con “era”. Resultado: ” + str3);

//substituya todas las ocurrencias de una cadena (o del modelo regular de la expresión) por otra cadena
str3 = str.replaceAll (“mi”, “el suyo”);
Script.out (“substituyendo todas las ocurrencias “de mi” con “el suyo”. Resultado: ” + str3);

//consiga una subcadena que comienza en el índice especificado
str3 = str.substring (8);
Script.out (“subcadena begining en el índice 8 =” + str3);

//consiga una subcadena contenida dentro de índices especificados
str3 = str.substring (8.30);
Script.out (“subcadena beggining en el índice 8 y que termina en el índice 30 =” + str3);

//cadena del convertido a la minúscula
str3 = str.toLowerCase ();
Script.out (“cadena que convierte a = minúsculo” + str3);

//cadena del convertido al mayúscula
str3 = str.toUpperCase ();
Script.out (“cadena que convierte a = mayúsculo” + str3);

Ejemplo: números de Java

//Los tipos primitivos del número de Java incluya interno, largo, flotador, doble, cortocircuito, octeto
//Usted requerirá sobre todo interno y largo. Usted puede necesitar a veces utilizar el flotador.
//Cada uno de estos tipos primitivos tiene clases de Java que se envuelvan alrededor de ellas. 
//Los abrigos del número entero de la clase alrededor de interno. Los abrigos largos de la clase alrededor de largo.

importación com.hitek.engine.mods.script.Script;

//defina algunos números
i interno = 3;
l largo = 123456787;
flotador f = 25.45;

Nuevo número entero del número entero I = (i);
Flotador nuevo del flotador F = (f);
L largo = nuevo (l) largo;

//impresión hacia fuera el interno y el número entero
Script.out (“el i interno es: ” + i);
Script.out (“el número entero de la clase de la envoltura es: ” + I. toString ());

//impresión hacia fuera el el largo y largo
Script.out (“el l largo es: ” + l);
Script.out (“la clase de la envoltura larga es: ” + L. toString ());

//impresión hacia fuera el flotador y flotador
Script.out (“el flotador f es: ” + f);
Script.out (“el flotador de la clase de la envoltura es: ” + F. toString ());

Ejemplo: valores de la cadena del convertido a los números

//Usted necesitará con frecuencia convertir valores de la cadena a los números

importación com.hitek.engine.mods.script.Script;

//defina algunas cadenas. 
Encadene = intString “25”;
Encadene = longString “123456789”;
Encadene = floatString “25.567”;

i interno = Integer.valueOf (el intString);
//impresión hacia fuera el interno
Script.out (“el i interno es: ” + i);

l largo = Long.valueOf (el longString);
//impresión hacia fuera el largo
Script.out (“el l largo es: ” + l);

flotador f = Float.valueOf (el floatString);
//impresión hacia fuera el flotador
Script.out (“el flotador f es: ” + f);

Ejemplo: clase de la matemáticas de Java

//La clase de la matemáticas de Java proporciona a más funciones de la matemáticas, con excepción de +, -,/o *

importación com.hitek.engine.mods.script.Script;

//defina algunos números
i2 interno = 3;
i3 interno = - 7;
l largo = 123456787;
flotador f = 25.45;
d2 doble = 25.34;
d3 doble = 2.4;

//impresión hacia fuera el máximo de dos números
Script.out (“el máximo entre i2 e i3 es: ” + Math.max (i2, i3));

//impresión hacia fuera el mínimo de dos números
Script.out (“el mínimo entre i2 e i3 es: ” + Math.min (i2, i3));

//redondo del flotador
Script.out (“25.45 se redondea apagado: ” + Math.round (f));

//consiga el valor del exp
Script.out (“exp (3) =” + Math.exp (i2));

//consiga el valor del registro
Script.out (“registro (3) =” + Math.log (i2));

//consiga el valor de la raíz cuadrada
Script.out (“raíz cuadrada de 3 =” + Math.sqrt (i2));

Ejemplo: La clase boleana

//Los abrigos boleanos de la clase alrededor del tipo primitivo de Java boleano
//El boleano primitivo puede ser “verdad” o “falso” (el caso sensible)

importe com.hitek.engine.mods.script.Script;

//defina algunos booleans
= trueBoolean boleano verdad;
= falseBoolean boleano falso;

//convertido el boleano a la cadena y a la impresión hacia fuera el boleano 
Script.out (“trueBoolean es: ” + trueBoolean.toString ());
Script.out (“falseBoolean es: ” + falseBoolean.toString ());

//uso la clase boleana de convertir una cadena a boleano
Cadena trueString = “verdad”;
Prueba boleana = Boolean.valueOf (el trueString);
= convertedBoolean boleano test.booleanValue ();
Script.out (la “cadena que convierte “verdad” al tipo boleano”);
Script.out (“valor boleano convertido =” + convertedBoolean.toString ());


Sección 4 - Las matrices y dataron de la parte superior

Ejemplo: Matrices

//Las matrices será requerido con frecuencia para procesar el listado y otro del directorio las aplicaciones.

importación com.hitek.engine.mods.script.Script;

//declare un arsenal del intetger
[] arr interno; 

//cree el arsenal del número entero
interno nuevo del arr = [10]; 

//asigne un valor a cada elemento de arsenal e imprímalo hacia fuera
//el campo “longitud” vuelve el size del arsenal
// 
para (i interno = 0; i < arr.length; i++) 
{
arr [i] = i * 2;
Script.out (“el elemento de arsenal en el índice: ” + i + “es: ” + arr [i]);
}

//ejemplo de usar arsenal de la cadena
Str = de la cadena [] {“uno es 1”, “dos es 2”, “tres es 3”};
para (i interno = 0; i < str.length; i++) 
{
Script.out (“el elemento de arsenal en el índice: ” + i + “es: ” + str [i]);
}

//2.as matrices
Nombres = de la cadena [] []
{
{“cuenta”, “sacudida”, “betty”},
{“marca”, “mate”,},
{“karen”, “gatito”, “kevin”, “kong”,},
};

para (i interno = 0; i < names.length; i++) 
{
Script.out (“comienzo de 1-D subarray de nombres. Fila =” + i);
para (j interno = 0; j < nombres [i] .length; j++) 
{
Script.out (nombres [i] [j] + ““);
}
Script.out (“extremo de 1-D subarray de nombres. Fila =” + i);
}

Ejemplo: vectores

El vector//A es un arsenal que puede crecer o contraerse dinámicamente
El vector//A puede contener cualquier tipo de objeto o de tipo primitivo de Java

importación com.hitek.engine.mods.script.Script;

//cree un arraylist en blanco
Vector el nuevo vector de v = ();

//agregue algunos elementos a él
v. agregue (0);
v. agregue (“primera cadena”);
v. agregue (“segunda cadena”);
v. agregue (3);
v. agregue (la nueva fecha ());

//impresión hacia fuera los elementos del vector
para (i interno = 0; i < size del V. (); i++) 
{
Script.out (“el elemento de arsenal en el índice: ” + i + “es: ” + el V. consigue (i).toString ());
}

//impresión hacia fuera el size del vector
Script.out (“el size del vector es: ” + size del V. ());

//quite un elemento en el índice 3
v. quite (3);

//impresión hacia fuera el size del vector otra vez
Script.out (“elemento quitado en el índice 3. El nuevo size del vector es: ” + size del V. ());

//elemento del separador de millares en el índice 3 otra vez
v. agregue (3, “Sr. Insert”);

//de la impresión elemento 3 hacia fuera
Script.out (el “elemento insertado en el índice 3 es: ” + el V. consigue (3) .toString ());

//búsqueda el vector para los objetos
si (el V. contiene (“Sr. Insert”))
{
Script.out (“sí, este vector contiene “Sr. Insert” del elemento”);
}

//impresión hacia fuera el índice de “Sr. Insert”
Script.out (“el índice de Sr. Insert es: ” + indexOf del V. (“Sr. Insert”));

//sin obstrucción hacia fuera el arsenal
v. claro ();

//impresión hacia fuera el size del vector
Script.out (“vector borrado. El size del vector es: ” + size del V. ());

Ejemplo: Clases de la fecha y de DateFormat

//Las clases de la fecha y de DateFormat es útil en el formato, analizando y modificando timestamps del fichero
//Las clases del calendario ayude a realizar manipulaciones y comparaciones de la fecha.

importe com.hitek.engine.mods.script.Script;
importe java.text.DateFormat;

//consiga la fecha actual
Ahora feche = nueva fecha ();

//impresión hacia fuera la fecha usando un formateador del valor por defecto
Script.out (“la fecha/la hora actuales del formato del valor por defecto es: ” + now.toString ());

//cree un formateador de encargo de la fecha que muestra la fecha corta y formatos a corto plazo
//usted tiene que importar la clase de java.text.DateFormat en la parte superior del script
//java.text.DateFormat no es importado automáticamente por el script.
DateFormat df = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT);

//impresión hacia fuera la fecha usando este formateador corto de encargo
Script.out (la “fecha/hora CORTAS actuales del formato es: ” + df.format (ahora));

//interruptor el formato a desear fecha y hora
df = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG);
Script.out (la “fecha/la hora LARGAS actuales es: ” + df.format (ahora));

//permite para calcular tiempo transcurrido en milisegundos
//el método del getTime () vuelve los milisegundos totales transcurrió puesto que el comienzo del tiempo de ordenador (~1970)
startMillis largos = now.getTime ();
Script.out (“hora de salida en millis: ” + startMillis);

//permite para recalcular la fecha
ahora nueva fecha de = ();
endMillis largos = now.getTime ();
Script.out (“tiempo del final en millis: ” + endMillis);

//calcule el tiempo transcurrido en millis
desean los endMillis del diff = - startMillis;
Script.out (“elaspsed tiempo en millis: ” + diff);

//nosotros puede también convertir una época en milisegundos a una fecha 
Feche el endDate = nueva fecha (endMillis);
Script.out (“tiempo del final en formato largo: ” + df.format (endDate));

Ejemplo: Fecha del análisis

//Fecha del análisis de cadenas

importación com.hitek.engine.mods.script.Script;
importación java.text.DateFormat;

//Defina una cadena de fecha
Encadene = shortDateString “4/11/06 PM de 6:53”;
Encadene = longDateString el “11 de abril de 2006 6:53:27 PM PDT”;

//defina el formato de fecha corto
DateFormat df = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT);

//analice la fecha corta hacia adentro
Feche el shortDate = df.parse (el shortDateString);

//impresión hacia fuera la fecha corta usando un formateador del valor por defecto
Script.out (el “shortDate fue analizado correctamente. fecha corta: ” + shortDate.toString ());

//interruptor el formateador a desear formato de fecha
df = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG);

//analice en la fecha larga
Feche = longDate df.parse (el longDateString);

//impresión hacia fuera la fecha larga usando un formateador del valor por defecto
Script.out (“longDate fue analizado correctamente. fecha larga: ” + longDate.toString ());

Ejemplo: Clase del calendario

//Clase del calendario permite que manipulemos una fecha o que comparemos fechas

importación com.hitek.engine.mods.script.Script;
//clases de la fecha y del calendario de la importación que están situadas en el conjunto de java.util
importación java.util.*; //

//consiga el calendario actual
Ahora haga calendarios = Calendar.getInstance ();

//impresión hacia fuera la información del calendario.
Script.out (el “calendario actual es: ” + now.toString ());

//convertido el calendario a un objeto de la fecha usando la función del getTime del calendario ()
dateNow = now.getTime de la fecha ();

//impresión hacia fuera la información de la fecha
Script.out (la “fecha obtenida de calendario es: ” + dateNow.toString ());

//convertido a la fecha a un calendario usando la función del setTime del calendario (fecha)
now.setTime (dateNow);

//impresión hacia fuera la información del calendario otra vez
Script.out (el “calendario obtenido a partir de fecha es: ” + now.toString ());

//consiga los campos individuales del calendario
Script.out (“el año es: ” + now.get (Calendar.YEAR));
Script.out (“el mes es: ” + now.get (Calendar.MONTH));
Script.out (“la fecha es: ” + now.get (Calendar.DATE));
Script.out (“la hora (0-12) es: ” + now.get (Calendar.HOUR));
Script.out (“la hora del día (0-23) es: ” + now.get (Calendar.HOUR_OF_DAY));
Script.out (“el minuto es: ” + now.get (Calendar.MINUTE));
Script.out (“el segundo es: ” + now.get (Calendar.SECOND));
Script.out (“el milisegundo es: ” + now.get (Calendar.MILLISECOND));
Script.out (“el valor del AM/del PM es: ” + now.get (Calendar.AM_PM));

Script.out (“el día de la semana es: ” + now.get (Calendar.DAY_OF_WEEK));
Script.out (“la semana del mes es: ” + now.get (Calendar.WEEK_OF_MONTH));
Script.out (“el día del año es: ” + now.get (Calendar.DAY_OF_YEAR));
Script.out (“el día de la semana en mes es: ” + now.get (Calendar.DAY_OF_WEEK_IN_MONTH));
Script.out (“el día del mes es: ” + now.get (Calendar.DAY_OF_MONTH));
Script.out (“la semana del año es: ” + now.get (Calendar.DAY_OF_YEAR));

//ahora agregue algunos campos al calendario. El agregar automáticamente rueda sobre los campos más grandes para usted
Calendario ayer = Calendar.getInstance ();
yesterday.add (Calendar.DATE, - 1);

Calendario mañana = Calendar.getInstance ();
tomorrow.add (Calendar.DATE, 1);

//impresión hacia fuera las fechas que corresponden a estos calendarios. El primer convertido hasta la fecha se opone antes de imprimir
Script.out (“estaba ayer: ” + yesterday.getTime () .toString ());
Script.out (“está mañana: ” + tomorrow.getTime () .toString ());

//compare ayer y mañana con el calendario después y antes de métodos
si (yesterday.before (mañana))
{
Script.out (“sí, son ayer antes de man#ana”);
}

si (tomorrow.after (ayer))
{
Script.out (“sí, son mañana después de ayer”);
}

Sección 5 - Fichero y directorio de nuevo a parte superior

Ejemplo: información del directorio y del fichero 

//En la información de Java, del directorio y del fichero se obtiene de la clase del fichero de Java

importación com.hitek.engine.mods.script.Script;
importación java.text.DateFormat;

//consiga a valor por defecto Java el directorio temporal
Encadene el tmpdir = System.getProperty (“java.io.tmpdir”);

//impresión hacia fuera el nombre de directorio
Script.out (“la carpeta de la temperatura de Java del valor por defecto es: ” + tmpdir);

//cree un nuevo objeto del fichero del directorio
Clasifíe el fichero nuevo del dir = (tmpdir);

//cree un nuevo objeto del fichero
Clasifíe el fichero nuevo newFile de = (dir, “newFile.txt”);

//cree el fichero nuevo
éxito boleano = newFile.createNewFile ();

//impresión hacia fuera clasifía la información
si (== del éxito verdad)
{
Script.out (“fichero nuevo creado”);
}

{
Script.out (“no podido crear el fichero o el fichero existe ya”);
}

//verifique que el camino del fichero exista y sea un fichero
si (newFile.exists () y y newFile.isFile ())
{
Script.out (el “fichero existe y es un fichero”);
}

{
Script.out (el “fichero no existe, o no es un fichero”);
vuelta; //ninguna punta que continúa si no hay fichero
}

//impresión hacia fuera la información de los ficheros
Script.out (“nombre del archivo =” + newFile.getName ());
Script.out (“size = del fichero” + newFile.length ());
Script.out (“camino = del fichero” + newFile.getPath ());
Script.out (“camino absoluto = del fichero” + newFile.getAbsolutePath ());
Script.out (“camino canónico = del fichero” + newFile.getCanonicalPath ());
Script.out (“directorio = de los ficheros” + newFile.getParent ());
Script.out (el “fichero es = legible” + newFile.canRead ());
Script.out (el “fichero es = writeable” + newFile.canWrite ());
Script.out (el “fichero es = ocultado” + newFile.isHidden ());
DateFormat df = DateFormat.getDateTimeInstance ();
modtime largo = newFile.lastModified ();
Fecha de la Mod = de la fecha nueva (modtime);
Script.out (“fecha = del fichero” + df.format (Mod));

Ejemplo: métodos del fichero

importación com.hitek.engine.mods.script.Script;
importación java.text.DateFormat;

//consiga a valor por defecto Java el directorio temporal
Encadene el tmpdir = System.getProperty (“java.io.tmpdir”);

//impresión hacia fuera el nombre de directorio
Script.out (“la carpeta de la temperatura de Java del valor por defecto es: ” + tmpdir);

//cree un nuevo objeto del fichero del directorio
Clasifíe el fichero nuevo del dir = (tmpdir);

//cree un nuevo objeto del fichero
Clasifíe el fichero nuevo de file1 = (dir, “file1.txt”);
Clasifíe el fichero nuevo de file2 = (dir, “file2.txt”);

//cree el fichero nuevo 1
file1.createNewFile ();

//verifique que newfile1 exista y sea un fichero
si (file1.exists () y y file1.isFile ())
{
Script.out (“file1 existe”);
}

{
Script.out (“file1 no existe, o no es un fichero”);
vuelta; //ninguna punta que continúa si no hay fichero
}

//retitule el fichero
éxito boleano = file1.renameTo (file2);

si (== del éxito verdad)
{
Script.out (“retitule de file1 a file2 eran acertado”);
}
//confirme que no existe newFile1
¡si (!file1.exists ())
{
Script.out (“file1 no existe, porque fue retitulado”);
}

//cancelación newFile2
éxito = file2.delete ();
si (== del éxito verdad)
{
Script.out (“la cancelación file2 era acertada”);
}

Ejemplo:  read/write del fichero

//read/write del fichero

importación com.hitek.engine.mods.script.Script;

//consiga a valor por defecto Java el directorio temporal
Encadene el tmpdir = System.getProperty (“java.io.tmpdir”);

//impresión hacia fuera el nombre de directorio
Script.out (“la carpeta de la temperatura de Java del valor por defecto es: ” + tmpdir);

//cree un nuevo objeto del fichero del directorio
Clasifíe el fichero nuevo del dir = (tmpdir);

//cree un nuevo objeto del fichero
Clasifíe el fichero nuevo de file1 = (dir, “file1.txt”);

//cree FileWriter para escribir a file1, el falso es sobregrabar el fichero, verdad es añadir al final del fichero al extremo del fichero existente
FileWriter fw = FileWriter nuevo (file1, falsos);
Bw = BufferedWriter nuevo (fw) de BufferedWriter;
para (i interno = 0; i < 10; i++)
{
bw.write (“ésta es línea” + i);
//escriba una nueva línea carácter
bw.newLine ();
}
bw.close ();

//cree a programa de lectura para leer hacia adentro el fichero entero y para imprimirlo hacia fuera para hacer salir el registro
FileReader franco = FileReader nuevo (file1);
Br = BufferedReader nuevo (franco) de BufferedReader;
Línea "" de la cadena de =; 
¡mientras que ((línea = br.readLine ())!falta de información de =)
{
Script.out (línea);
}
br.close ();

Ejemplo: métodos del directorio

//En la información de Java, del directorio y del fichero se obtiene de la clase del fichero de Java

importación com.hitek.engine.mods.script.Script;

//consiga a valor por defecto Java el directorio temporal
Encadene el tmpdir = System.getProperty (“java.io.tmpdir”);

//impresión hacia fuera el nombre de directorio
Script.out (“la carpeta de la temperatura de Java del valor por defecto es: ” + tmpdir);

//cree un nuevo objeto del fichero del directorio
Clasifíe el fichero nuevo del dir = (tmpdir);

//confirme que este camino existe en su sistema
si (dir.exists ())
{
Script.out (“sí, este camino existe”);
}

//confirme que esto es un directorio válido en su sistema
si (dir.isDirectory ())
{
Script.out (“sí, esto es un directorio válido”);
}

//consiga el camino
Script.out (“el camino es: ” + dir.getPath ());

//consiga el camino absoluto
Script.out (“el camino absoluto es: ” + dir.getAbsolutePath ());

//consiga el directorio del padre
Clasifíe el padre = dir.getParentFile ();
Script.out (“el camino del padre es: ” + parent.getAbsolutePath ());

Ejemplo: información del directorio

//En la información de Java, del directorio y del fichero se obtiene de la clase del fichero de Java

importación com.hitek.engine.mods.script.Script;
importación java.text.DateFormat;

//consiga a valor por defecto Java el directorio temporal
Encadene el tmpdir = System.getProperty (“java.io.tmpdir”);

//impresión hacia fuera el nombre de directorio
Script.out (“la carpeta de la temperatura de Java del valor por defecto es: ” + tmpdir);

//cree un nuevo objeto del fichero del directorio
Clasifíe el fichero nuevo del dir = (tmpdir);

//consiga la lista de los nombres del fichero en el dir
Encadene [] los nombres = dir.list ();

//impresión hacia fuera los primeros 100 nombres de todos los ficheros en su dir de la temperatura
máximo interno = names.length;
si (máximo > 100)
{
máximo = 100;
}

para (i=0 interno; i < máximo; i++)
{
Script.out (“fichero” + i + “=” + nombres [i]);
}

//consiga un arsenal de objetos del fichero 
Clasifíe [] los ficheros = dir.listFiles ();

//impresión hacia fuera la información para los primeros 100 ficheros. 
"" Conocido de la cadena =;
size largo = 0;
Fecha modificada;

//consiga el formateador del tiempo de la fecha del valor por defecto
DateFormat df = DateFormat.getDateTimeInstance ();
"" De la Mod = de la cadena;

para (i=0 interno; i < máximo; i++)
{
La cadena = conocido clasifía [i] .getName ();
el size = clasifía [i] .length ();
nueva fecha modificada de = (ficheros [i] .lastModified ());
Mod = df.format (modificada);
Script.out (“fichero” + i + “=” + nombre + “, size =” + size + “, timestamp =” + Mod);
}

Ejemplo: haga las carpetas

//ejemplo para hacer carpetas 

importación com.hitek.engine.mods.script.Script;

//consiga a valor por defecto Java el directorio temporal
Encadene el tmpdir = System.getProperty (“java.io.tmpdir”);

//impresión hacia fuera el nombre de directorio
Script.out (“la carpeta de la temperatura de Java del valor por defecto es: ” + tmpdir);

//cree un nuevo objeto del fichero del directorio
Clasifíe el fichero nuevo del dir = (tmpdir);

//cree un objeto del fichero que representa un nuevo subfolder dentro del tmpdir
Clasifíe el fichero nuevo del newdir = (dir, “newDirectory2”);

//inspección si existe la carpeta
boleano existe = newdir.exists ();
si (existe el == verdad)
{
Script.out (la “carpeta existe ya: ” + newdir.getAbsolutePath ());
vuelta; //ninguna necesidad de crear el subfolder
}

//haga un nuevo subdirectory. el método vuelve verdad si tiene éxito
//las vueltas falsas si existe la carpeta ya, o no podría crear la carpeta
éxito boleano = newdir.mkdir ();
si (== del éxito verdad)
{
Script.out (“crearon la carpeta nueva: ” + newdir.getAbsolutePath ());
}

Sección 6 - Métodos de nuevo a parte superior

Ejemplo: usar métodos

//usted puede definir métodos para reutilizar código en sus scripts
//todos los métodos DEBE ser definido antes de que se ejecute el script principal

importe com.hitek.engine.mods.script.Script;

//este método hace salir simplemente el mensaje de la cadena al registro de la salida
vacío hacia fuera (mensaje de la cadena)
{
Script.out (mensaje);
}

//este método consigue el cuadrado de un número
cuadrado interno (entrada de información interna)
{
entrada de información de vuelta * entrada de información;
}

//método principal ahora comienza
//prueba los métodos antedichos
hacia fuera (“ésta es una prueba de usar métodos en scripts”);
cuadrado interno del fiveSquare = (5);
hacia fuera (“el cuadrado cinco es” + fiveSquare);

Ejemplo: métodos del hitek

//nosotros proporcione a algunos métodos que permitan que usted ejecute tasks, datos de registro, consiga y fije las variables y los parámetros del task.

importe com.hitek.engine.mods.script.Script;

//escriba una cadena al registro de la salida
Script.out (“escritura al registro de la salida”);

//escriba una cadena al registro de actividad
Script.act (“escritura al registro de actividad”);

//escriba un rastro de pila del error al registro del poner a punto
intento
{
Integer.parseInt (“mal número entero”);
}
retén (anomalía e)
{
Script.err (e);
}

//ejecute un task y consiga el código de la salida
//se cerciora de usted incorporar un título válido del task aquí
taskTitle = “Enter_valid_task_title_here” de la cadena;
taskTitle = “copy”;
exitCode interno = Script.run (taskTitle);
Script.out (“código de la salida del task =” + exitCode);

//consiga un paramter del task. Usted necesita incorporar el clave correcto del taskTitle y del parámetro
//mirada en los ficheros de la característica de los tasks en la carpeta de los datos \ de los tasks.
//estos ficheros muestre los claves del parámetro de Task.PARAMETERS0 a Task.PARAMETERS50

//lea Task.PARAMETERS1
Encadene = normal Script.getPar (taskTitle, “Task.PARAMETERS1”);
Script.out (“Task.PARAMETERS1 =” + igualdad);

//conjunto un parámetro del task dinámicamente
Script.setPar (taskTitle, “Task.PARAMETERS1”, “nuevo valor de la prueba”);

//lo leyó otra vez hacia fuera para confirmar que los cambios fueron realizados
= normal Script.getPar (taskTitle, “Task.PARAMETERS1”);
Script.out (“Task.PARAMETERS1 =” + igualdad);

//usted puede conseguir todo el task, utilizador, Java, y valores de la variable del sistema
//usted puede fijar valores de la variable del utilizador. No permitimos que los valores variables del task, de Java o del sistema sean sobregrabados.
taskTitle del var = de la cadena + “::ExitCode”;
Valor = Script.getVar (var) de la cadena;
Script.out (“valor variable =” + valor);

//conjunto un valor de la variable del utilizador
Script.setVar (“newVariable”, “variable que prueba”);
valor = Script.getVar (“newVariable”);
Script.out (“nuevo valor variable =” + valor);

 De nuevo a parte superior