• Bedienungsfreundlich: keine Programmierung oder scripting benötigt, grafische Schnittstelle
• Scriptingmerkmale sind für Benutzer mit Vorkenntnissen und Programmierer vorhanden
• Leistungsfähig, vielseitig begabt, zuverlässig und erschwinglich
• Lassen Sie Tausenden task ein Tag laufen
• Fristgerechter und freer technischer Support, vorher und nachher, das Sie kaufen
• Freer 30 Tagesversuch und frees geringes Aufsteigen
• Durchläufe auf window, Mac OSX, Linux und anderen Unix Plattformen

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

Scripting (Automize professional und Automize Unternehmen-Ausgaben)

• Erstellen Sie komplizierte Automatisierung script, die nach existierenden Automize task aufbauen
• Entwickeln Sie script, die die wiederholten verringern, mühsamen computer-related Aktivitäten.
• Fügen Sie hoch entwickelte Funktionalität Ihren Automize task wie email, FTP, Monitoren, Datei und Verzeichnislisten hinzu.
• Benutzen Sie die script-Funktion, um Dateilisten oder -dateinamen zu erhalten, die Sie im Exemplar, in FTP, in den ziptask ETC… benutzen können.
• Sie können den Wert der taskparameter vom script lesen und einstellen. Lassen Sie dann das task vom script laufen. Dieses verringert die Kompliziertheit des script.
• Gerade 20-50 Zeilen Kode können resultieren ist extrem leistungsfähige kundenspezifische task und Lösungen.
• Wir stellen free Hilfe für kleine 20-50 Zeilen script zur Verfügung, die zu den Benutzern verwendbar sein können.
• Der eingehende Tutorial- und Beispielcode, zum Sie zu erhalten begann.
• Unser Onlineforum hat viele tatsächliche Kodebeispiele, die auf Anwendungen des wirklichen Benutzers basieren.

Beispiel-script:
1) Script liest Dateiliste vom Dateisystem
2) Script stellt taskparameter basiert auf Dateinamen und Heft ein
3) Script lässt task laufen. Task läuft Lesetask-Parametergruppe über script nach.
4) Script liest taskausgang Kode und taskvariablen
5) Script kann task, in der gleichen Reihenfolge 2-4 für alle Dateinamen laufen zu lassen fortfahren

-----------------------------------------------------------------------------------------------------------------------------------------------
Automize Java scriptingTutorial

Automize verwendet BeanShell (beanshell.org) für sein scripting.  BeanShell unterstützt Java Syntax 100%, und Automize selbst wird in Java geschrieben.  Dieses ist eine große Methode, Java Syntax zu erlernen und begonnen auf der einfachsten und bedeutendsten modernen Programmiersprache zu erhalten.

In diesen Tutorial, in Exemplar durch folgen und diese Beispiele in das Automize script-window kleben. Lassen Sie dann diese Beispiele laufen:

Kapitel 1 - Grundlagen
Kapitel 2 - Steueranweisungen
Kapitel 3 - Zeichenketten, Zahlen und Booleans
Kapitel 4 - Reihen und Daten
Kapitel 5 - Datei und Verzeichnis
Kapitel 6 - Methoden

Kapitel 1 - Grundlagen

Beispiel: Einleitendes script

//Zeilen beginnend mit//Ar Kommentarzeilen

//Die meisten Programmiersprachen (c, Java, c++, benötigen ETC… eine Haupt () Methode)
//Jedoch, brauchen Sie nicht, eine Haupt () Methode zu definieren während scripting

//definieren Sie eine Zeichenkette
Reihen Sie Test = „Willkommen zum Java scripting! auf!“;

//schreiben Sie zum System stdout
System.out.println (Test);

Beispiel: Verwenden der scriptkategorie

//Die scriptkategorie stellt einen Anschluss zwischen Ihren script und inbuilt Funktionen der Hitek Software zur Verfügung

//erlauben Importanweisungen Ihnen, vorhandene Hitek Software oder Java Funktionen zu verwenden
//In diesem Beispiel, importieren wir die Hitek Software-scriptkategorie

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

//definieren Sie eine Zeichenkette

Reihen Sie Test = „Willkommen zum Java scripting! auf!“;

//Aufruf die Script.out Methode, zum der Ausgabe zur Ausgabeprotokolldatei zu schreiben

Script.out (Test);

//, nachdem Sie laufen,/dieses script Test, überprüfen die Ausgabeprotokolldatei (Protokollmenü in der Automize Benutzerschnittstelle)

Beispiel: Ganzzahlen und Zeichenketten

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

//Ganzzahlen - Sie häufig verwenden internes oder sehnen sich in Ihren script
internes largestInteger = Integer.MAX_VALUE;
langes largestLong = Long.MAX_VALUE;

//Boolesch - Sie müssen auch Boolesches verwenden 
Boolesche javaRocks = zutreffend;

//Zeichenkette - Sie werden Zeichenketten viel benutzen
Die Zeichenkette, die = „Java Zeichenketten testString ist, sind sehr nützlich“;

Script.out („maximaler Ganzzahl Wert =“ + largestInteger);
Script.out („maximaler langer Wert =“ + largestLong);
Script.out („Wert von javaRocks =“ + javaRocks);
Script.out (testString);

//überprüfung das Ausgabeprotokoll nach Ihnen lassen dieses script laufen.

Beispiel: Dieses Beispiel zeigt Ausdrücken, welches Arbeit mit Ganzzahlen.  Überprüfen Sie das Ausgabeprotokoll, nachdem Sie dieses script laufen lassen.

importieren Sie com.hitek.engine.mods.script.Script;

internes m = 10;
internes k = 5;

Script.out („variable Werte…“);
Script.out („m =“ + m);
Script.out („k =“ + k);

//den Stufensprungbediener ++ verwendend
m++;
Script.out („mit m++, neuer Wert erhöht von m =“ + m);

//verwendend > (grösser als) < (kleiner als)
wenn (m > k)
{
Script.out („ja,“ ist +m + „grösser als“ + k);
}

//das >= (grösser als oder Gleichgestelltes) und <= verwendend (weniger als oder Gleichgestelltes) 
wenn (m >= k +5)
{
Script.out („ja, ist m grösser als oder Gleichgestelltes zu k + 5“);
}

//das Gleichheitsoperator == verwendend
wenn (k==5)
{
Script.out („ja, ist k bis 5“ gleich);
}

//den nicht Gleichgestelltbediener verwendend!=
wenn (k!= 5)
{
Script.out („ja, ist k nicht bis 5“ gleich);
}

//Verwenden u. u. (logisch UND)
wenn ((k == 5) u. u. (m==10))
{
Script.out („ja, ist k bis 5 gleich, und m ist bis 10“ gleich);
}

//Verwenden || (logisch ODER)
wenn ((k == 5) || (m==234545))
{
Script.out („ja, entweder k ist bis 5 gleich, oder m ist bis 10“ gleich);
}

//überprüfung das Ausgabeprotokoll nach Ihnen lassen dieses script laufen.

Beispiel: Dieses Beispiel zeigt grundlegende Ganzzahl manipulierenbediener

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

//dieses Beispiel zeigt grundlegende Ganzzahl manipulierenbediener
//überprüfung das Ausgabeprotokoll nach Ihnen lassen dieses script laufen.

internes i = 10;
internes k = 5;

Script.out („variable Werte…“);
Script.out („i =“ + i);
Script.out („k =“ + k);

//Zahlen hinzufügend
Script.out („hinzufügend…“);
Script.out („i + k =“ + (i + k));

//Zahlen subtrahierend
Script.out („subtrahierend…“);
Script.out („i - k =“ + (i - k));

//Zahlen multiplizierend
Script.out („multiplizierend…“);
Script.out („i * k =“ + (i * k));

//Zahlen teilend
Script.out („teilend…“);
Script.out („i/k =“ + (i/k));

//überprüfung das Ausgabeprotokoll nach Ihnen lassen dieses script laufen.

Kapitel 2 - Steueranweisungen zurück zu Oberseite

Beispiel: wenn Anweisungen

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

interne Temperatur = 100;
Zeichenkettewetter = „Kälte“;

//Einfachstes Formular von, wenn Anweisung: 
wenn (Temperatur > 80) 
{
Wetter = „heiß“;
}
Script.out („das Wetter ist heute“ + Wetter);

//(wenn + sonst) Anweisungen
Temperatur = 60;
wenn (Temperatur > 80)
{
Wetter = „heiß“;
}
sonst
{
Wetter = „schön“;
}
Script.out („das Wetter ist heute“ + Wetter);

//(wenn + (sonst wenn) + sonst) Anweisungen

Temperatur = 75;
wenn (Temperatur < 70)
{
Wetter = „gut“;
}
sonst, wenn (Temperatur >= 70 u. u. Temperatur <= 80)
{
Wetter = „vervollkommnen“;
}
sonst
{
Wetter = „heiß“;
}
Script.out („das Wetter ist heute“ + Wetter);


//überprüfung das Ausgabeprotokoll nach Ihnen lassen dieses script laufen.

Beispiel: Verwenden „für“ Schleifen

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

//definieren Sie eine Ganzzahl und eine leere Zeichenkette
interne Summe = 0;
Zeichenketteresultat = "";

//Gebrauch „für“ Schleife zwischen 1 und 10, Stufensprungsumme durch 1. 
//++ Bediener erhöhend
//<= ist kleiner als oder Gleichgestelltes zu

für (interner Strom = 1; aktuelles <= 10; current++) 
{
Summe = Summe + Strom;
Resultat = „TTY-Schnittstelle Zahl =“ + Strom + „, Summe =“ + Summe;
Script.out (Resultat);
}

//, nachdem Sie laufen,/dieses script Test, überprüfen das Ausgabeprotokoll.

Beispiel: während Schleifen

//, während Anweisung fortwährend einen Block von Anweisungen durchführt, während eine Bedingung erfüllt ist
//, während Schleife den Ausdruck an der Oberseite der Schleife auswertet

//SEIEN SIE SEHR CAREFULL MIT WÄHREND SCHLEIFEN. 
//Überprüfen Sie, ob Sie einen Wert erhöhen, um die Schleife an etwas Punkt zu beenden.

importieren Sie com.hitek.engine.mods.script.Script;

interne Schleife = 1;
internes Maximum = 7;

während (Schleife < Maximum) 
{
//WARNEND - wenn Sie in einer endlosen Schleife gehaftet erhalten, die Sie die Maschine/die Benutzerschnittstelle WIEDERBEGINNEN müssen
Script.out („dieses ist eine Weileschleife. Schleife =“ + Schleife);

//Stufensprung der Wert der Schleife anders dieses, während Schleife nie! abbricht!
loop++;
}

//, -während Schleife den Ausdruck an der Unterseite auswertet

//zurückgesetzter Schleife Wert bis 1
Schleife = 1; 
 
{
//WARNEND - wenn Sie in einer endlosen Schleife gehaftet erhalten, die Sie die Maschine/die Benutzerschnittstelle WIEDERBEGINNEN müssen
Script.out („dieses ist -während Schleife. Schleife =“ + Schleife);

//Stufensprung der Wert der Schleife anders dieses, -während Schleife nie! abbricht!
loop++;
}
während (Schleife < Maximum);

Beispiel:  Die Schalteranweisung 

//die Schalteranweisung führt bedingt die Anweisungen durch, die auf einem Ganzzahl Ausdruck basieren

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

internes dayNumber = 3;
Zeichenkettetag = „„;

schalten Sie (dayNumber)
{
Fall 1: day= " Sonntag "; 
Bruch;
Fall 2: day= " Montag "; 
Bruch;
Fall 3: day= " Dienstag "; 
Bruch;
Fall 4: day= " Mittwoch "; 
Bruch;
Fall 5: day= " Donnerstag "; 
Bruch;
Fall 6: day= " Freitag "; 
Bruch;
Fall 7: day= " Samstag "; 
Bruch;
}

Script.out („heute“ + ist Tag);

Beispiel: Die fortfahrenanweisung

//die fortfahrenanweisung erlaubt Ihnen, die aktuelle Iteration von für zu überspringen oder während Schleife

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

internes Maximum = 7;

//brechen Sie von a für Schleife aus
für (internes i=1; I < 10; i++) 
{
wenn (i > 3 u. u. i < 7) 
{
fahren Sie fort;
}
Script.out („dieses ist a für Schleife mit fortfahren. Iteration =“ + i);
}


//fahren Sie fort und brechen Sie von einem endlosen während Schleife aus
interne Schleife = 1;
während (zutreffend) 
{
//WARNEND - wenn Sie in einer endlosen Schleife gehaftet erhalten, die Sie die Maschine/die Benutzerschnittstelle WIEDERBEGINNEN müssen
//Stufensprung der Wert der Schleife anders dieses, während Schleife nie! ausbricht!
//die Stufensprung sollte vor der fortfahrenanweisung getan werden
loop++;

//sonst brechen dieses aus, während Schleife nie! abbricht!
wenn (Schleife > Maximum)
{
Bruch;
}

//fahren Sie an zur Folgenden Iteration für Iterationen 1 und 2 fort
wenn (Schleife < 4)
{
fahren Sie fort;
}

Script.out („dieses ist eine Weileschleife mit contine für Iterationen < 3. Iteration =“ + Schleife);

//Können Sie nicht die Schleife Stufensprung nach fortfahren haben. 
//!! Schleife ++; !! Schleife ++ sollte nicht hier sein. Sie sollte vor fortfahren sich befinden.
}
Script.out („von während brechen Schleife nach Schleifen >“ + Maximum aus);

Beispiel: Die Bruchanweisung

//die Bruchanweisung erlaubt Ihnen, von den Schleifen auszubrechen. 

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

internes Maximum = 7;

//brechen Sie von a für Schleife aus
für (internes i=1; I < 10; i++) 
{
//WARNEND - wenn Sie in einer endlosen Schleife gehaftet erhalten, die Sie die Maschine/die Benutzerschnittstelle WIEDERBEGINNEN müssen
Script.out („dieses ist a für Schleife. Schleife =“ + i);
wenn (i >= Maximum) 
{
Bruch;
}
}

Script.out („für von der Schleife nach Schleifen >“ + brechen Maximum aus);

//von einem endlosen während brechen Schleife aus
interne Schleife = 1;
während (zutreffend) 
{
//WARNEND - wenn Sie in einer endlosen Schleife gehaftet erhalten, die Sie die Maschine/die Benutzerschnittstelle WIEDERBEGINNEN müssen
Script.out („dieses ist eine Weileschleife. Schleife =“ + Schleife);

//Stufensprung der Wert der Schleife anders dieses, während Schleife nie! abbricht!
loop++;

//sonst brechen dieses aus, während Schleife nie! abbricht!
wenn (Schleife > Maximum)
{
Bruch;
}
}
Script.out („von während brechen Schleife nach Schleifen >“ + Maximum aus);

Kapitel 3 - Zeichenketten, Zahlen und Booleans zurück zu Oberseite 

Beispiel: Java Zeichenkette-Kategorie Funktionen

//Die Java Zeichenkettekategorie erlaubt Ihnen, Informationen, Suche zu erhalten, manipuliert, wandelt um und gibt Zeichenketten aus

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

//definieren Sie eine Zeichenkette
Zeichenkette mein Vorname des str = „ist John. Mein Letzter Name ist Damhirschkuh.“;

//drucken Sie sie aus
Script.out („die Test Zeichenkette ist: “ + str);

//erhalten Sie Zeichenkettelänge
Script.out („die Länge des Zeichenkettestr ist: “ + str.length ());

//erhalten Sie Zeichen an Index 8
Script.out („das Zeichen an Index 9 ist: “ + str.charAt (9));

//Entdeckung das Erste Auftreten einer Reihenfolge in der Zeichenkette und drucken den Index
Script.out („die Reihenfolge „Name“ wurde zuerst am Index gefunden:“ + str.indexOf („Name“));

//, wenn die Reihenfolge nicht gefunden wird, der Rückholindex ist - 1
//sind Java Suchen nach einer Zeichenfolge und andere Operationen der Fall, der durch Rückstellung empfindlich ist
Script.out („die Reihenfolge „NAME“ wurde am Index gefunden:“ + str.indexOf („NAME“));

//Entdeckung das Erste Auftreten einer Reihenfolge in der Zeichenkette, die Suche an Index 15 anfangend
Script.out („die Reihenfolge „Name“ wurde auch am Index gefunden:“ + str.indexOf („Name“, 15));

//Entdeckung das Letzte Auftreten einer Reihenfolge in der Zeichenkette und drucken den Index
Script.out („die Reihenfolge „Name“ war gefunden am Index Letztes:“ + str.lastIndexOf („Name“));

//überprüfung, wenn die Zeichenkette mit einer bestimmten Reihenfolge beginnt.
//bringt startsWith Methode ein Boolesches ausrichten zurück, wenn die Zeichenkette mit der eingetragenen Reihenfolge beginnt.
wenn (str.startsWith („mein“) == zutreffend)
{
Script.out („ja. die Test Zeichenkette beginnt mit „meinem““);
}

//überprüfung, wenn die Zeichenkette mit einer bestimmten Reihenfolge beendet.
//bringt startsWith Methode ein Boolesches ausrichten zurück, wenn die Zeichenkette mit der eingetragenen Reihenfolge beendet.
wenn (str.endsWith („Damhirschkuh.“ ) == zutreffend)
{
Script.out („ja. die Test Zeichenketteenden mit „Damhirschkuh.“ „);
}

//überprüfung, wenn die Zeichenkette einer anderen Zeichenkette entspricht
Die Zeichenkette, die = „mein Vorname anotherString ist, ist John. Mein Letzter Name ist Damhirschkuh.“;
Script.out („anotherString =“ + anotherString);
wenn (str.equals (anotherString))
{
Script.out („ja. die Zeichenkette zwei sind“ gleich);
}

//überprüfung, wenn die Zeichenkette einer anderen Zeichenkette entspricht, die Fall ignoriert
Die Zeichenkette, die = „mein Vorname lowerCaseString ist, ist John. mein Letzter Name ist Damhirschkuh.“;
Script.out („lowerCaseString =“ + lowerCaseString);
wenn (str.equalsIgnoreCase (lowerCaseString))
{
Script.out („ja. die Zeichenkette zwei sind gleich, Fall ignorierend“);
}

Beispiel:  Zeichenkettehandhabung

//Zeichenkettehandhabung Beispiele

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

//definieren Sie etwas Zeichenketten
Zeichenkette mein Vorname des str = „ist John. Mein Letzter Name ist Damhirschkuh.“;
Zeichenkette str2 = „ich mag Kuchen.“;

//Druck es heraus
Script.out („die Test Zeichenkette ist: “ + str);

//verketten Sie (fügen Sie) hinzu, eine andere Zeichenkette zu dieser Zeichenkette
Reihen Sie str3 = str.concat auf (str2);
Script.out („, str2 zu str1 verkettend. Resultat: “ + str3);

//ersetzen Sie das Erste Auftreten einer Zeichenkette (oder des regelmäßigen Ausdruck Musters) mit einer anderen Zeichenkette
str3 = str.replaceFirst („ist“, „war“);
Script.out („Erstes Auftreten von zu ersetzen „ist“ mit „war“. Resultat: “ + str3);

//ersetzen Sie alles Auftreten einer Zeichenkette (oder des regelmäßigen Ausdruck Musters) mit einer anderen Zeichenkette
str3 = str.replaceAll („mein“, „seins“);
Script.out („, alles Auftreten von „meinem“ mit „seinem“ ersetzend. Resultat: “ + str3);

//erhalten Sie eine Teilkette, die an spezifiziertem Index anfängt
str3 = str.substring (8);
Script.out („Teilkette, die an Index 8 =“ + str3 anfängt);

//erhalten Sie eine Teilkette enthalten innerhalb der spezifizierten Indexe
str3 = str.substring (8.30);
Script.out („Teilkette, die an Index 8 anfängt und an Index 30 =“ + str3 beendet);

//Bekehrter Zeichenkette zur Kleinschreibung
str3 = str.toLowerCase ();
Script.out („umwandelnde Zeichenkette zu Klein=“ + str3);

//Bekehrter Zeichenkette zu den Versalien
str3 = str.toUpperCase ();
Script.out („umwandelnde Zeichenkette zu Versalien=“ + str3);

Beispiel: Java Zahlen

//Die ursprünglichen Typen der Java Zahl enthalten Sie internes, lang, Hin- und Herbewegung, Doppeltes, Kurzschluss, Byte
//Benötigen Sie meistens internes und langes. Manchmal können Sie Hin- und Herbewegung benutzen müssen.
//Jedes dieser ursprünglichen Typen haben Java Kategorien, die um sie aufwickeln. 
//Die Kategorie Ganzzahl Verpackungen um internes. Die Kategorie langen Verpackungen um langes.

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

//definieren Sie einige Zahlen
internes i = 3;
langes L = 123456787;
Hin- und Herbewegung f = 25.45;

Ganzzahl I = neue Ganzzahl (i);
Hin- und Herbewegung F = neue Hin- und Herbewegung (f);
Langes L = neues langes (L);

//Druck heraus das interne und die Ganzzahl
Script.out („das interne i ist: “ + i);
Script.out („die Verpackung Kategorie Ganzzahl ist: “ + toString I. ());

//Druck heraus das lange und das lang
Script.out („das lange L ist: “ + L);
Script.out („die lange Verpackung Kategorie ist: “ + toString L. ());

//Druck heraus die Hin- und Herbewegung und Hin- und Herbewegung
Script.out („die Hin- und Herbewegung f ist: “ + f);
Script.out („die Verpackung Kategorie Hin- und Herbewegung ist: “ + toString F. ());

Beispiel: Bekehrtzeichenkettewerte zu den Zahlen

//Müssen Sie häufig Zeichenkettewerte in Zahlen umwandeln

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

//definieren Sie etwas Zeichenketten. 
Reihen Sie intString = „25“ auf;
Reihen Sie longString = „123456789“ auf;
Reihen Sie floatString = „25.567“ auf;

internes i = Integer.valueOf (intString);
//Druck heraus das interne
Script.out („das interne i ist: “ + i);

langes L = Long.valueOf (longString);
//Druck heraus das lange
Script.out („das lange L ist: “ + L);

Hin- und Herbewegung f = Float.valueOf (floatString);
//Druck heraus die Hin- und Herbewegung
Script.out („die Hin- und Herbewegung f ist: “ + f);

Beispiel: Java Mathekategorie

//Die Java Mathekategorie stellt mehr Mathefunktionen, anders als + zur Verfügung, -,/oder *

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

//definieren Sie einige Zahlen
internes i2 = 3;
internes i3 = - 7;
langes L = 123456787;
Hin- und Herbewegung f = 25.45;
doppeltes d2 = 25.34;
doppeltes d3 = 2.4;

//Druck heraus das Maximum von zwei Zahlen
Script.out („das Maximum zwischen i2 und i3 ist: “ + Math.max (i2, i3));

//Druck heraus das Minimum von zwei Zahlen
Script.out („das Minimum zwischen i2 und i3 ist: “ + Math.min (i2, i3));

//rund weg von der Hin- und Herbewegung
Script.out („25.45 wird weg aufgerundet: “ + Math.round (f));

//erhalten Sie exp Wert
Script.out („exp (3) =“ + Math.exp (i2));

//erhalten Sie Protokollwert
Script.out („Protokoll (3) =“ + Math.log (i2));

//erhalten Sie Quadratwurzelwert
Script.out („Quadratwurzel von 3 =“ + Math.sqrt (i2));

Beispiel: Die Boolesche Kategorie

//Die Booleschen Kategorie Verpackungen um den Java ursprünglichen Typen Boolesch
//Das ursprüngliche Boolesche kann entweder „zutreffend“ oder „falsch“ sein (der Fall empfindlich)

importieren Sie com.hitek.engine.mods.script.Script;

//definieren Sie etwas booleans
Boolesches trueBoolean = zutreffend;
Boolesches falseBoolean = falsch;

//Bekehrter das Boolesche zur Zeichenkette und zum Druck heraus das Boolesche 
Script.out („trueBoolean ist: “ + trueBoolean.toString ());
Script.out („falseBoolean ist: “ + falseBoolean.toString ());

//Gebrauch die Boolesche Kategorie, eine Zeichenkette in Boolesches umzuwandeln
Zeichenkette, die = „zutreffend“ trueString ist;
Boolescher Test = Boolean.valueOf (trueString);
Boolesches convertedBoolean = test.booleanValue ();
Script.out („umwandelnde Zeichenkette „richten“ zum Booleschen Typen“ aus);
Script.out („umgewandelter Boolescher Wert =“ + convertedBoolean.toString ());


Kapitel 4 - Reihen und geht auf Oberseite zurück

Beispiel: Reihen

//Reihen wird häufig benoetigt, um Verzeichnislisten und -andere zu verarbeiten Gebrauch.

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

//erklären Sie eine intetger Reihe
internes [] arr; 

//erstellen Sie die Ganzzahl Reihe
arr = neues internes [10]; 

//weisen Sie einen Wert jedem Feldelement zu und drucken Sie ihn aus
//das Feld „Länge“ bringt das size der Reihe zurück
// 
für (internes i = 0; I < arr.length; i++) 
{
arr [i] = I * 2;
Script.out („das Feldelement am Index: “ + ist i + „: “ + arr [i]);
}

//Beispiel des Verwendens von von Zeichenkettereihe
Str = der Zeichenkette [] {„man ist 1“, „zwei ist 2“, „drei ist 3“};
für (internes i = 0; I < str.length; i++) 
{
Script.out („das Feldelement am Index: “ + ist i + „: “ + str [i]);
}

//2-D Reihen
Namen = der Zeichenkette [] []
{
{„Rechnung“, „Pendel“, „betty“},
{„Markierung“, „mattes“,},
{„karen“, „Kitty“, „kevin“, „kong“,},
};

für (internes i = 0; I < names.length; i++) 
{
Script.out („Anfang von 1-D subarray von den Namen. Reihe =“ + i);
für (internes J = 0; J < Namen [i] .length; j++) 
{
Script.out (Namen [i] [J] + „„);
}
Script.out („Ende von 1-D subarray von den Namen. Reihe =“ + i);
}

Beispiel: Vektoren

//A Vektor ist eine Reihe, die dynamisch wachsen oder schrumpfen kann
//A Vektor kann irgendeinen Typen Nachricht oder ursprünglicher Java Typ enthalten

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

//erstellen Sie ein unbelegtes arraylist
Vector v = neuen Vektor ();

//fügen Sie einige Elemente ihm hinzu
V. fügen Sie hinzu (0);
V. fügen Sie hinzu („Erste Zeichenkette“);
V. fügen Sie hinzu („Zweite Zeichenkette“);
V. fügen Sie (3) hinzu;
V. fügen Sie hinzu (neues Datum ());

//Druck heraus die vektorelemente
für (internes i = 0; I < V. size (); i++) 
{
Script.out („das Feldelement am Index: “ + ist i + „: “ + erhalten V. (i).toString ());
}

//Druck heraus das size des Vektors
Script.out („das vektorsize ist-: “ + V. size ());

//löschen Sie ein Element an Index 3
V. löschen Sie (3);

//Druck heraus das size des Vektors wieder
Script.out („gelöschtes Element an Index 3. Das neue vektorsize ist-: “ + V. size ());

//Einsatzelement in Index 3 wieder
V. fügen Sie hinzu (3, „Herr Insert“);

//des Druckes Element 3 heraus
Script.out („eingesetztes Element an Index 3 ist: “ + erhalten V. (3).toString ());

//Suche der Vektor für Nachrichten
wenn (V. enthält („Herr Insert“))
{
Script.out („ja, enthält dieser Vektor das Element „Herr Insert““);
}

//Druck heraus der Index von „Herrn Insert“
Script.out („der Index von Herrn Insert ist: “ + V. indexOf („Herr Insert“));

//frei heraus die Reihe
V. freier Raum ();

//Druck heraus das size des Vektors
Script.out („Vektor gelöscht. Das vektorsize ist-: “ + V. size ());

Beispiel: Datum- und DateFormatkategorien

//Datum- und DateFormatkategorien sind in der Formatierung nützlich und analysieren und ändern Dateizeitstempel
//Kalenderkategorien helfen Sie, Datumhandhabungen und -vergleiche durchzuführen.

importieren Sie com.hitek.engine.mods.script.Script;
importieren Sie java.text.DateFormat;

//erhalten Sie das Tagesdatum
Datieren Sie jetzt = neues Datum ();

//Druck heraus das Datum mit einem Rückstellung Formatierer
Script.out („aktuelles Rückstellung Format Datum/Zeit ist: “ + now.toString ());

//stellen Sie einen kundenspezifischen Datumformatierer her, der kurzes Datum und kurzzeitige Formate zeigt
//müssen Sie die java.text.DateFormat Kategorie an der Oberseite des script importieren
//java.text.DateFormat wird nicht automatisch durch das script importiert.
DateFormat DF = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT);

//Druck heraus das Datum mit diesem kundenspezifischen kurzen Formatierer
Script.out („aktuelles KURZES Format Datum/Zeit ist: “ + df.format (jetzt));

//Schalter das Format, zum sich zu sehnen Datum und Zeit
DF = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG);
Script.out („aktuelles LANGES Datum/Zeit ist: “ + df.format (jetzt));

//lässt Betriebsstunden in den Millisekunden errechnen
//die getTime () Methode bringen die Gesamtmillisekunden abliefen zurück, seit der Anfang der Maschinenzeit (~1970)
lange startMillis = now.getTime ();
Script.out („Anlasszeit in den millis: “ + startMillis);

//lässt das Datum nachrechnen
jetzt = neues Datum ();
lange endMillis = now.getTime ();
Script.out („Ende Zeit in den millis: “ + endMillis);

//errechnen Sie die Betriebsstunden in den millis
sehnen sich diff = endMillis - startMillis;
Script.out („elaspsed Zeit in den millis: “ + diff);

//wir kann eine Zeit in den Millisekunden in ein Datum auch umwandeln 
Datieren Sie endDate = neues Datum (endMillis);
Script.out („Ende Zeit im langen Format: “ + df.format (endDate));

Beispiel: Satzgliederung Datum

//Satzgliederung Datum von den Zeichenketten

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

//Definieren Sie eine Datum-Zeichenkette
Reihen Sie shortDateString = „4/11/06 6:53 PM“ auf;
Reihen Sie longDateString = „11. April 2006 6:53 auf:27 PM PDT“;

//definieren Sie kurzes Datumformat
DateFormat DF = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT);

//analysieren Sie das kurze Datum innen
Datieren Sie shortDate = df.parse (shortDateString);

//Druck heraus das kurze Datum mit einem Rückstellung Formatierer
Script.out („shortDate wurde richtig analysiert. kurzes Datum: “ + shortDate.toString ());

//Schalter der Formatierer, zum sich zu sehnen Datumformat
DF = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG);

//analysieren Sie im langen Datum
Datieren Sie longDate = df.parse (longDateString);

//Druck heraus das lange Datum mit einem Rückstellung Formatierer
Script.out („longDate wurde richtig analysiert. langes Datum: “ + longDate.toString ());

Beispiel: Kalenderkategorie

//Kalenderkategorie erlaubt uns, ein Datum zu manipulieren oder Daten zu vergleichen

Import com.hitek.engine.mods.script.Script;
//Import Datum- und Kalenderkategorien, die im java.util Paket sind
Import java.util.*; //

//erhalten Sie den aktuellen Kalender
Tragen Sie jetzt = Calendar.getInstance ein ();

//Druck heraus die Kalenderinformationen.
Script.out („aktueller Kalender ist: “ + now.toString ());

//Bekehrter der Kalender zu einer Datumnachricht mit der Kalender getTime () Funktion
Datum dateNow = now.getTime ();

//Druck heraus die Datuminformationen
Script.out („das Datum, das vom Kalender erreicht wird, ist: “ + dateNow.toString ());

//Bekehrter ein Datum zu einem Kalender mit der Kalender setTime (Datum) Funktion
now.setTime (dateNow);

//Druck heraus die Kalenderinformationen wieder
Script.out („der Kalender, der vom Datum erreicht wird, ist: “ + now.toString ());

//erhalten Sie die Einzelperson auffängt vom Kalender
Script.out („das Jahr ist: “ + now.get (Calendar.YEAR));
Script.out („der Monat ist: “ + now.get (Calendar.MONTH));
Script.out („das Datum ist: “ + now.get (Calendar.DATE));
Script.out („die Stunde (0-12) ist: “ + now.get (Calendar.HOUR));
Script.out („die Stunde des Tages (0-23) ist: “ + now.get (Calendar.HOUR_OF_DAY));
Script.out („die Minute ist: “ + now.get (Calendar.MINUTE));
Script.out („die Sekunde ist: “ + now.get (Calendar.SECOND));
Script.out („die Millisekunde ist: “ + now.get (Calendar.MILLISECOND));
Script.out („der AM/PM-Wert ist: “ + now.get (Calendar.AM_PM));

Script.out („der Tag der Woche ist: “ + now.get (Calendar.DAY_OF_WEEK));
Script.out („die Woche des Monats ist: “ + now.get (Calendar.WEEK_OF_MONTH));
Script.out („der Tag des Jahres ist: “ + now.get (Calendar.DAY_OF_YEAR));
Script.out („der Tag der Woche im Monat ist: “ + now.get (Calendar.DAY_OF_WEEK_IN_MONTH));
Script.out („der Tag des Monats ist: “ + now.get (Calendar.DAY_OF_MONTH));
Script.out („die Woche des Jahres ist: “ + now.get (Calendar.DAY_OF_YEAR));

//fügen Sie einiges auffängt zum jetzt Kalender hinzu. Automatisch hinzufügen rollt über dem grösseren auffängt für Sie
Kalender gestern = Calendar.getInstance ();
yesterday.add (Calendar.DATE, - 1);

Kalender morgen = Calendar.getInstance ();
tomorrow.add (Calendar.DATE, 1);

//Druck heraus die Daten, die diesen Kalendern entsprechen. Vor dem Druck Erster Bekehrter wendet bis jetzt ein
Script.out („war gestern: “ + yesterday.getTime () .toString ());
Script.out („ist morgen: “ + tomorrow.getTime () .toString ());

//vergleichen Sie gestern und morgen mit dem Kalender nach und vor Methoden
wenn (yesterday.before (morgen))
{
Script.out („ja, sind gestern vor Morgen“);
}

wenn (tomorrow.after (gestern))
{
Script.out („ja, sind morgen nach Gestern“);
}

Kapitel 5 - Datei und Verzeichnis zurück zu Oberseite

Beispiel: Verzeichnis- und Dateiinformationen 

//Java, Verzeichnis- und Dateiin den informationen wird von der Java Dateikategorie erreicht

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

//erhalten Sie der Rückstellung Java temporäres Verzeichnis
Reihen Sie tmpdir = System.getProperty auf („java.io.tmpdir“);

//Druck heraus der Verzeichnisname
Script.out („das Rückstellung Java Temperatur Heft ist: “ + tmpdir);

//erstellen Sie eine neue Dateinachricht des Verzeichnisses
Archivieren Sie dir = neue Datei (tmpdir);

//erstellen Sie eine neue Dateinachricht
Archivieren Sie newFile = neue Datei (dir, „newFile.txt“);

//stellen Sie die neue Datei her
Boolescher Erfolg = newFile.createNewFile ();

//Druck heraus archivieren Informationen
wenn (Erfolg == zutreffend)
{
Script.out („hergestellte neue Datei“);
}
sonst
{
Script.out („nicht gekonnt Datei oder Datei existiert herstellen bereits“);
}

//überprüfen Sie, dass Dateipfad eine Datei existiert und ist
wenn (newFile.exists () u. u. newFile.isFile ())
{
Script.out („Datei existiert und ist eine Datei“);
}
sonst
{
Script.out („Datei nicht existiert oder ist nicht eine Datei“);
Rückkehr; //kein fortfahrender Punkt, wenn es keine Datei gibt
}

//Druck heraus die Dateiinformationen
Script.out („Dateiname =“ + newFile.getName ());
Script.out („Datei-size =“ + newFile.length ());
Script.out („Dateipfad =“ + newFile.getPath ());
Script.out („absoluter Pfad = der Datei“ + newFile.getAbsolutePath ());
Script.out („kanonischer Pfad = der Datei“ + newFile.getCanonicalPath ());
Script.out („Dateiverzeichnis =“ + newFile.getParent ());
Script.out („Datei ist lesbares =“ + newFile.canRead ());
Script.out („Datei ist writeable =“ + newFile.canWrite ());
Script.out („Datei ist verstecktes =“ + newFile.isHidden ());
DateFormat DF = DateFormat.getDateTimeInstance ();
langes modtime = newFile.lastModified ();
Datum-MOD = neues Datum (modtime);
Script.out („Dateidatum =“ + df.format (MOD));

Beispiel: Dateimethoden

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

//erhalten Sie der Rückstellung Java temporäres Verzeichnis
Reihen Sie tmpdir = System.getProperty auf („java.io.tmpdir“);

//Druck heraus der Verzeichnisname
Script.out („das Rückstellung Java Temperatur Heft ist: “ + tmpdir);

//erstellen Sie eine neue Dateinachricht des Verzeichnisses
Archivieren Sie dir = neue Datei (tmpdir);

//erstellen Sie eine neue Dateinachricht
Archivieren Sie file1 = neue Datei (dir, „file1.txt“);
Archivieren Sie file2 = neue Datei (dir, „file2.txt“);

//stellen Sie die neue Datei 1 her
file1.createNewFile ();

//überprüfen Sie, dass newfile1 eine Datei existiert und ist
wenn (file1.exists () u. u. file1.isFile ())
{
Script.out („file1 existiert“);
}
sonst
{
Script.out („file1 nicht existiert oder ist nicht eine Datei“);
Rückkehr; //kein fortfahrender Punkt, wenn es keine Datei gibt
}

//benennen Sie die Datei um
Boolescher Erfolg = file1.renameTo (file2);

wenn (Erfolg == zutreffend)
{
Script.out („benennen Sie von file1 zu file2 waren erfolgreich“ um);
}
//bestätigen Sie, dass newFile1 nicht existiert
wenn (!file1.exists ())
{
Script.out („file1 nicht existiert, weil es“ umbenannt wurde);
}

//Löschung newFile2
Erfolg = file2.delete ();
wenn (Erfolg == zutreffend)
{
Script.out („Löschung file2 war“ erfolgreich);
}

Beispiel:  Dateilesen/schreiben

//Dateilesen/schreiben

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

//erhalten Sie der Rückstellung Java temporäres Verzeichnis
Reihen Sie tmpdir = System.getProperty auf („java.io.tmpdir“);

//Druck heraus der Verzeichnisname
Script.out („das Rückstellung Java Temperatur Heft ist: “ + tmpdir);

//erstellen Sie eine neue Dateinachricht des Verzeichnisses
Archivieren Sie dir = neue Datei (tmpdir);

//erstellen Sie eine neue Dateinachricht
Archivieren Sie file1 = neue Datei (dir, „file1.txt“);

//erstellen Sie FileWriter, um zu file1 zu schreiben, das falsche ist, die Datei zu überschreiben, zutreffend ist, zum Ende der vorhandenen Datei hinzuzufügen
FileWriter FW = neues FileWriter (file1, falsch);
BufferedWriter bw = neues BufferedWriter (FW);
für (internes i = 0; I < 10; i++)
{
bw.write („dieses ist Zeile“ + i);
//schreiben Sie Zeilenvorschubzeichen
bw.newLine ();
}
bw.close ();

//stellen Sie einen Leser her, um die vollständige Datei innen zu lesen und sie auszudrucken, um Protokoll auszugeben
FileReader Franc = neues FileReader (file1);
BufferedReader Br = neues BufferedReader (Franc);
Zeichenkettezeile = ""; 
während ((Zeile = br.readLine ())!= Null)
{
Script.out (Zeile);
}
br.close ();

Beispiel: Verzeichnismethoden

//Java, Verzeichnis- und Dateiin den informationen wird von der Java Dateikategorie erreicht

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

//erhalten Sie der Rückstellung Java temporäres Verzeichnis
Reihen Sie tmpdir = System.getProperty auf („java.io.tmpdir“);

//Druck heraus der Verzeichnisname
Script.out („das Rückstellung Java Temperatur Heft ist: “ + tmpdir);

//erstellen Sie eine neue Dateinachricht des Verzeichnisses
Archivieren Sie dir = neue Datei (tmpdir);

//bestätigen Sie, dass dieser Pfad von Ihrem System existiert
wenn (dir.exists ())
{
Script.out („ja, existiert dieser Pfad“);
}

//bestätigen Sie, dass dieses ein gültiges Verzeichnis auf Ihrem System ist
wenn (dir.isDirectory ())
{
Script.out („ja, ist dieses ein gültiges Verzeichnis“);
}

//erhalten Sie den Pfad
Script.out („der Pfad ist: “ + dir.getPath ());

//erhalten Sie den absoluten Pfad
Script.out („der absolute Pfad ist: “ + dir.getAbsolutePath ());

//erhalten Sie das Elternteilverzeichnis
Archivieren Sie Elternteil = dir.getParentFile ();
Script.out („der Elternteilpfad ist: “ + parent.getAbsolutePath ());

Beispiel: Verzeichnisinformationen

//Java, Verzeichnis- und Dateiin den informationen wird von der Java Dateikategorie erreicht

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

//erhalten Sie der Rückstellung Java temporäres Verzeichnis
Reihen Sie tmpdir = System.getProperty auf („java.io.tmpdir“);

//Druck heraus der Verzeichnisname
Script.out („das Rückstellung Java Temperatur Heft ist: “ + tmpdir);

//erstellen Sie eine neue Dateinachricht des Verzeichnisses
Archivieren Sie dir = neue Datei (tmpdir);

//erhalten Sie die Liste der Dateinamen im dir
Reihen Sie [] Namen = dir.list auf ();

//Druck heraus die Ersten 100 Namen aller Dateien in Ihrem Temperatur dir
internes Maximum = names.length;
wenn (Maximum > 100)
{
Maximum = 100;
}

für (internes i=0; I < Maximum; i++)
{
Script.out („Datei“ + i + „=“ + Namen [i]);
}

//erhalten Sie eine Reihe Dateinachrichten 
Archivieren Sie [] Dateien = dir.listFiles ();

//Druck heraus die Informationen für die Ersten 100 Dateien. 
Zeichenkette Namens= "";
langes size = 0;
Datum geändert;

//erhalten Sie Rückstellung Datum/Uhrzeitformatierer
DateFormat DF = DateFormat.getDateTimeInstance ();
Zeichenkette-MOD = "";

für (internes i=0; I < Maximum; i++)
{
Zeichenkette Namens= archiviert [i] .getName ();
size = archiviert [i] .length ();
geändertes = neues Datum (Dateien [i] .lastModified ());
MOD = df.format (geändert);
Script.out („Datei“ + i + „=“ + Name + „, size =“ + size + „, Zeitstempel =“ + MOD);
}

Beispiel: bilden Sie Hefte

//Beispiel, zum der Hefte zu bilden 

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

//erhalten Sie der Rückstellung Java temporäres Verzeichnis
Reihen Sie tmpdir = System.getProperty auf („java.io.tmpdir“);

//Druck heraus der Verzeichnisname
Script.out („das Rückstellung Java Temperatur Heft ist: “ + tmpdir);

//erstellen Sie eine neue Dateinachricht des Verzeichnisses
Archivieren Sie dir = neue Datei (tmpdir);

//erstellen Sie eine Dateinachricht, die ein neues subfolder innerhalb des tmpdir darstellt
Archivieren Sie newdir = neue Datei (dir, „newDirectory2“);

//überprüfung, wenn Heft existiert
Boolesch existiert = newdir.exists ();
wenn (existiert das zutreffende ==)
{
Script.out („Heft existiert bereits: “ + newdir.getAbsolutePath ());
Rückkehr; //keine Notwendigkeit, subfolder zu erstellen
}

//bilden Sie ein neues Unterverzeichnis. Methode bringt zutreffendes zurück, wenn sie folgt
//die falsche Rückkehr, wenn Heft bereits existiert oder könnte nicht Heft herstellen
Boolescher Erfolg = newdir.mkdir ();
wenn (Erfolg == zutreffend)
{
Script.out („stellten neues Heft her: “ + newdir.getAbsolutePath ());
}

Kapitel 6 - Methoden zurück zu Oberseite

Beispiel: Verwenden von von Methoden

//können Sie Methoden definieren, um Kode in Ihren script wiederzuverwenden
//alle Methoden MUSS definiert werden, bevor das Hauptscript durchgeführt wird

importieren Sie com.hitek.engine.mods.script.Script;

//diese Methode gibt einfach die Zeichenkettemeldung zum Ausgabeprotokoll aus
Lücke heraus (Zeichenkettemeldung)
{
Script.out (Meldung);
}

//diese Methode erhält das Quadrat einer Zahl
internes Quadrat (interner Input)
{
Rückholinput * Input;
}

//Hauptmethode beginnt jetzt
//Test die oben genannten Methoden
heraus („dieses ist ein Test des Verwendens von von Methoden in den script“);
internes fiveSquare = Quadrat (5);
heraus („Quadrat fünf ist“ + fiveSquare);

Beispiel: hitek Methoden

//wir stellen Sie einige Methoden, die Ihnen erlauben, task laufen zu lassen, Journaldaten zur Verfügung, erhalten Sie und stellen Sie Variablen und taskparameter ein.

importieren Sie com.hitek.engine.mods.script.Script;

//schreiben Sie eine Zeichenkette zum Ausgabeprotokoll
Script.out („Schreiben zum Ausgabeprotokoll“);

//schreiben Sie eine Zeichenkette zum änderungsprotokoll
Script.act („Schreiben zum änderungsprotokoll“);

//schreiben Sie ein FehlerKellerprotokoll zum ausprüfenprotokoll
Versuch
{
Integer.parseInt („falsche Ganzzahl“);
}
Verriegelung (Ausnahme e)
{
Script.err (e);
}

//lassen Sie ein task laufen und erhalten Sie den Ausgang Kode
//stellen Sie, einen gültigen tasknamen hier einzutragen sicher
Zeichenkette taskTitle = „Enter_valid_task_title_here“;
taskTitle = „copy“;
internes exitCode = Script.run (taskTitle);
Script.out („Ausgang Kode von task =“ + exitCode);

//erhalten Sie ein task paramter. Sie müssen die korrekte taskTitle und Parametertaste eintragen
//Blick auf die Eigenschaft Dateien der task im Daten- \ taskheft.
//diese Dateien zeigen Sie die Parametertasten von Task.PARAMETERS0 zu Task.PARAMETERS50

//lesen Sie Task.PARAMETERS1
Reihen Sie durchschnittliches = Script.getPar auf (taskTitle, „Task.PARAMETERS1“);
Script.out („Task.PARAMETERS1 =“ + Gleichheit);

//Set ein taskparameter dynamisch
Script.setPar (taskTitle, „Task.PARAMETERS1“, „neuer Testwert“);

//lasen ihn wieder aus, um zu bestätigen, dass änderungen vorgenommen wurden
durchschnittliches = Script.getPar (taskTitle, „Task.PARAMETERS1“);
Script.out („Task.PARAMETERS1 =“ + Gleichheit);

//können Sie alles task, Benutzer, Java und System Variable Werte erhalten
//können Sie Benutzervariable Werte einstellen. Wir erlauben nicht, dass variable Werte des task, Java oder des Systems überschrieben werden.
Zeichenkette var = taskTitle + „::ExitCode“;
Zeichenkettewert = Script.getVar (var);
Script.out („variabler Wert =“ + Wert);

//Set ein Benutzervariable Wert
Script.setVar („newVariable“, „prüfende Variable“);
Wert = Script.getVar („newVariable“);
Script.out („neuer variabler Wert =“ + Wert);

 Zurück zu Oberseite