CREATEOLEOBJクリエイトオーエルイーオブジェクト関数

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

Contents

構文
  1. Object = CREATEOLEOBJ( COMオブジェクト名 )
引数
COMオブジェクト名 (String)必須
COMオブジェクト名
戻り値

COMオブジェクト

COMからメソッド使用時に引数に値取得(OUT引数)がある場合は、引数の変数の前にVarを付ける

COMオブジェクト一覧

アプリ名 COMオブジェクト名
Internet Explorer InternetExplorer オブジェクト
Shell オブジェクト
CDO.Message
FileSystemObject Scripting.FileSystemObject
WshShell WScript.Shell
Excel Excel オブジェクト
Word Word オブジェクト
Outlook Outlook オブジェクト

プログラム実行例

UWSC.INIよりUWSC本体のウィンドウの幅と高さを取得

UWSC起動時のウィンドウの座標を幅,高さの形式で取得します。

MainSizeキーは初期では定義されていないので、値を取得できないこともあります。

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")
DIM path = WshShell.ExpandEnvironmentStrings("%AppData%\UWSC\UWSC.INI")

PRINT READINI("SET", "MainSize", path)

//////////////////////////////////////////////////
// 【引数】
//   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
結果
プレーンテキスト
220,61
使用関数
解説

「プログラム」の右クリックメニューの動作項目を取得

UWSC
CONST ssfPROGRAMS = 2

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace(ssfPROGRAMS)
DIM FolderItemVerbs = Folder.Self.Verbs()

FOR FolderItemVerb IN FolderItemVerbs
	PRINT FolderItemVerb.Name
NEXT
結果
プレーンテキスト
開く(&O)
クイック アクセスに​​ピン留めする
コピー(&C)

以前のバージョンの復元(&V)


切り取り(&T)
コピー(&C)
ショートカットの作成(&S)
削除(&D)
名前の変更(&M)
プロパティ(&R)
使用関数

デスクトップを開く

UWSC
CONST ssfDESKTOP = 0

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace(ssfDESKTOP)
DIM FolderItemVerbs = Folder.Self.Verbs()

FOR FolderItemVerb IN FolderItemVerbs
	IF POS("&O", FolderItemVerb.Name) <> 0 THEN FolderItemVerb.DoIt()
NEXT
使用関数

右クリックメニュー取得

UWSC
CONST ssfDesktop = 0

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace(ssfDesktop)
DIM FolderItem = Folder.ParseName("log.txt")
DIM FolderItemVerbs = FolderItem.Verbs

FOR FolderItemVerb IN FolderItemVerbs
	PRINT FolderItemVerb.Name
NEXT
結果
プレーンテキスト
開く(&O)
印刷(&P)
編集(&E)

ALZipで圧縮(&L)
管理者権限で圧縮(&Y)
"log.zip" で圧縮(&Q)
コピー(&C)
削除(&D)
共有

以前のバージョンの復元(&V)

切り取り(&T)
コピー(&C)
ショートカットの作成(&S)
削除(&D)
名前の変更(&M)
プロパティ(&R)
使用関数

表の最終データの下のセルを選択

[download "/example/620/東京月別平均気温(2000-2019年).xlsx"]
UWSC
CONST xlDown = -4121

DIM Excel = CREATEOLEOBJ("Excel.Application")
Excel.Visible = TRUE
Excel.Workbooks.Open("C:\Users\Owner\Downloads\東京月別平均気温(2000-2019年).xlsx")

Excel.Range("B4").End(xlDown).Offset(1).Select
使用関数

ワークブックの数と名前を取得

UWSC
DIM Excel = CREATEOLEOBJ("Excel.Application")
Excel.Visible = TRUE

FOR i = 1 TO 3
	Excel.Workbooks.Add()
NEXT

DIM Workbooks = Excel.Application.Workbooks

PRINT "ブック数:" + Excel.Workbooks.Count
PRINT "-----"

FOR Workbook IN Workbooks
	PRINT "ブック名:" + Workbook.Name
NEXT

SLEEP(3.00)

Excel.Application.Quit
結果
プレーンテキスト
ブック数:3
-----
ブック名:Book1
ブック名:Book2
ブック名:Book3
使用関数

指定したフォルダ内の拡張子とファイルの種類を返す

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM folderspec = "D:\Desktop\"
DIM Files = FSO.GetFolder(folderspec).Files

FOR File IN Files
	PRINT FSO.GetExtensionName(File.Name) + ":" + File.Type
NEXT
使用関数

オフライン作業取得

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")

TRY
	// Ver11以上
	DIM version = WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\svcVersion")
EXCEPT
	// Ver10以下
	version = WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\Version")
ENDTRY

IFB VAL(TOKEN(".", version)) <= 10 THEN
	// Ver10以下
	DIM IE = CREATEOLEOBJ("InternetExplorer.Application")
	IE.Visible = TRUE
	IFB IE.Offilne = TRUE THEN
		PRINT "オフライン作業中です"
	ELSE
		PRINT "オフライン作業中ではありません"
	ENDIF
	IE.Quit
ELSE
	// Ver11以上
	PRINT "オフライン作業は利用できません"	
ENDIF
結果
プレーンテキスト
オフライン作業は利用できません
使用関数

指定期間のメールを日毎に集計(Outlook)

UWSC
CONST olFolderIndex = 6

DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM NameSpace = Outlook.GetNameSpace("MAPI")
DIM Folder = NameSpace.GetDefaultFolder(olFolderIndex)
DIM Items = Folder.Items

Items = Items.Restrict("[ReceivedTime] >= '2020/12/01' AND [ReceivedTime] < '2020/12/31'")

HASHTBL dates = HASH_SORT

FOR MailItem IN Items
	DIM datetime = MailItem.ReceivedTime
	GETTIME(0, datetime)
	DIM date = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2
	dates[date] = dates[date] + 1 
NEXT

FOR i = 0 TO LENGTH(dates) - 1
	PRINT dates[i, HASH_KEY] + "<#TAB>" + dates[i, HASH_VAL]
NEXT
結果
プレーンテキスト
2020/12/05	78
2020/12/06	60
2020/12/07	72
2020/12/08	82
2020/12/09	75
2020/12/10	91
2020/12/11	82
2020/12/12	77
2020/12/13	63
2020/12/14	71
2020/12/15	104
2020/12/16	84
2020/12/17	80
2020/12/18	93
2020/12/19	78
2020/12/20	66
2020/12/21	67
2020/12/22	75
2020/12/23	82
2020/12/24	73
2020/12/25	87
2020/12/26	73
2020/12/27	56
2020/12/28	65
2020/12/29	69
2020/12/30	44
2020/12/31	1
使用関数

タスクバーにある時計の秒を非表示にする

PC再起動後に適用されます。

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")

DIM name = "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced\ShowSecondsInSystemClock"
DIM value = 0
DIM type = "REG_DWORD"

WshShell.RegWrite(name, value, type)

//DOSCMD("shutdown /r /t 0")
使用関数

予定データをExcelから読み込み追加する(Outlook)

[download "/example/625/予定一覧.xlsx"]
UWSC
CONST xlUp = -4162
CONST olAppointmentItem = 1

HASHTBL reminders
reminders["なし"] = -1;       reminders["0分"] = 0;       reminders["5分"] = 5
reminders["10分"] = 10;       reminders["15分"] = 15;     reminders["30分"] = 30
reminders["1時間"] = 60;      reminders["2時間"] = 120;   reminders["3時間"] = 180
reminders["4時間"] = 240;     reminders["5時間"] = 300;   reminders["6時間"] = 360
reminders["7時間"] = 420;     reminders["8時間"] = 480;   reminders["9時間"] = 540
reminders["10時間"] = 600;    reminders["11時間"] = 660;  reminders["0.5日"] = 720
reminders["18時間"] = 1080;   reminders["1日"] = 1440;    reminders["2日"] = 2880
reminders["3日"] = 4320;      reminders["4日"] = 5760;    reminders["1週"] = 10080
reminders["2週"] = 20160

DIM Excel = CREATEOLEOBJ("Excel.Application")
Excel.Visible = TRUE
DIM Workbook = Excel.Workbooks.Open("D:\Desktop\予定一覧.xlsx")

DIM MaxRow = Excel.Cells(Excel.Rows.Count, 1).End(xlUp).Row

DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM AppointmentItem = Outlook.CreateItem(olAppointmentItem)

FOR row = 2 TO MaxRow
	PRINT row
	WITH AppointmentItem
		.Subject = Excel.Cells(row, 2).Value        // 件名
		.Location = Excel.Cells(row, 3).Value       // 場所
		.Start = Excel.Cells(row, 4).Value          // 開始時刻
		.End = Excel.Cells(row, 5).Value            // 終了時刻
		IF Excel.Cells(row, 6).Value = "○" THEN .AllDayEvent = TRUE     // 終日
		IFB reminders[Excel.Cells(row, 7).Value] <> -1 THEN
			.ReminderSet = TRUE
			.ReminderMinutesBeforeStart = reminders[Excel.Cells(row, 7).Value]     // リマインダー
		ELSE
			.ReminderSet = FALSE
		ENDIF
		.BusyStatus = 1                             // 公開方法
		.Body = Excel.Cells(row, 8).Value           // 本文
		.Save
	ENDWITH
NEXT

MSGBOX((MaxRow - 1) + "件の予定を登録しました。")

Outlook.Quit
Excel.Quit

指定フォルダ内の拡張子をすべて小文字にする

UWSC
CONST ssfDESKTOP = 0

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM folderspec = Shell.NameSpace(ssfDESKTOP).Self.Path
DIM Folder = Shell.NameSpace(folderspec + "\test\")
DIM FolderItems = Folder.Items

DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")

FOR FolderItem IN FolderItems
    DIM path = FolderItem.Path
    WITH FSO
        DIM filename1 = .GetParentFolderName(path) + "\" + .GetBaseName(path) + "." + .GetExtensionName(path)
        DIM filename2 = .GetBaseName(path) + "." + STRCONV(.GetExtensionName(path), SC_LOWERCASE)
    ENDWITH
    DOSCMD("RENAME <#DBL>" + filename1 + "<#DBL> <#DBL>" + filename2 + "<#DBL>")
NEXT
使用関数
解説

UWSC.INIのDefaultFontを変更する

UWSC
CONST ssfFONTS = 20

DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace(ssfFONTS)
DIM FolderItems = Folder.Items
DIM array[-1]

FOR FolderItem IN FolderItems
	arrayPush(array, FolderItem.Name)
NEXT

QSORT(array, QSRT_UNICODEA)
SHIFTARRAY(array, 1)
array[0] = "(なし)"

DIM filename = "C:\Users\" + BETWEENSTR(DOSCMD("SET"), "USERNAME=", "<#CR>") + "\AppData\Roaming\UWSC\UWSC.INI"
DIM str = SPLIT(READINI("SET", "DefaultFont", filename), ",")[0]
DIM font = SLCTBOX(SLCT_CMB OR SLCT_STR, 0, "フォントを選択してください。(現在:" + str + ")", array)

IF font = "(なし)" THEN font = ""
IF font <> -1 THEN WRITEINI("SET", "DefaultFont", font + ",", filename)

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

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

//////////////////////////////////////////////////
// 【引数】
//   inputs : 繰り返す文字列 
//   multiplier : inputsを繰り返す回数 
// 【戻り値】
//   
//////////////////////////////////////////////////
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
使用関数

メール本文からURLを取得(Outook)

メールの本文から正規表現でURL部分のみを取得します。

UWSC
DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM NameSpace = Outlook.GetNameSpace("MAPI")
DIM Folder = NameSpace.Folders("info@example.com").Folders("受信トレイ")
//DIM Folder = NameSpace.GetDefaultFolder(olFolderIndex)

// 昨日のメールを取得
GETTIME(-1)
DIM datetime = G_TIME_YY4 + G_TIME_MM2 + G_TIME_DD2 + "_" + G_TIME_HH2 + G_TIME_NN2
// 今日の日付
DIM date1 = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2
// 明日の日付
DIM date2 = dateAdd("d", 1, date1)

// 処理するメールの条件=受信日時が今日のメール ※[ReceivedTime] = [受信日時]
DIM Items = Folder.Items.Restrict("[ReceivedTime] >= '" + date1 + " 0:00 AM' AND [ReceivedTime] < '" + date2 + " 0:00 AM'")

// 「受信日時」でソート
Items.Sort("受信日時")

FOR Index = 1 TO Items.Count
	WITH Items.Item(Index)
		DIM Matches = reExecute(.Body, "https?://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?")
		FOR Match IN Matches
			PRINT Match.Value
		NEXT
	ENDWITH
NEXT

//////////////////////////////////////////////////
// 【引数】
//   interval : 加算する時間間隔を表す文字列式(yyyy:年、m:月、d:日、ww:週、h:時、n:分、s:秒) 
//   num : dateに加算する値。未来は正、過去は負で指定 
//   date : 時間間隔を加算する日付 
// 【戻り値】
//   
//////////////////////////////////////////////////
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

//////////////////////////////////////////////////
// 【引数】
//   date : 日付(”YYYYMMDD” or “YYYY/MM/DD” or “YYYY-MM-DD” or “YYYYMMDDHHNNSS” or “YYYY/MM/DD HH:NN:SS”) 
//   m : 第一引数の指定日からプラスマイナス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

//////////////////////////////////////////////////
// 【引数】
//   expr : 評価する式 
//   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のいずれかの形式。 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION isDate(date)
	TRY
		GETTIME(0, date)
		RESULT = TRUE
	EXCEPT
		RESULT = FALSE
	ENDTRY
FEND

//////////////////////////////////////////////////
// 【引数】
//   str : 正規表現による検索の対象となる文字列 
//   Pattern : 正規表現で使用するパターンを設定 
//   IgnoreCase : 大文字・小文字を区別しない場合はTrue、区別する場合はFalse 
//   Global : 文字列全体を検索する場合はTrue、しない場合はFalse 
// 【戻り値】
//   
//////////////////////////////////////////////////
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
使用関数

レジストリからGoogle Chromeの実行ファイルのパスを取得

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")
PRINT WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe\")
結果
プレーンテキスト
C:\Program Files (x86)\Google\Chrome\Application\chrome.exe
使用関数

レジストリからInternet Explorerの実行ファイルのパスを取得

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")
PRINT WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\IEXPLORE.EXE\")
結果
プレーンテキスト
C:\Program Files\Internet Explorer\IEXPLORE.EXE
使用関数

レジストリからFirefoxの実行ファイルのパスを取得

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")
PRINT WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\firefox.exe\")
結果
プレーンテキスト
C:\Program Files\Mozilla Firefox\firefox.exe
使用関数

レジストリからMicrosoft Edgeの実行ファイルのパスを取得

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")
PRINT WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\msedge.exe\")
結果
プレーンテキスト
C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe
使用関数
解説

すべてのフォルダの項目と件数を取得する

UWSC
DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM NameSpace = Outlook.GetNameSpace("MAPI")
DIM Folders = NameSpace.Folders

FOR Folder IN Folders
	PRINT "■" + Folder.Name
	Folders2 = NameSpace.Folders(Folder.Name).Folders
	FOR Folder2 IN Folders2
		PRINT "・" + Folder2.Name + ":" + Folder2.Items.Count + "件"
	NEXT
	PRINT
NEXT
結果
プレーンテキスト
■Android_旧
・受信トレイ:7698件
・削除済みアイテム:8件
・送信済みアイテム:0件
・迷惑メール:0件
・送信トレイ:0件
・連絡先候補:0件
・ニュース フィード:0件
・予定表:1件
・連絡先:0件
・履歴:0件
・メモ:0件
・タスク:0件
・下書き:0件
・RSS フィード:0件
・スレッド アクション設定:0件
・クイック操作設定:0件

■Yahoo!_旧
・削除済みアイテム:1件
・受信トレイ:323518件
・送信トレイ:0件
・送信済みアイテム:1件
・予定表:34件
・連絡先:620件
・履歴:0件
・メモ:0件
・タスク:0件
・下書き:1件
・RSS フィード:0件
・スレッド アクション設定:0件
・クイック操作設定:0件
・迷惑メール:44025件
・連絡先候補:0件
・ニュース フィード:0件

■Android_新
・受信トレイ:10902件
・削除済みアイテム:0件
・送信済みアイテム:0件
・迷惑メール:0件

■Yahoo!_新
・削除済みアイテム:1件
・受信トレイ:410292件
・送信トレイ:0件
・送信済みアイテム:1件
・予定表:34件
・連絡先:620件
・履歴:0件
・メモ:0件
・タスク:0件
・下書き:1件
・RSS フィード:0件
・スレッド アクション設定:0件
・クイック操作設定:0件
・迷惑メール:51607件
・連絡先候補:0件
・ニュース フィード:0件
使用関数

過去7日間に受信した迷惑メールの受信日時とメールアドレスを取得

UWSC
DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM NameSpace = Outlook.GetNameSpace("MAPI")
DIM Folders = NameSpace.Folders("Yahoo!_新").Folders("迷惑メール")
DIM startDate = dateAdd("d", -7, today())
DIM endDate = dateAdd("d", -1, today())
DIM Items = Folders.Items.Restrict("[ReceivedTime] >= '" + startDate + "' AND [ReceivedTime] < '" + endDate + "'")
DIM count = Items.Count

Items.Sort("受信日時")

FOR Index = 1 TO count
	WITH Items.Item(Index)
		PRINT .ReceivedTime + "<#TAB>" + .SenderEmailAddress
	ENDWITH
NEXT

//////////////////////////////////////////////////
// 【引数】
//   interval : 加算する時間間隔を表す文字列式(yyyy:年、m:月、d:日、ww:週、h:時、n:分、s:秒) 
//   num : dateに加算する値。未来は正、過去は負で指定 
//   date : 時間間隔を加算する日付 
// 【戻り値】
//   
//////////////////////////////////////////////////
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

//////////////////////////////////////////////////
// 【引数】
//   date : 日付(”YYYYMMDD” or “YYYY/MM/DD” or “YYYY-MM-DD” or “YYYYMMDDHHNNSS” or “YYYY/MM/DD HH:NN:SS”) 
//   m : 第一引数の指定日からプラスマイナス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

//////////////////////////////////////////////////
// 【引数】
//   expr : 評価する式 
//   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のいずれかの形式。 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION isDate(date)
	TRY
		GETTIME(0, date)
		RESULT = TRUE
	EXCEPT
		RESULT = FALSE
	ENDTRY
FEND

//////////////////////////////////////////////////
// 【引数】
//   
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION today()
	GETTIME()
	RESULT = G_TIME_YY4 + "/" + G_TIME_MM2 + "/" + G_TIME_DD2
FEND
使用関数
解説

未読メールの本文からURLを抽出

UWSC
DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM NameSpace = Outlook.GetNameSpace("MAPI")
DIM Folder = NameSpace.Folders("Android_新").Folders("受信トレイ")
DIM Items = Folder.Items.Restrict("[UnRead] = TRUE")

Items.Sort("受信日時", TRUE)

// クリックするURLを格納した配列(部分一致)
DIM urls[] = "://example.com"

DIM driver = CREATEOLEOBJ("Selenium.WebDriver")
WebDriverDownload.Chrome()

// ログイン情報を保存
CONST PROFILE_PATH = "C:\Users\" + BETWEENSTR(DOSCMD("SET"), "USERNAME=", "<#CR>") + "\AppData\Local\Google\Chrome\User Data\Default"
driver.AddArgument("user-data-dir=" + PROFILE_PATH)
driver.Start("chrome")

DIM count = Items.Count

FOR Index = count TO 1 STEP -1
	WITH Items.Item(Index)
		FUKIDASI(Index + "<#TAB>" + .SenderEmailAddress + "<#TAB>" + .ReceivedTime)
		DIM Matches = reExecute(.Body, "https?://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?")
		// メール本文のURLをループ
		FOR Match IN Matches
			// クリックするURLをチェック
			FOR i = 0 TO UBound(urls)
				IF POS(urls[i], Match.Value) = 0 THEN CONTINUE
				driver.Get(Match.Value)		// リンクを開く
			NEXT
		NEXT
		SLEEP(1.000)
	ENDWITH
NEXT

//////////////////////////////////////////////////
// 【引数】
//   expr : 評価する式 
//   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 
// 【戻り値】
//   
//////////////////////////////////////////////////
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

//////////////////////////////////////////////////
// 【引数】
//   inputs : 繰り返す文字列 
//   multiplier : inputsを繰り返す回数 
// 【戻り値】
//   
//////////////////////////////////////////////////
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 
//   destination 
// 【戻り値】
//   
//////////////////////////////////////////////////
PROCEDURE UnZip(path, destination = "")
	DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
	DIM folderspec = FSO.GetParentFolderName(path)
	DIM filename = FSO.GetFileName(path)
	IF destination = "" THEN destination = folderspec
	POWERSHELL("Set-Location " + folderspec + "; Expand-Archive " + filename + " -DestinationPath " + destination + " -Force")
FEND

//////////////////////////////////////////////////
// 【引数】
//   bit64 : Chromeブラウザが64bitの場合はTrue、32bitの場合はFalseを指定。省略した場合、インストール先のフォルダパスから判断。 
//   force : 現在インストールされているドライバーとバージョンが一致しても強制的にインストール処理を行うには場合、Trueを指定 
// 【戻り値】
//   
//////////////////////////////////////////////////
MODULE WebDriverDownload
	DIM WshShell = CREATEOLEOBJ("WScript.Shell")
	DIM folderspec = WshShell.ExpandEnvironmentStrings("%LOCALAPPDATA%\SeleniumBasic\")
	PROCEDURE Chrome(bit64 = "", force = FALSE)
		HASHTBL url
		HASHTBL version
		TRY
			DIM path = WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe\Path")
		EXCEPT
			PRINT "Google Chromeがインストールされていません"
			EXIT
		ENDTRY
		version["browser"] = TRIM(DOSCMD("DIR /B /O-N <#DBL>" + path + "<#DBL> | FINDSTR <#DBL>^[0-9].*¥>"))
		IF version["browser"] = READINI("Chrome", "version", folderspec + "WebDriverVersion.ini") AND !force THEN EXIT
		DIM major = VAL(COPY(version["browser"], 1, POS(".", version["browser"]) - 1))
		url["version"] = "https://googlechromelabs.github.io/chrome-for-testing/LATEST_RELEASE_" + major
		WITH CREATEOLEOBJ("Msxml2.XMLHTTP")
			.Open("GET", url["version"], FALSE)
			.Send()
			version["driver"] = .ResponseText
		ENDWITH
		SELECT bit64
			CASE TRUE
				bit = 64
			CASE FALSE
				bit = 32
			DEFAULT
				bit = IIF(POS("Program Files (x86)", path) <> 0, "32", "64")
		SELEND
		url["driver"] = "https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/" + version["driver"] + "/win" + bit + "/chromedriver-win" + bit + ".zip"
		DIM filename = "chromedriver.zip"
		IF Download(url["driver"], folderspec, filename) THEN UnZip(folderspec + filename)
		path = folderspec + "chromedriver-win" + bit + "\chromedriver.exe"
		WITH CREATEOLEOBJ("Scripting.FileSystemObject")
			.CopyFile(path, folderspec, TRUE)
			.DeleteFolder(.GetParentFolderName(path))
		ENDWITH
		WRITEINI("Chrome", "version", version["browser"], folderspec + "WebDriverVersion.ini")
	FEND
	PROCEDURE Firefox(force = FALSE)
		HASHTBL url
		url["version"] = "https://api.github.com/repos/mozilla/geckodriver/tags"
		WITH CREATEOLEOBJ("Msxml2.XMLHTTP")
			.Open("GET", url["version"], FALSE)
			.Send()
			DIM str = .ResponseText
		ENDWITH
		CONST TemporaryFolder = 2
		HASHTBL temp
		DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
		DIM Folder = FSO.GetSpecialFolder(TemporaryFolder)
		temp["folderspec"] = Folder.Path
		temp["filename"] = FSO.GetTempName
		DIM path = FSO.BuildPath(temp["folderspec"], temp["filename"])
		WITH FSO.CreateTextFile(path)
			.WriteLine(str)
			.Close
		ENDWITH
		str = POWERSHELL("Set-Location <#DBL>" + temp["folderspec"] + "<#DBL>; Get-Content -Path " + temp["filename"] + " -Raw | ConvertFrom-Json | ForEach-Object{echo $_.name}")
		DIM version = SPLIT(str, "<#CR>")[0]
		IF version = READINI("Firefox", "version", folderspec + "WebDriverVersion.ini") AND !force THEN EXIT
		FSO.DeleteFile(path)
		TRY
			path = WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\firefox.exe\")
			DIM bit = IIF(POS("Program Files (x86)", path), 32, 64)
		EXCEPT
			PRINT "Firefoxがインストールされていません"
			EXIT
		ENDTRY
		url["driver"] = "https://github.com/mozilla/geckodriver/releases/download/" + version + "/geckodriver-" + version + "-win" + bit + ".zip"
		DIM filename = "geckodriver.zip"
		IF Download(url["driver"], folderspec , filename, TRUE) THEN UnZip(folderspec + filename)
		WRITEINI("Firefox", "version", version, folderspec + "WebDriverVersion.ini")
	FEND
	PROCEDURE MsEdge(force = FALSE)
		HASHTBL url
		TRY
			path = WshShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\msedge.exe\")
		EXCEPT
			PRINT "Microsoft Edgeがインストールされていません"
			EXIT
		ENDTRY
		DIM version = TRIM(POWERSHELL("(get-item (<#DBL>" + path + "<#DBL>)).VersionInfo.FileVersion"))
		DIM major = TOKEN(".", version)
		IF version = READINI("MsEdge", "version", folderspec + "WebDriverVersion.ini") AND !force THEN EXIT
		url["download"] = "https://msedgewebdriverstorage.blob.core.windows.net/edgewebdriver/LATEST_RELEASE_" + major + "_WINDOWS"
		DIM Request = Request(url["download"])
		version = TRIM(Request.responseText)
		url["driver"] = "https://msedgewebdriverstorage.blob.core.windows.net/edgewebdriver/" + version + "/edgedriver_win" + IIF(KINDOFOS(TRUE), "64", "32") + ".zip"
		DIM filename = "msedgedriver." + version + ".zip"
		IF Download(url["driver"], folderspec, filename) THEN UnZip(folderspec + filename)
		WRITEINI("MsEdge", "version", version, folderspec + "WebDriverVersion.ini")
	FEND
ENDMODULE

//////////////////////////////////////////////////
// ダウンロード
// url:URL、dir:ディレクトリ名、filename:ファイル名、isServerXMLHTTP:
//////////////////////////////////////////////////
FUNCTION Download(url, dir, filename, isServerXMLHTTP = FALSE)
	CONST adSaveCreateOverWrite = 2
	WITH CREATEOLEOBJ("ADODB.Stream")
		.Open()
		.Type = 1
		IF isServerXMLHTTP THEN
			obj = CREATEOLEOBJ("Msxml2.ServerXMLHTTP")
		ELSE
			obj = CREATEOLEOBJ("Msxml2.XMLHTTP")
		ENDIF
		obj.Open("GET", url, FALSE)
		obj.Send()
		.Write(obj.responseBody)
		.SaveToFile(dir + filename, adSaveCreateOverWrite)
		.Close()
	ENDWITH
	RESULT = FOPEN(dir + filename, F_EXISTS)
FEND

//////////////////////////////////////////////////
// 要求
// url:URL、isServerXMLHTTP:
//////////////////////////////////////////////////
FUNCTION Request(url, isServerXMLHTTP = FALSE)
	IFB isServerXMLHTTP THEN
		RESULT = CREATEOLEOBJ("Msxml2.ServerXMLHTTP")
	ELSE
		RESULT = CREATEOLEOBJ("Msxml2.XMLHTTP")
	ENDIF
	WITH RESULT
		.Open("GET", url, FALSE)
		.Send()
	ENDWITH
FEND
使用関数

HTMLメールを送信(Outlook)

HTMLメールの本文は長くなるので、TEXTBLOCKで定義して代入しています。

UWSC
CONST olMailItem = 0
CONST olFormatHTML = 2

DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM MailItem = Outlook.Application.CreateItem(olMailItem)

WITH MailItem
   .BodyFormat = olFormatHTML
   .Subject = "HTMLメールのテスト"
   .HTMLBody = Body
   .To = "contact@example.com"   // 送信先
   Account = Outlook.Session.Accounts.Item("info@example.com")    // 送信元
   .SendUsingAccount = Account
   .Send
ENDWITH

TEXTBLOCK Body
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional/a/EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
   <head>
       <meta name="viewport" content="target-densitydpi=device-dpi,width=device-width,maximum-scale=1.0,user-scalable=yes">
       <meta http-equiv="Content-Language" content="ja">
       <meta charset="shift_jis">
       <title></title>
   </head>
   <body>
       <table border="0" cellpadding="0" cellspacing="0" width="600px">
           <tr>
               <td><img alt="画像" src="http://example.com/image.jpg" width="600px" style="width:600px;"></td>
           </tr>
           <tr>
               <table border="1px" cellpadding="0" cellspacing="0" width="600px">
                   <tr>
                       <td width="50%">テキスト1</td>
                       <td width="50%">テキスト2</td>
                   </tr>
               </table>
           </tr>
       </table>
   </body>
</html>
ENDTEXTBLOCK
使用関数
解説

UWSC
DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM NameSpace = Outlook.GetNameSpace("MAPI")
DIM Stores = NameSpace.Stores

FOR Store IN Stores
	PRINT Store.FilePath
NEXT
結果
プレーンテキスト
D:\Outlook\info1@example.com.pst
C:\Users\username\AppData\Local\Microsoft\Outlook\info2@example.com.pst

D:\Outlook\info3@example.com.pst
使用関数

ビットマップ画像を補色に変換(24ビット)

UWSC
PUBLIC item
PUBLIC count
PUBLIC starttime
PUBLIC bool = FALSE

CONST adTypeBinary = 1

DIM path = "D:\Desktop\UWSC\d22.bmp"
DIM array = getBitmap(path)
DIM width = array[1]
DIM height = array[2]

DIM Stream = CREATEOLEOBJ("ADODB.Stream")

WITH Stream
	.Open()
	.Type = adTypeBinary
	.LoadFromFile(path)
	DIM tmp = .Read(-1)
	.Close()
ENDWITH

THREAD progress()

starttime = text(now(), "yyyy/mm/dd hh:nn:ss")
count = width * height

FOR h = 0 TO height-1
	FOR w = 0 TO width
		item = w + width * h
		i = 54 + w * 3 + (h * (width+1) * 3)
		col = ""
		FOR rgb = 0 TO 2
			ii = i + rgb
			TRY
				hex = decToHex(tmp[ii])
			EXCEPT
				BREAK 2
			ENDTRY
			col = col + IIF(LENGTH(hex) = 1, "0", "") + hex
		NEXT
		color = hexToDec(col)
		comp = complementaryColor(color)
		comp = decToHex(comp)
		FOR rgb = 0 TO 2
			tmp[i + rgb] = hexToDec(COPY(comp, rgb * 2 + 1, 2))
		NEXT
	NEXT
	PRINT
NEXT
bool = TRUE

WITH Stream
	.Open()
	.Type = adTypeBinary
	.Write(tmp)
	DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
	DIM folderspec = FSO.GetParentFolderName(path)
	DIM filename = FSO.GetBaseName(path)
	DIM extension = FSO.GetExtensionName(path)
	path = folderspec + "\" + filename + "_comp." + extension
	.SaveToFile(uniqueFilename(path))
	.Close()
ENDWITH

PROCEDURE progress()
	REPEAT
		DIM elapsedTime = GETTIME() - GETTIME(0, starttime)
		DIM ratio = item / count
		time = elapsedTime / ratio
		FUKIDASI("開始時刻<#TAB>" + starttime + "<#CR>" + _
					"経過時間<#TAB>" + text(elapsedTime/86400, "hh:nn:ss") + "<#CR>" + _
					"進捗率<#TAB><#TAB>" + ROUND(ratio * 100, -5) + "%<#CR>" + _
					"項目数<#TAB><#TAB>" + item + "/" + count + "<#CR>" + _
					"残り時間<#TAB>" + IIF(INT((time-elapsedTime)/86400) <> 0, INT((time-elapsedTime)/86400) + "日", "") + text((time-elapsedTime)/86400, "hh:nn:ss") + "<#CR>" + _
					"終了予定時刻<#TAB>" + IIF(item = "" OR starttime = "", "∞", dateAdd("s", time, starttime)), 0, 0)
		SLEEP(0.001)
	UNTIL bool
FEND

//////////////////////////////////////////////////
// 【引数】
//   bin : 2進数 
//   signFlg : 符号付きならばTrue 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION binToDec(bin, signFlg = TRUE)
	DIM dec = 0
	DIM decimalFlg = IIF(POS(".", bin), TRUE, FALSE)
	IFB COPY(bin, 1, 1) = "1" AND signFlg THEN
		// 負数
		// ビット反転用の値
		// 最上位ビット
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		// 最下位ビット
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		// 整数部
		DIM dec2 = POWER(2, msb) - 1
		// 小数部
		FOR i = -1 TO lsb STEP -1
			dec2 = dec2 + POWER(2, i)
		NEXT
		DIM a = binToDec(bin, FALSE)
		DIM b = dec2
		dec = -1 * (bitXor(a, b) + POWER(2, lsb))
	ELSE
		// 正数(先頭ビットが0、もしくは、signFlgがFalse)
		IFB decimalFlg THEN
			// 小数部分
			DIM integer = COPY(bin, 1, POS(".", bin) - 1)
			DIM decimal = COPY(bin, POS(".", bin) + 1)
			FOR i = 1 TO LENGTH(decimal)
				dec = dec + COPY(decimal, i, 1) * POWER(2, -1 * i)
			NEXT
		ELSE
			integer = bin
		ENDIF
		// 整数部分
		FOR i = 1 TO LENGTH(integer)
			dec = dec + COPY(integer, i, 1) * POWER(2, LENGTH(integer) - i)
		NEXT
	ENDIF
	RESULT = dec
FEND

//////////////////////////////////////////////////
// 【引数】
//   arg1 : 数値1(10進数) 
//   arg2 : 数値2(10進数) 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION bitXor(arg1, arg2)
	DIM args[1] = arg1, arg2
	DIM bins[1]
	DIM decimals[1]
	DIM integers[1]
	DIM keta[1]
	IFB ABS(arg1) <> arg1 OR ABS(arg2) <> arg2 THEN
		RESULT = ERR_VALUE
		EXIT
	ENDIF
	FOR i = 0 TO 1
		bins[i] = decToBin(args[i])
		decimals[i] = 0
		IFB POS(".", bins[i]) <> 0 THEN
			integers[i] = COPY(bins[i], 1, POS(".", bins[i]) - 1)
			decimals[i] = COPY(bins[i], POS(".", bins[i]) + 1)
		ELSE
			integers[i] = bins[i]
		ENDIF
	NEXT
	keta[0] = IIF(LENGTH(integers[0]) > LENGTH(integers[1]), LENGTH(integers[0]), LENGTH(integers[1]))
	integers[0] = strPad(integers[0], keta[0], "0", LEFT)
	integers[1] = strPad(integers[1], keta[0], "0", LEFT)
	keta[1] = IIF(LENGTH(decimals[0]) > LENGTH(decimals[1]), LENGTH(decimals[0]), LENGTH(decimals[1]))
	decimals[0] = strPad(decimals[0], keta[1], "0", RIGHT)
	decimals[1] = strPad(decimals[1], keta[1], "0", RIGHT)
	DIM bin = ""
	FOR i = 1 TO keta[0]
		bin = bin + (VAL(COPY(integers[0], i, 1)) XOR VAL(COPY(integers[1], i, 1)))
	NEXT
	bin = bin + "."
	FOR i = 1 TO keta[1]
		bin = bin + (VAL(COPY(decimals[0], i, 1)) XOR VAL(COPY(decimals[1], i, 1)))
	NEXT
	RESULT = binToDec(bin)
FEND

//////////////////////////////////////////////////
// 【引数】
//   color : Color値 
//   flg : #RRGGBB形式で返す場合Trueを指定 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION colorToRGB(color, flg = FALSE)
	DIM array[2]
	array[0] = color AND $FF
	array[1] = (color AND $FF00) / $100
	array[2] = (color AND $FF0000) / $10000
	IFB flg THEN
		DIM rgb = ""
		FOR item IN array
			DIM hex = decToHex(item)
			rgb = rgb + COPY(hex, LENGTH(hex)-1)
		NEXT
		RESULT = "#" + rgb
	ELSE
		RESULT = SLICE(array)
	ENDIF
FEND

//////////////////////////////////////////////////
// 【引数】
//   color : Color値 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION complementaryColor(r, g = EMPTY, b = EMPTY)
	IFB COPY(r, 1, 1) = "#" AND g = EMPTY AND b = EMPTY THEN
		array = colorToRGB(RGBToColor(r))
		num = CALCARRAY(array, CALC_MAX) + CALCARRAY(array, CALC_MIN)
		DIM rgb = ""
		FOR item IN array
			DIM hex = decToHex(num - item)
			rgb = rgb + COPY(hex, LENGTH(hex) - 1)
		NEXT
		RESULT = "#" + rgb
	ELSEIF VAL(r) <> ERR_VALUE AND g = EMPTY AND b = EMPTY THEN
		array = colorToRGB(r)
		num = CALCARRAY(array, CALC_MAX) + CALCARRAY(array, CALC_MIN)
		FOR i = 0 TO UBound(array)
			array[i] = num - array[i]
		NEXT
		RESULT = RGBToColor(array[0], array[1], array[2])
	ELSEIF VAL(r) <> ERR_VALUE AND VAL(g) <> ERR_VALUE AND VAL(b) <> ERR_VALUE THEN
		DIM array[2]
		array[0] = r
		array[1] = g
		array[2] = b
		num = CALCARRAY(array, CALC_MAX) + CALCARRAY(array, CALC_MIN)
		FOR i = 0 TO UBound(array)
			array[i] = num - array[i]
		NEXT
		RESULT = SLICE(array)
	ENDIF
FEND

//////////////////////////////////////////////////
// 【引数】
//   interval : 加算する時間間隔を表す文字列式(yyyy:年、m:月、d:日、ww:週、h:時、n:分、s:秒) 
//   num : dateに加算する値。未来は正、過去は負で指定 
//   date : 時間間隔を加算する日付 
// 【戻り値】
//   
//////////////////////////////////////////////////
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 
// 【戻り値】
//   
//////////////////////////////////////////////////
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

//////////////////////////////////////////////////
// 【引数】
//   dec : 10進数 
//   signFlg : 符号付きならばTrue 
//   digits : 桁数 
//   recursive : 再帰処理の深さ。処理する際に必要なだけで指定する必要はありません。 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION decToBin(dec, signFlg = FALSE, digits = FALSE, recursive = 1)
	DIM bin = ""
	DIM decimalFlg = IIF(POS(".", dec) <> 0, TRUE, FALSE)
	DIM negativeFlg = IIF(dec < 0, TRUE, FALSE)
	dec = ABS(dec)
	DIM integer = IIF(decimalFlg, COPY(dec, 1, POS(".", dec) - 1), dec)
	DIM offset = POWER(10, LENGTH(dec) - POS(".", dec))
	DIM decimal = IIF(decimalFlg, COPY(dec, POS(".", dec) + 1) / offset, 0)
	REPEAT
		bin = (integer MOD 2) + bin
		integer = INT(integer / 2)
	UNTIL integer = 0
	IFB decimalFlg THEN
		bin = bin + "."
		DIM loop = 0
		REPEAT
			loop = loop + 1
			decimal = decimal * 2
			bin = bin + IIF(decimal >= 1, "1", "0")
			IF decimal > 1 THEN decimal = decimal - 1
		UNTIL decimal = 1 OR loop >= 16
		WHILE loop MOD 4 <> 0
			loop = loop + 1
			bin = bin + "0"
		WEND
	ENDIF
	WHILE LENGTH(REPLACE(bin, ".", "")) MOD 8 <> 0
		bin = "0" + bin
	WEND
	IFB negativeFlg THEN
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg , POS(".", bin) - LENGTH(bin), 0)
		DIM a = binToDec(bin)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
  		dec = bitXor(a, b) + POWER(2, lsb)
 		bin = decToBin(dec, signFlg, digits, recursive + 1)
	ENDIF
	IFB recursive = 1 THEN
		DIM bit = COPY(bin, 1, 1)
 		DIM len = LENGTH(REPLACE(bin, ".", ""))
		IF negativeFlg AND (bit = "0" OR len MOD 2 <> 0) THEN bin = strRepeat("1", IIF(len MOD 2 <> 0, 4, 8)) + bin
		IF !negativeFlg AND (bit = "1" OR len MOD 2 <> 0) THEN bin = strRepeat("0", IIF(len MOD 2 <> 0, 4, 8)) + bin
	ENDIF
	RESULT = bin
FEND

//////////////////////////////////////////////////
// 【引数】
//   dec : 10進数 
//   signFlg : 符号付きならばTrue 
//   recursive : 再帰処理の深さ 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION decToHex(dec, signFlg = FALSE, recursive = 1)
	DIM hex = ""
	DIM array[] = "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"
	DIM decimalFlg = IIF(POS(".", dec) <> 0, TRUE, FALSE)
	DIM negativeFlg = IIF(dec < 0, TRUE, FALSE)
	dec = ABS(dec)
	DIM integer = IIF(decimalFlg, COPY(dec, 1, POS(".", dec) - 1), dec)
	DIM offset = POWER(10, LENGTH(dec) - POS(".", dec))
	DIM decimal = IIF(decimalFlg, COPY(dec, POS(".", dec) + 1) / offset, 0)
	REPEAT
		hex = array[integer MOD 16] + hex
		integer = INT(integer / 16)
	UNTIL integer = 0
	IFB decimalFlg THEN
		hex = hex + "."
		DIM loop = 0
		REPEAT
			loop = loop + 1
			decimal = decimal * 16
			hex = hex + array[decimal]
			offset = POWER(10, LENGTH(decimal) - POS(".", decimal))
			decimal = (decimal * offset - INT(decimal) * offset) / offset
		UNTIL decimal = 0 OR loop >= 4
	ENDIF
	IFB negativeFlg THEN
		DIM bin = hexToBin(hex)
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		DIM a = hexToDec(hex)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
		dec = bitXor(a, b) + POWER(2, lsb)
		hex = decToHex(dec, signFlg, recursive + 1)
	ENDIF
	IFB recursive = 1 THEN
		DIM bit = COPY(hexToBin(COPY(hex, 1, 1)), 1, 1)
		DIM len = LENGTH(REPLACE(hex, ".", ""))
		IF negativeFlg AND (bit = "0" OR len MOD 2 <> 0) THEN hex = strRepeat("F", IIF(len MOD 2 <> 0, 1, 2)) + hex
		IF !negativeFlg AND (bit = "1" OR len MOD 2 <> 0) THEN hex = strRepeat("0", IIF(len MOD 2 <> 0, 1, 2)) + hex
	ENDIF
	RESULT = hex
FEND

//////////////////////////////////////////////////
// 【引数】
//   str : 相互変換させるバイナリデータ 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION Endian(str)
	DIM len = LENGTH(str)
	
	IFB !isEven(len) THEN
		str = "0" + str
		len = len + 1
	ENDIF
	
	DIM res = ""
	FOR n = 1 TO len STEP 2
		res = COPY(str, n, 2)  + res
	NEXT
	
	RESULT = res
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

//////////////////////////////////////////////////
// 【引数】
//   path : ビットマップ画像のパス 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION getBitmap(path)
	DIM arr[3]		// 戻り値
	
	DIM Stream = CREATEOLEOBJ("ADODB.Stream")
	Stream.Open()
	Stream.Type = 1		// adTypeBinary
	Stream.LoadFromFile(path)
	DIM tmp = Stream.Read(30)
	Stream.Close()

	// BM(0~1)
	DIM fmt = ""
	FOR n = 0 TO 1
		fmt = fmt + decToHex(tmp[n])
	NEXT

	IFB fmt <> "424D" THEN
		RESULT = ERR_VALUE
		EXIT
	ENDIF
	
	// サイズ(2~5)
	DIM size = ""
	FOR n = 2 TO 5
		hex = decToHex(tmp[n])
		size = size + IIF(LENGTH(hex) = 1, "0", "") + hex
	NEXT
	arr[0] = hexToDec(Endian(size))
	
	// 幅(18~21)
	DIM width = ""
	FOR n = 18 TO 21
		hex = decToHex(tmp[n])
		width = width +IIF(LENGTH(hex) = 1, "0", "") + hex
	NEXT
	arr[1] = hexToDec(Endian(width))
	
	// 高さ(22~25)
	DIM height = ""
	FOR n = 22 TO 25
		hex = decToHex(tmp[n])
		height = height + IIF(LENGTH(hex) = 1, "0", "") + hex
	NEXT
	arr[2] = hexToDec(Endian(height))
	
	// ビットの深さ(28~29)
	DIM bit = ""
	FOR n = 28 TO 29
		hex = decToHex(tmp[n])
		bit = bit + IIF(LENGTH(hex) = 1, "0", "") + hex
	NEXT
	arr[3] = hexToDec(Endian(bit))

	RESULT = SLICE(arr)
FEND

//////////////////////////////////////////////////
// 【引数】
//   date : 日付(”YYYYMMDD” or “YYYY/MM/DD” or “YYYY-MM-DD” or “YYYYMMDDHHNNSS” or “YYYY/MM/DD HH:NN:SS”) 
//   m : 第一引数の指定日からプラスマイナス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”) 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION getWeekday(date)
	GETTIME(0, date)
	RESULT = G_TIME_WW
FEND

//////////////////////////////////////////////////
// 【引数】
//   数値 : GETTIMEで取得した曜日の番号(G_TIME_WW=0:日曜….6:土曜) 
//   フォーマット : 以下のアルファベットは数値で指定した対応する曜日に置き換えられます。(aaa : 日〜土、aaaa : 日曜日〜土曜日、ddd : Sun〜Sat、dddd : Sunday〜Saturday) 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION getWeekdayName(num, format = "aaa")
	DIM re = CREATEOLEOBJ("VBScript.RegExp")
	DIM aaa[] = "日", "月", "火", "水", "木", "金", "土";
	DIM aaaa[] = "日曜日", "月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日";
	DIM ddd[] = "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat";
	DIM dddd[] = "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday";
	match = reExecute(format, "(a|d)+")
	type = match.Item(0).Value
	RESULT = reReplace(format, EVAL(type + "[" + num + "]"), type)
FEND

//////////////////////////////////////////////////
// 【引数】
//   hex : 16進数 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION hexToBin(hex)
	HASHTBL hb
	hb["0"] = "0000";	hb["1"] = "0001";	hb["2"] = "0010";	hb["3"] = "0011";
	hb["4"] = "0100";	hb["5"] = "0101";	hb["6"] = "0110";	hb["7"] = "0111";
	hb["8"] = "1000";	hb["9"] = "1001";	hb["A"] = "1010";	hb["B"] = "1011";
	hb["C"] = "1100";	hb["D"] = "1101";	hb["E"] = "1110";	hb["F"] = "1111";
	DIM bin = ""
	IFB POS(".", hex) <> 0 THEN
		FOR i = 1 TO LENGTH(hex)
			DIM str = COPY(hex, i, 1)
			IF str = "." THEN bin = bin + "."
			bin = bin + hb[str]
		NEXT
	ELSE
		FOR i = 1 TO LENGTH(hex)
			bin = bin + hb[COPY(hex, i, 1)]
		NEXT
	ENDIF
	RESULT = bin
FEND

//////////////////////////////////////////////////
// 【引数】
//   hex : 16進数 
//   signFlg : 符号付きならばTrue 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION hexToDec(hex, signFlg = TRUE)
	hex = STRCONV(hex, SC_UPPERCASE)
	DIM dec = 0
	DIM decimalFlg = IIF(POS(".", hex) <> 0, TRUE, FALSE)
	hex = IIF(LENGTH(REPLACE(hex,".", "" )) MOD 2 <> 0, "0", "") + hex
	DIM negativeFlg = IIF(COPY(hexToBin(hex), 1, 1) = "1", TRUE, FALSE)
	DIM sign = 1
	IF negativeFlg AND signFlg THEN sign = -1
	IFB negativeFlg AND signFlg THEN
		DIM bin = hexToBin(hex)
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		DIM a = hexToDec(hex, FALSE)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
		DIM dec2 = bitXor(a, b) + POWER(2, lsb)
		hex = decToHex(dec2)
	ENDIF
	integer = IIF(decimalFlg, COPY(hex, 1, POS(".", hex) - 1), hex)
	decimal = IIF(decimalFlg, COPY(hex, POS(".", hex) + 1), "0")
	FOR i = 1 TO LENGTH(integer)
		s = COPY(hex, i, 1)
		num = IIF(CHKNUM(s), s, ASC(s) - (ASC("A") - 10))
		dec = dec + num * POWER(16, LENGTH(integer) - i)
	NEXT
	FOR i = 1 TO LENGTH(decimal)
		s = COPY(decimal, i, 1)
		num = IIF(CHKNUM(s), s, ASC(s) - (ASC("A") - 10))
		dec = dec + num * POWER(16, -1 * i)
	NEXT
	RESULT = sign * dec
FEND

//////////////////////////////////////////////////
// 【引数】
//   serial : 時間を表すシリアル値を指定 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION Hour(serial)
	RESULT = INT(serial * 24) MOD 24
FEND

//////////////////////////////////////////////////
// 【引数】
//   expr : 評価する式 
//   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のいずれかの形式。 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION isDate(date)
	TRY
		GETTIME(0, date)
		RESULT = TRUE
	EXCEPT
		RESULT = FALSE
	ENDTRY
FEND

//////////////////////////////////////////////////
// 【引数】
//   数値 : 整数 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION isEven(n)
	IFB VAL(n) = n THEN
		RESULT = IIF(INT(n) MOD 2 = 0, TRUE, FALSE)
	ELSE
		RESULT = ERR_VALUE
	ENDIF
FEND

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

//////////////////////////////////////////////////
// 【引数】
//   str1 : 置換される文字列 
//   str2 : 置換後の文字列 
//   Pattern : 置換する文字列のパターン 
//   IgnoreCase : 大文字・小文字を区別しない場合はTrue、区別する場合はFalse 
//   Global : 文字列全体を検索する場合はTrue、しない場合はFalse 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION reReplace(str1, str2, Pattern, IgnoreCase = TRUE, Global = TRUE)
	DIM re = CREATEOLEOBJ("VBScript.RegExp")
	re.Pattern = Pattern
	re.IgnoreCase = IgnoreCase
	re.Global = Global
	RESULT = re.Replace(str1, str2)
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

//////////////////////////////////////////////////
// 【引数】
//   r : 赤成分もしくは#RRGGBB形式の文字列 
//   g : 緑成分。rで#RRGGBB形式の文字列を指定した場合は省略。 
//   b : 青成分。rで#RRGGBB形式の文字列を指定した場合は省略。 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION RGBToColor(r, g = EMPTY, b = EMPTY)
	IFB COPY(r, 1, 1) = "#" THEN
		DIM color = 0
		FOR i = 1 TO 3
			color = color + VAL(hexToDec(COPY(r, i * 2, 2), FALSE)) * POWER(256, i - 1)
		NEXT
		RESULT =  color
	ELSE
		RESULT = r + g * 256 + b * 65536
	ENDIF
FEND

//////////////////////////////////////////////////
// 【引数】
//   num : 符号を求める数値 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION sign(num)
	SELECT TRUE
		CASE !CHKNUM(num)
			RESULT = ERR_VALUE
		CASE num > 0
			RESULT = 1
		CASE num = 0
			RESULT = 0
		CASE num < 0
			RESULT = -1
	SELEND
FEND

//////////////////////////////////////////////////
// 【引数】
//   input : 入力文字列 
//   length : 埋めたあとの長さ 
//   str : 埋める文字 
//   type : 埋める方向 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION strPad(input, length, str = " ", type = RIGHT)
	DIM s = ""
	SELECT type
		CASE LEFT
			FOR i = 1 TO CEIL((length - LENGTH(input)) / LENGTH(str))
				s = s + str
			NEXT
			input = COPY(s, 1, length - LENGTH(input)) + input
		CASE RIGHT
			FOR i = 1 TO CEIL((length - LENGTH(input)) / LENGTH(str))
				s = s + str
			NEXT
			input = input + COPY(s, 1, length - LENGTH(input))
	SELEND
	RESULT = input
FEND

//////////////////////////////////////////////////
// 【引数】
//   inputs : 繰り返す文字列 
//   multiplier : inputsを繰り返す回数 
// 【戻り値】
//   
//////////////////////////////////////////////////
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"
	
	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)
			RESULT = getWeekdayName(G_TIME_WW, Matches.Item(0).SubMatches(0))
		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

//////////////////////////////////////////////////
// 【引数】
//   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
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のときに返す値 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION IIF(expr, truepart, falsepart)
	IFB EVAL(expr) THEN
		RESULT = truepart
	ELSE
		RESULT = falsepart
	ENDIF
FEND
使用関数
解説

コロナのグラフ

UWSC
CONST xlDown = -4121
CONST xlColumnClustered = 51
CONST xlCategory = 1
CONST xlValue = 2
CONST xlLine = 4
CONST msoThemeColorText2 = 15
CONST msoThemeColorBackground1 = 14

DIM Excel = CREATEOLEOBJ("Excel.Application")

WITH Excel
	.Visible = TRUE
	.Workbooks.Open("D:\Downloads\covid19_data.csv")

	DIM ws = .ActiveSheet
	DIM ws2 = .Worksheets.Add(EMPTYPARAM, .Worksheets(.Worksheets.Count))
	ws2.Name = "7日間平均"
	ws.Range("1:1").Copy(ws2.Range("1:1"))
	ws.Range("A:D").Copy(ws2.Range("A:D"))
	ws.Range("W:AB").Copy(ws2.Range("W:AB"))
	ws2.Range("E8").Value = "=INT(SUM(covid19_data!E2:E8)/7)"
	ws2.Range("E8").AutoFill(ws2.Range("E8:V8"))
	DIM lastRow = ws.Range("B2").End(xlDown).Row	
	ws2.Range("E8:V8").AutoFill(ws2.Range("E8:V" + lastRow))

	DIM Chart

	// 検査数
	Chart = .Charts.Add
	.ActiveSheet.Move(EMPTYPARAM, .Sheets(.Sheets.Count))
	.ActiveSheet.Name = "検査数"

	WITH Chart
		.ChartType = xlColumnClustered
		.SetSourceData(ws.Range("covid19_data!$E:$E"))
	
		WITH .SeriesCollection(1)
			.Name = "日検査数"
			.XValues = "covid19_data!$Y2:$Y" + lastRow
			WITH .Format.Line
				.ForeColor.ObjectThemeColor = msoThemeColorText2
				.ForeColor.TintAndShade = 0
				.ForeColor.Brightness = 0.6000000238
				.Transparency = 0
			ENDWITH
		ENDWITH

		WITH .Axes(xlCategory)
			.MinimumScale = dateSerial(2020, 1, 1)		//43831
			.MajorUnit = 4
			.TickLabels.Font.Size = 14
		ENDWITH
	
		WITH .Axes(xlValue)
			.HasMajorGridLines = TRUE
			.HasMinorGridLines = TRUE
			.MinimumScale = 0
			.MajorUnit = 5000
			.MinorUnit = 1000
			.TickLabels.Font.Size = 14
		ENDWITH
	ENDWITH	

	// 陽性数
	Chart = .Charts.Add
	.ActiveSheet.Move(EMPTYPARAM, .Sheets(.Sheets.Count))
	.ActiveSheet.Name = "陽性者数"

	WITH Chart
		.ChartType = xlColumnClustered
		.SetSourceData(ws.Range("covid19_data!$G2:$G" + lastRow))
		.SeriesCollection.NewSeries
		.SeriesCollection(2).Values = "='7日間平均'!$G2:$G" + lastRow

		// 日付
		WITH .SeriesCollection(1)
			.Name = "日陽性数"
			.XValues = "covid19_data!$Y2:$Y" + lastRow
			WITH .Format.Line
				.ForeColor.ObjectThemeColor = msoThemeColorText2
				.ForeColor.TintAndShade = 0
				.ForeColor.Brightness = 0.6000000238
				.Transparency = 0
			ENDWITH
		ENDWITH
	
		// 7日間平均
		WITH .SeriesCollection(2)
			.Name = "7日間平均"
			.ChartType = xlLine
			.Format.Line.ForeColor.RGB = RGBToColor(0, 112, 192)
		ENDWITH
	
		// x軸
		WITH .Axes(xlCategory)
			.MinimumScale = dateSerial(2020, 1, 1)		//43831
			.MajorUnit = 4
			.TickLabels.Font.Size = 14
		ENDWITH
	
		// y軸
		WITH .Axes(xlValue)
			.HasMajorGridLines = TRUE
			.HasMinorGridLines = TRUE
			.MinimumScale = 0
			.MajorUnit = 5000
			.MinorUnit = 1000
			.TickLabels.Font.Size = 14
		ENDWITH
	ENDWITH

	// 死亡数
	Chart = .Charts.Add
	.ActiveSheet.Move(EMPTYPARAM, .Sheets(.Sheets.Count))
	.ActiveSheet.Name = "死亡数"
	
	WITH Chart
		.ChartType = xlColumnClustered
		.SetSourceData(ws.Range("covid19_data!$O2:$O" + lastRow))
		.SeriesCollection.NewSeries
		.SeriesCollection(2).Values = "='7日間平均'!$O2:$O" + lastRow

		WITH .SeriesCollection(1)
			.Name = "日死亡数"
			.XValues = "covid19_data!$Y2:$Y" + lastRow
			WITH .Format.Line
				.ForeColor.ObjectThemeColor = msoThemeColorBackground1
				.ForeColor.TintAndShade = 0
				.ForeColor.Brightness = -0.150000006
				.Transparency = 0
			ENDWITH
		ENDWITH

		WITH .SeriesCollection(2)
			.Name = "7日間平均"
			.ChartType = xlLine
			WITH .Format.Line
				.Weight = 2.5
				.Transparency = 0
				.ForeColor.ObjectThemeColor = msoThemeColorBackground1
				.ForeColor.TintAndShade = 0
				.ForeColor.Brightness = -0.5
			ENDWITH
		ENDWITH	

		WITH .Axes(xlCategory)
			.MinimumScale = dateSerial(2020, 1, 1)		//43831
			.MajorUnit = 4
			.TickLabels.Font.Size = 14
		ENDWITH

		WITH .Axes(xlValue)
			.HasMajorGridLines = TRUE		// 軸あり
			.HasMinorGridLines = TRUE		// 目盛線あり
			.MinimumScale = 0				// 最小値
			.TickLabels.Font.Size = 14		// フォントサイズ
		ENDWITH
	ENDWITH

	// 死亡累計
	Chart = .Charts.Add
	.ActiveSheet.Move(EMPTYPARAM, .Sheets(.Sheets.Count))
	.ActiveSheet.Name = "死亡累計"
	
	WITH Chart
		.ChartType = xlColumnClustered
		.SetSourceData(ws.Range("covid19_data!$P2:$P" + lastRow))
				
		WITH .SeriesCollection(1)
			.Name = "死亡累計"
			.XValues = "covid19_data!$Y2:$Y" + lastRow
			WITH .Format.Line
				.ForeColor.ObjectThemeColor = msoThemeColorBackground1
				.ForeColor.TintAndShade = 0
				.ForeColor.Brightness = -0.150000006
				.Transparency = 0
			ENDWITH
		ENDWITH
		
		WITH .Axes(xlCategory)
			.MinimumScale = dateSerial(2020, 1, 1)		//43831
			.MajorUnit = 4
			.TickLabels.Font.Size = 14
		ENDWITH

		WITH .Axes(xlValue)
			.HasMajorGridLines = TRUE		// 軸あり
			.MinimumScale = 0				// 最小値
			.TickLabels.Font.Size = 14		// フォントサイズ
		ENDWITH

		.ChartTitle.Delete

	ENDWITH

ENDWITH

//////////////////////////////////////////////////
// 【引数】
//   bin : 2進数 
//   signFlg : 符号付きならばTrue 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION binToDec(bin, signFlg = TRUE)
	DIM dec = 0
	DIM decimalFlg = IIF(POS(".", bin), TRUE, FALSE)
	IFB COPY(bin, 1, 1) = "1" AND signFlg THEN
		// 負数
		// ビット反転用の値
		// 最上位ビット
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		// 最下位ビット
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		// 整数部
		DIM dec2 = POWER(2, msb) - 1
		// 小数部
		FOR i = -1 TO lsb STEP -1
			dec2 = dec2 + POWER(2, i)
		NEXT
		DIM a = binToDec(bin, FALSE)
		DIM b = dec2
		dec = -1 * (bitXor(a, b) + POWER(2, lsb))
	ELSE
		// 正数(先頭ビットが0、もしくは、signFlgがFalse)
		IFB decimalFlg THEN
			// 小数部分
			DIM integer = COPY(bin, 1, POS(".", bin) - 1)
			DIM decimal = COPY(bin, POS(".", bin) + 1)
			FOR i = 1 TO LENGTH(decimal)
				dec = dec + COPY(decimal, i, 1) * POWER(2, -1 * i)
			NEXT
		ELSE
			integer = bin
		ENDIF
		// 整数部分
		FOR i = 1 TO LENGTH(integer)
			dec = dec + COPY(integer, i, 1) * POWER(2, LENGTH(integer) - i)
		NEXT
	ENDIF
	RESULT = dec
FEND

//////////////////////////////////////////////////
// 【引数】
//   arg1 : 数値1(10進数) 
//   arg2 : 数値2(10進数) 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION bitXor(arg1, arg2)
	DIM args[1] = arg1, arg2
	DIM bins[1]
	DIM decimals[1]
	DIM integers[1]
	DIM keta[1]
	IFB ABS(arg1) <> arg1 OR ABS(arg2) <> arg2 THEN
		RESULT = ERR_VALUE
		EXIT
	ENDIF
	FOR i = 0 TO 1
		bins[i] = decToBin(args[i])
		decimals[i] = 0
		IFB POS(".", bins[i]) <> 0 THEN
			integers[i] = COPY(bins[i], 1, POS(".", bins[i]) - 1)
			decimals[i] = COPY(bins[i], POS(".", bins[i]) + 1)
		ELSE
			integers[i] = bins[i]
		ENDIF
	NEXT
	keta[0] = IIF(LENGTH(integers[0]) > LENGTH(integers[1]), LENGTH(integers[0]), LENGTH(integers[1]))
	integers[0] = strPad(integers[0], keta[0], "0", LEFT)
	integers[1] = strPad(integers[1], keta[0], "0", LEFT)
	keta[1] = IIF(LENGTH(decimals[0]) > LENGTH(decimals[1]), LENGTH(decimals[0]), LENGTH(decimals[1]))
	decimals[0] = strPad(decimals[0], keta[1], "0", RIGHT)
	decimals[1] = strPad(decimals[1], keta[1], "0", RIGHT)
	DIM bin = ""
	FOR i = 1 TO keta[0]
		bin = bin + (VAL(COPY(integers[0], i, 1)) XOR VAL(COPY(integers[1], i, 1)))
	NEXT
	bin = bin + "."
	FOR i = 1 TO keta[1]
		bin = bin + (VAL(COPY(decimals[0], i, 1)) XOR VAL(COPY(decimals[1], i, 1)))
	NEXT
	RESULT = binToDec(bin)
FEND

//////////////////////////////////////////////////
// 【引数】
//   year : 年 
//   month : 月 
//   day : 日 
// 【戻り値】
//   シリアル値 
//////////////////////////////////////////////////
FUNCTION dateSerial(year, month, day)
	month = REPLACE(FORMAT(month, 2), " ", "0")
	day = REPLACE(FORMAT(day, 2), " ", "0")
	d = GETTIME(0, year + "/" + month + "/" + day)
	RESULT = uwscToSerial(d)
FEND

//////////////////////////////////////////////////
// 【引数】
//   dec : 10進数 
//   signFlg : 符号付きならばTrue 
//   digits : 桁数 
//   recursive : 再帰処理の深さ。処理する際に必要なだけで指定する必要はありません。 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION decToBin(dec, signFlg = FALSE, digits = FALSE, recursive = 1)
	DIM bin = ""
	DIM decimalFlg = IIF(POS(".", dec) <> 0, TRUE, FALSE)
	DIM negativeFlg = IIF(dec < 0, TRUE, FALSE)
	dec = ABS(dec)
	DIM integer = IIF(decimalFlg, COPY(dec, 1, POS(".", dec) - 1), dec)
	DIM offset = POWER(10, LENGTH(dec) - POS(".", dec))
	DIM decimal = IIF(decimalFlg, COPY(dec, POS(".", dec) + 1) / offset, 0)
	REPEAT
		bin = (integer MOD 2) + bin
		integer = INT(integer / 2)
	UNTIL integer = 0
	IFB decimalFlg THEN
		bin = bin + "."
		DIM loop = 0
		REPEAT
			loop = loop + 1
			decimal = decimal * 2
			bin = bin + IIF(decimal >= 1, "1", "0")
			IF decimal > 1 THEN decimal = decimal - 1
		UNTIL decimal = 1 OR loop >= 16
		WHILE loop MOD 4 <> 0
			loop = loop + 1
			bin = bin + "0"
		WEND
	ENDIF
	WHILE LENGTH(REPLACE(bin, ".", "")) MOD 8 <> 0
		bin = "0" + bin
	WEND
	IFB negativeFlg THEN
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg , POS(".", bin) - LENGTH(bin), 0)
		DIM a = binToDec(bin)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
  		dec = bitXor(a, b) + POWER(2, lsb)
 		bin = decToBin(dec, signFlg, digits, recursive + 1)
	ENDIF
	IFB recursive = 1 THEN
		DIM bit = COPY(bin, 1, 1)
 		DIM len = LENGTH(REPLACE(bin, ".", ""))
		IF negativeFlg AND (bit = "0" OR len MOD 2 <> 0) THEN bin = strRepeat("1", IIF(len MOD 2 <> 0, 4, 8)) + bin
		IF !negativeFlg AND (bit = "1" OR len MOD 2 <> 0) THEN bin = strRepeat("0", IIF(len MOD 2 <> 0, 4, 8)) + bin
	ENDIF
	RESULT = bin
FEND

//////////////////////////////////////////////////
// 【引数】
//   dec : 10進数 
//   signFlg : 符号付きならばTrue 
//   recursive : 再帰処理の深さ 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION decToHex(dec, signFlg = FALSE, recursive = 1)
	DIM hex = ""
	DIM array[] = "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"
	DIM decimalFlg = IIF(POS(".", dec) <> 0, TRUE, FALSE)
	DIM negativeFlg = IIF(dec < 0, TRUE, FALSE)
	dec = ABS(dec)
	DIM integer = IIF(decimalFlg, COPY(dec, 1, POS(".", dec) - 1), dec)
	DIM offset = POWER(10, LENGTH(dec) - POS(".", dec))
	DIM decimal = IIF(decimalFlg, COPY(dec, POS(".", dec) + 1) / offset, 0)
	REPEAT
		hex = array[integer MOD 16] + hex
		integer = INT(integer / 16)
	UNTIL integer = 0
	IFB decimalFlg THEN
		hex = hex + "."
		DIM loop = 0
		REPEAT
			loop = loop + 1
			decimal = decimal * 16
			hex = hex + array[decimal]
			offset = POWER(10, LENGTH(decimal) - POS(".", decimal))
			decimal = (decimal * offset - INT(decimal) * offset) / offset
		UNTIL decimal = 0 OR loop >= 4
	ENDIF
	IFB negativeFlg THEN
		DIM bin = hexToBin(hex)
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		DIM a = hexToDec(hex)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
		dec = bitXor(a, b) + POWER(2, lsb)
		hex = decToHex(dec, signFlg, recursive + 1)
	ENDIF
	IFB recursive = 1 THEN
		DIM bit = COPY(hexToBin(COPY(hex, 1, 1)), 1, 1)
		DIM len = LENGTH(REPLACE(hex, ".", ""))
		IF negativeFlg AND (bit = "0" OR len MOD 2 <> 0) THEN hex = strRepeat("F", IIF(len MOD 2 <> 0, 1, 2)) + hex
		IF !negativeFlg AND (bit = "1" OR len MOD 2 <> 0) THEN hex = strRepeat("0", IIF(len MOD 2 <> 0, 1, 2)) + hex
	ENDIF
	RESULT = hex
FEND

//////////////////////////////////////////////////
// 【引数】
//   hex : 16進数 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION hexToBin(hex)
	HASHTBL hb
	hb["0"] = "0000";	hb["1"] = "0001";	hb["2"] = "0010";	hb["3"] = "0011";
	hb["4"] = "0100";	hb["5"] = "0101";	hb["6"] = "0110";	hb["7"] = "0111";
	hb["8"] = "1000";	hb["9"] = "1001";	hb["A"] = "1010";	hb["B"] = "1011";
	hb["C"] = "1100";	hb["D"] = "1101";	hb["E"] = "1110";	hb["F"] = "1111";
	DIM bin = ""
	IFB POS(".", hex) <> 0 THEN
		FOR i = 1 TO LENGTH(hex)
			DIM str = COPY(hex, i, 1)
			IF str = "." THEN bin = bin + "."
			bin = bin + hb[str]
		NEXT
	ELSE
		FOR i = 1 TO LENGTH(hex)
			bin = bin + hb[COPY(hex, i, 1)]
		NEXT
	ENDIF
	RESULT = bin
FEND

//////////////////////////////////////////////////
// 【引数】
//   hex : 16進数 
//   signFlg : 符号付きならばTrue 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION hexToDec(hex, signFlg = TRUE)
	hex = STRCONV(hex, SC_UPPERCASE)
	DIM dec = 0
	DIM decimalFlg = IIF(POS(".", hex) <> 0, TRUE, FALSE)
	hex = IIF(LENGTH(REPLACE(hex,".", "" )) MOD 2 <> 0, "0", "") + hex
	DIM negativeFlg = IIF(COPY(hexToBin(hex), 1, 1) = "1", TRUE, FALSE)
	DIM sign = 1
	IF negativeFlg AND signFlg THEN sign = -1
	IFB negativeFlg AND signFlg THEN
		DIM bin = hexToBin(hex)
		DIM msb = IIF(decimalFlg, POS(".", bin) - 1, LENGTH(bin))
		DIM lsb = IIF(decimalFlg, POS(".", bin) - LENGTH(bin), 0)
		DIM a = hexToDec(hex, FALSE)
		DIM b = POWER(2, msb) - 1
		FOR i = -1 TO lsb STEP -1
			b = b + POWER(2, i)
		NEXT
		DIM dec2 = bitXor(a, b) + POWER(2, lsb)
		hex = decToHex(dec2)
	ENDIF
	integer = IIF(decimalFlg, COPY(hex, 1, POS(".", hex) - 1), hex)
	decimal = IIF(decimalFlg, COPY(hex, POS(".", hex) + 1), "0")
	FOR i = 1 TO LENGTH(integer)
		s = COPY(hex, i, 1)
		num = IIF(CHKNUM(s), s, ASC(s) - (ASC("A") - 10))
		dec = dec + num * POWER(16, LENGTH(integer) - i)
	NEXT
	FOR i = 1 TO LENGTH(decimal)
		s = COPY(decimal, i, 1)
		num = IIF(CHKNUM(s), s, ASC(s) - (ASC("A") - 10))
		dec = dec + num * POWER(16, -1 * i)
	NEXT
	RESULT = sign * dec
FEND

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

//////////////////////////////////////////////////
// 【引数】
//   r : 赤成分もしくは#RRGGBB形式の文字列 
//   g : 緑成分。rで#RRGGBB形式の文字列を指定した場合は省略。 
//   b : 青成分。rで#RRGGBB形式の文字列を指定した場合は省略。 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION RGBToColor(r, g = EMPTY, b = EMPTY)
	IFB COPY(r, 1, 1) = "#" THEN
		DIM color = 0
		FOR i = 1 TO 3
			color = color + VAL(hexToDec(COPY(r, i * 2, 2), FALSE)) * POWER(256, i - 1)
		NEXT
		RESULT =  color
	ELSE
		RESULT = r + g * 256 + b * 65536
	ENDIF
FEND

//////////////////////////////////////////////////
// 【引数】
//   num : 符号を求める数値 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION sign(num)
	SELECT TRUE
		CASE !CHKNUM(num)
			RESULT = ERR_VALUE
		CASE num > 0
			RESULT = 1
		CASE num = 0
			RESULT = 0
		CASE num < 0
			RESULT = -1
	SELEND
FEND

//////////////////////////////////////////////////
// 【引数】
//   input : 入力文字列 
//   length : 埋めたあとの長さ 
//   str : 埋める文字 
//   type : 埋める方向 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION strPad(input, length, str = " ", type = RIGHT)
	DIM s = ""
	SELECT type
		CASE LEFT
			FOR i = 1 TO CEIL((length - LENGTH(input)) / LENGTH(str))
				s = s + str
			NEXT
			input = COPY(s, 1, length - LENGTH(input)) + input
		CASE RIGHT
			FOR i = 1 TO CEIL((length - LENGTH(input)) / LENGTH(str))
				s = s + str
			NEXT
			input = input + COPY(s, 1, length - LENGTH(input))
	SELEND
	RESULT = input
FEND

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

//////////////////////////////////////////////////
// 【引数】
//   uwscTime : UWSC時間 
// 【戻り値】
//   
//////////////////////////////////////////////////
FUNCTION uwscToSerial(uwscTime)
	uwscDate = uwscTime / 86400
	RESULT = 36526 + uwscDate
FEND
使用関数

ファイルの最終アクセス日時を取得(FSO)

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM File = FSO.GetFile("D:\Desktop\log.txt")

PRINT File.DateLastAccessed()
結果
プレーンテキスト
2022/12/13 14:34:00
使用関数
解説

ファイルの最終更新日時を取得(FSO)

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM File = FSO.GetFile("D:\Desktop\log.txt")

PRINT File.DateLastModified()
結果
プレーンテキスト
2022/06/22 12:49:59
使用関数
解説

8.3形式のパスを取得します

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM File = FSO.GetFile("C:\Program Files (x86)\UWSC\DbgScript\Info_Under_MouseCursor.uws")

PRINT File.ShortPath()
結果
プレーンテキスト
C:\PROGRA~2\UWSC\DBGSCR~1\INFO_U~1.UWS
使用関数
解説

8.3形式のファイル名を取得します

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM File = FSO.GetFile("C:\Program Files (x86)\UWSC\DbgScript\Info_Under_MouseCursor.uws")

PRINT File.ShortName()
結果
プレーンテキスト
INFO_U~1.UWS
使用関数
解説

指定したファイルがショートカットかを取得

UWSC
DIM Shell = CREATEOLEOBJ("Shell.Application")
DIM Folder = Shell.NameSpace("C:\ProgramData\Microsoft\Windows\Start Menu\Programs\UWSC Pro\")
DIM FolderItem = Folder.ParseName("UWSC Pro.lnk")

PRINT FolderItem.IsLink()
結果
プレーンテキスト
True
使用関数
解説

Twitterをアプリモードで起動(Chrome)

Twitterをアプリモードで起動します。

UWSC
DIM WebDriver = CREATEOLEOBJ("Selenium.WebDriver")

WITH WebDriver
	.AddArgument("--app=https://twitter.com")
	.Start("chrome")
	.Wait(10000)
ENDWITH
使用関数
解説

Twitterをアプリモード・ユーザーエージェントをスマホにして起動(Chrome)

起動オプションを追加して起動します。起動オプションを複数指定する場合は、AddArgumentを繰り返し実行します。

UWSC
DIM WebDriver = CREATEOLEOBJ("Selenium.WebDriver")

WITH WebDriver
	.AddArgument("--app=https://twitter.com")
	.AddArgument("--user-agent='Mozilla/5.0 (Linux; Android 13; SOG06) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Mobile Safari/537.36'")
	.AddArgument("--window-position=0,0")
	.AddArgument("--window-size=432,768")
	.Start("chrome")
	.Wait(10000)
ENDWITH
使用関数
解説

Internet ExplorerからMicrosoft Edgeにリダイレクトされるのを無効化

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")

DIM name = "HKEY_CURRENT_USER\SOFTWARE\Microsoft\Internet Explorer\Main\TabProcGrowth"
DIM value = 0
DIM type = "REG_DWORD"

WshShell.RegWrite(name, value, type)
結果
TabProcGrowth.png
使用関数

既定フォルダの最新のメールを取得

既定フォルダで受信した最新のメールを取得し、差出人名件名受信日時を出力します。

UWSC
CONST olFolderInbox = 6

DIM Outlook = CREATEOLEOBJ("Outlook.Application")
DIM NameSpace = Outlook.GetNameSpace("MAPI")
DIM Folder = NameSpace.GetDefaultFolder(olFolderInbox)

DIM Items = Folder.Items
Items.Sort("[ReceivedTime]", FALSE)
DIM MailItem = Items.GetLast

WITH MailItem
	PRINT "差出人名," + .SenderName
	PRINT "件名," + .Subject
	PRINT "受信日時," + .ReceivedTime
ENDWITH
使用関数
解説

特殊フォルダに含まれるファイルの数を取得

Tempフォルダにあるファイルの数を出力します。

UWSC
CONST TemporaryFolder = 2

DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM Folder = FSO.GetSpecialFolder(TemporaryFolder)
DIM Files = Folder.Files

PRINT Files.Count
結果
プレーンテキスト
191
使用関数
解説

Cドライブの空き容量を割合で取得

Cドライブの空き容量を小数点以下第2位までの百分率(単位:%)で出力します。

UWSC
DIM FSO = CREATEOLEOBJ("Scripting.FileSystemObject")
DIM Drive = FSO.GetDrive("C")

WITH Drive
	PRINT ROUND(.FreeSpace / .TotalSize * 100, -2) + "%"
ENDWITH
結果
プレーンテキスト
19.47%
使用関数
解説

デスクトップのアイコン名に影を付ける

パフォーマンス-視覚効果のパフォーマンスオプションの「デスクトップのアイコン名に影を付ける」をオンにします。

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")

DIM name = "HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\ListviewShadow"
DIM value = 1
DIM type = "REG_DWORD"

WshShell.RegWrite(name, value, type)
使用関数

デスクトップのアイコン名に影を付けない

パフォーマンス-視覚効果のパフォーマンスオプションの「デスクトップのアイコン名に影を付ける」をオフにします。

UWSC
DIM WshShell = CREATEOLEOBJ("WScript.Shell")

DIM name = "HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\ListviewShadow"
DIM value = 0
DIM type = "REG_DWORD"

WshShell.RegWrite(name, value, type)
使用関数