FSO.BuildPath メソッド

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

フォルダパスとフォルダまたはファイルの名前を結合したパス文字列を返します。

フォルダパスやファイルパスの文字列を生成するだけで、実際にフォルダ・ファイルが作成されるわけではありません。

パスからフォルダ名を取得するにはFSO.GetParentFolderName メソッド、ファイル名を取得するには、FSO.GetFileName メソッドを使用します。

フォルダが存在するかはFSO.FolderExists メソッド、ファイルが存在するかはFSO.FileExists メソッドで確認できます。

構文
  1. String = FileSystemObject.BuildPath( path, name )
引数
path 省略可
nameが追加される既存のパスを指定します。絶対パス・相対パスを指定することができ、既存のフォルダを指定する必要はありません。
name 省略可
既存のpathに追加される名前を指定します。
戻り値
フォルダパスとフォルダまたはファイルの名前を結合したパス文字列

使い方

指定されたpathとnameを結合します。区切り文字の\があればそのまま結合し、なければpathの末尾に\を付与してからnameと結合します。

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

PRINT FSO.BuildPath("D:\Desktop\", "sample.txt")
PRINT FSO.BuildPath("D:\Desktop", "sample.txt")
結果
プレーンテキスト
D:\Desktop\sample.txt
D:\Desktop\sample.txt

nameにフォルダ名、フォルダ名を含んだパスを指定することもできます。フォルダ名を指定しても末尾に\が付与されることはありません。

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

PRINT FSO.BuildPath("D:\Desktop\", "test")
PRINT FSO.BuildPath("D:\Desktop\", "test\sample.txt")
PRINT FSO.BuildPath("D:\Desktop", "test\sample.txt")
結果
プレーンテキスト
D:\Desktop\test
D:\Desktop\test\sample.txt
D:\Desktop\test\sample.txt

pathの末尾、nameの先頭ともに\がある場合でも結合したときに\\と連続することはありません。

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

PRINT FSO.BuildPath("D:\Desktop\", "\test\sample.txt")
結果
プレーンテキスト
D:\Desktop\test\sample.txt

pathの末尾またはnameの先頭に\が2つ以上ある場合は、\が1につなることはありません。

pathの末尾またはnameの先頭ともに\がある場合、\が1つは消えます。

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

PRINT FSO.BuildPath("D:\Desktop\\", "\sample.txt")
PRINT FSO.BuildPath("D:\Desktop\\", "sample.txt")
PRINT FSO.BuildPath("D:\Desktop\", "\\sample.txt")
PRINT FSO.BuildPath("D:\Desktop", "\\sample.txt")
結果
プレーンテキスト
D:\Desktop\\sample.txt
D:\Desktop\\sample.txt
D:\Desktop\\sample.txt
D:\Desktop\\sample.txt

特殊フォルダを指定する場合、Shell.NameSpace メソッドを使うことで動的にパスを生成することができます。以下はデスクトップのsample.txtを指定する例。

UWSC
CONST ssfDesktop = 0

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

PRINT FSO.BuildPath(Shell.NameSpace(ssfDesktop).Self.Path, "sample.txt")
結果
プレーンテキスト
D:\Desktop\sample.txt

生成したパスに空のファイルを作成するにはコマンドプロンプトのfsutilコマンドを使い以下のように記述します。

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM path = FSO.BuildPath("D:\Desktop\", "sample.txt")

PRINT DOSCMD("fsutil file createnew " + path + " 0")

上記のプログラムは指定したフォルダが存在しない場合エラーとなるので、フォルダを生成する場合は以下のように記述します。

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM path = FSO.BuildPath("D:\Desktop\test", "sample.txt")

CreateFolders(FSO.GetParentFolderName(path))
PRINT DOSCMD("fsutil file createnew " + path + " 0")

//////////////////////////////////////////////////
// 【引数】
//   folderspec : 作成するフォルダのパス 
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE CreateFolders(folderspec)
	WITH CREATEOLEOBJ("Scripting.FileSystemObject")
		folderspec = .GetAbsolutePathName(folderspec)
		IF !.DriveExists(.GetDriveName(folderspec)) THEN EXIT
		DIM parentPath = .GetParentFolderName(folderspec)
		IF !.FolderExists(parentPath) THEN CreateFolders(parentPath)
		IF !.FolderExists(folderspec) THEN .CreateFolder(folderspec)
	ENDWITH
FEND

プログラム実行例

表示されているすべてのウィンドウのスクリーンショットを保存

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

DIM folderspec = "D:\Desktop\Screenshot"
IF FSO.FolderExists(folderspec) = FALSE THEN FSO.CreateFolder(folderspec)

FOR n = 0 TO GETALLWIN() - 1
	DIM ID = ALL_WIN_ID[n]
	IFB STATUS(ID, ST_VISIBLE) = TRUE		
		DIM filename = ID + "_" + STATUS(ID, ST_TITLE)
		filename = PathCleanupSpec(filename)
		DIM path = FSO.BuildPath(folderspec, filename)
		path = uniqueFilename(path)
		SAVEIMG(path, id)
	ENDIF
NEXT

//////////////////////////////////////////////////
// 【引数】
//   filename : 使えない文字を削除するファイル・フォルダ名 
// 【戻り値】
//   ファイル名として使えない文字を削除した文字列 
//////////////////////////////////////////////////
FUNCTION PathCleanupSpec(filename)
	DIM filenameErrChar[12] = "\", "/", ":", "*", "?", "<#DBL>", "<#CR>", "<#TAB>", "<", ">", "|", "[", "]"
	FOR item IN filenameErrChar
		filename = REPLACE(filename, item, "")
	NEXT
	RESULT = filename
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
使用関数

システム起動時間を取得

システムの起動時間をyyyy/mm/dd, hh:nn:ssの形式で取得します。

UWSC
HASHTBL INFO

DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

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

FID = FOPEN(filename, F_READ OR F_WRITE)
FOR col = 0 TO 33
	INFO[FGET(FID, 1, col)] = FGET(FID, 2, col)
NEXT
FCLOSE(FID)

FSO.DeleteFile(filename)

PRINT INFO["システム起動時間"]

//////////////////////////////////////////////////
// 【引数】
//   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
結果
プレーンテキスト
2019/12/21, 15:53:56
使用関数

Windowsの稼働時間を取得

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

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

UWSC
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

//////////////////////////////////////////////////
// 【引数】
//   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

//////////////////////////////////////////////////
// 【引数】
//   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 
// 【戻り値】
//   正規表現で検索した結果を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

//////////////////////////////////////////////////
// 【引数】
//   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

//////////////////////////////////////////////////
// 【引数】
//   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

//////////////////////////////////////////////////
// 【引数】
//   
// 【戻り値】
//   今日の日付 
//////////////////////////////////////////////////
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
結果
プレーンテキスト
0:08:16:46
使用関数

デスクトップにフォルダを作成

UWSC
CONST ssfDESKTOP = 0

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace(ssfDESKTOP)
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

WITH FSO
	.CreateFolder(.BuildPath(Folder.Self.Path, INPUT("デスクトップにフォルダを作成します。<#CR>フォルダ名を入力してください。")))
ENDWITH
使用関数

パス文字列を生成します

UWSC
CONST ssfDESKTOP = 0

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace(ssfDESKTOP)
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

PRINT FSO.BuildPath(Folder.Self.Path, INPUT("フォルダ名もしくはファイル名を入力してください。"))
使用関数

一時ファイルを作成・削除

UWSC
CONST TemporaryFolder = 2

DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM Folder = FSO.GetSpecialFolder(TemporaryFolder)
DIM folderspec = Folder.Path
DIM filename = FSO.GetTempName
DIM path = FSO.BuildPath(folderspec, filename)

PRINT path

DIM TextStream = FSO.CreateTextFile(path)
// 現在の日時をファイルに書き込む
TextStream.WriteLine(now())
TextStream.Close

// Tempファイルを削除
// FSO.DeleteFile(path)

FUNCTION now()
	GETTIME()
	RESULT = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2 + " " + G_TIME_HH2 + ":" + G_TIME_NN2
FEND
結果
プレーンテキスト
D:\TMP\rad83BB3.tmp
使用関数

csvファイルをHTMLのテーブルデータにする（csvToHTML）

CSVのデータをHTML（テーブル）に変換します。

クリップボードにcsvファイルのパスをコピーして実行します。

UWSC
CONST TemporaryFolder = 2

DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM Folder = FSO.GetSpecialFolder(TemporaryFolder)
DIM folderspec = Folder.Path
DIM name = FSO.GetTempName
DIM TempPath = FSO.BuildPath(folderspec, name)

DIM path = GETSTR(0)
DIM FID = FOPEN(path, F_READ)
DIM FID2 = FOPEN(TempPath, F_READ OR F_WRITE)
FPUT(FID2, "<table>", F_ALLTEXT)

FOR row = 1 TO FGET(FID, F_LINECOUNT)
	DIM col = 1
	FPUT(FID2, "<#TAB><tr>", 0)
	WHILE FGET(FID, row, col) <> ""
		FPUT(FID2, "<#TAB><#TAB><td>" + (FGET(FID, row, col)) + "</td>", 0)
		col = col + 1
	WEND
	FPUT(FID2, "<#TAB></tr>", 0)
NEXT
FPUT(FID2,"</table>", 0)

FCLOSE(FID)
FCLOSE(FID2)

FID = FOPEN(TempPath, F_READ)
SENDSTR(0, FGET(FID, F_ALLTEXT))
PRINT FGET(FID, F_ALLTEXT)
FCLOSE(FID)
使用関数

ファイルを開いているプロセスを調べる

UWSC
SETHOTKEY(VK_ESC, EMPTYPARAM, "forceQuit")

CONST TemporaryFolder = 2

DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

WITH FSO
	DIM Folder = .GetSpecialFolder(TemporaryFolder)
	DIM folderspec = Folder.Path
	DIM filename = .GetTempName
	DIM path = .BuildPath(folderspec, filename)
ENDWITH

DIM Shell = CREATEOLEOBJ("Shell.Application")
Shell.FileRun()

DIM ID = GETID("ファイル名を指定して実行", "#32770")

SENDSTR(ID, "cmd /c openfiles /query /fo CSV > " + path)
CLKITEM(ID, "OK", CLK_BTN)
SLEEP(0.500)

REPEAT
	SLEEP(0.100)
UNTIL GETID("C:\WINDOWS\system32\cmd.exe", "ConsoleWindowClass") = -1

DIM FID = FOPEN(path, F_READ)

TRY
	DIM ID2 = GETID("使用中", "OperationStatusWindow")

	GETITEM(ID2, ITM_ACCTXT, 1)
	DIM str = ALL_ITEM_LIST[1]
	
	DIM sep = IIF(POS("フォルダー", STATUS(ID2, ST_TITLE)) <> 0, "\", "")
	DIM msg = "■" + str + "<#CR>"
	
	FOR r = 5 TO FGET(FID, F_LINECOUNT)
		IF POS("\" + str + sep,  FGET(FID, r, 3)) <> 0 THEN
			msg = msg + "ID：" + FGET(FID, r, 1) + ", プロセス名：" + FGET(FID, r, 2) + "<#CR>"
		ENDIF
	NEXT
	FCLOSE(FID)

	REPEAT
		FUKIDASI(TRIM(msg))
		SLEEP(0.100)
	UNTIL GETID("使用中", "OperationStatusWindow") = -1
FINALLY
	FSO.DeleteFile(path)
ENDTRY

//////////////////////////////////////////////////
// 【引数】
//   
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE forceQuit()
	EXITEXIT
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
使用関数

楽天銀行定期預金の金利をExcelに保存

UWSC
DIM IE = CREATEOLEOBJ("InternetExplorer.Application")
IE.Visible = TRUE
IE.Navigate("https://rbweb.rakuten-bank.co.jp/REF/main/fis/BasicTimeDepositInterestRate.html?PageID=BasicTimeDepositInterestRatePresentationLogicBean")
BusyWait(IE)

DIM elements = IE.document.getElementsByTagName("table")
DIM element = elements.Item(0)
DIM arr[-1][-1]

getTableData(element, arr)

IE.Quit

DIM Excel = XLOPEN()
XLSETDATA(Excel, arr, "A1")

DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM path = uniqueFilename(FSO.BuildPath(GET_CUR_DIR, "楽天銀行定期預金金利.xlsx"))
XLCLOSE(Excel, path)

//////////////////////////////////////////////////
// 【引数】
//   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

//////////////////////////////////////////////////
// 【引数】
//   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

//////////////////////////////////////////////////
// 【引数】
//   IE : IEオブジェクト 
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE BusyWait(Var IE)
	SLEEP(0.500)
	DIM t = GETTIME()
	TRY
		REPEAT
			DIM tm = GETTIME() - t
			FUKIDASI("BusyWait：" + tm)
			SLEEP(0.010)
			IF tm >= 60 THEN BREAK
		UNTIL !IE.Busy AND IE.readyState = 4
	EXCEPT
		IE = getIEObj(-1)
		PRINT IE.document.URL + " のIEオブジェクトを取得しました。"
		BusyWait(IE)
	ENDTRY
	FUKIDASI()
FEND

//////////////////////////////////////////////////
// 【引数】
//   文字列 or 数値 : 取得したい<a href="https://uwsc.jp/com/ie/" >InternetExplorer オブジェクト</a>のタイトル・URLもしくは数値を指定 
//   完全一致フラグ : （TRUE : 文字列が完全一致したものを取得、FALSE : 文字列の一部を含むものを取得） 
// 【戻り値】
//   条件に一致する<a href="https://uwsc.jp/com/ie" >InternetExplorer</a> 
//////////////////////////////////////////////////
FUNCTION getIEObj(str, flg = FALSE)
	DIM Shell = CREATEOLEOBJ("Shell.Application")
	DIM ShellWindows = Shell.Windows
	DIM IE[-1]
	FOR i = 0 TO ShellWindows.Count - 1
		TRY
			IFB ShellWindows.Item(i).Name = "Internet Explorer" THEN
				arrayPush(IE, ShellWindows.Item(i))
			ENDIF
		EXCEPT
		ENDTRY
	NEXT
	SELECT CHKNUM(str)
		CASE TRUE
			IFB str = 0 THEN
				RESULT = LENGTH(IE)
			ELSE
				IF str < 0 THEN str = str + LENGTH(IE) + 1
				TRY
					RESULT = IE[str-1]
				EXCEPT
					RESULT = ERR_VALUE
				ENDTRY
			ENDIF
		CASE FALSE
			DIM pattern = IIF(flg, "^" + str + "$", str)
			DIM titleList = SLICE(IE)
			FOR i = 0 TO UBound(titleList)
				titleList[i] = titleList[i].Document.title
			NEXT
			DIM urlList = SLICE(IE)
			FOR i = 0 TO UBound(urlList)
				urlList[i] = urlList[i].Document.URL
			NEXT
			DIM num = ERR_VALUE
			SELECT TRUE
				CASE pregGrep(pattern, titleList) <> FALSE;	num = arraySearch(pregGrep(pattern, titleList)[0], titleList)
				CASE pregGrep(pattern, urlList) <> FALSE;		num = arraySearch(pregGrep(pattern, urlList)[0], urlList)
			SELEND
			TRY
				RESULT = IE[num]
			EXCEPT
				RESULT = ERR_VALUE
			ENDTRY
	SELEND
FEND

//////////////////////////////////////////////////
// 【引数】
//   table : tableエレメント 
//   arr : 取得したデータを格納する配列（参照引数） 
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE getTableData(table, Var arr[][])
	rowMax = table.rows.length - 1
	colMax = 0
	FOR row = 0 TO table.rows.length - 1
		IFB table.rows(row).cells.length - 1 > colMax THEN
			colMax = table.rows(row).cells.length - 1
		ENDIF
	NEXT
	DIM arr[rowMax][colMax]
	FOR row = 0 TO table.rows.length - 1
		FOR col = 0 TO table.rows(row).cells.length - 1
			n = 0
			WHILE arr[row][col + n] <> ""
				n = n + 1
			WEND
			arr[row][col + n] = table.rows(row).cells(col).innerText
			IFB table.rows(row).cells(col).rowSpan > 1 AND table.rows(row).cells(col).colSpan > 1 THEN
				rmax = table.rows(row).cells(col).rowSpan - 1
				cmax = table.rows(row).cells(col).colSpan - 1
				FOR r = 1 TO rmax
					FOR c = 1 TO cmax
						arr[row + r][col + c] = "←"
					NEXT
				NEXT
			ENDIF
			IFB table.rows(row).cells(col).rowSpan > 1 THEN
				n = table.rows(row).cells(col).rowSpan - 1
				WHILE n
					arr[row + n][col] = "↑"
					n = n - 1
				WEND
			ENDIF
			IFB table.rows(row).cells(col).colSpan > 1 THEN
				n = table.rows(row).cells(col).colSpan - 1
				WHILE n
					arr[row][col + n] = "←"
					n = n - 1
				WEND
			ENDIF
		NEXT
	NEXT
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

//////////////////////////////////////////////////
// 【引数】
//   pattern : 検索するパターンを表す文字列 
//   array : 検索される配列 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION pregGrep(pattern, array[], flags = 0)
	DIM res[-1]
	FOR item IN array
		IF reTest(item, pattern) THEN arrayPush(res, item)
	NEXT
	RESULT = SLICE(res)
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

//////////////////////////////////////////////////
// 【引数】
//   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
使用関数

UWSC.INIよりUWSCを再生するホットキーを取得

Roamingフォルダ（C:\Users\username\AppData\Roaming\）のUWSCフォルダにあるUWSC.INIを読み込み、UWSCを停止するホットキーを取得します。

UWSC
DIM modifers[] = "CTRL", "WIN", "ALT", "SHIFT+CTRL", "SHIFT+ALT", "CTRL+ALT"
DIM keys[] = "SPACE", "F1", "F2", "F3", "F4", "F9", "F10", "F11", "F12", "↑", _
				"↓", "→", "←", "Q", "W", "E", "R", "A", "S", "D", _
				"F", "End", "Home", "F5", "F6", "F7", "F8", "T", "Y", "U", _
				"I", "O", "P", "G", "H", "J", "K", "L", "Z", "X", _
				"C", "V", "B", "N", "M", "1", "2", "3", "4", "5", _
				"6", "7", "8", "9"

DIM WshShell = CREATEOLEOBJ("WScript.Shell")
DIM str = READINI("SET", "PlayHotKey", WshShell.ExpandEnvironmentStrings("%AppData%\UWSC\UWSC.INI"))
DIM nums = SPLIT(str, ",")

PRINT modifers[nums[1]] + "+" + keys[nums[0]]

//////////////////////////////////////////////////
// 【引数】
//   section : セクション 
//   key : キー（Delete関数は省略可） 
//   value : 値 
//   path : INIファイルのパス 
//   default : セクションとキーが存在しなかった場合に返す値 
// 【戻り値】
//   
//////////////////////////////////////////////////
MODULE INI
	DEF_DLL GetPrivateProfileStringW(wstring,wstring,wstring,var pwchar,dword,wstring):dword:kernel32
	DEF_DLL WritePrivateProfileStringW(wstring,wstring,wstring,wstring):bool:kernel32
	FUNCTION Read(section = NULL, key = NULL, path = NULL, default = EMPTY)
		DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
		IFB path = NULL THEN
			path = FSO.GetAbsolutePathName(FSO.GetBaseName(GET_UWSC_NAME) + ".INI")
		ELSE
			path = FSO.GetAbsolutePathName(path)
		ENDIF
		DIM n = 1024
		DIM buffer = FORMAT(CHR(0), n)
		IFB GetPrivateProfileStringW(section, key, default, buffer, n, path) = 0 THEN
			RESULT = default
		ELSE
			RESULT = SLICE(SPLIT(buffer, CHR(0), TRUE))
			IF section <> NULL AND key <> NULL THEN RESULT = RESULT[0]
		ENDIF
	FEND
	FUNCTION Write(section, key, value, path = NULL)
		DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
		IFB path = NULL THEN
			path = FSO.GetAbsolutePathName(FSO.GetBaseName(GET_UWSC_NAME) + ".INI")
		ELSE
			path = FSO.GetAbsolutePathName(path)
		ENDIF
		RESULT = WritePrivateProfileStringW(section, key, value, path)
	FEND
	PROCEDURE Delete(section, key = NULL, path = NULL)
		DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
		IFB path = NULL THEN
			path = FSO.GetAbsolutePathName(FSO.GetBaseName(GET_UWSC_NAME) + ".INI")
		ELSE
			path = FSO.GetAbsolutePathName(path)
		ENDIF
		PRINT WritePrivateProfileStringW(section, key, NULL, path)
	FEND
	FUNCTION escape(value)
		DIM esc = ";#=:"
		FOR i = 1 TO LENGTH(esc)
			DIM s = COPY(esc, i, 1)
			value = REPLACE(value, s, "\" + s)
		NEXT
		RESULT = value
	FEND
	FUNCTION unescape(value)
		DIM esc = ";#=:"
		FOR i = 1 TO LENGTH(esc)
			DIM s = COPY(esc, i, 1)
			value = REPLACE(value, "\" + s, s)
		NEXT
		RESULT = value
	FEND
ENDMODULE
[syntaxHighlight language="INI" title="UWSC.INI"][SET] Position=7,81 PlayHotKey=1,2 StopHotKey=2,2 RecHotKey=3,2 TrayHotKey=14,5 LunchMenuHotKey=14,0 MouseOrg=0 NotActive=0 StayOnTop=0 LogLines=2000 DefaultFont=, TaskTrayStart=1[/syntaxHighlight]
結果
プレーンテキスト
ALT+F1
使用関数

古いキャッシュファイルを削除する

Localフォルダ（C:\Users\username\AppData\Local\Temp \）にあるファイルの最終更新日時が7日以上前のファイルをごみ箱に移動します。

UWSC
CONST ssfBITBUCKET = 10
CONST ssfLOCALAPPDATA = 28

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder2 = Shell.NameSpace(ssfLOCALAPPDATA)
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM folderspec = FSO.BuildPath(Folder2.Self.Path, "Temp")
DIM FolderTemp = FSO.GetFolder(folderspec)
DIM FolderRecycle = Shell.NameSpace(ssfBITBUCKET)
DIM base = GETTIME(-7)

DIM Files = FolderTemp.Files
DIM count = Files.Count

DIM res = MSGBOX(count + "個のフォイルをごみ箱に移動します。", BTN_YES OR BTN_NO,,, BTN_NO)

IFB res = BTN_YES THEN
	FOR File IN Files
		DIM datetime = File.DateLastModified
		IFB GETTIME(0, datetime) - base <= 0 THEN
			PRINT File.Path
			FolderRecycle.MoveHere(File.Path)
		ENDIF
	NEXT
ENDIF
使用関数

関連記事

IE.Navigate メソッド
URLまたは絶対パスで指定されたファイルを開きます。
Shell.Explore メソッド
指定したディレクトリをエクスプローラで開きます。
FSO.GetExtensionName メソッド
指定したパスの最後のコンポーネントのファイル拡張子名を返します。
File.Path プロパティ (FSO)
指定したファイルのパスを返します。
getBitmap関数 (自作関数)
引数に指定したビットマップ画像のサイズ・幅・高さ・ビットの深さを配列で返します。
ShellLinkObject.Path プロパティ (Shell)
リンク オブジェクトへのパスを取得または設定します。
FSO.GetFolder メソッド
指定したパスのFolder オブジェクトを返します。