• Kraftigt, böjligt, pålitligt och som man har råd med
• Scripting särdrag är tillgängliga för avancerade användare och programmerare
• Kör uppgifter 1000+ om dagen
• Teknisk service i rätt tid och fri för och efter dig inhandlar
• Frigör 30 dag prov och fria minorförbättringar
• Körningar på Windows, Mac OSX, Linux och andra Unixplattformar

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

Scripting (Automize professionell och Automize företagupplagor)

• Skapa komplexa automationskrifter som bygger på existerande Automize uppgifter
• Framkalla skrifter, som förminskar upprepade mödosama computer-related aktiviteter.
• Tillfoga avancerad funktionsduglighet till dina Automize uppgifter lik email, FTP, övervakar, sparar, och arkivet listar.
• Använd skriftsärdrag för att få sparar listar, eller filenames, som du kan använda in, kopierar, FTP, vinandeuppgifter etc.…,
• Du kan läsa och uppsättningen värdera av uppgiftsparametrar från skriften. Kör därefter uppgiften från skriften. Detta förminskar komplexiteten av skriften.
• Precis 20-50 fodrar av kodifierar kan resultera är extremt kraftiga skräddarsy uppgifter och lösningar.
• Vi ger fri hjälp för liten 20-50 fodrar skriften som kan vara användbar till användare.
• Djupgående tutorial och tar prov kodifierar för att få dig startade.
• Vår forum har direktanslutet många faktiskt att kodifiera exempel som baseras på applikationer för verklig användare.

Exempelskrift:
1) Skriften läser sparar listar från sparar systemet
2) Parametrar för skriftuppsättninguppgiften som baseras på, sparar - namnge och mappen
3) Skriften kör uppgift. Uppgiften kör efter läs- uppgiftsparametrar som är fastställda via skriften.
4) Skriften läser uppgift går ut kodifierar och uppgiftsvariables
5) Skriften kan fortsätta rinnande uppgift i samma ordnar 2-4 för alla filenames

-----------------------------------------------------------------------------------------------------------------------------------------------,
Automize Java Scripting Tutorial

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.

Kopiera och klistra dessa exempel in i det Automize skriftfönstret för att följa igenom i denna tutorial. 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: Inledande skrift

//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 huvudsaklig () metodstund som scripting

//definiera en stränga
Stränga testar = ”välkomnar till java som scripting!!”;

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

Exempel: Genom att använda skriften klassificera

//Skriften klassificera ger en anslutning mellan dina skrifter, och inbuilt Hitek programvara fungerar

//importmeddelanden låter dig använda existerande Hitek programvara, eller java fungerar
//I detta exempel, oss import som den Hitek programvaruskriften klassificerar

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

//definiera en stränga

Stränga testar = ”välkomnar till Java Scripting!!”;

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

Script.out (testa);

//, efter du har kört/, testar denna skrift, kontrollerar efterbehandlingen loggar sparar (loggar menyn i den Automize användaren har kontakt),

Exempel: Heltal och strängar

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

//heltal - du skar vanligt internt bruk eller long i dina skrifter
intern largestInteger = Integer.MAX_VALUE;
lång largestLong = Long.MAX_VALUE;

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

//Stränga - du skar använder strängar mycket
Stränga testString = ”java strängar är mycket användbart”;

Script.out (”maximat heltal värderar =” + largestInteger);
Script.out (”det långa maximat värderar =” + largestLong);
Script.out (”värdera av javaRocks =” + javaRocks);
Script.out (testString);

//kontroll som efterbehandlingen loggar, efter du har kört denna skrift.

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

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++ som är ny värdera 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 som efterbehandlingen loggar, efter du har kört denna skrift.

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 som efterbehandlingen loggar, efter du har kört denna skrift.

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 som efterbehandlingen loggar, efter du har kört denna skrift.

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

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

Exempel: om meddelanden

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

interna vikarier = 100;
Stränga rider ut = ”förkylning”;

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

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

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

vikarier = 75;
om (vikarier < 70)
{
rida ut = ”kyler”;
}
annars, om (vikarie>= 70 & & vikarie<= 80)
{
rida ut = ”görar perfekt”;
}
annars
{
rida ut = ”hoat”;
}
Script.out (”rida ut är i dag” + rider ut);


//kontroll som efterbehandlingen loggar, efter du har kört denna skrift.

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

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

//definiera ett heltal, och tomt stränga
intern summa = 0;
Stränga resultatet = "";

//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 ström = 1; ström<= 10; current++) 
{
summa = summa + ström;
resultatet = ”strömmen kretsar numrerar =” + strömmen + ”, summan =” + summan;
Script.out (resultat);
}

//, efter du har kört/, testar denna skrift, kontrollerar efterbehandlingen loggar.

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;

internt kretsa = 1;
internt 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. kretsa =” + kretsar);

//ö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
kretsa = 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. kretsa =” + kretsar);

//ö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;
Stränga dagen = ””;

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;

internt 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
internt kretsa = 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 stund kretsar med continen för upprepningar <. upprepning 3 =” + kretsar);

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

internt 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. kretsa =” + I);
om (I->=maximal) 
{
avbrott;
}
}

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

//avbrott ut ur en oändlig stund kretsar
internt kretsa = 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. kretsa =” + kretsar);

//ö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
Stränga stren = ”det min förnamnet ä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
Stränga anotherString = ”det min förnamnet ä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
Stränga lowerCaseString = ”det min förnamnet ä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
Stränga stren = ”det min förnamnet är John. Det min efternamn är doen.”;
Stränga str2 = ”mig gillar tårtan.”;

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

//länka samman (fästa), another strängar till detta strängar
Stränga 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 (”min”, ”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 (”Substringbörjan på index 8 =” + str3);

//få en substring innehållen inom specificerade index
str3 = str.substring (8.30);
Script.out (”Substringbörjan på indexet 8 och avsluta på index 30 =” + str3);

//omvänd strängar till lowercase
str3 = str.toLowerCase ();
Script.out (”konvertera stränga till lowercase =” + str3);

//omvänd strängar till bokstav
str3 = str.toUpperCase ();
Script.out (”konvertera stränga till bokstav =” + 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;
flotte f = 25.45;

Heltal I = nytt heltal (I);
Flotte F = ny flotte (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. 
Stränga intString = ”25”;
Stränga longString = ”123456789”;
Stränga 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);

flotte 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
internt i2 = 3;
internt i3 = - 7;
långt l = 123456787;
flotte f = 25.45;
dubbelt d2 = 25.34;
dubbelt 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 (”logga (3) =” + Math.log (i2));

//få kvadrerar rotar värderar
Script.out (”kvadrera rotar 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
boolean trueBoolean = true;
boolean falseBoolean = falskt;

//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
Stränga trueString = ”riktigt”;
Boolean testa = Boolean.valueOf (trueString);
boolean convertedBoolean = test.booleanValue ();
Script.out (”konvertera stränga ”true” till boolean typ”);
Script.out (”konverterade boolean värderar =” + 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
arr = nytt internt [10]; 

//tilldela en värdera till varje uppbådbeståndsdel och skriv den ut ut
//fältet ”längd” går storleksanpassa av uppbådet 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
Stränga [] stren = {”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
Stränga [] [] namnger =
{
{”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. Ro =” + 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. Ro =” + 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
Vektor v = ny vektor ();

//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. storleksanpassar (); i++) 
{
Script.out (”uppbådbeståndsdelen på indexet: ” + I + ”är: ” + V. får (I) .toString ());
}

//tryck ut storleksanpassa av vektorn
Script.out (”vektorn storleksanpassar är: ” + V. storleksanpassar ());

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

//tryck ut storleksanpassa av vektorn igen
Script.out (”borttagen beståndsdel på index 3. Den nya vektorn storleksanpassar är: ” + V. storleksanpassar ());

//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 storleksanpassa av vektorn
Script.out (”vektorn görade klar. Vektorn storleksanpassar är: ” + V. storleksanpassar ());

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
Datera nu = nytt daterar ();

//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 importen java.text.DateFormaten att klassificera upptill av skriften
//java.text.DateFormat importeras inte automatiskt av skriften.
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ång startMillis = now.getTime ();
Script.out (”starttid i millis: ” + startMillis);

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

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

//oss kan också konvertera en tid i millisekunder till en datera 
Datera endDate = nytt daterar (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
Stränga shortDateString = ”4/11/06 6:53 PM”;
Stränga 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
Datera 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
Datera 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
Datera dateNow = 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 (”AMNA/PMEN värderar ä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 igår = Calendar.getInstance ();
yesterday.add (Calendar.DATE, - 1);

Kalender i morgon = 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
Stränga 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 dir = nytt sparar (tmpdir);

//skapa ett nytt sparar anmärker
Spara newFile = nytt sparar (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 (”spara - namnge =” + newFile.getName ());
Script.out (”spara storleksanpassar =” + newFile.length ());
Script.out (”spara banan =” + newFile.getPath ());
Script.out (”spara den absoluta banan =” + newFile.getAbsolutePath ());
Script.out (”spara den canonical banan =” + newFile.getCanonicalPath ());
Script.out (”sparar arkivet =” + newFile.getParent ());
Script.out (”spara är läsligt =” + newFile.canRead ());
Script.out (”spara är writeable =” + newFile.canWrite ());
Script.out (”spara döljas =” + newFile.isHidden ());
DateFormat df = DateFormat.getDateTimeInstance ();
lång modtime = newFile.lastModified ();
Datera ändring = nytt daterar (modtime);
Script.out (”spara daterar =” + df.format (ändring));

Exempel: spara metoder

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

//få standarden java det tillfälliga arkivet
Stränga 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 dir = nytt sparar (tmpdir);

//skapa ett nytt sparar anmärker
Spara file1 = nytt sparar (dir, ”file1.txt”);
Spara file2 = nytt sparar (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
Stränga 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 dir = nytt sparar (tmpdir);

//skapa ett nytt sparar anmärker
Spara file1 = nytt sparar (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);
Stränga fodrar = ""; 
stunder ((fodra = br.readLine ())!= ogiltigt)
{
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
Stränga 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 dir = nytt sparar (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 parenten = 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
Stränga 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 dir = nytt sparar (tmpdir);

//få lista av sparar namnger i diren
Stränga [] namnger = dir.list ();

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

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

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

//tryck, ut som informationen för de första 100na sparar. 
Stränga känt = "";
långt storleksanpassa = 0;
Datera ändrat;

//få standard daterar tidformatteren
DateFormat df = DateFormat.getDateTimeInstance ();
Stränga ändring = "";

för (intern i=0; i < maximal; i++)
{
Stränga känt = sparar [I] .getName ();
storleksanpassa = sparar [I] .length ();
ändrat = nytt datera (sparar [I] .lastModified ());
ändring = (ändrad) df.format;
Script.out (”spara” + I + ”=” + känt + ”, storleksanpassar =” + storleksanpassar + ”, 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
Stränga 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 dir = nytt sparar (tmpdir);

//skapa en spara anmärker föreställa en ny subfolder inom tmpdir
Spara newdir = nytt sparar (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 återanvända kodifierar i dina skrifter
//alla metoder MÅSTE definieras, för den huvudsakliga skriften 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 (”denna är en testa av att använda metoder i skrifter”);
intern fiveSquare = kvadrerar (5);
ut (”fem kvadrerar är” + fiveSquare);

Exempel: hitekmetoder

//oss ge några metoder som låter dig köra uppgifter, loggar data, får och fastställda variables och uppgiftsparametrar.

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 uppgift och få gå ut kodifierar
//ser till du att skriva in en giltig uppgiftstitel här
Stränga taskTitle = ”Enter_valid_task_title_here”;
taskTitle = ”kopierar”;
intern exitCode = Script.run (taskTitle);
Script.out (”gå ut kodifierar av uppgift =” + exitCode);

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

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

//uppsättning en uppgiftsparameter 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å all uppgift, användaren, java, och systemvariablen värderar
//du kan den fastställda användaren som variablen värderar. Vi låter inte uppgiften, java, eller systemvariablen värderar för att överskrivas.
Stränga var = taskTitle + ”::ExitCode”;
Stränga värderar = Script.getVar (var);
Script.out (”variablen värderar =” + värderar);

//uppsättning som en användarevariable värderar
Script.setVar (”newVariable”, ”variable som testar”);
värdera = Script.getVar (”newVariable”);
Script.out (”den nya variablen värderar =” + värderar);

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