• 易用： 没有需要的编程或scripting，图形接口
• Scripting功能为高级用户和程序员是可用的
• 强大，多才多艺，可靠和价格合理
• 运行千位task每日
• 及时和free技术支持在您前后购买
• free 30天试用和free较小升级
• 在Window、Mac OSX， Linux和其他UNIX平台运行

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

Scripting (Automize professional和Automize企业版)

• 创建编译在现有的Automize task的复杂自动化script
• 开发减少被重复的script，费力计算机有关的活动。
• 添加先进的功能到您的Automize task象电子邮件、FTP、监控器、文件和目录列表。
• 使用Script功能get您在复制、FTP， zip task等能使用的文件列表或文件名。
• 您能读和设置task参数的值从script。 然后运行task从script。 这减少script的复杂。
• 20-50个代码行可能发生是极其强大的自定义的task和解决方法。
• 我们为可以是可用的对用户的小的20-50条线路script提供free帮助。
• get您的详细指南和范例编码开始了。
• 我们的在线论坛有根据实际用户应用的许多实际编码示例。

示例Script ：
1) Script读文件列表从文件系统
2) Script设置task参数根据文件名字和文件夹
3) Script运行task。 Task运行在之后读task参数通过script设置了。
4) Script读task退出编码和Task变量
5) Script在同样顺序2-4可能持续运行task为所有文件名

-----------------------------------------------------------------------------------------------------------------------------------------------
Automize Java Scripting指南

Automize为其scripting使用BeanShell (beanshell.org)。  BeanShell支持100% Java语法，并且Automize在Java被写。  这是一个非常好方式了解Java语法和开始在最容易和最强大的现代编程语言。

进行到底在本指南，复制和粘贴这些示例到Automize Script Window。 然后运行这些示例：

第1部分-基本要点
第2部分-控制语句
第3部分-字符串、数和Booleans
第4部分-列阵和日期
第5部分-文件和目录
第6部分-方法

第1部分-基本要点

示例： 介绍Script

开始时//的//线路是注释行

//多数编程语言(c、Java、c++等等要求一个主要()方法)
然而//，您不需要定义一个主要()方法而scripting

//定义一个字符串
串起测试= “欢迎到Java scripting!!”;

//给系统stdout写
System.out.println (测试);

示例： 使用Script选件类

//Script选件类提供一连接在您的script和Hitek Software内藏的功能之间

//导入语句允许您使用现有的Hitek Software或Java功能
//在本例中，我们导入Hitek Software Script选件类

导入com.hitek.engine.mods.script.Script;

//定义一个字符串

串起测试= “欢迎到Java Scripting!!”;

//购买权写输出的Script.out方法给输出log文件

Script.out (测试);

//在您以后运行/测试此script，查输出log文件(log菜单在Automize用户接口)

示例： 整数和字符串

导入com.hitek.engine.mods.script.Script;

//整数-您频繁地将使用int或长在您的script
int largestInteger = Integer.MAX_VALUE;
长的largestLong = Long.MAX_VALUE;

//布尔型-您也将需要使用布尔型 
布尔型javaRocks =真;

//字符串-您将使用字符串很多
testString = “Java字符串的字符串是非常有用的”;

Script.out ("最大整数值=” + largestInteger);
Script.out ("最大长的值=” + largestLong);
Script.out (" javaRocks =的值” + javaRocks);
Script.out (testString);

//查输出log在您以后运行此script。

示例： 此示例显示表达式哪些与整数一起使用。  查输出log在您以后运行此script。

导入com.hitek.engine.mods.script.Script;

int m = 10;
int k = 5;

Script.out ("可变值…”);
Script.out (" m =” + m);
Script.out (" k =” + k);

//使用增量运算符++
m++;
Script.out ("增加使用m++， m =的新的值” + m);

//使用> (大于) < (较少比)
如果(m > k)
{
Script.out ("是”， +m + “大于” + k);
}

//使用>= (大于或等于)和<= (小于或等于) 
如果(m >= k +5)
{
Script.out ("是， m是大于或等于k + 5”);
}

//使用等于运算符==
如果(k==5)
{
Script.out ("是， k是等于的到5”);
}

//使用不是等于运算符!=
如果(k!= 5)
{
Script.out ("是， k不是等于的到5”);
}

//使用& & (逻辑和)
如果((k == 5) & & (m==10))
{
Script.out ("是， k是等于的到5，并且m是等于的到10”);
}

//使用 || (逻辑或)
如果((k == 5) || (m==234545))
{
Script.out ("是，或者k是等于的到5，或者m是等于的到10”);
}

//查输出log在您以后运行此script。

示例： 此示例显示基本的整数操作的运算符

导入com.hitek.engine.mods.script.Script;

//此示例显示基本的整数操作的运算符
//查输出log在您以后运行此script。

int i = 10;
int k = 5;

Script.out ("可变值…”);
Script.out (" i =” + i);
Script.out (" k =” + k);

数的//添加
Script.out ("添加…”);
Script.out (" i + k =” + (i + k));

数的//减去
Script.out ("减去…”);
Script.out (" i - k =” + (i - k));

数的//倍增
Script.out ("倍增…”);
Script.out (" i * k =” + (i * k));

数的//分开
Script.out ("分开…”);
Script.out (" i/k =” + (i/k));

//查输出log在您以后运行此script。

第2部分-控制语句回到顶层

示例： 如果语句

导入com.hitek.engine.mods.script.Script;

int临时= 100;
字符串天气= “寒冷”;

//简单形式的如果语句： 
如果(临时> 80) 
{
天气= “热”;
}
Script.out ("天气今天是” +天气);

//(如果+)语句
临时= 60;
如果(临时> 80)
{
天气= “热”;
}

{
天气= “好”;
}
Script.out ("天气今天是” +天气);

//(如果+ (如果) +)语句

临时= 75;
如果(临时< 70)
{
天气= “好”;
}
如果(临时>= 70 & &临时<= 80)
{
天气= “完善”;
}

{
天气= “热”;
}
Script.out ("天气今天是” +天气);


//查输出log在您以后运行此script。

示例： 使用“为”循环

导入com.hitek.engine.mods.script.Script;

//定义一个整数和空字符串
int总和= 0;
字符串结果= "";

//使用一个“为”循环在1和10之间，增量总和由1。 
增加运算符的//++
//<=是小于或等于

为(当前int = 1; 当前<= 10; current++) 
{
总和=总和+当前;
结果= “电流线圈数=” +当前+ “，总和=” +总和;
Script.out (结果);
}

//在您以后运行/测试此script，查输出log。

示例： 当循环时

//当语句连续执行语句时块当情况是满足的时
//当循环评估表达式在循环的顶层时

//是非常CAREFULL与当循环时。 
//切记您增加值退出循环。

导入com.hitek.engine.mods.script.Script;

int循环= 1;
int最大= 7;

当时(循环<最大) 
{
//警告-如果您陷在您必须重新启动引擎/用户接口的一个死循环
Script.out ("这是一会儿循环。 循环=” +循环);

//增量循环的值这当时循环将从未否则终止!!
loop++;
}

//做当循环评估表达式在底层

//被重新设置的循环值到1
循环= 1; 
 
{
//警告-如果您陷在您必须重新启动引擎/用户接口的一个死循环
Script.out ("这是做当循环。 循环=” +循环);

//循环的值此的增量做当循环将从未否则终止!!
loop++;
}
当时(循环<最大);

示例：  切换语句 

//切换语句有条件地执行根据整数表达式的语句

导入com.hitek.engine.mods.script.Script;

int dayNumber = 3;
字符串日= ““;

切换(dayNumber)
{
案例1 ： day= "星期天"; 
中断;
案例2 ： day= "星期一"; 
中断;
案例3 ： day= "星期二"; 
中断;
案例4 ： day= "星期三"; 
中断;
案例5 ： day= "星期四"; 
中断;
案例6 ： day= "星期五"; 
中断;
案例7 ： day= "星期六"; 
中断;
}

Script.out ("今天是” +日);

示例： 继续语句

//继续语句允许您跳过当前迭代为或当循环时

导入com.hitek.engine.mods.script.Script;

int最大= 7;

//发生a为循环
为(int i=1; i < 10; i++) 
{
如果(i > 3 & & i < 7) 
{
继续;
}
Script.out ("这是a为循环与继续。 迭代=” + i);
}


//继续并且发生无限当循环时
int循环= 1;
当时(真) 
{
//警告-如果您陷在您必须重新启动引擎/用户接口的一个死循环
//增量循环的值这当时循环将从未否则打开!!
//增量应该在继续语句之前执行
loop++;

当循环将从未终止，//打开此!时!
如果(循环>最大)
{
中断;
}

//继续到下迭代为迭代1和2
如果(循环< 4)
{
继续;
}

Script.out ("这是一会儿循环与contine为迭代< 3。迭代=” +循环);

//您不可能在继续以后有循环增量。 
//!! 循环++; !! 循环++不应该这里。 应该在继续之前位于它。
}
Script.out ("发生当循环在循环以后>” +最大)时;

示例： 中断语句

//中断语句允许您发生循环。 

导入com.hitek.engine.mods.script.Script;

int最大= 7;

//发生a为循环
为(int i=1; i < 10; i++) 
{
//警告-如果您陷在您必须重新启动引擎/用户接口的一个死循环
Script.out ("这是a为循环。 循环=” + i);
如果(i >=最大) 
{
中断;
}
}

Script.out ("发生为循环在循环以后>” +最大);

//发生无限当循环时
int循环= 1;
当时(真) 
{
//警告-如果您陷在您必须重新启动引擎/用户接口的一个死循环
Script.out ("这是一会儿循环。 循环=” +循环);

//增量循环的值这当时循环将从未否则终止!!
loop++;

当循环将从未终止，//打开此!时!
如果(循环>最大)
{
中断;
}
}
Script.out ("发生当循环在循环以后>” +最大)时;

第3部分-字符串、数和Booleans回到顶层 

示例： Java字符串选件类功能

//Java字符串选件类允许您get信息，搜索，操作，转换，并且输出字符串

导入com.hitek.engine.mods.script.Script;

//定义一个字符串
字符串str = “我的名字是John。 我的姓氏是母鹿。”;

//打印他们出来
Script.out ("测试字符串是： ” + str);

//get字符串长度
Script.out ("字符串str的长度是： ” + str.length ());

//get字符在索引8
Script.out ("字符在索引9是： ” + str.charAt (9));

//查找一个顺序的第一个出现时间在字符串和打印索引
Script.out ("顺序“名字”首先被查找了在索引：” + str.indexOf ("名字”));

//如果顺序没有被找到，回归索引是- 1
默认情况下//Java串搜索和其他运算区分大小写
Script.out ("顺序“名字”被查找了在索引：” + str.indexOf ("名字”));

//查找一个顺序的第一个出现时间在字符串，开始搜索在索引15
Script.out ("顺序“名字”也被查找了在索引：” + str.indexOf ("名字”， 15));

//查找一个顺序的最后出现时间在字符串和打印索引
Script.out ("顺序“名字”前被查找在索引：” + str.lastIndexOf ("名字”));

如果字符串开始以某一顺序，//查。
如果字符串开始以键入，的顺序//startsWith方法返回布尔型配齐。
如果(str.startsWith ("我”) ==真)
{
Script.out ("是。 测试字符串开始以“我””);
}

如果字符串以某一顺序，结束//查。
如果字符串以键入，的顺序结束//startsWith方法返回布尔型配齐。
如果(str.endsWith ("母鹿”。 ) ==真)
{
Script.out ("是。 测试字符串末端与“母鹿”。 “);
}

如果字符串等于另一个字符串，//查
anotherString =的字符串“我的名字是John。 我的姓氏是母鹿。”;
Script.out (" anotherString的=” + anotherString);
如果(str.equals (anotherString))
{
Script.out ("是。 二字符串是等于的”);
}

如果字符串等于忽略案件，的另一个字符串//查
lowerCaseString =的字符串“我的名字是john。 我的姓氏是母鹿。”;
Script.out (" lowerCaseString的=” + lowerCaseString);
如果(str.equalsIgnoreCase (lowerCaseString))
{
Script.out ("是。 二字符串是等于的忽略案件”);
}

示例：  字处理

//字处理示例

导入com.hitek.engine.mods.script.Script;

//定义那些字符串
字符串str = “我的名字是John。 我的姓氏是母鹿。”;
字符串str2 = “我喜欢蛋糕。”;

//打印它
Script.out ("测试字符串是： ” + str);

//连接(添附)另一个字符串对此字符串
串起str3 = str.concat (str2);
Script.out ("连接str2对str1。 结果： ” + str3);

//用另一个字符串替换字符串(或规则表达样式的)第一个出现时间
str3 = str.replaceFirst ("是”， “是”);
Script.out ("替换第一个出现时间“”与“是”。 结果： ” + str3);

//用另一个字符串替换字符串(或规则表达样式的)所有出现时间
str3 = str.replaceAll ("我”， “他的”);
Script.out ("替换所有出现时间“我”用“他的”。 结果： ” + str3);

//get子链期初在指定的索引
str3 = str.substring (8);
Script.out ("子链期初在索引8 =” + str3);

//get在指定的索引内包含子链
str3 = str.substring (8,30);
Script.out ("子链期初在索引8和结束在索引30 =” + str3);

//转换字符串到小写
str3 = str.toLowerCase ();
Script.out ("转换字符串成小写=” + str3);

//转换字符串到大写
str3 = str.toUpperCase ();
Script.out ("转换字符串成大写=” + str3);

示例： Java数

//Java数原始类型包括int，长，浮动，双，短小，字节
//您将主要要求int和长期。 有时您可能需要使用浮动。
//每一个个这些个原始类型有在他们附近包裹的Java类。 
//选件类整数换行在int附近。 长期长期选件类换行。

导入com.hitek.engine.mods.script.Script;

//定义有些数
int i = 3;
长的l = 123456787;
浮动f = 25.45;

整数I =新的整数(i);
浮动F =新的浮动(f);
长的L =新的长的(l);

//打印int和整数
Script.out (" int i是： ” + i);
Script.out ("封皮选件类整数是： ” + I. toString ());

//打印长和长期
Script.out ("长的l是： ” + l);
Script.out ("封皮选件类长期是： ” + L. toString ());

//打印浮动和浮动
Script.out ("浮动f是： ” + f);
Script.out ("封皮选件类浮动是： ” + F. toString ());

示例： 转换字符串值到数

//您频繁地将需要转换字符串值成数

导入com.hitek.engine.mods.script.Script;

//定义那些字符串。 
串起intString的= “25”;
串起longString的= “123456789”;
串起floatString的= “25.567”;

int i = Integer.valueOf (intString);
//打印int
Script.out (" int i是： ” + i);

长的l = Long.valueOf (longString);
//打印长
Script.out ("长的l是： ” + l);

浮动f = Float.valueOf (floatString);
//打印浮动
Script.out ("浮动f是： ” + f);

示例： Java算术选件类

//Java算术选件类提供更多算术功能，除之外+， -，/或*

导入com.hitek.engine.mods.script.Script;

//定义有些数
int i2 = 3;
int i3 = - 7;
长的l = 123456787;
浮动f = 25.45;
双d2 = 25.34;
双d3 = 2.4;

//打印最多二数
Script.out ("最大数量在i2和i3之间是： ” + Math.max (i2， i3));

//打印最小限度于二数
Script.out ("最小数量在i2和i3之间是： ” + Math.min (i2， i3));

//来回浮动
Script.out (" 25.45被舍入： ” + Math.round (f));

//get exp值
Script.out (" exp (3) =” + Math.exp (i2));

//get log值
Script.out (" log (3) =” + Math.log (i2));

//get方根值
Script.out ("方根3 =” + Math.sqrt (i2));

示例： 布尔型选件类

//布尔型选件类换行在Java原始类型附近布尔型
//原始布尔型可以是“真”或“错误的” (区分大小写)

导入com.hitek.engine.mods.script.Script;

//定义那些booleans
布尔型trueBoolean =真;
布尔型falseBoolean =错误;

//转换布尔型对字符串和打印布尔型 
Script.out (" trueBoolean是： ” + trueBoolean.toString ());
Script.out (" falseBoolean是： ” + falseBoolean.toString ());

//使用布尔型选件类转换字符串成布尔型
trueString =的字符串“真”;
布尔型测试= Boolean.valueOf (trueString);
布尔型convertedBoolean = test.booleanValue ();
Script.out ("转换字符串“真”成布尔型类型”);
Script.out ("被转换的布尔值=” + convertedBoolean.toString ());


第4部分-列阵和建于顶层

示例： 列阵

//列阵将频繁地要求得处理目录列表和其他用途。

导入com.hitek.engine.mods.script.Script;

//宣称intetger列阵
int [] arr; 

//创建整数列阵
arr =新的int [10]; 

//赋予值到每种数组元素并且打印它出来
//域“长度”返回列阵的size
// 
为(int i = 0; i < arr.length; i++) 
{
arr [i] = i * 2;
Script.out ("数组元素在索引： ” + i + “是： ” + arr [i]);
}

//用途实例字符串列阵
字符串[] str = {“你是1”， “二是2”， “三是3”};
为(int i = 0; i < str.length; i++) 
{
Script.out ("数组元素在索引： ” + i + “是： ” + str [i]);
}

//第2个列阵
字符串[] []名字=
{
{“票据”， “突然移动”， “贝蒂”}，
{“标记”， “暗淡”，}，
{“karen”， “全部赌注”， “凯文”， “kong”，}，
};

为(int i = 0; i < names.length; i++) 
{
Script.out (" 1-D起始时间subarray名字。 A +PRED =” + i);
为(int j = 0; j <名字[i] .length; j++) 
{
Script.out (名字[i] [j] + ““);
}
Script.out (" 1-D的结尾subarray名字。 A +PRED =” + i);
}

示例： 向量

//A向量是可能动态地增长或收缩的列阵
//A向量可能包含对象或原始Java类型的任何类型

导入com.hitek.engine.mods.script.Script;

//创建一空白arraylist
导航v =新的向量();

//添加有些要素到它
v.添加(0);
v.添加("正选”);
v.添加("第二个字符串”);
v.加(3);
v.添加(新的日期());

//打印向量要素
为(int i = 0; i < v. size (); i++) 
{
Script.out ("数组元素在索引： ” + i + “是： ” + v. get (i).toString ());
}

//打印size向量
Script.out ("向量size是： ” + v. size ());

//去除要素在索引3
v.去除(3);

//打印size再向量
Script.out ("被去除的要素在索引3。 新的向量size是： ” + v. size ());

//插入要素到索引3里再
v.添加(3， “Insert先生”);

//打印要素3
Script.out ("被插入的要素在索引3是： ” + v. get (3).toString ());

//搜索向量为对象
如果(v.包含(" Insert先生”))
{
Script.out ("是，此向量包含要素“Insert先生””);
}

//打印“Insert先生”索引
Script.out (" Insert先生索引是： ” + v. indexOf (" Insert先生”));

//清楚列阵
v.结算();

//打印size向量
Script.out ("向量清除了。 向量size是： ” + v. size ());

示例： 日期和DateFormat选件类

//日期和DateFormat选件类是有用的在格式化，解析和修改文件时间标记
//日历选件类帮助进行日期处理和比较。

导入com.hitek.engine.mods.script.Script;
导入java.text.DateFormat;

//get当前日期
现在日期=新的日期();

//打印日期使用默认制格式器
Script.out ("当前默认格式化日期/时间是： ” + now.toString ());

//创建显示短的日期和短期格式的一台自定义日期制格式器
//您必须导入java.text.DateFormat选件类在script的顶层
script没有自动地导入//java.text.DateFormat。
DateFormat df = DateFormat.getDateTimeInstance (DateFormat.SHORT， DateFormat.SHORT);

//打印日期使用此自定义短的制格式器
Script.out ("当前短的格式日期/时间是： ” + df.format (现在));

//切换格式到久日期和时刻
df = DateFormat.getDateTimeInstance (DateFormat.LONG， DateFormat.LONG);
Script.out ("当前长的日期/时间是： ” + df.format (现在));

//在毫秒让计算共用的时间
//getTime ()方法返回总毫秒流逝了自从计算机时间(~1970)起始时间
长的startMillis = now.getTime ();
Script.out ("启动时间在millis ： ” + startMillis);

//让重估日期
现在=新的日期();
长的endMillis = now.getTime ();
Script.out ("结尾时间在millis ： ” + endMillis);

//计算共用的时间在millis
长的diff = endMillis - startMillis;
Script.out ("在millis elaspsed时间： ” + diff);

//我们在毫秒能也转换一时期成日期 
日期endDate =新的日期(endMillis);
Script.out ("结尾时间以长的格式： ” + df.format (endDate));

示例： 解析日期

//解析建于字符串

导入com.hitek.engine.mods.script.Script;
导入java.text.DateFormat;

//定义一个日期字符串
串起shortDateString的= “4/11/下午06点6:53”;
串起longDateString的= “2006年4月11日6:53 ：下午27点PDT”;

//定义短的日期格式
DateFormat df = DateFormat.getDateTimeInstance (DateFormat.SHORT， DateFormat.SHORT);

//解析短的日期
日期shortDate = df.parse (shortDateString);

//打印短的日期使用默认制格式器
Script.out (" shortDate正确地解析。 短的日期： ” + shortDate.toString ());

//切换制格式器到长的日期格式
df = DateFormat.getDateTimeInstance (DateFormat.LONG， DateFormat.LONG);

//解析在长的日期
日期longDate = df.parse (longDateString);

//打印长的日期使用默认制格式器
Script.out (" longDate正确地解析。 长的日期： ” + longDate.toString ());

示例： 日历选件类

//日历选件类允许我们操作日期或比较日期

导入com.hitek.engine.mods.script.Script;
位于java.util程序包的//导入日期和日历选件类
导入java.util。*; //

//get当前日历
现在排进日程= Calendar.getInstance ();

//打印日历信息。
Script.out ("当前日历是： ” + now.toString ());

//转换日历对一个日期对象使用日历getTime ()功能
日期dateNow = now.getTime ();

//打印日期信息
Script.out ("获得的日期从日历是： ” + dateNow.toString ());

//转换每日期对一个日历使用日历setTime (日期)功能
now.setTime (dateNow);

//打印再日历信息
Script.out ("从日期获得日历是： ” + now.toString ());

//get日历的个人域
Script.out ("年是： ” + now.get (Calendar.YEAR));
Script.out ("月是： ” + now.get (Calendar.MONTH));
Script.out ("日期是： ” + now.get (Calendar.DATE));
Script.out ("时数(0-12)是： ” + now.get (Calendar.HOUR));
Script.out ("日(0-23的)时数是： ” + now.get (Calendar.HOUR_OF_DAY));
Script.out ("分钟是： ” + now.get (Calendar.MINUTE));
Script.out ("秒钟是： ” + now.get (Calendar.SECOND));
Script.out ("毫秒是： ” + now.get (Calendar.MILLISECOND));
Script.out (" AM/PM值是： ” + now.get (Calendar.AM_PM));

Script.out ("日星期是： ” + now.get (Calendar.DAY_OF_WEEK));
Script.out ("星期月是： ” + now.get (Calendar.WEEK_OF_MONTH));
Script.out ("日年是： ” + now.get (Calendar.DAY_OF_YEAR));
Script.out ("日星期在月是： ” + now.get (Calendar.DAY_OF_WEEK_IN_MONTH));
Script.out ("日月是： ” + now.get (Calendar.DAY_OF_MONTH));
Script.out ("星期年是： ” + now.get (Calendar.DAY_OF_YEAR));

//添加有些域到现在日历。 自动添加变成更大的域为您
昨天日历= Calendar.getInstance ();
yesterday.add (Calendar.DATE， - 1);

明天日历= Calendar.getInstance ();
tomorrow.add (Calendar.DATE， 1);

//打印对应于这些日历的日期。 在打印之前，第一个转换迄今反对
Script.out ("昨天是： ” + yesterday.getTime () .toString ());
Script.out ("明天是： ” + tomorrow.getTime () .toString ());

//使用日历昨天比较和明天在和在方法之前以后
如果(yesterday.before (明天))
{
Script.out ("是，昨天是在明天之前”);
}

如果(tomorrow.after (昨天))
{
Script.out ("是，明天是在昨天以后”);
}

第5部分-文件和目录回到顶层

示例： 目录和文件信息 

//在Java、目录和文件信息从Java文件选件类获得

导入com.hitek.engine.mods.script.Script;
导入java.text.DateFormat;

//get默认Java临时目录
串起tmpdir = System.getProperty (" java.io.tmpdir”);

//打印目录名称
Script.out ("默认Java临时文件夹是： ” + tmpdir);

//创建目录的一个新的文件对象
归档dir =新的文件(tmpdir);

//创建一个新的文件对象
归档newFile =新的文件(dir， “newFile.txt”);

//创建新的文件
布尔型成功= newFile.createNewFile ();

//打印文件信息
如果(成功==真)
{
Script.out ("被创建的新的文件”);
}

{
Script.out ("失败创建文件或文件已经存在”);
}

//验证文件路径存在并且是文件
如果(newFile.exists () & & newFile.isFile ())
{
Script.out ("文件存在并且是文件”);
}

{
Script.out ("文件不存在或者不是文件”);
回归; //没有点继续如果没有文件
}

//打印文件信息
Script.out ("文件命名=” + newFile.getName ());
Script.out ("文件Size =” + newFile.length ());
Script.out ("文件路径=” + newFile.getPath ());
Script.out ("文件绝对路径=” + newFile.getAbsolutePath ());
Script.out ("文件标准路径=” + newFile.getCanonicalPath ());
Script.out ("文件目录=” + newFile.getParent ());
Script.out ("文件是可读的=” + newFile.canRead ());
Script.out ("文件是writeable =” + newFile.canWrite ());
Script.out ("文件是隐藏的=” + newFile.isHidden ());
DateFormat df = DateFormat.getDateTimeInstance ();
长的modtime = newFile.lastModified ();
日期mod =新的日期(modtime);
Script.out ("文件日期=” + df.format (mod));

示例： 文件方法

导入com.hitek.engine.mods.script.Script;
导入java.text.DateFormat;

//get默认Java临时目录
串起tmpdir = System.getProperty (" java.io.tmpdir”);

//打印目录名称
Script.out ("默认Java临时文件夹是： ” + tmpdir);

//创建目录的一个新的文件对象
归档dir =新的文件(tmpdir);

//创建一个新的文件对象
归档file1 =新的文件(dir， “file1.txt”);
归档file2 =新的文件(dir， “file2.txt”);

//创建新的文件1
file1.createNewFile ();

//验证newfile1存在并且是文件
如果(file1.exists () & & file1.isFile ())
{
Script.out (" file1存在”);
}

{
Script.out (" file1不存在或者不是文件”);
回归; //没有点继续如果没有文件
}

//给文件改名
布尔型成功= file1.renameTo (file2);

如果(成功==真)
{
Script.out ("从file1改名到file2是成功的”);
}
//确认newFile1不存在
如果(!file1.exists ())
{
Script.out (" file1不存在，因为它改了名”);
}

//删除newFile2
成功= file2.delete ();
如果(成功==真)
{
Script.out (" file2删除是成功的”);
}

示例：  文件读/写

//文件读/写

导入com.hitek.engine.mods.script.Script;

//get默认Java临时目录
串起tmpdir = System.getProperty (" java.io.tmpdir”);

//打印目录名称
Script.out ("默认Java临时文件夹是： ” + tmpdir);

//创建目录的一个新的文件对象
归档dir =新的文件(tmpdir);

//创建一个新的文件对象
归档file1 =新的文件(dir， “file1.txt”);

//创建FileWriter给file1写，错误是重写文件，真是添附对现有文件的末端
FileWriter fw =新的FileWriter (file1，错误);
BufferedWriter bw =新的BufferedWriter (fw);
为(int i = 0; i < 10; i++)
{
bw.write ("这是线路” + i);
//写换行字
bw.newLine ();
}
bw.close ();

//创建一个阅读程序读全部的文件和打印它出来输出log
FileReader法郎=新的FileReader (file1);
BufferedReader增殖比=新的BufferedReader (法郎);
字符串线路= ""; 
当时((线路= br.readLine ())!=空)
{
Script.out (线路);
}
br.close ();

示例： 目录方法

//在Java、目录和文件信息从Java文件选件类获得

导入com.hitek.engine.mods.script.Script;

//get默认Java临时目录
串起tmpdir = System.getProperty (" java.io.tmpdir”);

//打印目录名称
Script.out ("默认Java临时文件夹是： ” + tmpdir);

//创建目录的一个新的文件对象
归档dir =新的文件(tmpdir);

//确认此路径在您的系统存在
如果(dir.exists ())
{
Script.out ("是，此路径存在”);
}

//确认这是一个有效的目录在您的系统
如果(dir.isDirectory ())
{
Script.out ("是，这是一个有效的目录”);
}

//get路径
Script.out ("路径是： ” + dir.getPath ());

//get绝对路径
Script.out ("绝对路径是： ” + dir.getAbsolutePath ());

//get始目录
归档父项= dir.getParentFile ();
Script.out ("父项路径是： ” + parent.getAbsolutePath ());

示例： 目录信息

//在Java、目录和文件信息从Java文件选件类获得

导入com.hitek.engine.mods.script.Script;
导入java.text.DateFormat;

//get默认Java临时目录
串起tmpdir = System.getProperty (" java.io.tmpdir”);

//打印目录名称
Script.out ("默认Java临时文件夹是： ” + tmpdir);

//创建目录的一个新的文件对象
归档dir =新的文件(tmpdir);

//get文件名字列表在dir
串起[]名字= dir.list ();

//打印所有文件的前100个名字在您的临时dir的
int最大= names.length;
如果(最大> 100)
{
最大= 100;
}

为(int i=0; i <最大; i++)
{
Script.out ("文件” +我+ “=” +名字[i]);
}

//get一一些文件对象 
归档[]文件= dir.listFiles ();

//打印信息为前100个文件。 
字符串命名= "";
长的size = 0;
日期修改了;

//get默认日期-时间制格式器
DateFormat df = DateFormat.getDateTimeInstance ();
字符串mod = "";

为(int i=0; i <最大; i++)
{
字符串命名=归档[i] .getName ();
size =归档[i] .length ();
被修改的=新的日期(文件[i] .lastModified ());
mod = df.format (被修改);
Script.out ("文件” +我+ “=” +名字+ “， size =” + size + “，时间标记=” + mod);
}

示例： 做文件夹

//做文件夹的示例 

导入com.hitek.engine.mods.script.Script;

//get默认Java临时目录
串起tmpdir = System.getProperty (" java.io.tmpdir”);

//打印目录名称
Script.out ("默认Java临时文件夹是： ” + tmpdir);

//创建目录的一个新的文件对象
归档dir =新的文件(tmpdir);

//创建表示一新的subfolder在tmpdir之内的一个文件对象
归档newdir =新的文件(dir， “newDirectory2”);

如果文件夹存在，//查
布尔型存在= newdir.exists ();
如果(存在==真)
{
Script.out ("文件夹已经存在： ” + newdir.getAbsolutePath ());
回归; //没有需要创建subfolder
}

//做一个新的子目录。 如果它成功，方法返回真
//回归错误如果文件夹已经存在或者不可能创建文件夹
布尔型成功= newdir.mkdir ();
如果(成功==真)
{
Script.out ("被创建的新的文件夹： ” + newdir.getAbsolutePath ());
}

第6部分-方法回到顶层

示例： 运用方法

//您在您的script能定义方法重新使用编码
在主要script被执行之前，//所有方法必须定义

导入com.hitek.engine.mods.script.Script;

//此方法简单输出字符串消息到输出log
无效(字符串消息)
{
Script.out (消息);
}

//此方法get数的正方形
int正方形(输入的int)
{
回归输入*输入;
}

//主要方法现在开始
//测试上述方法
("这是使用方法测试在script”);
int fiveSquare =正方形(5);
("五正方形是” + fiveSquare);

示例： hitek方法

//我们提供允许您运行task的有些方法， log数据， get并且设置变量和task参数。

导入com.hitek.engine.mods.script.Script;

//给输出log写一个字符串
Script.out ("文字对输出log”);

//给活动log写一个字符串
Script.act ("文字对活动log”);

//给调试log写错误栈检索
尝试
{
Integer.parseInt ("坏整数”);
}
抓住(例外e)
{
Script.err (e);
}

//运行task并且get退出编码
//保证您这里键入一有效的task标题
串起taskTitle = “Enter_valid_task_title_here”;
taskTitle = “复制”;
int exitCode = Script.run (taskTitle);
Script.out ("退出task =编码” + exitCode);

//get task paramter。 您需要键入正确的taskTitle和参数密码
//查找在task的属性文件在数据\ task文件夹。
//这些文件显示参数密码从Task.PARAMETERS0到Task.PARAMETERS50

//读Task.PARAMETERS1
串起平价= Script.getPar (taskTitle， “Task.PARAMETERS1”);
Script.out (" Task.PARAMETERS1 =” +同水准);

//集task参数动态地
Script.setPar (taskTitle， “Task.PARAMETERS1”， “新的测试值”);

//再读它确认变化做
平价= Script.getPar (taskTitle， “Task.PARAMETERS1”);
Script.out (" Task.PARAMETERS1 =” +同水准);

//您能get所有task、用户、Java和系统变量值
//您能设置用户可变值。 我们不允许task、Java或者系统变量值重写。
字符串var = taskTitle + “： ：ExitCode”;
字符串值= Script.getVar (var);
Script.out ("可变值=” +值);

//集用户可变值
Script.setVar (" newVariable”， “变量测试”);
值= Script.getVar (" newVariable”);
Script.out ("新的可变值=” +值);

 回到顶层