FGETエフゲット関数

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

テキストファイルの読み込みを行います。

構文
  1. return = FGET( ファイルID, 行, 列, ダブルコーテイション )
引数
ファイルID （Integer）必須
オープン時に返されたID
行 （Integer,#fget）必須
取出したい行（１から指定）
F_LINECOUNTを指定した場合はファイルの行数を返す
F_ALLTEXTを指定した場合はファイルの全内容を返す
列 （Integer = 0）省略可
取出したい列（１から指定：,カンマ区切りのCSVファイルに対応）
ダブルコーテイション （Boolean = False）省略可
FALSE
両端のダブルコーテイションは削除する （デフォルト）
TRUE
削除しない
2
CSV処理にて２つ連続ダブルコーティションを１つに (Excel同等処理)
戻り値
取出された値

使い方

サンプル

テキストファイル

サンプルテキストとしてUWSCインストール時のReadme.txtを使います。C:\Program Files (x86)\UWSC\Readme.txtのファイルを実行するUWSファイルと同一フォルダにコピーするか、以下のテキストをコピーしてReadme.txtという名前で保存しておいてください。

Readme.txt
　　　UWSC Pro　Ver 5.3.0.2 版                      2017/04/18

[機能]
　マウス・キーボード入力をスクリプト形式で記録、再生
　スクリプト言語によるアプリの操作（COMオブジェクト、DLL利用も可）

　※ 本ソフトはシェアウェアであり、UWSC(Free版)の上位版です。
　　 EXE化ツール(uws2exe)、Web記録ツール(RecIE)、デバッガ(UDebug)の付属
　　 HTMLを利用した画面関数、EXCEL用関数等が追加されています。
　　 試用期間は2週間です。

[動作]
　Windows　XP / Vista / 7 / 8.x / 10

[ユーザー登録]
　UWSC起動時、もしくは "About"画面より登録してください。
　ご購入方法はWebにて確認してください。
　http://www.uwsc.info/purchase.html

[アンインストール]
　コントロールパネル内の「プログラムと機能」より削除してください。
　XPの場合「プログラムの追加と削除」

[バージョンアップについて]
実行中のUWSCを終了させてから、インストールを実行してください。
(旧バージョンをアンインストールする必要はありません)

[ファイル]
　UWSC.exe         // 自動化ソフト
　RecUws.dll       // 記録時のフック用DLL
　RecIE.exe        // Webページ(IE)上の動作を記録しスクリプト化します
　UDebug.exe       // デバッグ用ツール
　XRef.exe         // クロスリファレンスツール
　Uws2Exe.exe      // スクリプトをEXE化します
　exeuws.exe       // EXE化に利用するひな型
　UWSC.chm         // UWSC ヘルプ
　RecIE.chm        // RecIE ヘルプ
　Uws2Exe.chm      // Uws2Exe ヘルプ
　UDebug.chm       // UDebug ヘルプ
　Readme.txt       // これ
　\sample\*.uws    // 幾つかのサンプルスクリプト
　\DbgScript\*.uws // UDebug上でのスクリプト

=======================================================================
[Ver5.3.0]
  設定画面の低レベル記録に「バックグランドで実行できる形で記録」を付けた
　Javaアプリの制御が出来なくなっていたのを修正
　低レベル記録/再生にて 画面スケーリングが100%以外だとマウス位置がズレるのを修正
　STOPフォームの位置が一時停止後に デフォルト位置に戻されるのを修正
　SLCTBOX関数にて 位置指定に変数、式が使われているとNGなのを修正
　MOUSEORG関数のMORG_DIRECT指定時 子オブジェクトがクリックされた時は KBD情報はそこに送るようにした
　MOUSEORG関数のMORG_DIRECT指定時 Shift/Ctrl/Altが押されたままになる事があるのを修正
　MOUSEORG関数のMORG_DIRECT指定時 マウスクリックの位置が正しくないパターンを修正
　リモートデスクトップにて MOUSEORGのMORG_DIRECT指定時 Shift/Ctrl/AltがNGなのを修正
　CREATEFORM関数にて FOM_FORMHIDE使用時に「閉じるボタン」が効かないのを修正

=======================================================================
[その他]
・ご使用条件
　本ソフトウェアを逆アセンブル、逆コンパイル、リバースエンジニアすることは禁止です。
　その他、法律等により禁止されている事項での使用はできません。
　本ソフトウェアを第三者への譲渡、貸与、販売行為はできません。

・商用利用、配布について
　　商用利用は自己責任において可です。
　　EXE化したものはライセンスフリーです。(ご自由に配布して頂いて構いません)

・免責事項
　本ソフトウェアをご使用になった上で生じた損害に対して、著作権者は一切の責任を負いません。
　著作権者は保守、デバック、バージョンアップ等の義務を負う事はありません。

・Web
　　http://www.uwsc.info/
　　UWSC の操作に関するバグ報告、質問等はFAQを確認のうえ掲示板にお願いいたします。
　　よくある質問と回答(FAQ)：http://www.uwsc.info/faq.html
　　掲示板：http://www3.rocketbbs.com/13/bbs.cgi?id=umiumi

・e-mail (使用時は半角に)
　　ｕｗｓｃ＠ｕｗｓｃ．ｉｎｆｏ
CSVファイル

CSVファイルのサンプルとして以下の商品一覧.csvを保存しておいてください。

商品一覧.csv
商品名,価格,在庫数,カテゴリ,メーカー
ノートPC,"120,000",15,電子機器,TechBrand
ワイヤレスマウス,"3,500",50,周辺機器,MousePro
モニター,"25,000",30,電子機器,VisionTech
USBメモリ,"1,200",100,ストレージ,DataFast
キーボード,"4,500",40,周辺機器,KeyMax
スマートフォン,"98,000",20,電子機器,MobileX
タブレット,"68,000",25,電子機器,TabWorld
イヤホン,"7,800",60,オーディオ,SoundWave
外付けHDD,"15,000",35,ストレージ,StorageKing
プリンター,"22,000",18,周辺機器,PrintMaster

以下は見やすくしたものです。

CSV
商品名,             価格,      在庫数,   カテゴリ,     メーカー
ノートPC,           120,000,   15,       電子機器,     TechBrand
ワイヤレスマウス,   3,500,     50,       周辺機器,     MousePro
モニター,           25,000,    30,       電子機器,     VisionTech
USBメモリ,          1,200,     100,      ストレージ,   DataFast
キーボード,         4,500,     40,       周辺機器,     KeyMax
スマートフォン,     98,000,    20,       電子機器,     MobileX
タブレット,         68,000,    25,       電子機器,     TabWorld
イヤホン,           7,800,     60,       オーディオ,   SoundWave
外付けHDD,          15,000,    35,       ストレージ,   StorageKing
プリンター,         22,000,    18,       周辺機器,     PrintMaster

ファイルIDの取得

FGET関数でファイルの内容を取得するには、まずファイルを開きファイルIDを取得する必要があります。そのファイルIDを取得するにはFOPEN関数を使います。ファイルの内容を取得する際、FOPEN関数のオープンモードの引数にF_READもしくはF_READ or F_WRITEを指定する必要があります。変数のFIDはFile IDを表しています。

以下は実行しているUWSファイルと同一フォルダにあるReadme.txtを読み取り専用で開き、FIDにそのファイルIDを代入する例です。

UWSC
DIM FID = FOPEN("Readme.txt", F_READ)
// FCLOSE(FID)

ファイルの行数を取得

Readme.txtの行数を取得し出力します。テキストのないEOF行は行数にカウントされません。Readme.txt本体には最後に空行を含むためサンプルテキストのテキストを保存したときと結果は異なります。以下はサンプルテキストで実行したときの結果です。

UWSC
DIM FID = FOPEN("Readme.txt", F_READ)
PRINT FGET(FID, F_LINECOUNT)
FCLOSE(FID)
結果
プレーンテキスト
79

ファイルの全内容を取得

Readme.txtの全内容を取得し出力します。結果はReadme.txtと同一なので省略します。

UWSC
DIM FID = FOPEN("Readme.txt",F_READ)
PRINT FGET(FID, F_ALLTEXT)
FCLOSE(FID)

テキストファイルの指定行を出力

指定した行のテキストを取得するにはFGET関数の第2引数に取得する行番号を数値で指定します。以下のプログラムはReadme.txtの3行目を取得、出力しています。

UWSC
DIM FID = FOPEN("Readme.txt", F_READ)
PRINT FGET(FID, 3)
FCLOSE(FID)
結果
プレーンテキスト
[機能]

テキストファイルを1行ずつ読み込む

FGET関数の第2引数に数値を指定するとその行のテキストのみを取り出すことができます。またF_LINECOUNTを指定するとファイル全体の行数を取得でるので、FOR-TO文で1行ずつ読み込むことができます。以下のループではrowが1から最終行まで1行ずつテキストが出力されます。

UWSC
DIM FID = FOPEN("Readme.txt", F_READ)

FOR row = 1 TO FGET(FID, F_LINECOUNT)
	PRINT FGET(FID, row)
NEXT

FCLOSE(FID)

以下は1行ずつ読み込みながらUWSCを含む行のみ抽出しています。textにrow行目のテキストが代入されます。

UWSC
DIM FID = FOPEN("Readme.txt", F_READ)

FOR row = 1 TO FGET(FID, F_LINECOUNT)
	DIM text = FGET(FID, row)
	IF POS("UWSC", text) THEN PRINT text
NEXT

FCLOSE(FID)
結果
プレーンテキスト
　　　UWSC Pro　Ver 5.3.0.2 版                      2017/04/18
　※ 本ソフトはシェアウェアであり、UWSC(Free版)の上位版です。
　UWSC起動時、もしくは "About"画面より登録してください。
　http://www.uwsc.info/purchase.html
実行中のUWSCを終了させてから、インストールを実行してください。
　UWSC.exe         // 自動化ソフト
　UWSC.chm         // UWSC ヘルプ
　　http://www.uwsc.info/
　　UWSC の操作に関するバグ報告、質問等はFAQを確認のうえ掲示板にお願いいたします。
　　よくある質問と回答(FAQ)：http://www.uwsc.info/faq.html

偶数行

テキストファイルの偶数行のテキストのみ出力します。

UWSC
FOR row = 2 TO FGET(FID, F_LINECOUNT) STEP 2
	PRINT FGET(FID, row)
NEXT

奇数行

テキストファイルの奇数行のテキストのみ出力します。

UWSC
FOR row = 1 TO FGET(FID, F_LINECOUNT) STEP 2
	PRINT FGET(FID, row)
NEXT

指定行毎

startからdifferenceごとに出力。

以下は4行目から5行毎（row=4,9,14,19,…）に出力します。

UWSC
DIM start = 4
DIM difference = 5

FOR row = start TO FGET(FID, F_LINECOUNT) STEP difference
	PRINT FGET(FID, row)
NEXT

配列に指定した行

配列に指定した行番号のテキストのみ出力します。以下はReadme.txtの1,5,6,7,10,15行目のテキストのみ出力します。

UWSC
DIM FID = FOPEN("Readme.txt", F_READ)
DIM array[] = 1, 5, 6, 7, 10, 15

FOR i = 0 TO UBound(array)
	PRINT FGET(FID, array[i])
NEXT

FCLOSE(FID)

CSVファイルの読み込み

商品一覧.csvの1行1列目のデータを読み込みます。

UWSC
DIM FID = FOPEN("商品一覧.csv", F_READ)
PRINT FGET(FID, 1, 1)
FCLOSE(FID)
結果
プレーンテキスト
商品名

商品一覧.csvの3行2列目のデータを読み込みます。

UWSC
DIM FID = FOPEN("D:\Desktop\商品一覧.csv", F_READ)
PRINT FGET(FID, 3, 2)
FCLOSE(FID)
結果
プレーンテキスト
3,500

CSVファイルの全データを取得

CSVファイルのすべての行と列のデータにアクセスしてデータを出力します。FOR-TO文で行、WHILE文で列にアクセスします。WHILE文の継続条件はrow行col列目のテキストが空文字でない限りなので、空文字が来たら次の行に処理を移します。

UWSC
DIM FID = FOPEN("商品一覧.csv", F_READ)

FOR row = 1 TO FGET(FID, F_LINECOUNT)
	DIM col = 1
	WHILE FGET(FID, row, col) <> ""
		PRINT row + ", " + col + "<#TAB>" + FGET(FID, row, col)
		col = col + 1
	WEND
	PRINT "--------------------"
NEXT

FCLOSE(FID)
結果
プレーンテキスト
1, 1	商品名
1, 2	価格
1, 3	在庫数
1, 4	カテゴリ
1, 5	メーカー
--------------------
2, 1	ノートPC
2, 2	120,000
2, 3	15
2, 4	電子機器
2, 5	TechBrand
--------------------
3, 1	ワイヤレスマウス
3, 2	3,500
3, 3	50
3, 4	周辺機器
3, 5	MousePro
--------------------
4, 1	モニター
4, 2	25,000
4, 3	30
4, 4	電子機器
4, 5	VisionTech
--------------------
5, 1	USBメモリ
5, 2	1,200
5, 3	100
5, 4	ストレージ
5, 5	DataFast
--------------------
6, 1	キーボード
6, 2	4,500
6, 3	40
6, 4	周辺機器
6, 5	KeyMax
--------------------
7, 1	スマートフォン
7, 2	98,000
7, 3	20
7, 4	電子機器
7, 5	MobileX
--------------------
8, 1	タブレット
8, 2	68,000
8, 3	25
8, 4	電子機器
8, 5	TabWorld
--------------------
9, 1	イヤホン
9, 2	7,800
9, 3	60
9, 4	オーディオ
9, 5	SoundWave
--------------------
10, 1	外付けHDD
10, 2	15,000
10, 3	35
10, 4	ストレージ
10, 5	StorageKing
--------------------
11, 1	プリンター
11, 2	22,000
11, 3	18
11, 4	周辺機器
11, 5	PrintMaster
--------------------

FGET関数の第4引数にTrueを指定するとデータ両側にあるダブルクォーテーションを削除しません。

UWSC
DIM FID = FOPEN("D:\Desktop\商品一覧.csv", F_READ)

FOR row = 1 TO FGET(FID, F_LINECOUNT)
	DIM col = 1
	WHILE FGET(FID, row, col) <> ""
		PRINT row + ", " + col + "<#TAB>" + FGET(FID, row, col, TRUE)
		col = col + 1
	WEND
	PRINT "--------------------"
NEXT

FCLOSE(FID)
結果
プレーンテキスト
1, 1	商品名
1, 2	価格
1, 3	在庫数
1, 4	カテゴリ
1, 5	メーカー
--------------------
2, 1	ノートPC
2, 2	"120,000"
2, 3	15
2, 4	電子機器
2, 5	TechBrand
--------------------
3, 1	ワイヤレスマウス
3, 2	"3,500"
3, 3	50
3, 4	周辺機器
3, 5	MousePro
--------------------
4, 1	モニター
4, 2	"25,000"
4, 3	30
4, 4	電子機器
4, 5	VisionTech
--------------------
5, 1	USBメモリ
5, 2	"1,200"
5, 3	100
5, 4	ストレージ
5, 5	DataFast
--------------------
6, 1	キーボード
6, 2	"4,500"
6, 3	40
6, 4	周辺機器
6, 5	KeyMax
--------------------
7, 1	スマートフォン
7, 2	"98,000"
7, 3	20
7, 4	電子機器
7, 5	MobileX
--------------------
8, 1	タブレット
8, 2	"68,000"
8, 3	25
8, 4	電子機器
8, 5	TabWorld
--------------------
9, 1	イヤホン
9, 2	"7,800"
9, 3	60
9, 4	オーディオ
9, 5	SoundWave
--------------------
10, 1	外付けHDD
10, 2	"15,000"
10, 3	35
10, 4	ストレージ
10, 5	StorageKing
--------------------
11, 1	プリンター
11, 2	"22,000"
11, 3	18
11, 4	周辺機器
11, 5	PrintMaster
--------------------

プログラム実行例

システム起動時間を取得

システムの起動時間を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 : フォーマット 
// 【戻り値】
//   数値を表示書式に基づいて変換した文字列 
//////////////////////////////////////////////////
//////////////////////////////////////////////////
// 【引数】
//   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
DIM FID = FOPEN("D:\Documents\sample.txt", F_READ)
DIM array[-1]

FOR i = 1 TO FGET(FID, F_LINECOUNT)
	arrayPush(array, FGET(FiD, i))
NEXT

FCLOSE(FID)

QSORT(array, QSRT_A)

FOR i = 0 TO UBound(array)
	PRINT array[i]
NEXT

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

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

テキストファイルの内容を行毎にソートして書き換える

UWSC
DIM FID = FOPEN("D:\Documents\sample.txt", F_READ OR F_WRITE)
DIM array[-1]

FOR i = 1 TO FGET(FID, F_LINECOUNT)
	arrayPush(array, FGET(FiD, i))
NEXT

QSORT(array, QSRT_A)

FPUT(FID, "", F_ALLTEXT)

FOR i = 0 TO UBound(array)
	FPUT(FID, array[i], i + 1)
NEXT

FCLOSE(FID)

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

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

テキストファイルを行毎に読み上げる

UWSC
DIM FID = FOPEN("D:\Documents\sample.txt", F_READ)

FOR i = 1 TO FGET(FID, F_LINECOUNT)
	FUKIDASI(i)
	SPEAK(FGET(FID, i))
	SLEEP(1.000)
NEXT

FCLOSE(FID)
使用関数

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
使用関数
解説

一時ファイル

UWSC
DIM FID = FOPEN("", F_READ OR F_WRITE)
FPUT(FID, data, F_ALLTEXT)

FOR r = 1 TO FGET(FID, F_LINECOUNT)
	FOR c = 1 TO 4
		PRINT FGET(FID, r, c)
	NEXT
NEXT

FCLOSE(FID)

TEXTBLOCK data
12, 22, 45, 61
42, 53, 45, 98
ENDTEXTBLOCK
使用関数

関連記事

FCLOSE関数 (スクリプト関数)
テキストファイルを閉じます。
FDELLINE関数 (スクリプト関数)
テキストファイルの指定行を削除します。
FOPEN関数 (スクリプト関数)
テキストファイルを開き、ファイルIDを取得します。
FPUT関数 (スクリプト関数)
テキストファイルの書き込みを行います。
DELETEFILE関数 (スクリプト関数)
テキストファイルを削除します。
GETDIR関数 (スクリプト関数)
Folder.CopyHere メソッド (Shell)
1つまたは複数のアイテムをフォルダにコピーします。
Folder.MoveHere メソッド (Shell)
1つまたは複数のアイテムをこのフォルダーに移動します。
FileSystemObject オブジェクト
FSO.CopyFile メソッド
CopyFileは、指定したファイルを別の場所にコピーする関数です。sourceに指定したファイルをdestinationに指定したパスにコピーします。sourceはワイルドカード文字を使うことができます。