timeValue関数

本ページには広告が含まれています。

時刻を表す文字列をシリアル値に変換します。結果は、0～0.999988425925926（(23:59:59)/(24:00:00)→(23×3600+59×60+59)/(24×3600)=86399/86400=0.999988425926）の範囲の値を取ります。

引数に日付が含まれる場合日付は無視され、時刻情報のみ変換されます。

構文

UString = timeValue( str )

引数

str 必須: 時刻文字列。hh:nn:ss AM/PM、hh:nn AM/PM、hh AM/PM、hh:nn:ss、hh:nn、hh時nn分ss秒、hh時nn分のいずれかの形式を指定。

戻り値: シリアル値　（例）0…00:00:00、0.5…12:00:00、0.999988425925926…23:59:59

プログラム

//////////////////////////////////////////////////
// 【引数】
//   str : 時刻文字列。hh:nn:ss AM/PM、hh:nn AM/PM、hh AM/PM、hh:nn:ss、hh:nn、hh時nn分ss秒、hh時nn分のいずれかの形式を指定。
// 【戻り値】
//   シリアル値　（例）0…00:00:00、0.5…12:00:00、0.999988425925926…23:59:59
//////////////////////////////////////////////////
FUNCTION timeValue(str)
	DIM serial = 0
	DIM Matches
	DIM pattern = "(\d+)"
	DIM hh = "(0?[0-9]|1[0-2])"
	DIM ampm = "([AP]M|[ap]m)"
	SELECT TRUE
		CASE reTest(str, "\b" + hh + ":" + pattern + ":" + pattern + " " + ampm + "\b")
			Matches = reExecute(str, "\b" + hh + ":" + pattern + ":" + pattern + " " + ampm + "\b")
			WITH Matches.Item(0)
				serial = timeValue(.SubMatches(0) + " " + .SubMatches(3)) + VAL(.SubMatches(1)) / 1440 + VAL(.SubMatches(2)) / 86400
			ENDWITH
		CASE reTest(str, "\b" + hh + ":" + pattern + " " + ampm + "\b")
			Matches = reExecute(str, "\b" + hh + ":" + pattern + " " + ampm + "\b")
			WITH Matches.Item(0)
				serial = timeValue(.SubMatches(0) + " " + .SubMatches(2)) + VAL(.SubMatches(1)) / 1440
			ENDWITH
		CASE reTest(str, "\b" + hh + " " + ampm + "\b")
			Matches = reExecute(str, "\b" + hh + " " + ampm + "\b")
			WITH Matches.Item(0)
				serial = VAL(.SubMatches(0) MOD 12) + IIF(reTest(.SubMatches(1), "AM|am"), 0, 12)
				serial = serial / 24
			ENDWITH
		CASE reTest(str, "\b" + pattern + ":" + pattern + ":" + pattern + "\b")
			Matches = reExecute(str, "\b" + pattern + ":" + pattern + ":" + pattern + "\b")
			WITH Matches.Item(0)
				serial = VAL(.SubMatches(0)) / 24 + VAL(.SubMatches(1)) / 1440 + VAL(.SubMatches(2)) / 86400
			ENDWITH
		CASE reTest(str, "\b" + pattern + ":" + pattern + "\b")
			Matches = reExecute(str, "\b" + pattern + ":" + pattern + "\b")
			WITH Matches.Item(0)
				serial = VAL(.SubMatches(0)) / 24 + VAL(.SubMatches(1)) / 1440
			ENDWITH
		CASE reTest(str, "\b" + pattern + "時" + pattern + "分" + pattern + "秒")
			Matches = reExecute(str, "\b" + pattern + "時" + pattern + "分" + pattern + "秒")
			WITH Matches.Item(0)
				serial = VAL(.SubMatches(0)) / 24 + VAL(.SubMatches(1)) / 1440 + VAL(.SubMatches(2)) / 86400
			ENDWITH
		CASE reTest(str, "\b" + pattern + "時" + pattern + "分")
			Matches = reExecute(str, "\b" + pattern + "時" + pattern + "分")
			WITH Matches.Item(0)
				serial = VAL(.SubMatches(0)) / 24 + VAL(.SubMatches(1)) / 1440
			ENDWITH
		DEFAULT
			serial = ERR_VALUE
	SELEND
	RESULT = serial - INT(serial)
FEND

//////////////////////////////////////////////////
// 【引数】
//   expr : 評価する式
//   truepart : 評価した式がTrueのときに返す値
//   falsepart : 評価した式がFalseのときに返す値
// 【戻り値】
//   truepart : 評価した式がTrueのとき、falsepart : 評価した式がFalseのとき
//////////////////////////////////////////////////
FUNCTION IIF(expr, truepart, falsepart)
	IFB EVAL(expr) THEN
		RESULT = truepart
	ELSE
		RESULT = falsepart
	ENDIF
FEND

//////////////////////////////////////////////////
// 【引数】
//   str : 正規表現による検索の対象となる文字列
//   Pattern : 正規表現で使用するパターンを設定
//   IgnoreCase : 大文字・小文字を区別しない場合はTrue、区別する場合はFalse
//   Global : 文字列全体を検索する場合はTrue、しない場合はFalse
// 【戻り値】
//   正規表現で検索した結果をMatchesコレクションとして返します。
//////////////////////////////////////////////////
FUNCTION reExecute(str, Pattern, IgnoreCase = TRUE, Global = TRUE)
	DIM re = CREATEOLEOBJ("VBScript.RegExp")
	re.Pattern = Pattern
	re.IgnoreCase = IgnoreCase
	re.Global = Global
	RESULT = re.Execute(str)
FEND

//////////////////////////////////////////////////
// 【引数】
//   str : 正規表現による検索の対象となる文字列
//   Pattern : 正規表現で使用するパターンを設定
//   IgnoreCase : 大文字・小文字を区別しない場合はTrue、区別する場合はFalse
//   Global : 文字列全体を検索する場合はTrue、しない場合はFalse
// 【戻り値】
//   正規表現にマッチするかどうかを示すブール値
//////////////////////////////////////////////////
FUNCTION reTest(str, Pattern, IgnoreCase = TRUE, Global = TRUE)
	DIM re = CREATEOLEOBJ("VBScript.RegExp")
	re.Pattern = Pattern
	re.IgnoreCase = IgnoreCase
	re.Global = Global
	RESULT = re.Test(str)
FEND

解説

2-6行目

7,46行目

時・分・秒・AM/PMを正規表現を使い形式を判断し、Matchesコレクションとして取得。SubMatchesコレクションに各要素の値を代入。取得した値は文字列のためVAL関数で数値に変換。シリアル値は1日=1.0とするため、「時」は24、「分」は1440、「秒」は86400で割ります。

AMは午前、PMは午後を表し、AM0時=AM12時、PM0時=PM12時として計算します。AM/PM表記を含む場合、「hh AM/PM」部分で再帰呼び出しをしています。例えば「hh:nn:ss AM/PM」の場合、「hh AM/PM」と「nn:ss」の部分で分けて計算しています。

「hh:nn:ss AM/PM」の形式ならば8行目>>>を実行。
「hh:nn AM/PM」の形式ならば13行目>>>を実行。
「hh AM/PM」の形式ならば19行目>>>を実行。
「hh:nn:ss」の形式ならば24行目>>>を実行。
「hh:nn」の形式ならば29行目>>>を実行。
「hh時nn分ss秒」の形式ならば34行目>>>を実行。
「hh時nn分」の形式ならば39行目>>>を実行。
いずれの形式にもあれはまらなければ44行目>>>を実行。

8-12行目

「hh:nn:ss AM/PM」の形式。

SubMatches(0): 時
SubMatches(1): 分
SubMatches(2): 秒
SubMatches(3): AM/PM

13-18行目

「hh:nn AM/PM」の形式。

SubMatches(0): 時
SubMatches(1): 分
SubMatches(2): AM/PM

19-23行目

「hh AM/PM」の形式。まず「.SubMatches(0) MOD 12」で「時」を12時間表記に直します。「.SubMatches(1)」が「AM」もしくは「am」にマッチしたら午前なので「0」、マッチしなければ午後なので「12」を加え24時間表記にします。IIF関数の部分が午前・午後の判断をしています。

SubMatches(0): 時
Submatches(1): AM/PM

24-28行目

「hh:nn:ss」の形式。

SubMatches(0): 時
SubMatches(1): 分
SubMatches(2): 秒

29-33行目

「hh:nn」の形式。

SubMatches(0): 時
SubMatches(1): 分

34-38行目

「hh時nn分ss秒」の形式。

SubMatches(0): 時
SubMatches(1): 分
SubMatches(2): 秒

39-43行目

「hh時nn分」の形式。

SubMatches(0): 時
SubMatches(1): 分

44-45行目

いずれの形式にも当てはまらなければエラー値を返す。

47行目

serialの小数部分のみ返します。

使い方

結果

プログラム実行例

Windowsの稼働時間を取得

Windowsシステムの起動時間から稼働時間を求めます。

結果はd:hh:nn:ssの形式で出力されます。

HASHTBL INFO

DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

DIM filename = uniqueFilename(FSO.BuildPath(GET_CUR_DIR, "SYSTEMINFO.csv"))
DIM FID = FOPEN(filename, F_READ OR F_WRITE)
FPUT(FID, DOSCMD("systeminfo /FO CSV"))
FCLOSE(FID)

FID = FOPEN(filename, F_READ OR F_WRITE)
DIM col = 1

WHILE FGET(FID, 1, col) <> ""
	INFO[FGET(FID, 1, col)] = FGET(FID, 2, col)
	col = col + 1
WEND

FCLOSE(FID)

FSO.DeleteFile(filename)

DIM startupTime = INFO["システム起動時間"]
DIM date1 = dateValue(startupTime) + timeValue(startupTime)
DIM date2 = uwscToSerial(GETTIME())
PRINT INT(date2 - date1) + ":" + text(date2 - date1, "hh:mm:ss")

//////////////////////////////////////////////////
// 【引数】
//   needle : 検索する値
//   haystack : 配列
// 【戻り値】
//   needleが見つかった場合に配列のキー
//////////////////////////////////////////////////
FUNCTION arraySearch(needle, haystack[])
	DIM i = 0
	FOR item IN haystack
		IFB item = needle THEN
			RESULT = i
			EXIT
		ENDIF
		i = i + 1
	NEXT
FEND

//////////////////////////////////////////////////
// 【引数】
//   interval : 加算する時間間隔を表す文字列式（yyyy：年、m：月、d：日、ww：週、h：時、n：分、s：秒）
//   num : dateに加算する値。未来は正、過去は負で指定
//   date : 時間間隔を加算する日付
// 【戻り値】
//   日時（date）に、指定した単位（interval）の時間（num）を加算して返します
//////////////////////////////////////////////////
FUNCTION dateAdd(interval, num, date)
	DIM year, month, day, d
	GETTIME(0, date)
	DIM time = G_TIME_HH2 + ":" + G_TIME_NN2 + ":" + G_TIME_SS2
	SELECT interval
		CASE "yyyy"
			d = (G_TIME_YY + num) + "/" + G_TIME_MM2 + "/" + G_TIME_DD2
			IF time <> "00:00:00" THEN d = d + " " + time
		CASE "m"
			IFB num > 0 THEN
				year = G_TIME_YY + INT((G_TIME_MM + num) / 12)
				month = REPLACE(FORMAT(((G_TIME_MM + num) MOD 12), 2), " ", "0")
			ELSE
				year = G_TIME_YY + CEIL((G_TIME_MM + num) / 12 - 1)
				month = REPLACE(FORMAT(G_TIME_MM - (ABS(num) MOD 12), 2), " ", "0")
			ENDIF
			IF month = "00" THEN month = 12
			day = G_TIME_DD2
			d = "" + year + month + day
			IFB !isDate(d) THEN
				d = year + "/" + month + "/" + "01"
				d = getEndOfMonth(d)
			ELSE
				d = year + "/" + month + "/" + day
			ENDIF
			IF time <> "00:00:00" THEN d = d + " " + time
		CASE "d"
			t = GETTIME(num, date)
			d = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2 + IIF(t MOD 86400, " " + G_TIME_HH2 + ":" + G_TIME_NN2 + ":" + G_TIME_SS2, "")
		CASE "ww"
			t = GETTIME(num * 7, date)
			d = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2 + IIF(t MOD 86400, " " + G_TIME_HH2 + ":" + G_TIME_NN2 + ":" + G_TIME_SS2, "")
		CASE "h"
			t = GETTIME(num / 24, date)
			d = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2 + IIF(t MOD 86400, " " + G_TIME_HH2 + ":" + G_TIME_NN2 + ":" + G_TIME_SS2, "")
		CASE "n"
			t = GETTIME(num / 1440, date)
			d = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2 + IIF(t MOD 86400, " " + G_TIME_HH2 + ":" + G_TIME_NN2 + ":" + G_TIME_SS2, "")
		CASE "s"
			t = GETTIME(num / 86400, date)
			d = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2 + IIF(t MOD 86400, " " + G_TIME_HH2 + ":" + G_TIME_NN2 + ":" + G_TIME_SS2, "")
	SELEND
	RESULT = d
FEND

//////////////////////////////////////////////////
// 【引数】
//   interval : 時間単位（yyyy︰年、q：四半期、m︰月、d︰日、w：週日、ww：週、h：時、n：分、s：秒）
//   date1 : 日時1
//   date2 : 日時2
// 【戻り値】
//   date2からdate1を引いた時間間隔を求めます。
//////////////////////////////////////////////////
FUNCTION dateDiff(interval, date1, date2)
	DIM y1, y2, m1, m2, d1, d2, d
	SELECT interval
		CASE "yyyy"
			GETTIME(0, date1)
			y1 = G_TIME_YY
			GETTIME(0, date2)
			y2 = G_TIME_YY
			d = y2 - y1
		CASE "q"
			GETTIME(0, date1)
			y1 = G_TIME_YY
			m1 = G_TIME_MM
			GETTIME(0, date2)
			y2 = G_TIME_YY
			m2 = G_TIME_MM
			d = y2 * 4 + CEIL(m2/3) - (y1 * 4 + CEIL(m1/3))
		CASE "m"
			GETTIME(0, date1)
			y1 = G_TIME_YY
			m1 = G_TIME_MM
			GETTIME(0, date2)
			y2 = G_TIME_YY
			m2 = G_TIME_MM
			d = (y2 - y1) * 12 + m2 - m1
		CASE "d"
			d1 = GETTIME(0, date1)
			d2 = GETTIME(0, date2)
			d = (d2 - d1) / 86400
		CASE "w"
			d = INT(dateDiff("d", date1, date2) / 7)
		CASE "ww"
			date1 = dateAdd("d", -1 * getWeekday(date1), date1)
			d = INT(dateDiff("d", date1, date2) / 7)
		CASE "h"
			d = dateDiff("d", date1, date2) * 24
		CASE "n"
			d = dateDiff("d", date1, date2) * 1440
		CASE "s"
			d = dateDiff("d", date1, date2) * 86400
	SELEND
	RESULT = d
FEND

//////////////////////////////////////////////////
// 【引数】
//   str : 日付文字列
// 【戻り値】
//   シリアル値
//////////////////////////////////////////////////
FUNCTION dateValue(str)
	CONST cutOffYear = 2049
	DIM Months[] = "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
	
	HASHTBL Pattern
	Pattern["year"] = "(19[0-9]{2}|[2-9][0-9]{3})"
	Pattern["year2"] = "([0-9]{2})"
	Pattern["era"] = "(明治?|大正?|昭和?|平成?|令和?|[MTSHR])(元|\d+)"
	Pattern["month"] = "(1[0-2]|0?[1-9])"
	Pattern["month2"] = "(0[1-9]|1[0-2])"
	Pattern["month_en"] = "(Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Ap(?:ril)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Sept|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)"
	Pattern["day"] = "([1-2][0-9]|3[0-1]|0?[1-9])"
	Pattern["day2"] = "(0[1-9]|[1-2][0-9]|3[0-1])"
	Pattern["day_en"] = "(1(?:st)|2?2(?:nd)|2?3(?:rd)|[1-3]?[04-9](?:th)|1[1-3](?:th)|[1-3]1(?:st))"
	Pattern["separator"] = "([./\-])"
	
	HASHTBL era
	era["明治"] = 1867;	era["明"] = 1867;	era["M"] = 1867;
	era["大正"] = 1911;	era["大"] = 1911;	era["T"] = 1911;
	era["昭和"] = 1925;	era["昭"] = 1925;	era["S"] = 1925;
	era["平成"] = 1988;	era["平"] = 1988;	era["H"] = 1988;
	era["令和"] = 2018;	era["令"] = 2018;	era["R"] = 2018;

SELECT TRUE
		CASE reTest(str, "\b" + Pattern["year"] + Pattern["separator"] + Pattern["month"] + "(?:\2" + Pattern["day"] + ")?\b")
			Matches = reExecute(str, "\b(?:" + Pattern["year"] + Pattern["separator"] + ")?" + Pattern["month"] + "(?:\2" + Pattern["day"] + ")?\b")
			WITH Matches.Item(0)
				date = .SubMatches(0) + "/" + text(.SubMatches(2), "00") + "/" + text(IIF(.SubMatches(3)="", "01", .SubMatches(3)), "00")
			ENDWITH
		CASE reTest(str, "\b" + Pattern["month"] + Pattern["separator"] + Pattern["day"] + "(?:\2" + Pattern["year"] + ")?\b")
			Matches = reExecute(str, "\b" + Pattern["month"] + Pattern["separator"] + Pattern["day"] + "(?:\2" + Pattern["year"] + ")?\b")
			WITH Matches.Item(0)
				date = .SubMatches(3) + "/" + text(.SubMatches(0), "00") + "/" + text(.SubMatches(2), "00")
			ENDWITH
		CASE reTest(str, "\b" + Pattern["day"] + Pattern["separator"] + Pattern["month"] + "\2" + Pattern["year"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["day"] + Pattern["separator"] + Pattern["month"] + "\2" + Pattern["year"] + "\b")
			WITH Matches.Item(0)
				date = .SubMatches(3) + "/" + text(.SubMatches(2), "00") + "/" + text(.SubMatches(0), "00")
			ENDWITH
		CASE reTest(str, Pattern["era"] + Pattern["separator"] + Pattern["month"] + "(?:\3" + Pattern["day"] + ")?")
			Matches = reExecute(str, Pattern["era"] + Pattern["separator"] + Pattern["month"] + "(?:\3" + Pattern["day"] + ")?")
			WITH Matches.Item(0)
				date = (era[.SubMatches(0)] + VAL(.SubMatches(1))) + "/" + text(.SubMatches(3), "00") + "/" + IIF(.SubMatches(4)="", "01", text(.SubMatches(4), "00"))
			ENDWITH
		CASE reTest(str, "\b" + Pattern["year2"] + Pattern["separator"] + Pattern["month"] + "\2" + Pattern["day"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["year2"] + Pattern["separator"] + Pattern["month"] + "\2" + Pattern["day"] + "\b")
			WITH Matches.Item(0)
				y = VAL(.SubMatches(0))
				date = (IIF(y <= cutOffYear MOD 100, INT(cutOffYear/100) * 100, INT(cutOffYear/100) * 100 - 100) + y) + "/" + text(.SubMatches(2), "00") + "/" + text(.SubMatches(3), "00")
			ENDWITH
		CASE reTest(str, "\b" + Pattern["month"] + Pattern["separator"] + Pattern["day"] + "\2" + Pattern["year2"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["month"] + Pattern["separator"] + Pattern["day"] + "\2" + Pattern["year2"] + "\b")
			WITH Matches.Item(0)
				y = VAL(.SubMatches(3))
				date = (IIF(y <= cutOffYear MOD 100, INT(cutOffYear/100) * 100, INT(cutOffYear/100) * 100 - 100) + y) + "/" + text(.SubMatches(0), "00") + "/" + text(.SubMatches(2), "00")
			ENDWITH
		CASE reTest(str, "\b" + Pattern["day"] + Pattern["separator"] + Pattern["month"] + "\2" + Pattern["year2"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["day"] + Pattern["separator"] + Pattern["month"] + "\2" + Pattern["year2"] + "\b")
			WITH Matches.Item(0)
				y = VAL(.SubMatches(3))
				date = (IIF(y <= cutOffYear MOD 100, INT(cutOffYear/100) * 100, INT(cutOffYear/100) * 100 - 100) + y) + "/" + text(.SubMatches(2), "00") + "/" + text(.SubMatches(0), "00")
			ENDWITH
		CASE reTest(str, "\b" + Pattern["month_en"] + " " + Pattern["day_en"] + ",\s*" + Pattern["year"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["month_en"] + " " + Pattern["day_en"] + ",\s*" + Pattern["year"] + "\b")
			WITH Matches.Item(0)
				date = .SubMatches(2) + "/" + text(VAL(arraySearch(COPY(.SubMatches(0), 1, 3), Months)) + 1, "00") + "/" + REPLACE(REPLACE(REPLACE(REPLACE(.SubMatches(1), "st", ""), "nd", ""), "rd", ""), "th", "")
			ENDWITH
		CASE reTest(str, "\b" + Pattern["day_en"] + " " + Pattern["month_en"] + " " + Pattern["year"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["day_en"] + " " + Pattern["month_en"] + " " + Pattern["year"] + "\b")
			WITH Matches.Item(0)
				date = .SubMatches(2) + "/" + text(VAL(arraySearch(COPY(.SubMatches(1), 1, 3), Months)) + 1, "00") + "/" + REPLACE(REPLACE(REPLACE(REPLACE(.SubMatches(0), "st", ""), "nd", ""), "rd", ""), "th", "")
			ENDWITH
		CASE reTest(str, Pattern["era"] + "年" + Pattern["month"] + "月(?:" + Pattern["day"] + "日)?")
			Matches = reExecute(str, Pattern["era"] + "年" + Pattern["month"] + "月(?:" + Pattern["day"] + "日)?")
			WITH Matches.Item(0)
				date = era[.SubMatches(0)] + VAL(.SubMatches(1)) + "/" + text(.SubMatches(2), "00") + "/" + IIF(.SubMatches(3)="", "01", text(.SubMatches(3), "00"))
			ENDWITH
		CASE reTest(str, "\b" + Pattern["year"] + "年" + Pattern["month"] + "月(?:" + Pattern["day"] + "日)?")
			Matches = reExecute(str, "\b" + Pattern["year"] + "年" + Pattern["month"] + "月(?:" + Pattern["day"] + "日)?")
			WITH Matches.Item(0)
				date = .SubMatches(0) + "/" + text(.SubMatches(1), "00") + "/" + IIF(.SubMatches(2)="", "01", text(.SubMatches(2), "00"))
			ENDWITH
		CASE reTest(str, "\b" + Pattern["month"] + "月" + Pattern["day"] + "日")
			Matches = reExecute(str, "\b" + Pattern["month"] + "月" + Pattern["day"] + "日")
			WITH Matches.Item(0)
				date = getYear(today()) + "/" + text(.SubMatches(0), "00") + "/" + text(.SubMatches(1), "00")
			ENDWITH
		CASE LENGTH(str) = 6 AND reTest(str, Pattern["year2"] + Pattern["month2"] + Pattern["day2"])
			Matches = reExecute(str, Pattern["year2"] + Pattern["month2"] + Pattern["day2"])
			WITH Matches.Item(0)
				y = VAL(.SubMatches(0))
				date = (IIF(y <= cutOffYear MOD 100, INT(cutOffYear/100) * 100, INT(cutOffYear/100) * 100 - 100) + y) + "/" + .SubMatches(1) + "/" + .SubMatches(2)
			ENDWITH
		CASE LENGTH(str) = 6 AND reTest(str, Pattern["month2"] + Pattern["day2"] + Pattern["year2"])
			Matches = reExecute(str, Pattern["month2"] + Pattern["day2"] + Pattern["year2"])
			WITH Matches.Item(0)
				y = VAL(.SubMatches(2))
				date = (IIF(y <= cutOffYear MOD 100, INT(cutOffYear/100) * 100, INT(cutOffYear/100) * 100 - 100) + y) + "/" + .SubMatches(0) + "/" + .SubMatches(1)
			ENDWITH					
		CASE LENGTH(str) = 6 AND reTest(str, Pattern["day2"] + Pattern["month2"] + Pattern["year2"])
			Matches = reExecute(str, Pattern["day2"] + Pattern["month2"] + Pattern["year2"])
			WITH Matches.Item(0)
				y = VAL(.SubMatches(2))
				date = (IIF(y <= cutOffYear MOD 100, INT(cutOffYear/100) * 100, INT(cutOffYear/100) * 100 - 100) + y) + "/" + .SubMatches(1) + "/" + .SubMatches(0)
			ENDWITH
		CASE reTest(str, "\b" + Pattern["year"] + Pattern["month"] + Pattern["day"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["year"] + Pattern["month"] + Pattern["day"] + "\b")
			WITH Matches.Item(0)
				date = .SubMatches(0) + "/" + .SubMatches(1) + "/" + .SubMatches(2)
			ENDWITH
		CASE reTest(str, "\b" + Pattern["month"] + Pattern["day"] + Pattern["year"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["month"] + Pattern["day"] + Pattern["year"] + "\b")
			WITH Matches.Item(0)
				date = .SubMatches(2) + "/" + .SubMatches(0) + "/" + .SubMatches(1)
			ENDWITH
		CASE reTest(str, "\b" + Pattern["day"] + Pattern["month"] + Pattern["year"] + "\b")
			Matches = reExecute(str, "\b" + Pattern["day"] + Pattern["month"] + Pattern["year"] + "\b")
			WITH Matches.Item(0)
				date = .SubMatches(2) + "/" + .SubMatches(1) + "/" + .SubMatches(0)
			ENDWITH
		DEFAULT
			RESULT = ERR_VALUE
			EXIT
	SELEND
	RESULT = uwscToSerial(GETTIME(0, date))
FEND

//////////////////////////////////////////////////
// 【引数】
//   array : 最大公約数を求める数値を格納した配列
// 【戻り値】
//   最大公約数
//////////////////////////////////////////////////
FUNCTION GCD(array[])
	DIM c = LENGTH(array)
	DIM rem = array[c-1] MOD array[c-2]
	IFB rem = 0 THEN
		IFB LENGTH(array) = 2 THEN
			RESULT = array[c-2]
			EXIT
		ENDIF
		RESIZE(array, c-2)
		RESULT = GCD(array)
		EXIT
	ENDIF
	array[c-1] = array[c-2]
	array[c-2] = rem
	RESULT = GCD(array)
FEND

//////////////////////////////////////////////////
// 【引数】
//   date : 日付（”YYYYMMDD” or “YYYY/MM/DD” or “YYYY-MM-DD” or “YYYYMMDDHHNNSS” or “YYYY/MM/DD HH:NN:SS”）
//   m : 第一引数の指定日からプラスマイナスm月とする
// 【戻り値】
//   dateからm月後の月末の日付
//////////////////////////////////////////////////
FUNCTION getEndOfMonth(date, m = 0)
	date = dateAdd("m", m + 1, date)
	GETTIME(0, date)
	GETTIME(-G_TIME_DD, date)
	RESULT = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2
FEND

//////////////////////////////////////////////////
// 【引数】
//   date : 日付文字列（”YYYYMMDD” or “YYYY/MM/DD” or “YYYY-MM-DD” or “YYYYMMDDHHNNSS” or “YYYY/MM/DD HH:NN:SS”）もしくはシリアル値
//   type : 取得する曜日番号の種類を示す0〜3または11〜17の値。1と17は日曜日を1、2と11は月曜日を1とカウントします。11以降はExcel2010で追加された値で、互換性を保つために重複した値があります。
// 【戻り値】
//   typeで指定した種類によって以下の値を返します。 : （0 : 0(日曜)〜6(土曜)、1 : 1(日曜)～7(土曜)、2 : 1(月曜)～7(日曜)、3 : 0(月曜)〜6(日曜)、11 : 1(月曜)～7(日曜)、12 : 1(火曜)～7(月曜)、13 : 1(水曜)～7(火曜)、14 : 1(木曜)～7(水曜)、15 : 1(金曜)～7(木曜)、16 : 1(土曜)～7(金曜)、17 : 1(日曜)～7(土曜)）
//////////////////////////////////////////////////
FUNCTION getWeekday(date, type = 1)
	IF VARTYPE(date) <> 258 THEN date = text(date, "yyyy/mm/dd")
	GETTIME(0, date)
	DIM w = G_TIME_WW
	SELECT TRUE
		CASE type = 0
			RESULT = w
		CASE type = 1
			RESULT = w + 1
		CASE type = 2
			RESULT = IIF(w=0, 7, w)
		CASE type = 3
			RESULT = (w+6) MOD 7
		CASE type >= 11
			RESULT = ((getWeekday(date, 2) + 17 - type) MOD 7) + 1
	SELEND
FEND

//////////////////////////////////////////////////
// 【引数】
//   date : 日付（”YYYYMMDD” or “YYYY/MM/DD” or “YYYY-MM-DD” or “YYYYMMDDHHNNSS” or “YYYY/MM/DD HH:NN:SS”）
// 【戻り値】
//   指定した日付の「年」
//////////////////////////////////////////////////
FUNCTION getYear(date)
	GETTIME(0, date)
	RESULT = G_TIME_YY4
FEND

//////////////////////////////////////////////////
// 【引数】
//   serial : シリアル値もしくは時刻文字列
// 【戻り値】
//   時刻から時間を表す0〜23の範囲の値
//////////////////////////////////////////////////
FUNCTION Hour(serial)
	IF VARTYPE(serial) = 258 THEN serial = timeValue(serial)
	RESULT = INT(serial * 24) MOD 24
FEND

//////////////////////////////////////////////////
// 【引数】
//   date : 存在するかを調べる日付文字列。YYYYMMDD or YYYY/MM/DD or YYYY-MM-DDのいずれかの形式。
// 【戻り値】
//   TRUE : 日付として認識できる、FALSE : 日付として認識できない
//////////////////////////////////////////////////
FUNCTION isDate(date)
	TRY
		GETTIME(0, date)
		RESULT = TRUE
	EXCEPT
		RESULT = FALSE
	ENDTRY
FEND

//////////////////////////////////////////////////
// 【引数】
//   str : 正規表現による検索の対象となる文字列
//   Pattern : 正規表現で使用するパターンを設定
//   IgnoreCase : 大文字・小文字を区別しない場合はTrue、区別する場合はFalse
//   Global : 文字列全体を検索する場合はTrue、しない場合はFalse
// 【戻り値】
//   正規表現にマッチするかどうかを示すブール値
//////////////////////////////////////////////////
FUNCTION reTest(str, Pattern, IgnoreCase = TRUE, Global = TRUE)
	DIM re = CREATEOLEOBJ("VBScript.RegExp")
	re.Pattern = Pattern
	re.IgnoreCase = IgnoreCase
	re.Global = Global
	RESULT = re.Test(str)
FEND

//////////////////////////////////////////////////
// 【引数】
//   inputs : 繰り返す文字列
//   multiplier : inputsを繰り返す回数
// 【戻り値】
//   inputsをmultiplier回を繰り返した文字列を返します
//////////////////////////////////////////////////
FUNCTION strRepeat(inputs, multiplier)
	DIM res = ""
	FOR n = 1 TO multiplier
		res = res + inputs
	NEXT
	RESULT = res
FEND

//////////////////////////////////////////////////
// 【引数】
//   serial : シリアル値
//   format : フォーマット
// 【戻り値】
//   数値を表示書式に基づいて変換した文字列
//////////////////////////////////////////////////
FUNCTION text(serial, format, hour12 = FALSE)
	HASHTBL startDate
	startDate["明治"] = "1868/01/25"
	startDate["大正"] = "1912/07/30"
	startDate["昭和"] = "1926/12/25"
	startDate["平成"] = "1989/01/08"
	startDate["令和"] = "2019/05/01"
	
	DIM baseDate = "1899/12/30"
	serial = VAL(serial)
	SELECT TRUE
		CASE reTest(format, "\[h+\]")
			Matches = reExecute(format, "\[(h+)\]")
			DIM hour = iif(hour12, Hour(serial) MOD 12, Hour(serial))
			RESULT = text(hour, strRepeat("0", LENGTH(Matches.Item(0).SubMatches(0))))
		CASE reTest(format, "^h+$")
			Matches = reExecute(format, "^(h+)$")
			hour = iif(hour12, Hour(serial) MOD 12, Hour(serial))
			RESULT = text(hour MOD 24, strRepeat("0", LENGTH(Matches.Item(0).SubMatches(0))))
		CASE reTest(format, "\[m+\]")
			Matches = reExecute(format, "\[(m+)\]")
			RESULT = text(serial * 1440, strRepeat("0", LENGTH(Matches.Item(0).SubMatches(0))))
		CASE format = "m"
			GETTIME(serial, baseDate)
			RESULT = text(G_TIME_MM, "0")
		CASE format = "mm"
			GETTIME(serial, baseDate)
			RESULT = G_TIME_MM2
		CASE format = "n"
			GETTIME(serial, baseDate)
			RESULT = G_TIME_NN
		CASE format = "nn"
			GETTIME(serial, baseDate)
			RESULT = G_TIME_NN2
		CASE format = "s"
			GETTIME(serial, baseDate)
			RESULT = text(G_TIME_SS, "0")
		CASE format = "ss"
			GETTIME(serial, baseDate)
			RESULT = G_TIME_SS2
		CASE format = "yyyy"
			GETTIME(serial, baseDate)
			RESULT = G_TIME_YY4
		CASE format = "yy"
			GETTIME(serial, baseDate)
			RESULT = COPY(G_TIME_YY4, 3, 2)
		CASE format = "e"
			SELECT TRUE
				CASE dateDiff("d", startDate["令和"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(serial, "yyyy") - 2018
				CASE dateDiff("d", startDate["平成"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(serial, "yyyy") - 1988
				CASE dateDiff("d", startDate["昭和"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(serial, "yyyy") - 1925
				CASE dateDiff("d", startDate["大正"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(serial, "yyyy") - 1911
				CASE dateDiff("d", startDate["明治"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(serial, "yyyy") - 1867
			SELEND
		CASE format = "ee"
			SELECT TRUE
				CASE dateDiff("d", startDate["令和"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(text(serial, "yyyy") - 2018, "00")
				CASE dateDiff("d", startDate["平成"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(text(serial, "yyyy") - 1988, "00")
				CASE dateDiff("d", startDate["昭和"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(text(serial, "yyyy") - 1925, "00")
				CASE dateDiff("d", startDate["大正"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(text(serial, "yyyy") - 1911, "00")
				CASE dateDiff("d", startDate["明治"], text(serial, "yyyy/mm/dd")) >= 0
					RESULT = text(text(serial, "yyyy") - 1867, "00")
			SELEND
		CASE format = "g"
			SELECT TRUE
				CASE dateDiff("d", startDate["令和"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "R"
				CASE dateDiff("d", startDate["平成"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "H"
				CASE dateDiff("d", startDate["昭和"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "S"
				CASE dateDiff("d", startDate["大正"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "T"
				CASE dateDiff("d", startDate["明治"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "M"
			SELEND
		CASE format = "gg"
			RESULT = COPY(text(serial, "ggg"), 1, 1)
		CASE format = "ggg"
			SELECT TRUE
				CASE dateDiff("d", startDate["令和"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "令和"
				CASE dateDiff("d", startDate["平成"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "平成"
				CASE dateDiff("d", startDate["昭和"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "昭和"
				CASE dateDiff("d", startDate["大正"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "大正"
				CASE dateDiff("d", startDate["明治"], text(serial, "yyyy/mm/dd")) >= 0;		RESULT = "明治"
			SELEND
		CASE format = "mmmmm"
			RESULT = COPY(text(serial, "mmmm"), 1, 1)
		CASE format = "mmmm"
			DIM month[] = "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
			RESULT = month[text(serial, "m") - 1]
		CASE format = "mmm"
			RESULT = COPY(text(serial, "mmmm"), 1, 3)
		CASE format = "dd"
			GETTIME(serial, baseDate)
			RESULT = text(G_TIME_DD2, "00")
		CASE format = "d"
			GETTIME(serial, baseDate)
			RESULT = text(G_TIME_DD, "0")
		CASE reTest(format, "^[ad]{3,4}$")
			Matches = reExecute(format, "([ad]{3,4})")
			GETTIME(serial, baseDate)
			DIM aaa[] = "日", "月", "火", "水", "木", "金", "土"
			DIM aaaa[] = "日曜日", "月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日"
			DIM ddd[] = "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
			DIM dddd[] = "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
			RESULT = EVAL(Matches.Item(0).SubMatches(0) + "[" + getWeekday(G_TIME_WW, 1) + "]")
		CASE reTest(format, "(0+\.?0+)?%")
			Matches = reExecute(format, "(0+\.?0+)?%")
			RESULT = text(serial * 100, Matches.Item(0).SubMatches(0)) + "%"
		CASE reTest(format, "^\[DBNum\d{1,4}\](.*?)$")
			Matches = reExecute(format, "^\[DBNum(\d{1,4})\](.*?)$")
			DIM value = VAL(Matches.Item(0).SubMatches(0))
			DIM sss = text(serial, Matches.Item(0).SubMatches(1))
			Matches = reExecute(sss, "(\D+)?(\d+)(\D+)?")
			DIM res = ""
			FOR m = 0 TO Matches.Count - 1
				serial = Matches.Item(m).SubMatches(1)
				SELECT value
					CASE 1, 2
						DIM n[][9] = "〇", "一", "二", "三", "四", "五", "六", "七", "八", "九", _
										"", "壱", "弐", "参", "四", "伍", "六", "七", "八", "九"
						DIM a[][3] = "", "十", "百", "千",  _
										"", "拾", "百", "阡"
						DIM b[][3] = "", "万", "億", "兆", _
										"", "萬", "億", "兆"
						DIM r = ""
						DIM j = 0
						type = value - 1
						REPEAT
							DIM str = ""
							DIM n4 = serial MOD 10000
							FOR i = LENGTH(n4) TO 1 STEP -1
								s = COPY(n4, i, 1)
								IFB s = 1 AND a[type][LENGTH(n4)-i] <> "" THEN
									str = IIF(s, a[type][LENGTH(n4)-i], "") + str
								ELSE	
									str = n[type][s] + IIF(s, a[type][LENGTH(n4)-i], "") + str
								ENDIF
							NEXT
							IF str <> "" THEN r = str + b[type][j] + r
							j = j + 1
							serial = INT(serial / 10000)
						UNTIL serial = 0
						res = res + Matches.Item(m).SubMatches(0) + r + Matches.Item(m).SubMatches(2)
					CASE 3
						res = res + Matches.Item(m).SubMatches(0) + STRCONV(serial, SC_FULLWIDTH) + Matches.Item(m).SubMatches(2)
					CASE 4
						res = res + Matches.Item(m).SubMatches(0) + STRCONV(serial, SC_HALFWIDTH) + Matches.Item(m).SubMatches(2)
				SELEND
			NEXT
			RESULT = res
		CASE reTest(format, "^(.*?)(AM\/PM|am\/pm|A\/P|a\/p)(.*?)$")
			Matches = reExecute(format, "^(.*?)(AM\/PM|am\/pm|A\/P|a\/p)(.*?)$")
			DIM array = SPLIT(Matches.Item(0).SubMatches(1), "/")
			ampm = array[IIF(serial - INT(serial) >= 0.5, 1, 0)]
			hour12 = TRUE
			res = ""
			WITH Matches.Item(0)
				res = text(serial, .SubMatches(0), hour12) + ampm + text(serial, .SubMatches(2), hour12)
			ENDWITH
			RESULT = res
		CASE reTest(format, "([^ymdagehns]{0,})?(([ymdagehns])\3{0,})([^ymdagehns]+)?")
			Matches = reExecute(format, "([^ymdagehns]{0,})?(([ymdagehns])\3{0,})([^ymdagehns]+)?")
			FOR n = 0 TO Matches.Count - 1
				IF n = 0 THEN res = Matches.Item(n).SubMatches(0)
			NEXT
			FOR n = 0 TO Matches.Count - 1
				WITH Matches.Item(n)
					res = res + text(serial, .SubMatches(1), hour12) + .SubMatches(3)
				ENDWITH
			NEXT
			RESULT = res
		CASE format = "0/0"
			DIM separator = POS(".", serial)
			DIM g = 0
			IFB separator <> 0 THEN
				DIM keta = LENGTH(serial)
				DIM shift = POWER(10, keta - separator)
				IFB shift >= POWER(10, 15) THEN
					DIM position = 0
					FOR i = 0 TO 14
						IFB serial * POWER(10, i) - serial >= 1 THEN
							position = i
							BREAK
						ENDIF
					NEXT
					tmp = serial * POWER(10, position)
					FOR i = 1 TO 15
						r = (tmp * POWER(10, i)) / serial - (tmp / serial)
						a1 = tmp * POWER(10, i) - tmp
						IF a1 = INT(a1) THEN BREAK 
					NEXT
					DIM frac[] = a1, r
					g = GCD(frac)
					RESULT = (a1/g) + "/" + (r/g)
				ELSE
					DIM molecule = serial * shift	// 分子
					DIM denominator = shift		// 分母
					DIM nums[] = molecule, denominator
					g = GCD(nums)
					molecule = molecule / g
					denominator = denominator / g
					RESULT = molecule + "/" + denominator
				ENDIF
			ELSE
				RESULT = serial + "/1"
			ENDIF
		CASE reTest(format, "(0+)\.?(0+)?") AND UBound(SPLIT(format, ".")) <= 1 
			Matches = reExecute(format, "(0+)\.?(0+)?")
			len1 = LENGTH(Matches.Item(0).SubMatches(0))
			len2 = LENGTH(Matches.Item(0).SubMatches(1))
			DIM arr[] = LENGTH(INT(serial)), len1
			IFB POS(".", format) THEN
				RESULT = REPLACE(FORMAT(serial, CALCARRAY(arr, CALC_MAX) + len2 + 1, len2), " ", "0")
			ELSE
				RESULT = REPLACE(FORMAT(serial, CALCARRAY(arr, CALC_MAX)), " ", "0")
			ENDIF
	SELEND
FEND

//////////////////////////////////////////////////
// 【引数】
// 【戻り値】
//   今日の日付
//////////////////////////////////////////////////
FUNCTION today()
	GETTIME()
	RESULT = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2
FEND

//////////////////////////////////////////////////
// 【引数】
//   arrayname : 上限値を求める配列の名前
//   dimension : 返す次元を示す整数
// 【戻り値】
//   配列の上限値
//////////////////////////////////////////////////
FUNCTION UBound(arrayname[], dimension = 1)
	RESULT = EVAL("RESIZE(arrayname" + strRepeat("[0]", dimension - 1) + ")")
FEND

//////////////////////////////////////////////////
// 【引数】
//   path : ファイルのパス
// 【戻り値】
//   重複しないファイル名
//////////////////////////////////////////////////
FUNCTION uniqueFilename(path)
	DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
	IFB FSO.FileExists(path) THEN
		DIM fol = FSO.GetParentFolderName(path)
		DIM filename = FSO.GetBaseName(path)
		DIM extension = FSO.GetExtensionName(path)
		DIM i = 2
		WHILE FSO.FileExists(FSO.BuildPath(fol, filename + " (" + i + ")." + extension))
			i = i + 1
		WEND
		RESULT = FSO.BuildPath(fol, filename + " (" + i + ")." + extension)
	ELSE
		RESULT = path
	ENDIF
FEND

//////////////////////////////////////////////////
// 【引数】
//   uwscTime : UWSC時間
// 【戻り値】
//   シリアル値
//////////////////////////////////////////////////
FUNCTION uwscToSerial(uwscTime)
	uwscDate = uwscTime / 86400
	RESULT = 36526 + uwscDate
FEND

結果

使用関数

時刻が指定した範囲内にあるか

現在の日時が18:00:00〜22:00:00の範囲内にあるか。

DIM datetime = now()
DIM time = datetime - INT(datetime)

IFB timeValue("18:00:00") <= time AND time <= timeValue("22:00:00") THEN
	PRINT "範囲内です"
ELSE
	PRINT "範囲外です"
ENDIF

//////////////////////////////////////////////////
// 【引数】
// 【戻り値】
//   現在の日時
//////////////////////////////////////////////////
FUNCTION now()
	GETTIME()
	DIM datetime = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2 + " " + G_TIME_HH2 + ":" + G_TIME_NN2 + ":" + G_TIME_SS2
	RESULT = (GETTIME(0, datetime) - GETTIME(0, "1899/12/30")) / 86400
FEND

//////////////////////////////////////////////////
// 【引数】
//   str : 正規表現による検索の対象となる文字列
//   Pattern : 正規表現で使用するパターンを設定
//   IgnoreCase : 大文字・小文字を区別しない場合はTrue、区別する場合はFalse
//   Global : 文字列全体を検索する場合はTrue、しない場合はFalse
// 【戻り値】
//   正規表現にマッチするかどうかを示すブール値
//////////////////////////////////////////////////
FUNCTION reTest(str, Pattern, IgnoreCase = TRUE, Global = TRUE)
	DIM re = CREATEOLEOBJ("VBScript.RegExp")
	re.Pattern = Pattern
	re.IgnoreCase = IgnoreCase
	re.Global = Global
	RESULT = re.Test(str)
FEND

使用関数

フォルダ内のファイルを更新日時でソートする

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace("C:\Program Files (x86)\UWSC")
DIM FolderItems = Folder.Items

HASHTBL iColumn

FOR i = 0 TO 350
	iColumn[Folder.GetDetailsOf(EMPTYPARAM, i)] = i
NEXT

DIM filename[-1]
DIM datetime[-1]

FOR i = 0 TO FolderItems.Count - 1
	DIM FolderItem = FolderItems.Item(i)
	IF FolderItem.isFolder THEN CONTINUE
	arrayPush(filename, Folder.GetDetailsOf(FolderItem,iColumn["名前"]))
	arrayPush(datetime, Folder.GetDetailsOf(FolderItem, iColumn["更新日時"]))
NEXT

QSORT(datetime, QSRT_NATURALA, filename)

FOR i = 0 TO UBound(filename)
	PRINT filename[i] + "<#TAB>" + datetime[i]
NEXT

//////////////////////////////////////////////////
// 【引数】
//   array : 要素を追加する配列（参照引数）
//   values : 追加する要素をvalue1から指定
// 【戻り値】
//   処理後の配列の要素の数
//////////////////////////////////////////////////
FUNCTION arrayPush(var array[], value1 = EMPTY, value2 = EMPTY, value3 = EMPTY, value4 = EMPTY, value5 = EMPTY, value6 = EMPTY, value7 = EMPTY, value8 = EMPTY, value9 = EMPTY, value10 = EMPTY, value11 = EMPTY, value12 = EMPTY, value13 = EMPTY, value14 = EMPTY, value15 = EMPTY, value16 = EMPTY)
    DIM i = 1
    WHILE EVAL("value" + i) <> EMPTY
	  DIM res = RESIZE(array, UBound(array) + 1)
	  array[res] = EVAL("value" + i)
	  i = i + 1
	WEND
	RESULT = LENGTH(array)
FEND

結果

使用関数

時刻文字列をシリアル値に変換

DIM array[] = "0:00:00", "23:59:59", "1 AM", "11 PM", "13:50:25", + _
				"12:56", "2021/06/01 12:52:12", "2021/06/01 01:58 AM"

FOR item IN array
	PRINT timeValue(item)
NEXT

//////////////////////////////////////////////////
// 【引数】
//   str : 正規表現による検索の対象となる文字列
//   Pattern : 正規表現で使用するパターンを設定
//   IgnoreCase : 大文字・小文字を区別しない場合はTrue、区別する場合はFalse
//   Global : 文字列全体を検索する場合はTrue、しない場合はFalse
// 【戻り値】
//   正規表現にマッチするかどうかを示すブール値
//////////////////////////////////////////////////
FUNCTION reTest(str, Pattern, IgnoreCase = TRUE, Global = TRUE)
	DIM re = CREATEOLEOBJ("VBScript.RegExp")
	re.Pattern = Pattern
	re.IgnoreCase = IgnoreCase
	re.Global = Global
	RESULT = re.Test(str)
FEND

結果

使用関数

指定したフォルダの動画の合計時間を求める

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace("D:\Videos\")
DIM FolderItems = Folder.Items
DIM serial

HASHTBL iColumn

FOR n = 0 TO 350
	iColumn[Folder.GetDetailsOf(EMPTYPARAM, n)] = n
NEXT

FOR n = 0 TO FolderItems.Count - 1
	WITH Folder
		DIM FolderItem = .Items.Item(n)
		extension = .GetDetailsOf(FolderItem, iColumn["ファイル拡張子"])
		IFB FolderItem.IsFolder = FALSE THEN
			serial = serial + timeValue(.GetDetailsOf(FolderItem, iColumn["長さ"]))
		ENDIF
	ENDWITH
NEXT

PRINT text(serial, "hh:mm:ss")

//////////////////////////////////////////////////
// 【引数】
//   str : 正規表現による検索の対象となる文字列
//   Pattern : 正規表現で使用するパターンを設定
//   IgnoreCase : 大文字・小文字を区別しない場合はTrue、区別する場合はFalse
//   Global : 文字列全体を検索する場合はTrue、しない場合はFalse
// 【戻り値】
//   正規表現にマッチするかどうかを示すブール値
//////////////////////////////////////////////////
FUNCTION reTest(str, Pattern, IgnoreCase = TRUE, Global = TRUE)
	DIM re = CREATEOLEOBJ("VBScript.RegExp")
	re.Pattern = Pattern
	re.IgnoreCase = IgnoreCase
	re.Global = Global
	RESULT = re.Test(str)
FEND

結果

使用関数

now関数 (自作関数): 現在の日時のシリアル値を返します。
getSerialTime関数 (自作関数): UWSC時間からシリアル値を取得します。
uwscToSerial関数 (自作関数): UWSC時間をシリアル値に変換します。
serialToUNIX関数 (自作関数): シリアル値をUNIX時間に変換します。
UNIXToSerial関数 (自作関数): UNIX時間をシリアル値に変換します。
Second関数 (自作関数): シリアル値から秒を求めます。
serialToUwsc関数 (自作関数): シリアル値をUWSC時間に変換します。
Hour関数 (自作関数): シリアル値で与えられた時刻から時間を求めます。戻り値は0〜23の範囲の整数となります。
Minute関数 (自作関数): シリアル値で与えられた時刻から分を求めます。戻り値は0〜59の範囲の整数となります。
GETTIME関数 (スクリプト関数): 日付、時間を取得します。