• Puissant, flexible, fiable et accessible
• Les dispositifs de Scripting sont disponibles pour les utilisateurs avançés et les programmeurs
• Le passage 1000+ charge un jour
• Le support technique opportun et libre avant et après toi achètent
• Libérez l'épreuve de 30 jours et les mises à niveau libres de mineur
• Passages sur Windows, imper OSX, Linux, et d'autres plateformes d'Unix

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

Scripting (éditions de professionnel d'Automize et d'entreprise d'Automize)

• Créez les séquences type complexes d'automatisation qui construisent sur Automize existant chargent
• Développez les séquences type qui réduisent des activités parainformatiques répétées et laborieuses.
• Ajoutez la fonctionnalité avançée à votre Automize charge comme l'email, le ftp, les moniteurs, le fichier et les listes de répertoire.
• Employez le dispositif de séquence type pour obtenir des listes de fichier ou les noms de fichier que vous pouvez utiliser dans la copie, ftp, fermeture éclair charge etc….
• Vous pouvez lire et placer la valeur de chargez les paramètres de la séquence type. Exécutez alors le charger de la séquence type. Ceci réduit la complexité de la séquence type.
• Juste 20-50 lignes de code peuvent résulter est extrêmement puissante personnalisée charge et des solutions.
• Nous fournissons l'aide libre pour les petites 20-50 lignes séquence type qui peuvent être utilisables aux utilisateurs.
• Le code détaillé de cours d'instruction et d'échantillon pour vous obtenir a commencé.
• Notre forum en ligne a beaucoup d'exemples réels de code basés sur des applications de vrai utilisateur.

Séquence type d'exemple :
1) La séquence type lit la liste de fichier du système de fichiers
2) Les positionnements de séquence type chargent des paramètres basés sur le nom de fichier et la chemise
3) Les passages de séquence type chargent. Chargez les passages après que lisant chargiez le positionnement de paramètres par l'intermédiaire de la séquence type.
4) La séquence type lit chargent le code de sortie et chargent des variables
5) La séquence type peut continuer de fonctionner chargent dans le même ordre 2-4 pour tous les noms de fichier

-----------------------------------------------------------------------------------------------------------------------------------------------
Cours d'instruction d'Automize Java Scripting

Automize utilise BeanShell (beanshell.org) pour son scripting.  BeanShell supporte la syntaxe 100% de Java, et Automize lui-même est écrit dans Java.  C'est une grande voie d'apprendre la syntaxe de Java et d'obtenir commencée sur le langage de programmation moderne le plus facile et le plus puissant.

Pour suivre à travers dans ces cours d'instruction, copie et coller ces exemples dans la fenêtre de séquence type d'Automize. Exécutez alors ces exemples :

Section 1 - Fondations
Section 2 - Ordres de contrôle
Section 3 - Chaînes de caractères, nombres et Booleans
Section 4 - Alignements et dates
Section 5 - Fichier et répertoire
Section 6 - Méthodes

Section 1 - Fondations

Exemple : Séquence type préliminaire

//Lignes lignes de commentaire commençant par//are

//La plupart des langages de programmation (c, Java, c++, exigent etc… () une méthode principale)
//Cependant, vous n'avez pas besoin de définir () une méthode principale tout en scripting

//définissez une chaîne de caractères
Ficelez l'essai = « bienvenue à Java scripting ! ! » ;

//écrivez au stdout de système
System.out.println (essai) ;

Exemple : Utilisation de la classe de séquence type

//Classe de séquence type fournit une connexion entre vos séquences type et fonctions incorporées de logiciel de Hitek

//rapports d'importation te permettent d'utiliser le logiciel de Hitek ou les fonctions existant de Java
//Dans cet exemple, nous importons la classe de séquence type de logiciel de Hitek

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

//définissez une chaîne de caractères

Ficelez l'essai = « bienvenue à Java Scripting ! ! » ;

//Appel la méthode de Script.out pour écrire la sortie au fichier de logarithme naturel de sortie

Script.out (essai) ;

//après que vous exécutiez/essai cette séquence type, contrôlent le fichier de logarithme naturel de sortie (le menu de logarithmes naturels dans l'interface utilisateur d'Automize)

Exemple : Nombres entiers et chaînes de caractères

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

//nombres entiers - vous fréquemment utiliserez interne ou désirerez ardemment en vos séquences type
largestInteger interne = Integer.MAX_VALUE ;
long largestLong = Long.MAX_VALUE ;

//booléen - vous devrez également utiliser booléen 
les javaRocks booléens = rectifient ;

//Chaîne de caractères - vous utiliserez des chaînes de caractères beaucoup
La chaîne de caractères testString = des « chaînes de caractères de Java sont très utile » ;

Script.out (" valeur maximum de nombre entier = » + largestInteger) ;
Script.out (" longue valeur maximum = » + largestLong) ;
Script.out (" valeur des javaRocks = » + javaRocks) ;
Script.out (testString) ;

//contrôle le logarithme naturel de sortie après toi exécutent cette séquence type.

Exemple : Cet exemple montre à des expressions quel travail avec des nombres entiers.  Contrôlez le logarithme naturel de sortie après que vous exécutiez cette séquence type.

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

interne m = 10 ;
interne k = 5 ;

Script.out (" valeurs variables… ») ;
Script.out (" m = » + m) ;
Script.out (" k = » + k) ;

//utilisant l'opérateur ++ d'incrément
m++ ;
Script.out (" incrémenté en utilisant m++, nouvelle valeur de m = » + m) ;

//utilisant > (plus grand que) < (moins que)
si (m > k)
{
Script.out (" oui, » +m + « est plus grand que » + k) ;
}

//utilisant le >= (plus grand qu'ou égal) et le <= (moins qu'ou égale) 
si (>= k +5 de m)
{
Script.out (" oui, m est supérieur ou égal à k + 5 ») ;
}

//utilisant le == d'opérateur d'égalité
si (k==5)
{
Script.out (" oui, k est égal à 5 ») ;
}

//utilisant pas l'opérateur d'égales !=
si (k != 5)
{
Script.out (" oui, k n'est pas égal à 5 ») ;
}

//utilisation et et (logique ET)
si ((== 5 de k) et et (m==10))
{
Script.out (" oui, k est égal à 5, et m est égal à 10 ») ;
}

//utilisation || (logique OU)
si ((== 5 de k) || (m==234545))
{
Script.out (" oui, ou k est égal à 5, ou m est égal à 10 ») ;
}

//contrôle le logarithme naturel de sortie après toi exécutent cette séquence type.

Exemple : Cet exemple montre les opérateurs manipulants de nombre entier de base

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

//cet exemple montre les opérateurs manipulants de nombre entier de base
//contrôle le logarithme naturel de sortie après toi exécutent cette séquence type.

interne I = 10 ;
interne k = 5 ;

Script.out (" valeurs variables… ») ;
Script.out (" I = » + I) ;
Script.out (" k = » + k) ;

//ajoutant des nombres
Script.out (" ajoutant… ») ;
Script.out (" I + k = » + (I + k));

//soustrayant des nombres
Script.out (" soustrayant… ») ;
Script.out (" I - k = » + (I - k));

//multipliant des nombres
Script.out (" se multipliant… ») ;
Script.out (" I * k = » + (I * k));

//divisant des nombres
Script.out (" se divisant… ») ;
Script.out (" I/k = » + (I/k));

//contrôle le logarithme naturel de sortie après toi exécutent cette séquence type.

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

Section 2 - Ordres de contrôle de nouveau au dessus

Exemple : si rapports

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

interne la température = 100 ;
La chaîne de caractères survivent à = « froid » ;

//Forme la plus simple de si rapport : 
si (la température > 80) 
{
survivez à = « chaud » ;
}
Script.out (" le survivre à est aujourd'hui » + survivent à) ;

//(si + autrement) rapports
la température = 60 ;
si (la température > 80)
{
survivez à = « chaud » ;
}
autrement
{
survivez à = « gentil » ;
}
Script.out (" le survivre à est aujourd'hui » + survivent à) ;

//(si + (autrement si) + autrement) rapports

la température = 75 ;
si (la température < 70)
{
survivez à = « se refroidissent » ;
}
autrement si (>= 70 de la température et et <= 80 de la température)
{
survivez à = « se perfectionnent » ;
}
autrement
{
survivez à = « chaud » ;
}
Script.out (" le survivre à est aujourd'hui » + survivent à) ;


//contrôle le logarithme naturel de sortie après toi exécutent cette séquence type.

Exemple : Utilisation « pour » des boucles

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

//définissez un nombre entier et une chaîne de caractères vide
somme interne = 0 ;
Résultat = "" de chaîne de caractères ;

//utilisation « pour » la boucle entre 1 et 10, somme d'incrément par 1. 
//++ incrémentant l'opérateur
//<= est inférieur ou égal à

pour (courant interne = 1 ; <= actuel 10 ; current++) 
{
somme = somme + courant ;
résultat = « nombre de boucle de courant = » + courant + « , somme = » + somme ;
Script.out (résultat) ;
}

//après que vous exécutiez/essai cette séquence type, contrôlent le logarithme naturel de sortie.

Exemple : tandis que boucles

//tandis que le rapport exécute continuellement un bloc de rapports tandis qu'une condition est satisfaite
//tandis que la boucle évalue l'expression au dessus de la boucle

//SOYEZ TRÈS CAREFULL AVEC TANDIS QUE DES BOUCLES. 
//Assurez-vous que vous incrémentez une valeur pour quitter la boucle à un certain point.

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

boucle interne = 1 ;
interne maximum = 7 ;

tandis que (boucle < maximum) 
{
//AVERTISSANT - si vous vous coincez dans une boucle infinie que vous devez RELANCER le moteur/interface utilisateur
Script.out (" c'est une boucle de moment. boucle = » + boucle) ;

//incrément la valeur de la boucle autrement ceci tandis que la boucle ne se terminera jamais ! !
loop++ ;
}

//-tandis que la boucle évalue l'expression au bas

//valeur remise à l'état initial de boucle à 1
boucle = 1 ; 
 
{
//AVERTISSANT - si vous vous coincez dans une boucle infinie que vous devez RELANCER le moteur/interface utilisateur
Script.out (" c'est -tandis que boucle. boucle = » + boucle) ;

//incrément la valeur de la boucle autrement ceci -tandis que la boucle ne se terminera jamais ! !
loop++ ;
}
tandis que (boucle < maximum) ;

Exemple :  Le rapport de commutateur 

//rapport de commutateur exécute conditionnellement des rapports basés sur une expression de nombre entier

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

dayNumber interne = 3 ;
Jour de chaîne de caractères = « « ;

commutez (dayNumber)
{
affaire 1 : day= " dimanche " ; 
rupture ;
affaire 2 : day= " lundi " ; 
rupture ;
affaire 3 : day= " mardi " ; 
rupture ;
affaire 4 : day= " mercredi " ; 
rupture ;
affaire 5 : day= " jeudi " ; 
rupture ;
affaire 6 : day= " vendredi " ; 
rupture ;
affaire 7 : day= " samedi " ; 
rupture ;
}

Script.out (" est aujourd'hui » + le jour) ;

Exemple : Le rapport de continuer

//rapport de continuer te permet de sauter l'itération actuelle du pour ou tandis que boucle

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

interne maximum = 7 ;

//éclatez d'a pour la boucle
pour (i=1 interne ; i < 10 ; i++) 
{
si (I > 3 et et I < 7) 
{
continuez ;
}
Script.out (" c'est a pour la boucle avec continuent. itération = » + I) ;
}


//continuez et éclatez d'un infini tandis que boucle
boucle interne = 1 ;
tandis que (vrai) 
{
//AVERTISSANT - si vous vous coincez dans une boucle infinie que vous devez RELANCER le moteur/interface utilisateur
//incrément la valeur de la boucle autrement ceci tandis que la boucle n'éclatera jamais ! !
//incrément devrait être fait avant le rapport de continuer
loop++ ;

//éclatent autrement ceci tandis que la boucle ne se terminera jamais ! !
si (boucle > maximum)
{
rupture ;
}

//continuez en fonction à la prochaine itération pour les itérations 1 et 2
si (boucle < 4)
{
continuez ;
}

Script.out (" c'est une boucle de moment avec le contine pour des itérations <. l'itération 3 = » + boucle) ;

//Vous ne pouvez pas avoir l'incrément de boucle après le continuer. 
//! ! boucle ++ ; ! ! la boucle ++ ne devrait pas être ici. Elle devrait être située avant le continuer.
}
Script.out (" éclatent de tandis que la boucle après des boucles > » + maximum) ;

Exemple : Le rapport de rupture

//rapport de rupture te permet d'éclater des boucles. 

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

interne maximum = 7 ;

//éclatez d'a pour la boucle
pour (i=1 interne ; i < 10 ; i++) 
{
//AVERTISSANT - si vous vous coincez dans une boucle infinie que vous devez RELANCER le moteur/interface utilisateur
Script.out (" c'est a pour la boucle. boucle = » + I) ;
si (>= maximum d'I) 
{
rupture ;
}
}

Script.out (" éclatent de pour la boucle après des boucles > » + le maximum) ;

//éclatent d'un infini tandis que la boucle
boucle interne = 1 ;
tandis que (vrai) 
{
//AVERTISSANT - si vous vous coincez dans une boucle infinie que vous devez RELANCER le moteur/interface utilisateur
Script.out (" c'est une boucle de moment. boucle = » + boucle) ;

//incrément la valeur de la boucle autrement ceci tandis que la boucle ne se terminera jamais ! !
loop++ ;

//éclatent autrement ceci tandis que la boucle ne se terminera jamais ! !
si (boucle > maximum)
{
rupture ;
}
}
Script.out (" éclatent de tandis que la boucle après des boucles > » + maximum) ;

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

Section 3 - Chaînes de caractères, nombres et Booleans de nouveau au dessus 

Exemple : Fonctions de classe de chaîne de caractères de Java

//Classe de chaîne de caractères de Java te permet d'obtenir l'information, recherche, manipule, convertit, et sort des chaînes de caractères

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

//définissez une chaîne de caractères
Le streptocoque de chaîne de caractères = « mon prénom est John. Mon dernier nom est daine. » ;

//imprimez-les
Script.out (" la chaîne de caractères d'essai est :  » + streptocoque) ;

//obtenez la longueur de chaîne de caractères
Script.out (" la longueur du streptocoque de chaîne de caractères est :  » + str.length ()) ;

//obtenez le caractère à l'incrément 8
Script.out (" le caractère à l'incrément 9 est :  » + str.charAt (9)) ;

//trouvaille la première occurrence d'un ordre dans la chaîne de caractères et impriment l'incrément
Script.out (" l'ordre « nom » a été trouvé la première fois à l'incrément : » + str.indexOf (" nom »)) ;

//si l'ordre n'est pas trouvé, l'incrément de retour est - 1
//les recherches chaîne de caractères de Java et d'autres exécutions sont cas sensible par défaut
Script.out (" l'ordre « NOM » a été trouvé à l'incrément : » + str.indexOf (" NOM »)) ;

//trouvaille la première occurrence d'un ordre dans la chaîne de caractères, commençant la recherche à l'incrément 15
Script.out (" l'ordre « nom » a été également trouvé à l'incrément : » + str.indexOf (" nom », 15)) ;

//trouvaille la dernière occurrence d'un ordre dans la chaîne de caractères et impriment l'incrément
Script.out (" l'ordre « nom » était dernier trouvé à l'incrément : » + str.lastIndexOf (" nom »)) ;

//contrôle si la chaîne de caractères commence par un certain ordre.
//méthode de startsWith renvoie un booléen rectifient si la chaîne de caractères commence par l'ordre écrit.
si == (de str.startsWith (" mon ») vrai)
{
Script.out (" oui. la chaîne de caractères d'essai commence par le « mon » ») ;
}

//contrôle si la chaîne de caractères termine avec un certain ordre.
//méthode de startsWith renvoie un booléen rectifient si la chaîne de caractères termine avec l'ordre écrit.
si (str.endsWith (" daine. » ) == vrai)
{
Script.out (" oui. les extrémités de chaîne de caractères d'essai avec la « daine. » « ) ;
}

//contrôle si la chaîne de caractères égale une autre chaîne de caractères
La chaîne de caractères anotherString = « mon prénom est John. Mon dernier nom est daine. » ;
Script.out (" anotherString = » + anotherString) ;
si (str.equals (anotherString))
{
Script.out (" oui. la chaîne de caractères deux sont égale ») ;
}

//contrôle si la chaîne de caractères égale une autre chaîne de caractères ignorant le cas
La chaîne de caractères lowerCaseString = « mon prénom est John. mon dernier nom est daine. » ;
Script.out (" lowerCaseString = » + lowerCaseString) ;
si (str.equalsIgnoreCase (lowerCaseString))
{
Script.out (" oui. la chaîne de caractères deux sont égale ignorant le cas ») ;
}

Exemple :  La modification de chaîne de caractères

//Exemples modification de chaîne de caractères

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

//définissez quelques chaînes de caractères
Le streptocoque de chaîne de caractères = « mon prénom est John. Mon dernier nom est daine. » ;
Chaîne de caractères str2 = « j'aime le gâteau. » ;

//copie il dehors
Script.out (" la chaîne de caractères d'essai est :  » + streptocoque) ;

//enchaînez (ajoutez) une autre chaîne de caractères à cette chaîne de caractères
Ficelez str3 = str.concat (str2) ;
Script.out (" enchaînant str2 à str1. Résultat :  » + str3) ;

//substituez la première occurrence d'une chaîne de caractères (ou de la configuration régulière d'expression) avec une autre chaîne de caractères
str3 = str.replaceFirst (" est », « était ») ;
Script.out (" la substitution de la première occurrence de « est » avec « était ». Résultat :  » + str3) ;

//substituez toutes les occurrences d'une chaîne de caractères (ou de configuration régulière d'expression) avec une autre chaîne de caractères
str3 = str.replaceAll (" mon », « sien ») ;
Script.out (" substituant toutes les occurrences de « mon » avec le « sien ». Résultat :  » + str3) ;

//obtenez une sous-chaîne commençant à l'incrément indiqué
str3 = str.substring (8) ;
Script.out (" sous-chaîne commençant à incrément 8 = » + str3) ;

//obtenez une sous-chaîne contenue dans des incréments indiqués
str3 = str.substring (8.30) ;
Script.out (" sous-chaîne commençant à incrément 8 et terminant à incrément 30 = » + str3) ;

//chaîne de caractères de converti à la lettre minuscule
str3 = str.toLowerCase () ;
Script.out (" chaîne de caractères convertissante à la lettre minuscule = » + str3) ;

//chaîne de caractères de converti au haut de casse
str3 = str.toUpperCase () ;
Script.out (" chaîne de caractères convertissante au haut de casse = » + str3) ;

Exemple : nombres de Java

//Types primitifs de nombre de Java incluez interne, long, flotteur, double, short, octet
//Vous aurez besoin la plupart du temps d'interne et de long. Parfois vous pouvez devoir utiliser le flotteur.
//Chacun de ces types primitifs ont les classes de Java qui enroulent autour de elles. 
//Enrouler de nombre entier de classe autour d'interne. Les longs enrouler de classe autour de long.

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

//définissez quelques nombres
interne I = 3 ;
long l = 123456787 ;
flotteur f = 25.45 ;

Nombre entier I = nouveau nombre entier (i) ;
Flotteur F = nouveau flotteur (f) ;
Long L = nouveau long (l) ;

//copie dehors l'interne et le nombre entier
Script.out (" l'I interne est :  » + I) ;
Script.out (" le nombre entier de classe d'emballage est :  » + I. toString ()) ;

//copie dehors le long et long
Script.out (" le long l est :  » + l) ;
Script.out (" la classe d'emballage longue est :  » + L. toString ()) ;

//copie dehors le flotteur et flotteur
Script.out (" le flotteur f est :  » + f) ;
Script.out (" le flotteur de classe d'emballage est :  » + F. toString ()) ;

Exemple : valeurs de chaîne de caractères de converti aux nombres

//Vous devrez fréquemment convertir des valeurs de chaîne de caractères en nombres

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

//définissez quelques chaînes de caractères. 
Ficelez intString = « 25 » ;
Ficelez longString = « 123456789 » ;
Ficelez floatString = « 25.567 » ;

interne I = Integer.valueOf (intString) ;
//copie dehors l'interne
Script.out (" l'I interne est :  » + I) ;

long l = Long.valueOf (longString) ;
//copie dehors le long
Script.out (" le long l est :  » + l) ;

flotteur f = Float.valueOf (floatString) ;
//copie dehors le flotteur
Script.out (" le flotteur f est :  » + f) ;

Exemple : classe de maths de Java

//Classe de maths de Java fournit plus de fonctions de maths, autre que +, -,/ou *

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

//définissez quelques nombres
interne i2 = 3 ;
interne i3 = - 7 ;
long l = 123456787 ;
flotteur f = 25.45 ;
double d2 = 25.34 ;
double d3 = 2.4 ;

//copie dehors le maximum de deux nombres
Script.out (" le maximum entre i2 et i3 est :  » + Math.max (i2, i3)) ;

//copie dehors le minimum de deux nombres
Script.out (" le minimum entre i2 et i3 est :  » + Math.min (i2, i3)) ;

//rond outre du flotteur
Script.out (" 25.45 est arrondis hors fonction :  » + Math.round (f)) ;

//obtenez la valeur d'exp
Script.out (" exp (3) = » + Math.exp (i2)) ;

//obtenez la valeur de logarithme naturel
Script.out (" logarithme naturel (3) = » + Math.log (i2)) ;

//obtenez la valeur de racine carrée
Script.out (" racine carrée de 3 = » + Math.sqrt (i2)) ;

Exemple : La classe booléenne

//Enrouler booléens de classe autour du type primitif de Java booléen
//Booléen primitif peut être « vrai » ou « faux » (le cas sensible)

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

//définissez quelques booleans
trueBoolean booléens = rectifient ;
falseBoolean = faux booléens ;

//converti le booléen à la chaîne de caractères et à la copie dehors le booléen 
Script.out (" trueBoolean est :  » + trueBoolean.toString ()) ;
Script.out (" falseBoolean est :  » + falseBoolean.toString ()) ;

//utilisation la classe booléenne de convertir une chaîne de caractères en booléen
Chaîne de caractères trueString = « vrai » ;
Essai booléen = Boolean.valueOf (trueString) ;
convertedBoolean booléen = test.booleanValue () ;
Script.out (" chaîne de caractères convertissante « vraie » au type booléen ») ;
Script.out (" valeur booléenne convertie = » + convertedBoolean.toString ()) ;

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

Section 4 - Les alignements et remonte au dessus

Exemple : Alignements

//Alignements sera prié fréquemment de traiter la liste et autre de répertoire des utilisations.

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

//déclarez un alignement d'intetger
[] arr interne ; 

//créez l'alignement de nombre entier
arr = nouvel interne [10] ; 

//assignez une valeur à chaque élément d'alignement et imprimez-la
//zone « longueur » renvoie la taille de l'alignement
// 
pour (interne I = 0 ; i < arr.length ; i++) 
{
arr [I] = I * 2 ;
Script.out (" l'élément d'alignement à l'incrément :  » + I + « est :  » + arr [I]) ;
}

//exemple d'utiliser l'alignement de chaîne de caractères
Streptocoque de chaîne de caractères [] = {« on est 1 », « deux est 2 », « trois est 3 »} ;
pour (interne I = 0 ; i < str.length ; i++) 
{
Script.out (" l'élément d'alignement à l'incrément :  » + I + « est :  » + streptocoque [I]) ;
}

//2-D alignements
La chaîne de caractères [] [] nomme =
{
{« facture », « plomb », « betty »},
{« marque », « mat »,},
{« karen », « kitty », « kevin », « kong »,},
} ;

pour (interne I = 0 ; i < names.length ; i++) 
{
Script.out (" début de 1-D subarray des noms. Ligne = » + I) ;
pour (interne j = 0 ; j < noms [I] .length ; j++) 
{
Script.out (noms [I] [j] + « « ) ;
}
Script.out (" fin de 1-D subarray des noms. Ligne = » + I) ;
}

Exemple : vecteurs

Le vecteur//A est un alignement qui peut se développer ou se rétrécir dynamiquement
Le vecteur//A peut contenir n'importe quel type d'objet ou de type primitif de Java

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

//créez un arraylist blanc
Dirigez v = nouveau vecteur () ;

//ajoutez quelques éléments à lui
v. ajoutez (0) ;
v. ajoutez (" première chaîne de caractères ») ;
v. ajoutez (" deuxième chaîne de caractères ») ;
v. additionnez (3) ;
v. ajoutez (la nouvelle date ());

//copie dehors les éléments de vecteur
pour (interne I = 0 ; i < taille de V. () ; i++) 
{
Script.out (" l'élément d'alignement à l'incrément :  » + I + « est :  » + le V. obtiennent (i).toString ()) ;
}

//copie dehors la taille du vecteur
Script.out (" la taille de vecteur est :  » + taille de V. ()) ;

//retirez un élément à l'incrément 3
v. retirez (3) ;

//copie dehors la taille du vecteur encore
Script.out (" élément retiré à incrément 3. La nouvelle taille de vecteur est :  » + taille de V. ()) ;

//élément d'insertion dans l'incrément 3 encore
v. ajoutez (3, « M. Insert ») ;

//d'impression élément 3 dehors
Script.out (" l'élément inséré à l'incrément 3 est :  » + le V. obtiennent (3).toString ()) ;

//recherche le vecteur pour des objets
si (le V. contient (" M. Insert »))
{
Script.out (" oui, ce vecteur « M. Insert » contient élément ») ;
}

//copie dehors l'incrément de « M. Insert »
Script.out (" l'incrément de M. Insert est :  » + indexOf de V. (" M. Insert »)) ;

//clair dehors l'alignement
v. espace libre () ;

//copie dehors la taille du vecteur
Script.out (" le vecteur a effacé. La taille de vecteur est :  » + taille de V. ()) ;

Exemple : Classes de date et de DateFormat

//Classes de date et de DateFormat sont utile dans le formatage, analysant et modifiant des horodateurs de fichier
//Classes de calendrier aidez à exécuter des manipulations et des comparaisons de date.

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

//obtenez la date du jour
Datez maintenant = nouvelle date () ;

//copie dehors la date à l'aide d'un formateur de défaut
Script.out (" le date/heure actuel de format de défaut est :  » + now.toString ()) ;

//créez un formateur fait sur commande de date montrant la date courte et les formats à court terme
//vous devez importer la classe de java.text.DateFormat au dessus de la séquence type
//java.text.DateFormat n'est pas automatiquement importé par la séquence type.
DateFormat DF = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT) ;

//copie dehors la date à l'aide de ce formateur court fait sur commande
Script.out (" le date/heure COURT actuel de format est :  » + df.format (maintenant)) ;

//commutateur le format à à long terme et au temps
DF = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG) ;
Script.out (" à long terme actuel/temps est :  » + df.format (maintenant)) ;

//laisse calculer le temps écoulé en millisecondes
//méthode de getTime () renvoie toutes les millisecondes s'est écoulé puisque le début du temps machine (~1970)
longs startMillis = now.getTime () ;
Script.out (" heure de départ dans les millis :  » + startMillis) ;

//laisse recalculer la date
maintenant = nouvelle date () ;
longs endMillis = now.getTime () ;
Script.out (" temps de fin dans les millis :  » + endMillis) ;

//calculez le temps écoulé dans les millis
désirent ardemment le diff = les endMillis - startMillis ;
Script.out (" elaspsed le temps dans les millis :  » + diff) ;

//nous peut également convertir un moment en millisecondes en date 
Datez l'endDate = nouvelle date (endMillis) ;
Script.out (" temps de fin dans le long format :  » + df.format (endDate)) ;

Exemple : Date d'analyse

//Date d'analyse des chaînes de caractères

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

//Définissez des caractères de datation
Ficelez shortDateString = « 4/11/06 6:53 P.M. » ;
Ficelez longDateString = « 11 avril 2006 6:53 :27 P.M. PDT » ;

//définissez le format de date court
DateFormat DF = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT) ;

//analysez la date courte dedans
Datez le shortDate = le df.parse (shortDateString) ;

//copie dehors la date courte à l'aide d'un formateur de défaut
Script.out (" le shortDate a été analysé correctement. date courte :  » + shortDate.toString ()) ;

//commutateur le formateur au format à long terme
DF = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG) ;

//analysez dans l'à long terme
Datez à long terme = df.parse (longDateString) ;

//copie dehors l'à long terme à l'aide d'un formateur de défaut
Script.out (" à long terme a été analysé correctement. à long terme :  » + longDate.toString ()) ;

Exemple : Classe de calendrier

//Classe de calendrier nous permet de manipuler une date ou de comparer des dates

importation com.hitek.engine.mods.script.Script ;
//classes de date et calendrier d'importation qui sont situées dans le module de java.util
importation java.util.* ; //

//obtenez le calendrier actuel
Classez maintenant = Calendar.getInstance () ;

//copie dehors l'information de calendrier.
Script.out (" le calendrier actuel est :  » + now.toString ()) ;

//converti le calendrier à un objet de date en utilisant la fonction de getTime de calendrier ()
dateNow de date = now.getTime () ;

//copie dehors l'information de date
Script.out (" la date obtenue à partir du calendrier est :  » + dateNow.toString ()) ;

//converti par date à un calendrier en utilisant la fonction de setTime de calendrier (date)
now.setTime (dateNow) ;

//copie dehors l'information de calendrier encore
Script.out (" le calendrier obtenu à partir de la date est :  » + now.toString ()) ;

//obtenez les différentes zones du calendrier
Script.out (" l'année est :  » + now.get (Calendar.YEAR)) ;
Script.out (" le mois est :  » + now.get (Calendar.MONTH)) ;
Script.out (" la date est :  » + now.get (Calendar.DATE)) ;
Script.out (" l'heure (0-12) est :  » + now.get (Calendar.HOUR)) ;
Script.out (" l'heure du jour (0-23) est :  » + now.get (Calendar.HOUR_OF_DAY)) ;
Script.out (" la minute est :  » + now.get (Calendar.MINUTE)) ;
Script.out (" la seconde est :  » + now.get (Calendar.SECOND)) ;
Script.out (" la milliseconde est :  » + now.get (Calendar.MILLISECOND)) ;
Script.out (" la valeur d'AM/P.M. est :  » + now.get (Calendar.AM_PM)) ;

Script.out (" le jour de la semaine est :  » + now.get (Calendar.DAY_OF_WEEK)) ;
Script.out (" la semaine du mois est :  » + now.get (Calendar.WEEK_OF_MONTH)) ;
Script.out (" le jour de l'année est :  » + now.get (Calendar.DAY_OF_YEAR)) ;
Script.out (" le jour de la semaine en mois est :  » + now.get (Calendar.DAY_OF_WEEK_IN_MONTH)) ;
Script.out (" le jour du mois est :  » + now.get (Calendar.DAY_OF_MONTH)) ;
Script.out (" la semaine de l'année est :  » + now.get (Calendar.DAY_OF_YEAR)) ;

//ajoutez quelques zones maintenant au calendrier. Ajouter automatiquement roule au-dessus des zones plus grandes pour toi
Calendrier hier = Calendar.getInstance () ;
yesterday.add (Calendar.DATE, - 1) ;

Calendrier demain = Calendar.getInstance () ;
tomorrow.add (Calendar.DATE, 1) ;

//copie dehors les dates correspondant à ces calendriers. Le premier converti objecte jusqu'ici avant l'impression
Script.out (" était hier :  » + yesterday.getTime () .toString ()) ;
Script.out (" est demain :  » + tomorrow.getTime () .toString ()) ;

//comparez hier et en utilisant demain le calendrier après et avant des méthodes
si (yesterday.before (demain))
{
Script.out (" oui, ont lieu hier avant demain ») ;
}

si (tomorrow.after (hier))
{
Script.out (" oui, ont lieu demain après hier ») ;
}

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

Section 5 - Fichier et répertoire de nouveau au dessus

Exemple : l'information de répertoire et de fichier 

//Dans l'information de Java, de répertoire et de fichier est obtenu à partir de la classe de fichier de Java

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

//obtenez au défaut Java le répertoire provisoire
Ficelez le tmpdir = le System.getProperty (" java.io.tmpdir ») ;

//copie dehors le nom de répertoire
Script.out (" la chemise de la température de Java de défaut est :  » + tmpdir) ;

//créez un nouvel objet de fichier du répertoire
Classez le dir = nouveau fichier (tmpdir) ;

//créez un nouvel objet de fichier
Classez le fichier newFile = nouveau (dir, « newFile.txt ») ;

//créez le nouveau fichier
succès booléen = newFile.createNewFile () ;

//copie dehors classent l'information
si (== de succès vrai)
{
Script.out (" nouveau fichier créé ») ;
}
autrement
{
Script.out (" n'est pas créé le fichier ou le fichier existe déjà ») ;
}

//vérifiez que la voie d'accès de fichier existe et est un fichier
si (newFile.exists () et et newFile.isFile ())
{
Script.out (" le fichier existe et est un fichier ») ;
}
autrement
{
Script.out (" le fichier pas existe, ou n'est pas un fichier ») ;
retour ; //aucun point continuant s'il n'y a aucun fichier
}

//copie dehors l'information de fichiers
Script.out (" nom de fichier = » + newFile.getName ()) ;
Script.out (" volume de fichier = » + newFile.length ()) ;
Script.out (" voie d'accès de fichier = » + newFile.getPath ()) ;
Script.out (" voie d'accès absolue de fichier = » + newFile.getAbsolutePath ()) ;
Script.out (" voie d'accès canonique de fichier = » + newFile.getCanonicalPath ()) ;
Script.out (" répertoire de fichiers = » + newFile.getParent ()) ;
Script.out (" le fichier est lisible = » + newFile.canRead ()) ;
Script.out (" le fichier est writeable = » + newFile.canWrite ()) ;
Script.out (" le fichier est caché = » + newFile.isHidden ()) ;
DateFormat DF = DateFormat.getDateTimeInstance () ;
long modtime = newFile.lastModified () ;
Date modèle = nouvelle date (modtime) ;
Script.out (" date de fichier = » + df.format (modèle)) ;

Exemple : méthodes de fichier

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

//obtenez au défaut Java le répertoire provisoire
Ficelez le tmpdir = le System.getProperty (" java.io.tmpdir ») ;

//copie dehors le nom de répertoire
Script.out (" la chemise de la température de Java de défaut est :  » + tmpdir) ;

//créez un nouvel objet de fichier du répertoire
Classez le dir = nouveau fichier (tmpdir) ;

//créez un nouvel objet de fichier
Classez file1 = nouveau fichier (dir, « file1.txt ») ;
Classez file2 = nouveau fichier (dir, « file2.txt ») ;

//créez le nouveau fichier 1
file1.createNewFile () ;

//vérifiez que newfile1 existe et est un fichier
si (file1.exists () et et file1.isFile ())
{
Script.out (" file1 existe ») ;
}
autrement
{
Script.out (" file1 pas existe, ou n'est pas un fichier ») ;
retour ; //aucun point continuant s'il n'y a aucun fichier
}

//renommez le fichier
succès booléen = file1.renameTo (file2) ;

si (== de succès vrai)
{
Script.out (" renommez de file1 à file2 étaient réussis ») ;
}
//confirmez que newFile1 n'existe pas
si (!file1.exists ())
{
Script.out (" file1 pas existe, parce qu'il a été renommé ») ;
}

//effacement newFile2
succès = file2.delete () ;
si (== de succès vrai)
{
Script.out (" l'effacement file2 était réussi ») ;
}

Exemple :  lecture/écriture de fichier

//lecture/écriture de fichier

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

//obtenez au défaut Java le répertoire provisoire
Ficelez le tmpdir = le System.getProperty (" java.io.tmpdir ») ;

//copie dehors le nom de répertoire
Script.out (" la chemise de la température de Java de défaut est :  » + tmpdir) ;

//créez un nouvel objet de fichier du répertoire
Classez le dir = nouveau fichier (tmpdir) ;

//créez un nouvel objet de fichier
Classez file1 = nouveau fichier (dir, « file1.txt ») ;

//créez FileWriter pour écrire à file1, le faux est de recouvrir le fichier, vrai est d'ajouter à l'extrémité du fichier existant
FileWriter FW = nouveau FileWriter (file1, faux) ;
Bw de BufferedWriter = nouveau BufferedWriter (FW) ;
pour (interne I = 0 ; i < 10 ; i++)
{
bw.write (" c'est ligne » + I) ;
//écrivez une nouvelle ligne caractère
bw.newLine () ;
}
bw.close () ;

//créez un lecteur pour lire dedans le fichier entier et pour l'imprimer pour sortir le logarithme naturel
FileReader franc = nouveau FileReader (file1) ;
Br de BufferedReader = nouveau BufferedReader (franc) ;
Ligne = "" de chaîne de caractères ; 
tandis que ((ligne = br.readLine ()) != nulle)
{
Script.out (ligne) ;
}
br.close () ;

Exemple : méthodes de répertoire

//Dans l'information de Java, de répertoire et de fichier est obtenu à partir de la classe de fichier de Java

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

//obtenez au défaut Java le répertoire provisoire
Ficelez le tmpdir = le System.getProperty (" java.io.tmpdir ») ;

//copie dehors le nom de répertoire
Script.out (" la chemise de la température de Java de défaut est :  » + tmpdir) ;

//créez un nouvel objet de fichier du répertoire
Classez le dir = nouveau fichier (tmpdir) ;

//confirmez que cette voie d'accès existe sur votre système
si (dir.exists ())
{
Script.out (" oui, cette voie d'accès existe ») ;
}

//confirmez que c'est un répertoire valide sur votre système
si (dir.isDirectory ())
{
Script.out (" oui, c'est un répertoire valide ») ;
}

//obtenez la voie d'accès
Script.out (" la voie d'accès est :  » + dir.getPath ());

//obtenez la voie d'accès absolue
Script.out (" la voie d'accès absolue est :  » + dir.getAbsolutePath ());

//obtenez le répertoire de parent
Classez le parent = le dir.getParentFile () ;
Script.out (" la voie d'accès de parent est :  » + parent.getAbsolutePath ());

Exemple : l'information de répertoire

//Dans l'information de Java, de répertoire et de fichier est obtenu à partir de la classe de fichier de Java

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

//obtenez au défaut Java le répertoire provisoire
Ficelez le tmpdir = le System.getProperty (" java.io.tmpdir ») ;

//copie dehors le nom de répertoire
Script.out (" la chemise de la température de Java de défaut est :  » + tmpdir) ;

//créez un nouvel objet de fichier du répertoire
Classez le dir = nouveau fichier (tmpdir) ;

//obtenez la liste de noms de fichier dans le dir
Ficelez [] nomme = dir.list () ;

//copie dehors les 100 premiers noms de tous fichiers dans votre dir de la température
interne maximum = names.length ;
si (maximum > 100)
{
maximum = 100 ;
}

pour (i=0 interne ; i < maximum ; i++)
{
Script.out (" fichier » + I + « = » + noms [I]) ;
}

//obtenez un choix d'objets de fichier 
Classez [] classe = dir.listFiles () ;

//copie dehors l'information pour les 100 premiers fichiers. 
Nom = "" de chaîne de caractères ;
longue taille = 0 ;
La date a modifié ;

//obtenez le formateur de date time de défaut
DateFormat DF = DateFormat.getDateTimeInstance () ;
Chaîne de caractères modèle = "" ;

pour (i=0 interne ; i < maximum ; i++)
{
Nom de chaîne de caractères = fichiers [I] .getName () ;
la taille = classe [I] .length () ;
modifié = nouvelle date (fichiers [I] .lastModified ());
modèle = df.format (modifié) ;
Script.out (" fichier » + I + « = » + nom + « , taille = » + taille + « , horodateur = » + modèle) ;
}

Exemple : faites les chemises

//exemple pour faire des chemises 

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

//obtenez au défaut Java le répertoire provisoire
Ficelez le tmpdir = le System.getProperty (" java.io.tmpdir ») ;

//copie dehors le nom de répertoire
Script.out (" la chemise de la température de Java de défaut est :  » + tmpdir) ;

//créez un nouvel objet de fichier du répertoire
Classez le dir = nouveau fichier (tmpdir) ;

//créez un objet de fichier représentant un nouveau subfolder dans le tmpdir
Classez le newdir = nouveau fichier (dir, « newDirectory2 ») ;

//contrôle si la chemise existe
booléen existe = newdir.exists () ;
si (existe le == vrai)
{
Script.out (" la chemise existe déjà :  » + newdir.getAbsolutePath ()) ;
retour ; //aucun besoin de créer le subfolder
}

//faites un nouveau sous-répertoire. la méthode renvoie vrai si elle réussit
//retours faux si la chemise existe déjà, ou ne pourrait pas créer la chemise
succès booléen = newdir.mkdir () ;
si (== de succès vrai)
{
Script.out (" nouvelle chemise créée :  » + newdir.getAbsolutePath ()) ;
}

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

Section 6 - Méthodes de nouveau au dessus

Exemple : utilisation des méthodes

//vous pouvez définir des méthodes pour réutiliser le code en vos séquences type
//toutes les méthodes DOIT être défini avant qu'on exécute la séquence type principale

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

//cette méthode sort simplement le message de chaîne de caractères au logarithme naturel de sortie
vide dehors (message de chaîne de caractères)
{
Script.out (message) ;
}

//cette méthode obtient la place d'un nombre
place interne (entrée interne)
{
entrée de retour * entrée ;
}

//méthode principale commence maintenant
//essai les méthodes ci-dessus
dehors (" c'est un essai d'utiliser des méthodes en séquences type ») ;
fiveSquare = place internes (5) ;
dehors (" la place cinq est » + fiveSquare) ;

Exemple : méthodes de hitek

//nous fournissez quelques méthodes qui te permettent d'exécuter chargent, des données de logarithme naturel, obtiennent et placent des variables et chargent des paramètres.

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

//écrivez une chaîne de caractères au logarithme naturel de sortie
Script.out (" écriture au logarithme naturel de sortie ») ;

//écrivez une chaîne de caractères au fichier de journalisation d'activité
Script.act (" écriture au fichier de journalisation d'activité ») ;

//écrivez une trace de pile d'erreur au logarithme naturel de mise au point
essai
{
Integer.parseInt (" mauvais nombre entier ») ;
}
crochet (exception e)
{
Script.err (e) ;
}

//exécutez un charger et obtenez le code de sortie
//assurez-vous que vous entrer dans un valide chargez le titre ici
Ficelez le taskTitle = « Enter_valid_task_title_here » ;
taskTitle = « copy » ;
exitCode interne = Script.run (taskTitle) ;
Script.out (" le code de sortie de chargent = » + exitCode) ;

//obtenez un paramter de charger. Vous devez écrire la clé correcte de taskTitle et de paramètre
//regard aux fichiers de propriété du charge dans les données \ charge la chemise.
//ces fichiers montrez les clés de paramètre de Task.PARAMETERS0 à Task.PARAMETERS50

//lisez Task.PARAMETERS1
Ficelez le pair = le Script.getPar (taskTitle, « Task.PARAMETERS1 ») ;
Script.out (" Task.PARAMETERS1 = » + pair) ;

//positionnement un paramètre de charger dynamiquement
Script.setPar (taskTitle, « Task.PARAMETERS1 », « nouvelle valeur d'essai ») ;

//encore l'a donnée lecture pour confirmer que des changements ont été faits
pair = Script.getPar (taskTitle, « Task.PARAMETERS1 ») ;
Script.out (" Task.PARAMETERS1 = » + pair) ;

//vous pouvez obtenir tout chargez, utilisateur, Java, et valeurs de variable de système
//vous pouvez placer des valeurs de variable d'utilisateur. Nous ne laissons pas des valeurs variables chargeons, de Java ou de système à recouvrir.
Chaîne de caractères distributeur intégrant son logiciel au matériel = taskTitle + « : :ExitCode » ;
Valeur de chaîne de caractères = Script.getVar (distributeur intégrant son logiciel au matériel) ;
Script.out (" valeur variable = » + valeur) ;

//positionnement une valeur de variable d'utilisateur
Script.setVar (" newVariable », « variable testant ») ;
valeur = Script.getVar (" newVariable ») ;
Script.out (" nouvelle valeur variable = » + valeur) ;

Section 1 - Fondations
Section 2 - Ordres de contrôle
Section 3 - Chaînes de caractères, nombres et Booleans
Section 4 - Alignements et dates
Section 5 - Fichier et répertoire
Section 6 - Méthodes