Kettle js 脚本

目录

• JavaScript 内置脚本
• 字符串类型的函数
  • 日期转字符串(date2str)
  • 构造定长字符串(fillString(char,length))
  • 统计字符串出现频次(getOcuranceString(str,searchStr))
  • 获取字符串下标索引(indexOf)
  • 首字母大写(initCap)
  • 字符串转小写(lower)
  • 字符串填充左侧(lpad(string,char,length))
  • 字符串右侧填充(rpad(string,char,length))
  • 去空左字符(ltrim)
  • 去除右字符(rtrim)
  • 去除左右空格(trim)
  • 数字转字符串(num2str)
  • XML保护标签函数转换(protectXMLCDATA)
  • 替换字符串(replace)
  • 正则切分(str2RegExp)
  • 字符串截取(substr)
  • 字符串转大写(upper)
• 浮点型的函数
  • 计算绝对值(abs(num))
  • 字符串转数值(str2num(var))
• 日期类型函数
  • 日期相加(dateAdd(date,format,plusNum))
  • 日期比较(dateDiff(startDate,endDate,type))
  • 获取指定日期数值(getDayNumber(date,type))
  • 获取当前月份数值(month(date))
  • 获取年份(year(date))
  • 获取当年的周数(week(date))
  • 字符串转日期(str2date)
  • 截取日期(truncDate(date,type))
• 逻辑判断型函数
  • 是否为空(isEmpty(str))
  • 是否日期(isDate(str))
  • 判断是否是数值(isNum(str))
  • 是否正则匹配(isRegExp)
• 特殊的函数
  • 弹框信息(Alert(msg))
  • decode 函数
  • 执行SQL语句(fireToDB)
  • 仅仅获取数值(getDigitsOnly)
  • 获取Kettle环境变量的值(getEnvironmentVar)
  • 获取Kettle环境中的变量值(getVariable)
  • 设置变量(setVariable(key,value,level))
  • 写入日志(writeToLog)
• 文件处理类函数
  • 复制文件(copyFile(sourceFile,targetFile,overwrite))
  • 创建文件夹(createFolder(path))
  • 删除文件(deleteFile)
  • 判断文件是否存在(fileExists())
  • 获取文件扩展名(getFileExtension)
  • 获取文件大小(getFileSize)
  • 获取文件的父文件夹名称(getParentFoldername)
  • 获取文件简称(getShortName)
  • 判断是否是一个文件(isFile)
  • 判断是否是一个文件夹(isFolder)
  • 加载一个文件的内容(loadFileContent)
  • 移动文件(moveFile(source,target,overWrite))
  • 创建一个空文件(touch)
• JavaScript 脚本案例
  • js 输出日志
  • js 变量
  • js 获取当前时间并转为字符串
  • js 时间偏移
  • js 脚本弹出
  • js 处理 json
  • js 时间格式转换通用方法
  • js 执行sql

JavaScript 内置脚本

js 脚本组件包含的函数主要包括六大类：

• 字符串类型的函数 (String Functions)
• 浮点型的函数 (Numeric Functions)
• 日期类型函数 (Date Functions)
• 逻辑判断型函数 (Logic Functions)
• 特殊的函数 (Special Functions)
• 文件处理类函数 (File Functions)

字符串类型的函数

日期转字符串(date2str)

日期转字符串函数date2str主要有4个方法：

// 传入日期实例,转换成字符串类型
date2str(date)
// 传入日期和格式化参数,进行格式化转换
date2str(date, format)
// 传入日期和参数格式化及ISO代码进行转换,(DE = German, EN = English, FR = France, …)
date2str(date, format, iso)
// 传入时区进行格式化,例如北京时区(GMT+8)
date2str(date, format, iso, zone)

常用date2str(date,format)将时间格式化为字符串，如

var currentDate = new Date();
writeToLog(date2str(currentDate, "yyyy-MM-dd"));
writeToLog(date2str(currentDate, "yyyy-MM-dd HH:mm:ss"));   

控制台输出结果

2024/08/27 13:46:11 - JavaScript代码.0 - 2024-08-27
2024/08/27 13:46:11 - JavaScript代码.0 - 2024-08-27 13:46:11

构造定长字符串(fillString(char,length))

writeToLog(fillString("T", 10));
writeToLog(fillString("D", 3));

控制台输出结果

2024/08/27 13:46:11 - JavaScript代码.0 - TTTTTTTTTT
2024/08/27 13:46:11 - JavaScript代码.0 - DDD

注意： 第一个入参是一个char类型的单字符,不能是字符串

统计字符串出现频次(getOcuranceString(str,searchStr))

第一个参数是要搜索的完整字符串,第二个参数是要搜索统计的字符串

var sef = '2024-01-11';
writeToLog(getOcuranceString(sef, '0'))
writeToLog(getOcuranceString(sef, '1'))
writeToLog(getOcuranceString(sef, '2'))
writeToLog(getOcuranceString(sef, '4'))
writeToLog(getOcuranceString(sef, '-'))
writeToLog(getOcuranceString(sef, '11'))

控制台输出结果

2024/08/27 13:55:21 - JavaScript代码.0 - 2
2024/08/27 13:55:21 - JavaScript代码.0 - 3
2024/08/27 13:55:21 - JavaScript代码.0 - 2
2024/08/27 13:55:21 - JavaScript代码.0 - 1
2024/08/27 13:55:21 - JavaScript代码.0 - 2
2024/08/27 13:55:21 - JavaScript代码.0 - 1

获取字符串下标索引(indexOf)

获取下标索引主要有2个重构函数,分别是：

• 获取出现字符串的索引开始位置：indexOf(string,subString)
• 指定开始位置,获取字符串索引开始位置：indexOf(string,subString,fromIndex)

示例

var str1 = "Hello Pentaho!";
var str2 = indexOf(str1, "Pentaho");
var str3 = indexOf(str1, "o", 7);
writeToLog("Input : " + str1);
writeToLog("Index of 'Pentaho' : " + str2);
writeToLog("index of 'o', search from position 7 : " + str3);

控制台输出结果

2024/08/27 13:57:15 - JavaScript代码.0 - Input : Hello Pentaho!
2024/08/27 13:57:15 - JavaScript代码.0 - Index of 'Pentaho' : 6
2024/08/27 13:57:15 - JavaScript代码.0 - index of 'o', search from position 7 : 12

首字母大写(initCap)

将字符串的首字母转换为大写字母，如

var str1 = "my home";
writeToLog(initCap(str1));
writeToLog(initCap('test a aaa cw'));
writeToLog(initCap('myhome'));

控制台输出结果

2024/08/27 14:00:42 - JavaScript代码.0 - My Home
2024/08/27 14:00:42 - JavaScript代码.0 - Test A Aaa Cw
2024/08/27 14:00:42 - JavaScript代码.0 - Myhome

字符串转小写(lower)

将字符串的首字母转换为大写字母，如

var str1 = "Hello World!";
var str2 = lower(str1);
writeToLog("Input:" + str1);
writeToLog("Converted to LowerCase:" + str2);
writeToLog(lower('DDDHelloSWxss'));

控制台输出结果

2024/08/27 14:02:38 - JavaScript代码.0 - Input:Hello World!
2024/08/27 14:02:38 - JavaScript代码.0 - Converted to LowerCase:hello world!
2024/08/27 14:02:38 - JavaScript代码.0 - dddhelloswxss

字符串填充左侧(lpad(string,char,length))

用指定长度的给定字符将字符串填充到左侧，第一个参数为传入字符串，第二个参数为填充单字符，第三个参数为填充单字符长度，如

var lpadStr = "Hello World!";
writeToLog("Lpad:" + lpad(lpadStr, "x", 20));

控制台输出结果

2024/08/27 14:15:34 - JavaScript代码.0 - Lpad:xxxxxxxxHello World!

注意： 如果length长度小于给定字符串的长度,则默认返回原字符串,不做填充

字符串右侧填充(rpad(string,char,length))

使用方法同lpad，只是一个是左侧，一个是右侧

去空左字符(ltrim)

从左侧开始去除空字符串，如

var trimStr = " a b c d";
writeToLog("Input: " + trimStr);
writeToLog("Input ltrim:" + ltrim(trimStr));

控制台输出结果

2024/08/27 14:19:20 - JavaScript代码.0 - Input:  a b c d
2024/08/27 14:19:20 - JavaScript代码.0 - Input trim:a b c d

去除右字符(rtrim)

用法同ltrim，只不过一个是去除左侧空格，一个是去除右侧空格

去除左右空格(trim)

用法同ltrim和rtrim,相当于ltrim+rtrim

数字转字符串(num2str)

将数字转为字符串,主要有3个构造函数

• 转换num数字为字符串：num2str(num)
• 格式化数字为指定字符串：num2str(num,format)
• 按照本地ISO编码进行格式化：num2str(num,format,iso)

示例

var num1 = 123.40;
var num2 = -123.40;
writeToLog(num2str(num1));
writeToLog(num2str(num1, "0.00"));
writeToLog(num2str(num1, "0.00", "EN"));
writeToLog(num2str(num2, "0.00;(0.00)", "EN"));

控制台输出结果

2024/08/27 14:28:07 - JavaScript代码.0 - 123.4
2024/08/27 14:28:07 - JavaScript代码.0 - 123.40
2024/08/27 14:28:07 - JavaScript代码.0 - 123.40
2024/08/27 14:28:07 - JavaScript代码.0 - (123.40)

XML保护标签函数转换(protectXMLCDATA)

给指定xml添加保护标签，如

var xmlstr = '<message><warning>Hello World </warning></message>'
writeToLog('CDATA:' + protectXMLCDATA(xmlstr));

控制台输出结果

2024/08/27 14:31:28 - JavaScript代码.0 - CDATA:<![CDATA[<message><warning>Hello World </warning></message>]]>

替换字符串(replace)

替换字符串主要包括两个构造函数

• 从指定字符串中查询，然后替换：replace(str,searchStr,replaceStr)
• 无限查询替换：replace(str,firstSearch,firstReplace,secondSearch,SecondReplace...)

示例

var replaceStr1 = "Hello World, this is a nice function";
var replaceStr2 = replace(replaceStr1, "World", "Folk");
writeToLog(replaceStr2);
var replaceStr3 = replace(replaceStr1, "World", "Folk", "nice", "beautifull");
writeToLog(replaceStr3);

控制台输出结果

2024/08/27 14:34:38 - JavaScript代码.0 - Hello Folk, this is a nice function
2024/08/27 14:34:38 - JavaScript代码.0 - Hello Folk, this is a beautifull function

正则切分(str2RegExp)

根据正则表达式内容，对字符串执行分割，如

var strToMatch = "info@proconis.de";
var strReg = "^(\\w+)@([a-zA-Z_]+?)\\.([a-zA-Z]{2,3})$";
var xArr = str2RegExp(strToMatch, strReg);
if (xArr != null) {
    for (i = 0; i < xArr.length; i++) {
        writeToLog("正则匹配结果：" + xArr[i]);
    }
} else {
    writeToLog("no match");
}

控制台输出结果

2024/08/27 14:55:03 - JavaScript代码.0 - 正则匹配结果：info
2024/08/27 14:55:03 - JavaScript代码.0 - 正则匹配结果：proconis
2024/08/27 14:55:03 - JavaScript代码.0 - 正则匹配结果：de

字符串截取(substr)

通过指定索引开始对字符串进行截取操作,主要有两个重构参数

• 指定开始索引截取字符串：substr(string,from)
• 指定开始和截止索引进行截取：substr(string,from,to)

示例

var substr1 = "Hello Pentaho!";
var substr2 = substr(substr1, 6);
var substr3 = substr(substr1, 6, 7);
writeToLog("Input : " + substr1);
writeToLog("From position 6: " + substr2);
writeToLog("From position 6 for 7 long : " + substr3);

字符串转大写(upper)

将传入字符串全部转大写，如

var upperStr = "Hello World";
writeToLog("Input: " + upperStr);
writeToLog("Input upper: " + upper(upperStr));

控制台输出结果

2024/08/27 14:22:22 - JavaScript代码.0 - Input: Hello World
2024/08/27 14:22:22 - JavaScript代码.0 - Input upper: HELLO WORLD

浮点型的函数

计算绝对值(abs(num))

计算一个数值的绝对值，如

var absNum1 = -1234.01;
var absNum2 = 1234.01;
writeToLog("绝对值absNum1：" + abs(absNum1));
writeToLog("绝对值absNum2：" + abs(absNum1));

控制台输出结果

2024/08/27 15:04:38 - 浮点型的函数(Numeric Functions).0 - 绝对值absNum1：1234.01
2024/08/27 15:04:38 - 浮点型的函数(Numeric Functions).0 - 绝对值absNum2：1234.01

字符串转数值(str2num(var))

字符串转数值主要包含两个构造函数

• 将数字类型的字符串转为数字：str2num(str)
• 将数字类型的字符串根据指定格式转为数字：str2num(str,format)

示例

var numstr1 = "1.234,56";
var numstr2 = "12";
writeToLog("将" + numstr1 + "按照#,##0.00的格式转为数字，结果：" + str2num(numstr1, "#,##0.00"));
writeToLog("将" + numstr2 + "转为数字，结果：" + str2num(numstr2));

控制台输出结果

2024/08/27 15:09:57 - 浮点型的函数(Numeric Functions).0 - 将1.234,56按照#,##0.00的格式转为数字，结果：1.234
2024/08/27 15:09:57 - 浮点型的函数(Numeric Functions).0 - 将12转为数字，结果：12

日期类型函数

日期相加(dateAdd(date,format,plusNum))

针对日期变量进行相应的添加时间，添加频率包括年、月、日、时、分、秒，参数date为日期对象，参数format为类型，参数plusNum 为时间增加的数值

var date = new Date();
var formatStr = 'yyyy-MM-dd HH:mm:ss';
writeToLog("当前时间，date:" + date2str(date, formatStr));
var addDay = dateAdd(date, 'd', 1);
var substractDay = dateAdd(date, 'd', -1);
writeToLog("增加一天:" + date2str(addDay, formatStr));
writeToLog("减少一天:" + date2str(substractDay, formatStr));
var addMonth = dateAdd(date, 'm', 1);
var substractMonth = dateAdd(date, 'm', -1);
writeToLog("增加一月:" + date2str(addMonth, formatStr));
writeToLog("减少一月:" + date2str(substractMonth, formatStr));
var addYear = dateAdd(date, 'y', 1);
var substractYear = dateAdd(date, 'y', -1);
writeToLog("增加一年:" + date2str(addYear, formatStr));
writeToLog("减少一年:" + date2str(substractYear, formatStr));
var addWeek = dateAdd(date, 'w', 1);
var substractWeek = dateAdd(date, 'w', -1);
writeToLog("增加一周:" + date2str(addWeek, formatStr));
writeToLog("减少一周:" + date2str(substractWeek, formatStr));
var addWeekDay = dateAdd(date, 'wd', 1);
var substractWeekDay = dateAdd(date, 'wd', -1);
writeToLog("增加一周工作日:" + date2str(addWeekDay, formatStr));
writeToLog("减少一周工作日:" + date2str(substractWeekDay, formatStr));
var addHour = dateAdd(date, 'hh', 1);
var substractHour = dateAdd(date, 'hh', -1);
writeToLog("增加一小时:" + date2str(addHour, formatStr));
writeToLog("减少一小时:" + date2str(substractHour, formatStr));
var addMinute = dateAdd(date, 'mi', 1);
var substractMinute = dateAdd(date, 'mi', -1);
writeToLog("增加一分钟:" + date2str(addMinute, formatStr));
writeToLog("减少一分钟:" + date2str(substractMinute, formatStr));
var addSecond = dateAdd(date, 'ss', 1);
var substractSecond = dateAdd(date, 'ss', -1);
writeToLog("增加一秒中:" + date2str(addSecond, formatStr));
writeToLog("减少一秒钟:" + date2str(substractSecond, formatStr));

控制台输出结果

2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 当前时间，date:2024-08-27 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 增加一天:2024-08-28 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 减少一天:2024-08-26 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 增加一月:2024-09-27 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 减少一月:2024-07-27 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 增加一年:2025-08-27 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 减少一年:2023-08-27 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 增加一周:2024-09-03 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 减少一周:2024-08-20 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 增加一周工作日:2024-08-28 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 减少一周工作日:2024-08-27 15:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 增加一小时:2024-08-27 16:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 减少一小时:2024-08-27 14:37:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 增加一分钟:2024-08-27 15:38:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 减少一分钟:2024-08-27 15:36:06
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 增加一秒中:2024-08-27 15:37:07
2024/08/27 15:37:06 - 浮点型的函数(Numeric Functions).0 - 减少一秒钟:2024-08-27 15:37:05

注意： 时间相加format类型如下

• 年：y
• 月：m
• 日：d
• 周：w
• 周（工作日）：wd
• 小时：hh
• 分钟：mi
• 秒：ss

日期比较(dateDiff(startDate,endDate,type))

比较两个时间，参数startDate为开始日期，参数endDate为截止日期，参数type为日期相差返回的格式，如年、月、日……

示例

var now = new Date();
var formatStr = 'yyyy-MM-dd HH:mm:ss';
var yestorday = dateAdd(now, 'd', -1);
writeToLog("当前时间now:" + date2str(now, formatStr));
writeToLog("昨天yestorday:" + date2str(yestorday, formatStr));
var diffDate = dateDiff(now, yestorday, 'd');
writeToLog("相差天数:" + diffDate);

控制台输出结果

2024/08/27 15:46:22 - 浮点型的函数(Numeric Functions).0 - 当前时间now:2024-08-27 15:46:22
2024/08/27 15:46:22 - 浮点型的函数(Numeric Functions).0 - 昨天yestorday:2024-08-26 15:46:22
2024/08/27 15:46:22 - 浮点型的函数(Numeric Functions).0 - 相差天数:-1

注意： 为日期相差返回的格式type类型如下

• 年：y
• 月：m
• 日：d
• 周：w
• 周（工作日）：wd
• 小时：hh
• 分钟：mi
• 秒：ss

获取指定日期数值(getDayNumber(date,type))

根据类型获取指定日期的数值（天数），参数date为日期，参数type为执行类型

示例

var now = new Date();
writeToLog(getDayNumber(now, "y"));
writeToLog(getDayNumber(now, "m"));
writeToLog(getDayNumber(now, "w"));
writeToLog(getDayNumber(now, "wm"));

控制台输入结果

2024/08/27 15:55:06 - 浮点型的函数(Numeric Functions).0 - 240
2024/08/27 15:55:06 - 浮点型的函数(Numeric Functions).0 - 27
2024/08/27 15:55:06 - 浮点型的函数(Numeric Functions).0 - 3

注意：

1. getDayNumber获取的为日期所在周期的天数
2. type类型如下
   • 获取当年的天数：y
   • 获取当月的天数：m
   • 获取本周的天数：w
   • 获取当月中本周的天数：wm

获取当前月份数值(month(date))

获取当前日期的月份数值，需要注意的是，该值的月份是从0开始的，因此我们最终得到的结果应该+1才是我们的真实月份数值，如

var now = new Date();
writeToLog("当前月份:" + month(now));

控制台输出结果

2024/08/27 16:18:43 - 浮点型的函数(Numeric Functions).0 - 当前月份:7

获取年份(year(date))

获取传入日期的年份，如

var now = new Date();
writeToLog("当前年份:" + year(now));

控制台输出结果

2024/08/27 16:30:26 - 浮点型的函数(Numeric Functions).0 - 当前年份:2024

获取当年的周数(week(date))

获取指定日期的周数，如

var now = new Date();
writeToLog("当前周数:" + week(now));

控制台除数结果

2024/08/27 16:37:09 - 浮点型的函数(Numeric Functions).0 - 当前周数:35

字符串转日期(str2date)

字符串转日期和日期转字符串有点类似,只不过主体对换了一下,但是传入的格式参数都是一样的，主要有4个重载函数:

• 默认转换：str2date(str)
• 传入format格式化参数：str2date(str,format)
• 根据iso编码及格式化参数进行转换：str2date(str,format,iso)
• 根据不同时区的iso编码进行格式化转换：str2date(str,format,iso,timezone)

示例

writeToLog("字符串转时间（yyyy-MM-dd）：" + str2date("2024-01-02", "yyyy-MM-dd"));

控制台输出结果

2024/08/27 16:44:12 - 浮点型的函数(Numeric Functions).0 - 字符串转时间（yyyy-MM-dd）：Tue Jan 02 00:00:00 CST 2024

截取日期(truncDate(date,type))

指定截取不同的日期部分，参数date为传入时间，参数type为截取类型

示例

var now = new Date();
var date0 = truncDate(now, 0);
var date1 = truncDate(now, 1);
var date2 = truncDate(now, 2);
var date3 = truncDate(now, 3);
var date4 = truncDate(now, 4);
var date5 = truncDate(now, 5);
writeToLog("当前时间-now:" + date2str(now, 'yyyy-MM-dd HH:mm:ss'));
writeToLog("截取时间-date0:" + date2str(date0, 'yyyy-MM-dd HH:mm:ss'));
writeToLog("截取时间-date1:" + date2str(date1, 'yyyy-MM-dd HH:mm:ss'));
writeToLog("截取时间-date2:" + date2str(date2, 'yyyy-MM-dd HH:mm:ss'));
writeToLog("截取时间-date3:" + date2str(date3, 'yyyy-MM-dd HH:mm:ss'));
writeToLog("截取时间-date4:" + date2str(date4, 'yyyy-MM-dd HH:mm:ss'));
writeToLog("截取时间-date5:" + date2str(date5, 'yyyy-MM-dd HH:mm:ss'));

控制台输出结果

2024/08/27 17:07:39 - 浮点型的函数(Numeric Functions).0 - 当前时间-now:2024-08-27 17:07:39
2024/08/27 17:07:39 - 浮点型的函数(Numeric Functions).0 - 截取时间-date0:2024-08-27 17:07:39
2024/08/27 17:07:39 - 浮点型的函数(Numeric Functions).0 - 截取时间-date1:2024-08-27 17:07:00
2024/08/27 17:07:39 - 浮点型的函数(Numeric Functions).0 - 截取时间-date2:2024-08-27 17:00:00
2024/08/27 17:07:39 - 浮点型的函数(Numeric Functions).0 - 截取时间-date3:2024-08-27 00:00:00
2024/08/27 17:07:39 - 浮点型的函数(Numeric Functions).0 - 截取时间-date4:2024-08-01 00:00:00
2024/08/27 17:07:39 - 浮点型的函数(Numeric Functions).0 - 截取时间-date5:2024-01-01 00:00:00

逻辑判断型函数

是否为空(isEmpty(str))

判断字符串是否为空，如

var d = "Hello World";
Alert(isEmpty(d));

控制台输出结果

2024/08/27 17:41:10 - 逻辑判断型函数(Logic Functions).0 - false

是否日期(isDate(str))

判断当前字符串是否日期，如

var d1 = "Hello World";
var d2 = new Date();
writeToLog(isDate(d1));
writeToLog(isDate(d2));

控制台输出结果

2024/08/27 17:18:51 - 逻辑判断型函数(Logic Functions).0 - false
2024/08/27 17:18:51 - 逻辑判断型函数(Logic Functions).0 - true

判断是否是数值(isNum(str))

var str1 = "Hello World";
var str2 = 123456;
writeToLog(isNum(str1));
writeToLog(isNum(str2));

控制台输出结果

2024/08/27 17:42:32 - 逻辑判断型函数(Logic Functions).0 - false
2024/08/27 17:42:32 - 逻辑判断型函数(Logic Functions).0 - true

是否正则匹配(isRegExp)

判断给定的正则表达式是否匹配当前的字符串，主要有2个函数定义：

• 给定正则判断字符串是否匹配：isRegExp(str,reg)
• 可以递归判断正则匹配：isRegExp(str,reg1,reg2,reg3…)

注意： 返回值是匹配的次数（数值类型），如果不匹配，返回-1

示例

var email1 = "info@proconis.de";
var email2 = "support@proconis.co.uk";
var email3 = "HelloWorld@x";

var reg1 = "^\\w+@[a-zA-Z_]+?\\.[a-zA-Z]{2,3}$";
var reg2 = "^[\\w-\.]+@([\\w-]+\\.)+[\\w-]{2,4}$";

writeToLog(isRegExp(email1, reg1, reg2) + " Matches");
writeToLog(isRegExp(email2, reg1, reg2) + " Matches");
writeToLog(isRegExp(email3, reg1, reg2) + " Matches");

控制台输出结果

2024/08/27 17:44:32 - 逻辑判断型函数(Logic Functions).0 - 1 Matches
2024/08/27 17:44:32 - 逻辑判断型函数(Logic Functions).0 - 2 Matches
2024/08/27 17:44:32 - 逻辑判断型函数(Logic Functions).0 - -1 Matches

特殊的函数

弹框信息(Alert(msg))

在屏幕前弹出一个信息框

decode 函数

decode函数有点类似于IF-THEN-ELSE语句，即表示通过给定查询的字符串是否存在，如果存在，即替换,否则返回默认值，如

var str1 = "Hallo";
writeToLog(decode(str1, "Hallo", "Hello"));
writeToLog(decode(str1, "1", "Mr", "2", "Mrs", "N/A"));
writeToLog(decode(str1, "1", "Mr", "2", "Mrs"));
str1 = "Mrs";
writeToLog(decode(str1, "1", "Mr", "2", "Mrs"));

控制台输出结果

2024/08/27 17:50:57 - 特殊的函数(Special Functions).0 - Hallo 替换为 Hello ：Hello
2024/08/27 17:50:57 - 特殊的函数(Special Functions).0 - N/A
2024/08/27 17:50:57 - 特殊的函数(Special Functions).0 - Hallo
2024/08/27 17:50:57 - 特殊的函数(Special Functions).0 - Mrs

执行SQL语句(fireToDB)

通过获取数据库连接名称，传递SQL语句并返回SQL查询的值。

// kettle 配置的数据库连接名称
var strConn = "XXXX";
// sql 语句，也可以是过程
var strSQL = "call Pro_B1_1_1_2_1_dept('2024-01-01','2024-02-01','1','')";
var xArr = fireToDB(strConn, strSQL);
// 处理结果
for(var i in xArr){
	var dept = xArr[i][0];
    var sum = xArr[i][1];
    writeToLog("dept:"+dept+",sum:"+sum);
}

仅仅获取数值(getDigitsOnly)

在给定的字符串中仅仅筛选过滤得到数值，如

var str1 = "abc123cde";
writeToLog(getDigitsOnly(str1));

控制台输出结果

2024/08/27 17:52:52 - 特殊的函数(Special Functions).0 - 123

获取Kettle环境变量的值(getEnvironmentVar)

获取在Kettle中的环境变量的值，如

writeToLog(getEnvironmentVar("user.dir"));
writeToLog(getEnvironmentVar("user.name"));

控制台输出结果

2024/08/27 17:55:02 - 特殊的函数(Special Functions).0 - D:\develop\kettle\data-integration
2024/08/27 17:55:02 - 特殊的函数(Special Functions).0 - mars

获取Kettle环境中的变量值(getVariable)

从当前的Kettle环境中获取指定的变量值,目前函数有2个重载：

• 根据变量名获取值,如果不存在则使用默认值：getVariable(varName,defaultValue)

示例

var strVarName = "getVariableTest";
var strVarValue = "123456";
Alert(getVariable(strVarName, ""));
setVariable(strVarName, strVarValue, "r");
Alert(getVariable(strVarName, ""));
strVarValue = "654321";
setVariable(strVarName, strVarValue, "r");
Alert(getVariable(strVarName, ""));

设置变量(setVariable(key,value,level))

通过setVariable函数设置环境变量,该用途可以用于重新赋值Kettle环境中已经存在的变量值或者重新生成变量值，参数key 为变量名称，参数value为变量值，参数level为变量级别

var strVarName = "setEnvTest";
var strVarValue = "123456";
Alert(getVariable(strVarName, ""));
setVariable(strVarName, strVarValue, "r");
Alert(getVariable(strVarName, ""));
strVarValue = "654321";
setVariable(strVarName, strVarValue, "r");
Alert(getVariable(strVarName, ""));

注意： 参数level级别如下

• system:s
• root:r
• parent:p
• grandparent:g

写入日志(writeToLog)

打印并写入日志信息,该函数可能是我们用到的最多的函数,可以帮助我们调试信息,主要有两个重载

• 写入msg日志信息：writeToLog(msg)
• 根据level基本写入msg信息:writeToLog(level,msg)

注意： 参数level级别如下

• 调试模式（Debug）：d
• 详细（Detailde）：i
• 错误（error）：e
• 最小日志（Minimal）：m
• 行级日志（RowLevel）:r

文件处理类函数

复制文件(copyFile(sourceFile,targetFile,overwrite))

复制一个文件到目标目录，参数sourceFile为源文件，参数targetFile为目标文件，参数overwrite为是否覆盖（布尔类型）

var file1 = "F:/bak/log.txt";

var targetFile = "F:/bak/logTarget.txt";

copyFile(file1, targetFile, false)

创建文件夹(createFolder(path))

创建一个文件夹

var strFolder = "F:/bak/createFolder";
createFolder(strFolder);

删除文件(deleteFile)

删除一个文件(不能删除文件夹)

var targetFile = "F:/bak/logTarget.txt";
deleteFile(targetFile);

判断文件是否存在(fileExists())

判断文件是否存在

var targetFile = "F:/bak/logTarget.txt";
fileExists(targetFile);

获取文件扩展名(getFileExtension)

如果文件不存在,则返回null

var file1 = "F:/bak/log.txt";
var ext = getFileExtension(file1);
writeToLog("扩展名：" + ext);

获取文件大小(getFileSize)

获取文件大小,结果是一个long类型的长整型数值

var file1 = "F:/bak/log.txt";
var ext = getFileSize(file1);
writeToLog("大小：" + ext);

获取文件的父文件夹名称(getParentFoldername)

获取文件的父文件夹名称

var file1 = "F:/bak/log.txt";
var parentFolder = getParentFoldername(file1);

获取文件简称(getShortName)

获取文件简称

var file1 = "F:/bak/log.txt";
var shortName = getShortFilename(file1);
writeToLog("简单名称:" + shortName);

判断是否是一个文件(isFile)

判断是否是一个文件

var file1 = "F:/bak/log.txt";
var flag = isFile(file1);

判断是否是一个文件夹(isFolder)

判断是否是一个文件夹

var file1 = "F:/bak/log.txt";
var flag = isFolder(file1);

加载一个文件的内容(loadFileContent)

从指定文件中加载内容,主要有两个重载函数：

• 默认加载文件：loadFileContent(filePath)
• 指定编码加载文件内容：loadFileContent(filePath,encoding)

示例：

var file1 = "F:/bak/log.txt";
var content = loadFileContent(file1);
var c1 = loadFileContent(file1, "UTF-8")
writeToLog(content);

移动文件(moveFile(source,target,overWrite))

移动指定文件， 参数source为源文件，参数target为目标文件，参数overWrite为 是否覆盖

var file1 = "F:/bak/log.txt";
var targetFile = "F:/bak/logTarget.txt";
moveFile(file1, targetFile, false);

创建一个空文件(touch)

创建一个空文件

var strFile = "F:/bak/log.txt";
touch(strFile);

JavaScript 脚本案例

js 输出日志

• 作业中 js 输出日志

方式一

var subject = "自定义日志输出";
//实例化工厂类
var logFactory = new org.pentaho.di.core.logging.LogChannelFactory();
//实例化日志channel对象
var log = logFactory.create(subject);
//日志输出
log.logMinimal("************************************-js日志输出方式1");
true;

方式二

var subject = "自定义日志输出-方式2";
//实例化日志channel对象
var log = new org.pentaho.di.core.logging.LogChannel(subject);
//日志输出
log.logMinimal("************************************-js日志输出方式2");
true;

日志输出

• 转换中 js 输出日志

输出日志

writeToLog("测试日志,id:" + id);
writeToLog("测试日志,name:" + name);

注意： 运行时，日志级别需要在 debug (调试) 以上

日志输出

js 变量

作业中 js 获取/设置变量

• js 脚本

// 日志
var subject = "作业js获取变量";
var logFactory = new org.pentaho.di.core.logging.LogChannelFactory();
var log = logFactory.create(subject);

// 获取变量
var startTime = parent_job.getVariable("startTime");
// 设置变量
parent_job.setVariable("startTime", "2024-01-02");

//日志输出
log.logMinimal("作业js获取变量，startTime：" + startTime);
log.logMinimal("作业js设置变量，startTime：" + parent_job.getVariable("startTime"));

true;

• 结果

转换中 js 获取/设置变量

• 作业内容

• 转换内容

• js 内容

var testTime = startTime;
// 设置变量
testTime = "2024-01-02";

• 结果

js 获取当前时间并转为字符串

• 转换内容

• js 内容

var subject = "自定义日志输出";
//实例化工厂类
var logFactory = new org.pentaho.di.core.logging.LogChannelFactory();
//实例化日志channel对象
var log = logFactory.create(subject);
// 当前时间
var now = new Date();
log.logMinimal("当前时间now：" + now);
// 单枪时间字符串
var nowStr = date2str(now, "yyyy-MM-dd");
writeToLog("当前时间,yyyy-MM-dd：" + nowStr);

• 结果

js 时间偏移

• 转换内容

• js 内容

// 测试时间
var startDateStr = "2024-01-01";
var endDateStr = "2024-02-02";
//创建日期对象
var simpleDateFormat = new java.text.SimpleDateFormat("yyyy-MM-dd");
//将日期字符串转为Date
var startParse = simpleDateFormat.parse(startDateStr);
var endParse = simpleDateFormat.parse(endDateStr);
//创建日历对象
var startDate = java.util.Calendar.getInstance();
startDate.setTime(startParse);
var endDate = java.util.Calendar.getInstance();
endDate.setTime(endParse);
// 时间增加一天
startDate.add(startDate.DAY_OF_MONTH, 1);
// 时间减少一天
endDate.add(startDate.DAY_OF_MONTH, -1);
// 格式化为yyyy-mm-dd
var startStr = simpleDateFormat.format(startDate.getTime());
var endStr = simpleDateFormat.format(endDate.getTime());

// kettle 自带函数
var d1 = new Date();
var fmt = 'yyyy-MM-dd HH:mm:ss';
var addyear = dateAdd(d1, 'y', 1);
var addmonth = dateAdd(d1, 'm', 1);
var addday = dateAdd(d1, 'd', 1);

• 结果

js 脚本弹出

• 转换内容

• js 内容

var d = "Hello World";
Alert(isEmpty(d));

• 结果

js 处理 json

• 转换

1. 测试数据，使用“执行SQL脚本”组件

• js 内容

CREATE TABLE if not exists `dict_convert` (
  `id` varchar(32) NOT NULL COMMENT '主键',
  `dict_item` varchar(10) NOT NULL COMMENT '字典项目',
  `dict_value` varchar(10) NOT NULL COMMENT '字典值',
  `dict_name` varchar(150) NOT NULL COMMENT '字典名称',
  `dict_convert_value` varchar(10) NOT NULL COMMENT '字典转换值',
  `dict_description` varchar(150) DEFAULT NULL COMMENT '字典说明',
  `memo` varchar(300) DEFAULT NULL COMMENT '备注',
  `vali_flag` varchar(1) NOT NULL COMMENT '有效标志',
  `remark` text COMMENT 'remark',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `creator` varchar(100) NOT NULL COMMENT '创建人',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '操作时间',
  `operator` varchar(100) NOT NULL COMMENT '操作人',
  `dict_id` varchar(32) DEFAULT NULL COMMENT '数据字典id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

REPLACE INTO `demo`.`dict_convert` (`id`, `dict_item`, `dict_value`, `dict_name`, `dict_convert_value`, `dict_description`, `memo`, `vali_flag`, `remark`, `create_time`, `creator`, `update_time`, `operator`, `dict_id`) VALUES ('9', 'RC013', '3', '局部麻醉', '06', NULL, NULL, '1', NULL, '2024-06-19 02:26:37', 'init', '2024-06-20 07:17:27', 'init', '8');
REPLACE INTO `demo`.`dict_convert` (`id`, `dict_item`, `dict_value`, `dict_name`, `dict_convert_value`, `dict_description`, `memo`, `vali_flag`, `remark`, `create_time`, `creator`, `update_time`, `operator`, `dict_id`) VALUES ('8', 'RC013', '20209', '脑神经阻滞：三叉神经阻滞、舌咽神经阻滞', '0309', NULL, NULL, '1', NULL, '2024-06-19 02:18:10', 'init', '2024-06-21 11:59:37', 'init', '8');
REPLACE INTO `demo`.`dict_convert` (`id`, `dict_item`, `dict_value`, `dict_name`, `dict_convert_value`, `dict_description`, `memo`, `vali_flag`, `remark`, `create_time`, `creator`, `update_time`, `operator`, `dict_id`) VALUES ('7', 'RC013', '20204', '躯干神经阻滞：肋间神经阻滞', '0308', NULL, NULL, '1', NULL, '2024-06-19 02:18:10', 'init', '2024-06-21 11:59:34', 'init', '8');
REPLACE INTO `demo`.`dict_convert` (`id`, `dict_item`, `dict_value`, `dict_name`, `dict_convert_value`, `dict_description`, `memo`, `vali_flag`, `remark`, `create_time`, `creator`, `update_time`, `operator`, `dict_id`) VALUES ('6', 'RC013', '20205', '椎旁神经阻滞', '0304', NULL, NULL, '1', NULL, '2024-06-19 02:18:10', 'init', '2024-06-21 11:59:32', 'init', '8');
REPLACE INTO `demo`.`dict_convert` (`id`, `dict_item`, `dict_value`, `dict_name`, `dict_convert_value`, `dict_description`, `memo`, `vali_flag`, `remark`, `create_time`, `creator`, `update_time`, `operator`, `dict_id`) VALUES ('5', 'RC013', '5', '复合麻醉', '05', NULL, NULL, '1', NULL, '2024-06-19 02:18:10', 'init', '2024-06-20 07:00:49', 'init', '8');
REPLACE INTO `demo`.`dict_convert` (`id`, `dict_item`, `dict_value`, `dict_name`, `dict_convert_value`, `dict_description`, `memo`, `vali_flag`, `remark`, `create_time`, `creator`, `update_time`, `operator`, `dict_id`) VALUES ('4', 'RC013', '201', '椎管内麻醉', '02', NULL, NULL, '1', NULL, '2024-06-19 02:18:10', 'init', '2024-06-20 07:18:26', 'init', '8');
REPLACE INTO `demo`.`dict_convert` (`id`, `dict_item`, `dict_value`, `dict_name`, `dict_convert_value`, `dict_description`, `memo`, `vali_flag`, `remark`, `create_time`, `creator`, `update_time`, `operator`, `dict_id`) VALUES ('36', 'RC013', '502', '不同方法的复合：静吸复合全麻，针药复合麻醉，全身 -硬膜外复合麻醉，脊髓-硬膜外复合麻醉等', '0405', NULL, NULL, '1', NULL, '2024-06-19 09:40:01', 'init', '2024-06-21 11:59:30', 'init', '8');
REPLACE INTO `demo`.`dict_convert` (`id`, `dict_item`, `dict_value`, `dict_name`, `dict_convert_value`, `dict_description`, `memo`, `vali_flag`, `remark`, `create_time`, `creator`, `update_time`, `operator`, `dict_id`) VALUES ('35', 'RC013', '502', '不同方法的复合：静吸复合全麻，针药复合麻醉，全身 -硬膜外复合麻醉，脊髓-硬膜外复合麻醉等', '0404', NULL, NULL, '1', NULL, '2024-06-19 09:40:01', 'init', '2024-06-21 11:59:27', 'init', '8');

2. 获取数据，使用“表输入”组件

脚本内容

SELECT
*
FROM demo.dict_convert
where dict_item = 'RC013'  

3. 将数据转为json，使用“JSON output”组件

注意：

一个数据条目的数据行: 使用0，将所有记录写入到一个json数组种，如果使用1，将会输出多个json

4. 选择json，使用“字段选择”组件，排除掉其他流程字段，只保留要使用的json字段

5. 遍历json数据，使用“JavaScript代码”组件

js 内容

eval('var json=' + outputValue);
for (var i = 0; i < json.data.length; i++) {
    writeToLog("第" + i + "条数据 - dict_convert_value:" + json.data[i].dict_convert_value + ",dict_value:" + json.data[i].dict_value);
}

js 时间格式转换通用方法

• 转换

• js 内容

var format = null;
var format1 = "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$";
var format2 = "^\\d{4}\/(0[1-9]|1[0-2])\/(0[1-9]|[12]\\d|3[01])$";
var format3 = "^\\d{4}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])$";
var format4 = "(^\\d{4}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01]))(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]$)";
var format5 = "(^\\d{4}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])) (0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]$)";
var format6 = "(^\\d{4}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01]))(0[0-9]|1[0-9]|2[0-3])([0-5][0-9])([0-5][0-9]$)";
var format7 = "(^\\d{4}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])) (0[0-9]|1[0-9]|2[0-3])([0-5][0-9])([0-5][0-9]$)";
var format8 = "(^\\d{4}\/(0[1-9]|1[0-2])\/(0[1-9]|[12]\\d|3[01]))(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]$)";
var format9 = "(^\\d{4}\/(0[1-9]|1[0-2])\/(0[1-9]|[12]\\d|3[01])) (0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]$)";
var format10 = "(^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01]))(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]$)";
var format11 = "(^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])) (0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]$)";

function obtainFormat(dateStr) {

    if (isRegExp(dateStr, format1) != -1) {
        return "yyyy-MM-dd";
    }
    if (isRegExp(dateStr, format2) != -1) {
        return "yyyy/MM/dd";
    }
    if (isRegExp(dateStr, format3) != -1) {
        return "yyyyMMdd";
    }
    if (isRegExp(dateStr, format4) != -1) {
        return "yyyyMMddHH:mm:ss";
    }
    if (isRegExp(dateStr, format5) != -1) {
        return "yyyyMMdd HH:mm:ss";
    }
    if (isRegExp(dateStr, format6) != -1) {
        return "yyyyMMddHHmmss";
    }
    if (isRegExp(dateStr, format7) != -1) {
        return "yyyyMMdd HHmmss";
    }
    if (isRegExp(dateStr, format8) != -1) {
        return "yyyy/MM/ddHH:mm:ss";
    }
    if (isRegExp(dateStr, format9) != -1) {
        return "yyyy/MM/dd HH:mm:ss";
    }
    if (isRegExp(dateStr, format10) != -1) {
        return "yyyy-MM-ddHH:mm:ss";
    }
    if (isRegExp(dateStr, format11) != -1) {
        return "yyyy-MM-dd HH:mm:ss";
    }
}

var testdate = "2024-01-01 10:01:01";
format = obtainFormat(testdate);
Alert(format);
Alert(date2str(str2date(testdate, format), "yyyy-MM-dd HH:mm:ss"));

js 执行sql

除了使用firetodb方式，还可以通过内嵌java方式实现，优点是更方便获取返回值中明确的内容

• 转换

• js 内容

// 加载JDBC驱动
var DriverClass = Packages.java.lang.Class.forName("com.mysql.jdbc.Driver");
 
// 设置数据库连接字符串，用户名和密码
var url = "jdbc:mysql://ip:port/dbname?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&zeroDateTimeBehavior=convertToNull&useSSL=false";
var username = 'root';
var password = 'password';
 
// 创建数据库连接
var connection = new Packages.java.sql.DriverManager.getConnection(url, username, password);
 
// 创建一个Statement对象来执行SQL语句
var statement = connection.createStatement();
 
// 执行一个SQL查询
var resultSet = statement.executeQuery("call Pro_B1_1_1_2_1_dept('2024-01-01','2024-02-01','1','')");

// 处理结果
while (resultSet.next()) {
    // 获取并处理结果集中的数据
    var dept = resultSet.getString("deptCode");
    var sum = resultSet.getString("sumVal");
    writeToLog("科室编码："+dept + "    统计值：" + sum);
}
 
// 关闭结果集、语句和连接
resultSet.close();
statement.close();
connection.close();