• Enkelt att använda: inget krävda programmera eller scripting, grafisk manöverenhet
• Scriptingfunktioner är tillgängliga för advanced användare och programmerare
• Kraftigt, mångsidigt, pålitligt och som man har råd med
• Kör tusentals av taskar om dagen
• Teknisk service i rätt tid och free för och efter dig purchase
• Free 30 dag prov och free mindre förbättringar
• Körningar på windower, macen OSX, Linux och andra Unix plattformar

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

Scripting (professional Automize och Automize Enterpriseupplagor)

• Skapa komplicerade automationscript som bygger på finnasende Automize taskar
• Framkalla script, som förminskar upprepade laborious computer-related aktiviteter.
• Fyll på advanced funktionsduglighet till dina Automize taskar som email, FTP, bildskärmar, mapp och arkivlistor.
• Använd scriptfunktionen för att få mapplistor eller filenames som du kan använda i kopian, FTP, ziptaskar etc.…,
• Du kan läsa och ställa in värdet av taskparametrar från scriptet. Kör därefter tasken från scriptet. Detta förminskar komplexiteten av scriptet.
• Bara 20-50 linjer av kod kan resultera är extremt kraftiga specialtillverkade taskar och lösningar.
• Vi ger free hjälp för lilla 20-50 linjer script som kan vara användbara till användare.
• Djupgående tutorial och tar prov kodifierar för att få dig startade.
• Vårt online-fora har många faktiska kodexempel based på applicationer för verklig användare.

Exempelscript:
1) Scriptet läser mapplistan från mappsystem
2) Scriptet ställer in taskparametrar based på mapp - namnet och mappen
3) Scriptet kör task. Tasken kör efter set för avläsningstaskparametrar via scriptet.
4) Scriptet läser taskutgångskod och taskvariables
5) Scriptet kan fortsätta att köra task i samma följd 2-4 för alla filenames

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

Automize använder BeanShell (beanshell.org) för dess scripting.  BeanShell stöttar java syntax 100%, och Automize sig själv är skriftlig i java.  Denna är en store långt som lärer java syntax och som ska fås startad på det lättaste och kraftigaste moderna programmera språket.

Att följa igenom i denna tutorial, kopia och att klistra dessa exempel in i den Automize scriptwindowen. Kör därefter dessa exempel:

Dela upp 1 - Grunderna
Dela upp 2 - Kontrollera meddelanden
Dela upp 3 - Strängar, numrerar och Booleans
Dela upp 4 - Uppbåd och daterar
Dela upp 5 - Spara och arkivet
Dela upp 6 - Metoder

Dela upp 1 - Grunderna

Exempel: Introductory script

//Fodrar startmed//är kommentaren fodrar

//Mest programmera språk (c, java, c++, etc.… kräver en huvudsaklig () metod),
//Emellertid, du behöver inte att definiera en huvud() metod medan scriptingen

//definiera en stränga
String welcomen för prov = ”till den java scriptingen!!”;

//skriv till systemstdout
System.out.println (testa);

Exempel: Använda scriptgruppen

//Scriptgruppen ger en anslutning mellan dina script och inbuilt funktioner för Hitek Software

//importmeddelanden låter dig använda befintliga Hitek Software eller java funktioner
//I detta exempel, vi importerar Hitek Softwarescriptgruppen

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

//definiera en stränga

String welcomen för prov = ”till den Java scriptingen!!”;

//Appell Script.out-metoden som skriver efterbehandling till efterbehandlingen, loggar sparar

Script.out (testa);

//, efter du har kört/provet denna script, kontrollerar efterbehandlingsjournalmappen (journalmenyn i Automize användaremanöverenhet)

Exempel: Heltal och strängar

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

//integers - du använder internt eller long vanligt i dina script
intern largestInteger = Integer.MAX_VALUE;
lång largestLong = Long.MAX_VALUE;

//boolean - du skar också behov att använda boolean 
riktiga boolean javaRocks =;

//Stränga - du skar använder strängar mycket
Rad som testString rader för = ”java, är mycket praktisk”;

Script.out (”max integervärde =” + largestInteger);
Script.out (”max långt värde =” + largestLong);
Script.out (”värde av javaRocks =” + javaRocks);
Script.out (testString);

//kontroll efterbehandlingsjournalen efter dig kör denna script.

Exempel: Detta exempel visar uttryck vilket arbete med heltal.  Kontrollera efterbehandlingsjournalen, efter du har kört denna script.

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

internt M = 10;
internt K = 5;

Script.out (”variablen värderar…”);
Script.out (”M =” + M);
Script.out (”K =” + K);

//som använder ökaoperatören ++
m++;
Script.out (”ökat genom att använda m++, nytt värde av M =” + M);

//som använder > (mer viktig än) < (mindre än)
om (M > K)
{
Script.out (”ja,” +m + ”är större än” + K);
}

//som använder jämbördig >= (som är mer viktig än eller) och <= (mindre än eller jämbördigt) 
om (M->= K +5)
{
Script.out (”ja, M är mer viktig än eller jämbördigt till K + 5”);
}

//som använder jämställdhetoperatörs==en
om (k==5)
{
Script.out (”ja, K är jämbördigt till 5”);
}

//som använder inte jämlikeoperatören!=
om (K!= 5)
{
Script.out (”ja, K inte är lika till 5”);
}

//att använda & & (logiskt OCH)
om ((K-== 5) & & (m==10))
{
Script.out (”ja, K är jämbördigt till 5, och M är jämbördigt till 10”);
}

//använda || (logiskt ELLER)
om ((K-== 5) || (m==234545))
{
Script.out (”ja, endera K är jämbördigt till 5, eller M är jämbördigt till 10”);
}

//kontroll efterbehandlingsjournalen efter dig kör denna script.

Exempel: Detta exempel visar behandlande operatörer för grundläggande heltal

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

//detta exempel visar behandlande operatörer för grundläggande heltal
//kontroll efterbehandlingsjournalen efter dig kör denna script.

internt I = 10;
internt K = 5;

Script.out (”variablen värderar…”);
Script.out (”I =” + I);
Script.out (”K =” + K);

//som tillfogar, numrerar
Script.out (”tillfoga…”);
Script.out (”I + K =” + (I + K));

//som subtraherar, numrerar
Script.out (”subtrahera…”);
Script.out (”I - K =” + (I - K));

//som multiplicerar, numrerar
Script.out (”multiplicera…”);
Script.out (”I * K =” + (I * K));

//som delar, numrerar
Script.out (”dela…”);
Script.out (”I/K =” + (I/K));

//kontroll efterbehandlingsjournalen efter dig kör denna script.

Dela upp 2 - Kontrollera meddelanden tillbaka för att överträffa

Exempel: om meddelanden

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

intern temperatur = 100;
Radweather = ”cold”;

//Enklast bilda av, om meddelandet: 
om (vikarier > 80) 
{
weather ”varm” =;
}
Script.out (”rida ut är i dag” + rider ut);

//(om + annars) meddelanden
temperatur = 60;
om (vikarier > 80)
{
”varm” weather =;
}
annars
{
”nice” weather =;
}
Script.out (”rida ut är i dag” + rider ut);

//(om + (annars om) + annars) meddelanden

temperatur = 75;
om (vikarier < 70)
{
”god” weather =;
}
annars, om (vikarie>= 70 & & vikarie<= 80)
{
weather = ”perfect”;
}
annars
{
”varm” weather =;
}
Script.out (”rida ut är i dag” + rider ut);


//kontroll efterbehandlingsjournalen efter dig kör denna script.

Exempel: Att använda ”för” kretsar

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

//definiera ett heltal, och tomt stränga
intern summa = 0;
"" För radresultat =;

//bruk ”för” kretsar mellan 1, och 10, ökar summa vid 1. 
//++ som ökar operatören
//<= är mindre än eller jämbördig till

för (intern current = 1; ström<= 10; current++) 
{
summa + current för summa =;
”nummer = för aktuell ögla” för resultat = + current + ”, summa =” + summa;
Script.out (resultat);
}

//, efter du har kört/provet denna script, kontrollerar efterbehandlingsjournalen.

Exempel: stunden kretsar

//stundmeddelandet utför ständigt ett kvarter av meddelandestunder som en villkora tillfredsställs
//stunder kretsa utvärderar uttryckt upptill av kretsa

//VAR CAREFULL MED STUNDER KRETSAR MYCKET. 
//Se till att du ökar en värdera för att gå ut kretsa på något pekar.

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

intern ögla = 1;
intern maximal = 7;

stunder (kretsa < maximal), 
{
//Som VARNAR - om du får fastnad i ett oändligt kretsar dig måste ATT STARTA motorn/användaren om igen har kontakt
Script.out (”denna är en stund kretsar. ögla =” + ögla);

//öka värdera av kretsar denna stund kretsar annars skar avslutar aldrig!!
loop++;
}

//-stunder kretsa utvärderar det längst ner uttryckt

//som nollställas, kretsar värderar till 1
ögla = 1; 
 
{
//Som VARNAR - om du får fastnad i ett oändligt kretsar dig måste ATT STARTA motorn/användaren om igen har kontakt
Script.out (”denna är enstund kretsar. ögla =” + ögla);

//öka värdera av kretsar denna -stund kretsar annars skar avslutar aldrig!!
loop++;
}
stunder (kretsa < maximal);

Exempel:  Kopplameddelandet 

//kopplameddelandet utför villkorligt meddelanden som baseras på ett heltaluttryck

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

intern dayNumber = 3;
Raddag = ””;

koppla (dayNumber)
{
fall 1: day= " sunday "; 
avbrott;
fall 2: day= " måndag "; 
avbrott;
fall 3: day= " tuesday "; 
avbrott;
fall 4: day= " wednesday "; 
avbrott;
fall 5: day= " thursday "; 
avbrott;
fall 6: day= " friday "; 
avbrott;
fall 7: day= " saturday "; 
avbrott;
}

Script.out (”är i dag” + dagen);

Exempel: Fortsättameddelandet

//fortsättameddelandet låter dig hoppa over strömupprepningen av för, eller stunder kretsar

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

intern maximal = 7;

//avbrott ut ur a för kretsar
för (intern i=1; i < 10; i++) 
{
om (I > 3 & & I < 7) 
{
fortsätta;
}
Script.out (”detta är a för kretsar med fortsätter. upprepning =” + I);
}


//fortsätta, och avbrottet ut ur en oändlig stund kretsar
intern ögla = 1;
(riktiga) stunder, 
{
//Som VARNAR - om du får fastnad i ett oändligt kretsar dig måste ATT STARTA motorn/användaren om igen har kontakt
//öka värdera av kretsar denna stund kretsar annars skar aldrig avbrottet ut!!
//öka bör göras för fortsättameddelandet
loop++;

//avbrott ut denna stund kretsar annars som, skar avslutar aldrig!!
om (kretsa > maximal),
{
avbrott;
}

//fortsätta på till nästa upprepning för upprepningar 1 och 2
om (kretsa < 4),
{
fortsätta;
}

Script.out (”denna är en whileögla med continen för upprepningar < 3. upprepning =” + öglan);

//Du kan inte ha kretsa att öka efter fortsätta. 
//!! kretsa ++; !! kretsa ++ bör inte vara här. Den bör lokaliseras för fortsätta.
}
Script.out (”avbrottet ut ur stunder kretsar efter kretsar >” + maximal);

Exempel: Avbrottsmeddelandet

//avbrottsmeddelandet låter dig bryta ut ur kretsar. 

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

intern maximal = 7;

//avbrott ut ur a för kretsar
för (intern i=1; i < 10; i++) 
{
//Som VARNAR - om du får fastnad i ett oändligt kretsar dig måste ATT STARTA motorn/användaren om igen har kontakt
Script.out (”detta är a för kretsar. ögla =” + I);
om (I->=maximal) 
{
avbrott;
}
}

Script.out (”avbrottet ut ur för kretsar efter kretsar >” + maximal);

//avbrott ut ur en oändlig stund kretsar
intern ögla = 1;
(riktiga) stunder, 
{
//Som VARNAR - om du får fastnad i ett oändligt kretsar dig måste ATT STARTA motorn/användaren om igen har kontakt
Script.out (”denna är en stund kretsar. ögla =” + ögla);

//öka värdera av kretsar denna stund kretsar annars skar avslutar aldrig!!
loop++;

//avbrott ut denna stund kretsar annars som, skar avslutar aldrig!!
om (kretsa > maximal),
{
avbrott;
}
}
Script.out (”avbrottet ut ur stunder kretsar efter kretsar >” + maximal);

Dela upp 3 - Strängar, numrerar och Booleans baksida för att överträffa 

Exempel: Java strängar klassificerar fungerar

//Javaen stränga klassificerar låter dig få information, sökande, behandlar, konverterar, och efterbehandling strängar

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

//definiera en stränga
Rad My första namn för stren = ”är John. Det min efternamn är doen.”;

//skriv dem ut ut
Script.out (”testa strängar är: ” + str);

//få strängar längd
Script.out (”längden av strängastren är: ” + str.length ());

//få teckenet på index 8
Script.out (”teckenet på index 9 är: ” + str.charAt (9));

//fynd den första händelsen av en ordna i stränga och skrivar ut indexet
Script.out (””den kända” ordna var första som fanns på indexet:” + str.indexOf (”namnge”),);

//, om ordna inte finnas, det återgång indexet är - 1
//java strängar sökanden, och andra funktioner är fallet som är känsligt vid standard
Script.out (””den KÄNDA” ordna fanns på indexet:” + str.indexOf (”NAMNGE”),);

//fynd den första händelsen av en ordna i stränga, början sökandet på index 15
Script.out (””den kända” ordna fanns också på indexet:” + str.indexOf (”namnge”, 15),);

//fynd den sist händelsen av en ordna i stränga och skrivar ut indexet
Script.out (””den kända” ordna fanns sist på indexet:” + str.lastIndexOf (”namnge”),);

//kontroll, om stränga startar med ett bestämt, ordnar.
//startsWithmetoden går ett boolean tillbaka true, om stränga startar med ordnar skrivet in.
om, riktig == (för str.startsWith (”min”))
{
Script.out (”ja. testa strängar starter med ”min””);
}

//kontroll, om stränga avslutar med ett bestämt, ordnar.
//startsWithmetoden går ett boolean tillbaka true, om stränga avslutar med ordnar skrivet in.
om (str.endsWith (”doen.”, ) riktig ==)
{
Script.out (”ja. testa strängar avslutar med ”doen.”, ”);
}

//kontroll, om stränga vara lika bra som another, strängar
Rad som My första namn anotherString för = ”, är John. Det min efternamn är doen.”;
Script.out (”anotherString =” + anotherString);
om (str.equals (anotherString))
{
Script.out (”ja. tvåna strängar är jämbördiga”);
}

//kontroll, om stränga vara lika bra som another, strängar att ignorera fallet
Rad som my första namn lowerCaseString för = ”, är john. det min efternamn är doen.”;
Script.out (”lowerCaseString =” + lowerCaseString);
om (str.equalsIgnoreCase (lowerCaseString))
{
Script.out (”ja. tvåna strängar är jämbördiga ignorera fallet”);
}

Exempel:  Stränga behandlig

//Stränga behandligsexempel

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

//definiera något strängar
Rad My första namn för stren = ”är John. Det min efternamn är doen.”;
Rad str2 = ”jag like caken.”;

//tryck den ut
Script.out (”testa strängar är: ” + str);

//länka samman (fästa), another strängar till detta strängar
String str3 = str.concat (str2);
Script.out (”länka samman str2 till str1. Resultat: ” + str3);

//byt ut den första händelsen av en stränga (eller det vanliga uttryckt mönstra), med another strängar
str3 = str.replaceFirst (”är”, ”var”);
Script.out (”utbytning av den första händelsen av ”är” med ”var”. Resultat: ” + str3);

//byt ut alla händelser av en stränga (eller det vanliga uttryckt mönstra), med another strängar
str3 = str.replaceAll (”My”, ”His”);
Script.out (”byta ut alla händelser av ”min” med ”His”. Resultat: ” + str3);

//få en substringbörjan på det specificerade indexet
str3 = str.substring (8);
Script.out (”Substring som börjar på index 8 =” + str3);

//få en substring innehållen inom specificerade index
str3 = str.substring (8.30);
Script.out (”Substring som börjar på index 8 och avslutar på index 30 =” + str3);

//omvänd strängar till lowercase
str3 = str.toLowerCase ();
Script.out (”omvandlande rad till liten =” + str3);

//omvänd strängar till bokstav
str3 = str.toUpperCase ();
Script.out (”omvandlande rad till upper-case =” + str3);

Exempel: java numrerar

//Javaen numrera primitiva typer inkluderar internt, långt, svävar, dubblerar, kortsluter, byten
//Du skar kräver mestadels internt och långt. Ibland du kan behöva att använda flotten.
//Varje av dessa primitiva typer har Java klassificerar den sjal runt om dem. 
//Klassificeraheltalsjalarna runt om internt. De långa sjalarna för klassificera runt om långt.

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

//definiera något numrerar
internt I = 3;
långt l = 123456787;
float f = 25.45;

Ny Integer för Integer I = (I);
Ny Float för Float F = (f);
Långt L = ny lång (v);

//tryck ut det internt och heltalet
Script.out (”det interna Iet är: ” + I);
Script.out (”omslag klassificerar heltalet är: ” + I. som toString ());

//tryck ut det långt och långt
Script.out (”det långa let är: ” + l);
Script.out (”omslag klassificerar är Long: ” + L. som toString ());

//tryck ut flotten och flotte
Script.out (”flotten f är: ” + f);
Script.out (”omslag klassificerar flotten är: ” + F. som toString ());

Exempel: omvänden strängar värderar numrerar

//Du skar vanligt behov att konvertera strängar värderar numrerar

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

//definiera något strängar. 
String intString = ”25”;
String longString = ”123456789”;
String floatString = ”25.567”;

internt I = Integer.valueOf (intString);
//tryck ut det internt
Script.out (”det interna Iet är: ” + I);

långt l = Long.valueOf (longString);
//tryck ut det långt
Script.out (”det långa let är: ” + l);

float f = Float.valueOf (floatString);
//tryck ut flotten
Script.out (”flotten f är: ” + f);

Exempel: java Math klassificerar

//Den java mathen klassificera ger mer math fungerar, annan än +, -,/eller *

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

//definiera något numrerar
intern i2 = 3;
intern i3 = - 7;
långt l = 123456787;
float f = 25.45;
dubbel d2 = 25.34;
dubbel d3 = 2.4;

//tryck, ut som maximat av två numrerar
Script.out (”maximat mellan i2 och i3 är: ” + Math.max (i2, i3));

//tryck, ut som minimien av två numrerar
Script.out (”minimien mellan i2 och i3 är: ” + Math.min (i2, i3));

//runda av flotten
Script.out (”25.45 rundas av: ” + Math.round (f));

//få exp värderar
Script.out (”exp (3) =” + Math.exp (i2));

//få loggar värderar
Script.out (”journal (3) =” + Math.log (i2));

//få kvadrerar rotar värderar
Script.out (”fyrkantig root av 3 =” + Math.sqrt (i2));

Exempel: De Boolean klassificerar

//Det Boolean klassificera sjalar runt om den boolean java primitiva typen
//Det primitiva boolean kan vara endera ”riktigt” eller ”falskt” (det känsliga fallet)

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

//definiera några booleans
riktig boolean trueBoolean =;
falsk boolean falseBoolean =;

//omvänd det boolean som ut strängar och som skrivar ut det boolean 
Script.out (”trueBoolean är: ” + trueBoolean.toString ());
Script.out (”falseBoolean är: ” + falseBoolean.toString ());

//bruk som de Boolean klassificerar för att konvertera en stränga till boolean
Rad som trueString ”riktig” =;
Boolean prov = Boolean.valueOf (trueString);
boolean convertedBoolean = test.booleanValue ();
Script.out (”konvertera stränga ”true” till boolean typ”);
Script.out (”omvandlat boolean värde =” + convertedBoolean.toString ());


Dela upp 4 - Uppbåd och daterar tillbaka för att överträffa

Exempel: Uppbåd

//Uppbåd ska krävs vanligt för att bearbeta arkivatt lista och annat bruk.

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

//förklara ett intetgeruppbåd
intern [] arr; 

//skapa heltaluppbådet
nytt internt för arr = [10]; 

//tilldela en värdera till varje uppbådbeståndsdel och skriv den ut ut
//fältet ”längd” går size av arrayen tillbaka
//, 
för (internt I = 0; i < arr.length; i++) 
{
arr [I] = i * 2;
Script.out (”uppbådbeståndsdelen på indexet: ” + I + ”är: ” + arr [I]);
}

//exempel av att använda strängar uppbåd
String [] str = {”en är 1”, ”två är 2”, ”tre är 3”};
för (internt I = 0; i < str.length; i++) 
{
Script.out (”uppbådbeståndsdelen på indexet: ” + I + ”är: ” + str [I]);
}

//2-D uppbåd
Namn = för rad [] []
{
{”räkningen”, ”guppar”, ”betty”},
{”markera”, ”matt”,},
{”karen”, ”pott”, ”kevin”, ”kong”,},
};

för (internt I = 0; i < names.length; i++) 
{
Script.out (”starten av 1-D som är subarray av, namnger. Rad =” + I);
för (internt j = 0; j < namnger [I] .length; j++) 
{
Script.out (namnger [I] [j] + ””);
}
Script.out (”avsluta av 1-D som är subarray av, namnger. Row =” + I);
}

Exempel: vektorer

//A vektorn är ett uppbåd som kan växa eller hjärnskrynklaren dynamiskt
//A vektorn kan innehålla någon typ av anmärker eller primitiv java typ

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

//skapa en tom arraylist
Vector den nya vectoren för v = ();

//tillfoga några beståndsdelar till den
v. tillfoga (0);
v. tillfoga (”stränga först”);
v. tillfoga (”stränga second”);
v. tillfoga (3);
v. tillfoga (nytt datera ());

//tryck ut vektorbeståndsdelarna
för (internt I = 0; i < V.-size (); i++) 
{
Script.out (”uppbådbeståndsdelen på indexet: ” + I + ”är: ” + V. får (I) .toString ());
}

//tryck ut size av vectoren
Script.out (”vectorsize är: ” + V.-size ());

//ta bort en beståndsdel på index 3
v. ta bort (3);

//tryck ut size av vectoren igen
Script.out (”borttagen beståndsdel på index 3. Den nya vectorsize är: ” + V.-size ());

//mellanläggsbeståndsdel in i index 3 igen
v. tillfoga (3, ”Mr. In:sätta”);

//för tryck beståndsdel 3 ut
Script.out (”den insatta beståndsdelen på index 3 är: ” + V. får (3) .toString ());

//sökande som vektorn för anmärker
om (V. innehåller (”Mr. In:sätta”))
{
Script.out (”ja, denna vektor ”Mr. In:sätta” innehåller för beståndsdelen”);
}

//tryck ut indexet av ”Mr. In:sätta”,
Script.out (”indexet av Mr. In:sätta är: ” + V.-indexOf (”Mr. In:sätta”));

//göra klar ut uppbådet
v. klart ();

//tryck ut size av vectoren
Script.out (”görad klar vektor. Vectorsize är: ” + V.-size ());

Exempel: Datera, och DateFormat klassificerar

//Datera, och DateFormat klassificerar är användbar i formatering, satslösning, och ändra spara tidsstämplar
//Kalender klassificerar hjälp utför daterar behandligar och jämförelser.

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

//få strömmen daterar
Date nu = det nya datumet ();

//tryck ut datera genom att använda en standardformatter
Script.out (”strömstandard formaterar daterar/Time är: ” + now.toString ());

//skapa ett beställnings- daterar formattershowingkort stavelse daterar, och kort stavelse Time formaterar
//du måste att importera java.text.DateFormat-gruppen på överkanten av scriptet
//java.text.DateFormat importeras inte automatiskt av scriptet.
DateFormat df = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT);

//tryck ut datera genom att använda denna beställnings- kort formatter
Script.out (”strömKORT STAVELSE formaterar daterar/Time är: ” + df.format (nu));

//koppla formatera long för att datera och tajma
df = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG);
Script.out (”den LÅNGA strömmen daterar/Time är: ” + df.format (nu));

//låter för att beräkna förfluten tid i millisekunder
//metoden för getTime () går de sammanlagda millisekunderna tillbaka förflöt, sedan starten av datortid (~1970)
långa startMillis = now.getTime ();
Script.out (”starttid i millis: ” + startMillis);

//låter för att räkna om datera
nu nytt datum för = ();
långa endMillis = now.getTime ();
Script.out (”avsluta tid i millis: ” + endMillis);

//beräkna den förflutna tiden i millis
long endMillis för diff = - startMillis;
Script.out (”elaspsed tid i millis: ” + diff);

//oss kan också konvertera en tid i millisekunder till en datera 
Date endDate = det nya datumet (endMillis);
Script.out (”avsluta tid i långt formaterar: ” + df.format (endDate));

Exempel: Satslösningen daterar

//Satslösning daterar från strängar

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

//Definiera en datera strängar
String shortDateString = ”4/11/06 6:53 PM”;
String longDateString = ”April 11, 2006 6:53:27 PM PDT”;

//definiera kort stavelse daterar formaterar
DateFormat df = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT);

//parse kort stavelse daterar in
Date shortDate = df.parse (shortDateString);

//tryck, ut som kort stavelse daterar genom att använda en standardformatter
Script.out (”shortDate parsed korrekt. kort stavelse daterar: ” + shortDate.toString ());

//koppla formatteren long för att datera formaterar
df = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG);

//parse i det långt daterar
Date longDate = df.parse (longDateString);

//tryck, ut som de långa daterar genom att använda en standardformatter
Script.out (”longDate parsed korrekt. långt datera: ” + longDate.toString ());

Exempel: Kalendern klassificerar

//Kalender klassificerar låter oss behandla en datera, eller att jämföra daterar

import com.hitek.engine.mods.script.Script;
//import daterar, och kalendern klassificerar som lokaliseras i java.utilen paketerar
import java.util.*; //,

//få strömkalendern
Calendar nu = Calendar.getInstance ();

//tryck ut informationen om kalender.
Script.out (”strömkalendern är: ” + now.toString ());

//omvänd som kalendern till en datera anmärker genom att använda kalendergetTimen () fungerar
DatumdateNow = now.getTime ();

//tryck ut informationen om datera
Script.out (”datera erhållande från kalender är: ” + dateNow.toString ());

//omvänd som en datera till en kalender som använder kalendersetTimen (datera) fungerar
now.setTime (dateNow);

//tryck ut informationen om kalender igen
Script.out (”kalendern erhållande från daterar är: ” + now.toString ());

//få individfälten av kalendern
Script.out (”året är: ” + now.get (Calendar.YEAR));
Script.out (”monthen är: ” + now.get (Calendar.MONTH));
Script.out (”datera är: ” + now.get (Calendar.DATE));
Script.out (”timmen (0-12) är: ” + now.get (Calendar.HOUR));
Script.out (”timmen av dagen (0-23) är: ” + now.get (Calendar.HOUR_OF_DAY));
Script.out (”minuten är: ” + now.get (Calendar.MINUTE));
Script.out (”sekunden är: ” + now.get (Calendar.SECOND));
Script.out (”millisekunden är: ” + now.get (Calendar.MILLISECOND));
Script.out (”det AM-/PMvärdet är: ” + now.get (Calendar.AM_PM));

Script.out (”dagen av veckan är: ” + now.get (Calendar.DAY_OF_WEEK));
Script.out (”veckan av monthen är: ” + now.get (Calendar.WEEK_OF_MONTH));
Script.out (”dagen av året är: ” + now.get (Calendar.DAY_OF_YEAR));
Script.out (”dagen av veckan i month är: ” + now.get (Calendar.DAY_OF_WEEK_IN_MONTH));
Script.out (”dagen av monthen är: ” + now.get (Calendar.DAY_OF_MONTH));
Script.out (”veckan av året är: ” + now.get (Calendar.DAY_OF_YEAR));

//tillfoga några fält till nu kalendern. Att tillfoga automatiskt rullar över de större fälten för dig
Kalender yesterday = Calendar.getInstance ();
yesterday.add (Calendar.DATE, - 1);

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

//det trycket ut daterar att motsvara till dessa kalendrar. Den första omvänden anmärker hitintills, innan han skrivar ut
Script.out (”var igår: ” + yesterday.getTime () .toString ());
Script.out (”är i morgon: ” + tomorrow.getTime () .toString ());

//jämför igår och i morgon genom att använda kalendern efter och för metoder
om (yesterday.before (i morgon))
{
Script.out (”ja, är igår för morgondag”);
}

om (tomorrow.after (igår))
{
Script.out (”ja, är i morgon efter gårdag”);
}

Dela upp 5 - Spara och arkivbaksida för att överträffa

Exempel: arkivet och sparar information 

//I java, arkiv och sparar information erhålls från javaen sparar klassificerar

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

//få standarden java det tillfälliga arkivet
String tmpdir = System.getProperty (”java.io.tmpdir”);

//tryck ut det kända arkivet
Script.out (”mappen för standardjava vikarier är: ” + tmpdir);

//skapa ett nytt sparar anmärker av arkivet
Spara den nya mappen för dir = (tmpdir);

//skapa ett nytt sparar anmärker
Spara den newFile nya mappen för = (dir, ”newFile.txt”);

//skapa det nytt sparar
boolean framgång = newFile.createNewFile ();

//tryck ut sparar information
om (riktig framgångs==)
{
Script.out (”skapade nya sparar”);
}
annars
{
Script.out (”missat för att skapa spara eller spara finns redan”);
}

//verifiera att som sparar, banan finns och är en spara
om (newFile.exists () & & newFile.isFile ())
{
Script.out (”spara finns och är en spara”);
}
annars
{
Script.out (”spara inte finns eller inte är en spara”);
retur; //inget peka att fortsätta, om det finns inget sparar
}

//det trycket ut sparar information
Script.out (”mapp - namn =” + newFile.getName ());
Script.out (”mappsize =” + newFile.length ());
Script.out (”mappbana =” + newFile.getPath ());
Script.out (”absolut bana = för mapp” + newFile.getAbsolutePath ());
Script.out (”canonical bana = för mapp” + newFile.getCanonicalPath ());
Script.out (”mapparkiv =” + newFile.getParent ());
Script.out (”mappen är läslig =” + newFile.canRead ());
Script.out (”mappen är writeable =” + newFile.canWrite ());
Script.out (”mappen är hidden =” + newFile.isHidden ());
DateFormat df = DateFormat.getDateTimeInstance ();
lång modtime = newFile.lastModified ();
Nytt datum för datumändring = (modtime);
Script.out (”mappdatum =” + df.format (ändring));

Exempel: spara metoder

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

//få standarden java det tillfälliga arkivet
String tmpdir = System.getProperty (”java.io.tmpdir”);

//tryck ut det kända arkivet
Script.out (”mappen för standardjava vikarier är: ” + tmpdir);

//skapa ett nytt sparar anmärker av arkivet
Spara den nya mappen för dir = (tmpdir);

//skapa ett nytt sparar anmärker
Spara den nya mappen för file1 = (dir, ”file1.txt”);
Spara den nya mappen för file2 = (dir, ”file2.txt”);

//skapa det nytt sparar 1
file1.createNewFile ();

//verifiera att newfile1 finns och är en spara
om (file1.exists () & & file1.isFile ())
{
Script.out (”file1 finns”);
}
annars
{
Script.out (”file1 inte finns eller inte är en spara”);
retur; //inget peka att fortsätta, om det finns inget sparar
}

//byt namn på spara
boolean framgång = file1.renameTo (file2);

om (riktig framgångs==)
{
Script.out (”byt namn på från file1 till file2 var lyckat”);
}
//bekräfta att newFile1 inte finns
om (!file1.exists ())
{
Script.out (”file1 inte finns, därför att den byttes namn på”);
}

//borttagnings newFile2
framgång = file2.delete ();
om (riktig framgångs==)
{
Script.out (”borttagnings file2 var lyckad”);
}

Exempel:  spara read/write

//spara read/write

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

//få standarden java det tillfälliga arkivet
String tmpdir = System.getProperty (”java.io.tmpdir”);

//tryck ut det kända arkivet
Script.out (”mappen för standardjava vikarier är: ” + tmpdir);

//skapa ett nytt sparar anmärker av arkivet
Spara den nya mappen för dir = (tmpdir);

//skapa ett nytt sparar anmärker
Spara den nya mappen för file1 = (dir, ”file1.txt”);

//skapa FileWriter för att skriva till file1, det falskt är att överskriva spara som är riktig är att fästa för att avsluta av existerande sparar
FileWriter fw = nya FileWriter (file1 som, är falska);
BufferedWriter bw = nya BufferedWriter (fw);
för (internt I = 0; i < 10; i++)
{
bw.write (”detta är fodrar” + I);
//skriv ett nytt fodrar teckenet
bw.newLine ();
}
bw.close ();

//skapa en avläsare för att läsa in helheten sparar och skrivar den ut ut för att output loggar
FileReader fr = nya FileReader (file1);
BufferedReader br = nya BufferedReader (fr);
Radlinje =-""; 
medan ((linje = br.readLine ())!=-null)
{
Script.out (fodra);
}
br.close ();

Exempel: arkivmetoder

//I java, arkiv och sparar information erhålls från javaen sparar klassificerar

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

//få standarden java det tillfälliga arkivet
String tmpdir = System.getProperty (”java.io.tmpdir”);

//tryck ut det kända arkivet
Script.out (”mappen för standardjava vikarier är: ” + tmpdir);

//skapa ett nytt sparar anmärker av arkivet
Spara den nya mappen för dir = (tmpdir);

//bekräfta att denna bana finns på ditt system
om (dir.exists ())
{
Script.out (”ja, denna bana finns”);
}

//bekräfta att detta är ett giltigt arkiv på ditt system
om (dir.isDirectory ())
{
Script.out (”ja, detta är ett giltigt arkiv”);
}

//få banan
Script.out (”banan är: ” + dir.getPath ());

//få den absoluta banan
Script.out (”den absoluta banan är: ” + dir.getAbsolutePath ());

//få parentarkivet
Spara parent = dir.getParentFile ();
Script.out (”parentbanan är: ” + parent.getAbsolutePath ());

Exempel: information om arkiv

//I java, arkiv och sparar information erhålls från javaen sparar klassificerar

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

//få standarden java det tillfälliga arkivet
String tmpdir = System.getProperty (”java.io.tmpdir”);

//tryck ut det kända arkivet
Script.out (”mappen för standardjava vikarier är: ” + tmpdir);

//skapa ett nytt sparar anmärker av arkivet
Spara den nya mappen för dir = (tmpdir);

//få lista av sparar namnger i diren
String [] namn = dir.list ();

//tryck ut som de första 100na namnger, sparar allra i din vikariedir
intern maximal = names.length;
om (maximal > 100)
{
maximal = 100;
}

för (intern i=0; i < maximal; i++)
{
Script.out (”mapp” + I + ”=” + namn [I]);
}

//få ett uppbåd av sparar anmärker 
Spara [] mappar = dir.listFiles ();

//tryck, ut som informationen för de första 100na sparar. 
Name = "" för rad;
lång size = 0;
Datera ändrat;

//få standard daterar tidformatteren
DateFormat df = DateFormat.getDateTimeInstance ();
"" För radändring =;

för (intern i=0; i < maximal; i++)
{
Rad name = sparar [I] .getName ();
size = sparar [I] .length ();
ändrat nytt datum för = (mappar [I] .lastModified ());
(ändrad) ändring = df.format;
Script.out (”mapp” + I + ”=” + namn + ”, size =” + size + ”, tidsstämpel =” + ändring);
}

Exempel: gör mappar

//exempel som gör mappar 

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

//få standarden java det tillfälliga arkivet
String tmpdir = System.getProperty (”java.io.tmpdir”);

//tryck ut det kända arkivet
Script.out (”mappen för standardjava vikarier är: ” + tmpdir);

//skapa ett nytt sparar anmärker av arkivet
Spara den nya mappen för dir = (tmpdir);

//skapa en spara anmärker föreställa en ny subfolder inom tmpdir
Spara den nya mappen för newdir = (dir, ”newDirectory2”);

//kontroll, om mappen finns
boolean finns = newdir.exists ();
om (finns riktig ==),
{
Script.out (”mappen finns redan: ” + newdir.getAbsolutePath ());
retur; //inget behov att skapa subfolder
}

//gör en ny subdirectory. metoden går riktigt tillbaka, om den lyckas
//falska retur, om mappen finns redan, eller kunde inte skapa mappen
boolean framgång = newdir.mkdir ();
om (riktig framgångs==)
{
Script.out (”skapade den nya mappen: ” + newdir.getAbsolutePath ());
}

Dela upp 6 - Metoder drar tillbaka för att överträffa

Exempel: använda metoder

//du kan definiera metoder för att reuse kod i dina script
//alla metoder MÅSTE definieras, för huvudscriptet utförs

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

//denna metod outputs enkelt strängameddelandet till efterbehandlingen loggar
annullera ut (stränga meddelandet),
{
Script.out (meddelande);
}

//denna metod får kvadrera av en numrera
internt kvadrera (intern förlaga)
{
gå förlaga * förlaga tillbaka;
}

//den huvudsakliga metoden startar nu
//testa de ovannämnda metoderna
ut (”detta är ett prov av att använda metoder i script”);
intern fyrkant för fiveSquare = (5);
ut (”fem kvadrerar är” + fiveSquare);

Exempel: hitekmetoder

//oss ge några metoder, som låter dig köra taskar, journaldata, få och ställ in variables och taskparametrar.

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

//skriv en stränga till efterbehandlingen loggar
Script.out (”Writing till efterbehandlingen loggar”);

//skriv en stränga till aktiviteten loggar
Script.act (”Writing till aktiviteten loggar”);

//skriv en felbunttrace till feltestningen loggar
försök
{
Integer.parseInt (”dåligaheltal”);
}
lås (undantag e)
{
Script.err (e);
}

//kör en task och få utgångskoden
//ser till du att skriva in en giltig tasktitel här
RadtaskTitle = ”Enter_valid_task_title_here”;
taskTitle = ”kopia”;
intern exitCode = Script.run (taskTitle);
Script.out (”utgångskod av task =” + exitCode);

//få en taskparamter. Du behöver att skriva in den nyckel- korrekta taskTitlen och parametern
//look på egenskapsmapparna av taskarna i den data- \ taskmappen.
//dessa sparar show som parametern stämm från Task.PARAMETERS0 till Task.PARAMETERS50

//läs Task.PARAMETERS1
String par = Script.getPar (taskTitle, ”Task.PARAMETERS1”);
Script.out (”Task.PARAMETERS1 =” + par);

//set en taskparameter dynamiskt
Script.setPar (taskTitle, ”Task.PARAMETERS1”, ”nytt testar värderar”);

//läste igen den ut för att bekräfta att ändringar gjordes
par = Script.getPar (taskTitle, ”Task.PARAMETERS1”);
Script.out (”Task.PARAMETERS1 =” + par);

//du kan få alla task, användare, java och systemvariablevärden
//du kan den fastställda användaren som variablen värderar. Vi låter inte variabla värden för task, java eller för system överskrivas.
taskTitle för radvar = + ”::ExitCode”;
Radvärde = Script.getVar (var);
Script.out (”variabelt värde =” + värde);

//uppsättning som en användarevariable värderar
Script.setVar (”newVariable”, ”variable som testar”);
värde = Script.getVar (”newVariable”);
Script.out (”nytt variabelt värde =” + värde);

 Dra tillbaka för att överträffa