国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

磁盤的屬性比如磁盤的剩余空間，磁盤的總額提供了一個全局的信息給系統(tǒng)管理員。但是，對于系統(tǒng)管理而言，磁盤的信息雖然是必須的，但是還不夠。知道文件存儲在哪個盤固然重要，但是你也需要知道文件是存儲在哪個文件夾下的。此外許多的系統(tǒng)管理任務都是發(fā)生在文件夾級別的，比如復制，移動，刪除和列舉文件夾的內容。

FSO 可以返回一個磁盤上文件夾的全部信息。此外，FSO 提供了一系列的方法來完成諸如：復制、移動、刪除文件夾的操作。

※   如何綁定指定的文件夾

在微軟的調用文件中，文件夾是 COM

對象。這就是說在你訪問一個單獨的文件夾的屬性時，你必須去創(chuàng)建一個文件夾的對象reference，這個過程叫做綁定。你可以用FSO和GetObject的方法來綁定到一個文件夾。

當用 GetFolder 的時候，你必須：路徑既可以寫成本地路徑也可以寫成 UNC 路徑（例如：\\accounting\receivables）。但是通配符不能出現在路徑當中。此外，你不可以創(chuàng)建一個單獨的對象 reference

來同時綁定到多個文件夾。例如，如下的腳本代碼會產生一個錯誤：

objFSO.GetFolder("C:\FSO", "C:\Scripts")

如果你想針對多個文件夾同時工作，你要么用 WMI 或者用針對每個文件夾創(chuàng)建單獨的對象reference。

在設置的時候 Set 這個關鍵詞是必須的，因為你要標識這個對象 reference 變量。

例如下面的腳本綁定文件夾 C:\FSO

1  Set objFSO = CreateObject("Scripting.FileSystemObject")

2  Set objFolder = objFSO.GetFolder("C:\FSO")

雖然通配符是不允許的，但是你可以用點來關聯(lián)到當前的文件夾(.)，你可以用點點(..)來綁定到父文件夾，用 \ 

綁定到根文件夾。例如如下代碼語句綁定到當前的文件夾：

Set objFolder = objFSO.GetFolder(".")

※檢驗文件夾是否存在

許多的文件夾的操作包括復制、移動、刪除需要特定的文件夾存在才可以對其進行操作。畢竟，腳本不能復制、移動、刪除這些不存在的文件夾，如果一個腳本嘗試去對一個不存在的文件夾執(zhí)行類似的操作，那么會報錯“path not found”。為了避免這樣的問題發(fā)生，你可以用 FolderExists 方法來在你綁定一個文件夾之前檢查文件夾是否存在。FolderExists用一個簡單的參數（文件夾路徑）來返回一個 Boolean 值，如果文件夾存在，返回的值為 True，否則返回的值為 False。

例如，下例中列出的腳本，FolderExists 方法來檢查文件夾 C:\FSO 是否存在。如果存在，腳本用 GetFolder 方法來綁定文件夾。如果不存在，腳本就彈出一個 message box 說：Folder does not exist.

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   If objFSO.FolderExists("C:\FSO") Then

3   Set objFolder = objFSO.GetFolder("C:\FSO")

4   Wscript.Echo "Folder binding complete."

5   Else

6   Wscript.Echo "Folder does not exist?"

7   End If

※如何建立文件夾

你不可能永遠都使用你現有的文件系統(tǒng)結構，從來不去更改你的文件系統(tǒng)結構。而事實上，文件系統(tǒng)是動態(tài)的，因為需要變動，現存的文件夾可能被刪除，新的文件夾可能被創(chuàng)建。例如，你的單位在

file servers 上給用戶提供空間，你需要在每個新用戶來的時候創(chuàng)建一個新的文件夾給他。

FSO給腳本編寫者提供了這樣的能力，可以讓你通過腳本來創(chuàng)建文件夾。例如在上例中腳本檢查特定的文件夾是否存在，如果存在，腳本用 GetFolder 的的方法來綁定到這個特定的文件夾，如果不存在，腳本彈出一個消息框。雖然這個方法避免了腳本的失敗，但是你或許更希望在文件夾不存在的時候來創(chuàng)建一個文件夾，而不是簡單的報告說文件夾不存在。為了做到這點，首先創(chuàng)建一個 FSO 對象實例，然后用CreateFolder 方法，將文件夾的完成路徑作為參數，例如，下面腳本用這個方法來創(chuàng)建一個新的文件夾 C:\FSO

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   Set objFolder = objFSO.CreateFolder("C:\FSO")

如果文件夾存在，那么會報錯說”file exists”?；诖耍阈枰趧?chuàng)建文件夾的之前檢查文件對象是否存在。

Note：FSO 只能在本地創(chuàng)建文件夾。如果你想在遠程的計算機上創(chuàng)建文件夾，你需要用到     wshcontroller 對象。你可以在本地創(chuàng)建文件夾然后用 WMI 來將文件夾移動到遠程的計算     機上。（這個文件夾只能先創(chuàng)建再用WMI 移動，因為 WMI 不支持創(chuàng)建文件夾的方法。）

※  刪除文件夾

當你要刪除文件夾時，例如你用文件服務器存儲每一個員工的數據，當這個員工離開單位時，他的文件夾將被刪除。這保證了文件服務器上的磁盤空間，同樣，你或許用一個腳本來創(chuàng)建一個文件夾來存儲臨時文件，當腳本執(zhí)行完畢的時候，你會刪除這個臨時的文件。DeleteFolder方法使你可以刪除文件夾和文件夾下的所有文件。DeleteFolder需要一個單獨的參數：文件夾的完全路徑。例如下面腳本用來刪除C:\FSO 和其它所有的東西。

1  Set objFSO = CreateObject("Scripting.FileSystemObject")

2  objFSO.DeleteFolder("C:\FSO")

這個方法會立即刪除所有的文件，它不會讓你確認是否需要刪除就將其扔到垃圾筒。

※使用通配符（Wildcards）刪除文件夾

腳本的最大的一個優(yōu)點就是作為一個管理工具，腳本操作可以同時刪除許多個項目。例如你可以用腳本的一個單獨的操作就可以刪除所有的文件和文件夾，而不用一個一個去刪除了。

 FSO 允許你用通配符來刪除一些特定的文件。例如你希望刪除某文件夾下所有以 s 開頭的文件夾，這可以用下面的命令來完成。當用類似這樣的文件夾結構來運行這個的時候，那么文件夾subfolder1,subfolder2,scripts都會被刪除。

objFSO.DeleteFolder("C:\FSO\S*")

下面這個腳本用來刪除以 su 開頭的文件夾，就是說 subfolder1,subfolder2 會被刪除。

objFSO.DeleteFolder("C:\FSO\Su*")

通配符只能放在文件路徑的最末尾。

例如如下代碼將通配符放在路徑的中間，會報錯：path not found

objFSO.DeleteFolder("C:\*\Subfolder1")

※復制文件夾及文件夾下的內容

復制文件夾和文件夾當中所有數據能力的對于系統(tǒng)管理任務來說非常重要。有時你需要復制文件夾來創(chuàng)建備份，在計算機 A 和計算機 B 上有同樣的文件夾，如果計算機 B 意外的down掉之后，你就不怕數據丟失了。在其它的時候，你或許希望將含有特定文件的文件夾復制到很多臺計算機上。用腳本來向各個計算機復制這個文件夾比手工復制高效的多。

1、CopyFolder 方法允許你復制一個文件夾到另外一個地方。當不用通配符的時候，這個CopyFolder 的方法和命令 Xcopy /E 命令一樣：它拷貝所有的文件和子文件夾，包括空的文件夾。這個命令需要兩個參數：源文件夾->這個文件夾可以被確定為本地路徑(C:\Script)或者為 UNC 路徑(\\helpdesk\scripts)。目標文件夾->這個文件夾也可以是本地文件夾和 UNC路徑。如果目標文件夾不存在，那么將自動創(chuàng)建一個文件夾。此外這個方法有個可選的參數：Overwrite，當這個參數存在時，默認的情況下腳本會覆蓋已經存在的目標文件夾。

 Note：CopyFolder 方法會在遇到錯誤時停止，即使這個腳本中包含有 On Error Resume Next語句。例如你用腳本用來拷貝 100 的子文件夾，當成功拷貝三個之后，遇到一個錯誤。這時腳本會中止，它不去嘗試剩下的 97 的文件夾。

在下例中用 CopyFolder 的方法來復制文件夾 C:\scripts 到 c:\FSO 并且復寫目標文件夾。注意，這個的結果不是 C:\FSO\Scripts 而是 C:\FSO 下有和 C:\Scripts 有同樣的文件。如果你想更改文件夾叫 C:\FSO\Scripts，你應該將目標文件夾改為 C:\FSO\Scripts

1   Const OverWriteFiles = True

2   Set objFSO = CreateObject("Scripting.FileSystemObject")

3   objFSO.CopyFolder "C:\Scripts" , "C:\FSO" , OverWriteFiles

Note：因為這個 CopyFolder 是一個單獨的操作，你沒有辦法來跟蹤它的進程。你只是需要簡單的等待操作的結束。如果你想監(jiān)視 copy

命令的過程，你應該用 shell 應用程序。

※使用通配符（Wildcards）復制文件夾

用這個CopyFolder 命令也可以拷貝所有文件夾和子文件夾下的文件。這樣可能導致一個問題，如果只是想拷貝 C:\FSO

下的文件，而不是想拷貝C:\FSO\Subfolder1，C:\FSO\Subfolder2，C:\FSO\Sbufolder3 下的文件。

可是，不幸的是這里沒有直接的辦法來不拷貝子文件夾中的文件而只是拷貝父文件夾中的文件，你可以用通配符來限制子文件夾的拷貝。例如如下的腳本代碼只是拷貝以 log

字母開頭的文件夾。但是，你用通配符的時候就只是拷貝那些符合特定要求的文件夾才被拷貝：

objFSO.CopyFolder "C:\Scripts\Log*" , "C:\Archive", True

當上面的腳本代碼執(zhí)行的時候，C:\Scripts\logs,C:\Scripts\Logfiles 被拷貝了，包括它們的文件和子文件夾中的文件。但是，在

C:\Scripts 的文件沒有被拷貝。當你用 CopyFolder

方法的時候，你不能只是拷貝文件夾中的文件，而不拷貝子文件夾中的蚊子。如果你想只是拷貝文件而不拷貝子文件夾的文件，你可以應用 CopyFile 方法。

※移動文件夾

當你復制一個文件夾從一個地方到另外一個地方的時候，你以復制結束而告終。有時候這個正是你想要的，但是有的時候，你不需要兩份文件的信息，你或許希望將文件夾從計算機

A 移動到計算機 B，或者從硬盤 C 移動到硬盤

D。移動工作總會移動到特定磁盤的剩余空間上。例如你或許會周期的將很少訪問的文件夾移動到存檔磁盤中。此外你或許有一個腳本來監(jiān)視本地計算機的信息，當監(jiān)視結束的時候，你需要將它上傳到服務器，然后將本地文件刪除，然后本地計算機就開始下一次的監(jiān)視。

MoveFolder 需要兩個參數：

1、Source folder 源文件夾，可以是本地路徑或者是 UNC 路徑。

2、Destination folder 目標文件夾，這個文件系也可是本地或者 UNC 路徑。

如果你的目標文件夾不存在，那么移動是成功的。如果目標文件夾存在，那么不成功。你不能用這個 MoveFolder 的方法來覆蓋一個文件夾。下例腳本中，移動本地的文件夾 C:\Scripts 到一個共享的文件夾 \\helpdesk\management

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   objFSO.MoveFolder "C:\Scripts" , "\\helpdesk\management"

注意用 MoveFolder

方法當腳本失敗后不能循環(huán)操作。例如，假如你的網絡連接在腳本將文件從一個計算機移動到另外一個計算機完成前失敗了，那么很有可能你一些文件在計算機 A 上，另外一些文件在計算機 B 上，也有可能在移動的過程中丟失一些文件。因為這個 MoveFolder 的方法無法讓腳本恢復到以前狀態(tài)。

因為如此，你或許需要兩個方法來完成文件在網絡中的移動:CopyFolder 和 DeleteFolder。你可以用 CopyFolder 來將文件從計算機 A 移動到計算機 B。當復制的操作結束之后，你用DeleteFolder 來刪除計算機 A 上的文件，當復制操作失敗的時候，你可以確保你的文件還在你的計算機上。

※重命名文件夾

在FSO中沒有提供RenameFolder 方法重新命名文件夾。但是可以用

MoveFolder方法來將文件夾移動到相對同樣的位置，例如假如有文件夾路徑如下：

C:\Scripts\PerformanceMonitoring\Servers\Domain Controllers\Current Logs

如果你用 Windows 瀏覽器來更改文件夾的名字，那么文件夾還是它本身

C:\Scripts\PerformanceMonitoring\Servers\Domain Controllers\Archived Logs

MoveFolder 的方法可以讓你完成同樣任務，你將

C:\Scripts\PerformanceMonitoring\Servers\Domain Controllers\Current Logs作為源路徑，將 C:\Scripts\PerformanceMonitoring\Servers\Domain Controllers\Archived Logs作為目標路徑。這樣的結果和在 windows 瀏覽器中更改文件夾的名字效果是樣的。

例如，下例中的腳本將文件夾C:\FSO\Samples更改為C:\FSO\Scripts在腳本運行之前，Sample 是C:\Scripts的文件夾，在腳本運行之后，就是C:\FSO的子文件夾了。此外Scripts （FSO 下的）含有原來 Sample

所有的文件和子文件。

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   objFSO.MoveFolder "C:\FSO\Samples" , "C:\FSO\Scripts"

※獲得文件夾屬性

因為文件夾是一個 COM 對象，它們的屬性可以被獲得和列舉出來，為了列舉詳細的文件夾信息，你可以用文件夾對象，它是 FSO

的組件之一。文件夾對象的屬性列舉在了下表中。

Attributes             關于文件夾的屬性信息。

DateCreated          文件夾創(chuàng)建的日期

DateLastAccessed           用戶最后訪問這個文件夾的日期

DateLastModified     用戶最后更改文件夾屬性的日期

Drive               磁盤信息包括拖尾符號（比如，C:）標識文件夾所在的磁盤

Files                存儲在這個文件夾中所有文件的信息。

IsRootFolder           Boolean 值來表明這個文件夾是否是根文件夾

Name              文件夾的名字但不包括路徑信息

ParentFolder           文件夾存放的父文件夾的名字

Property                Description

Path                         文件夾的路徑

ShortName             MS-DOS 類型的文件夾的名字，遵循 8.3 的命名規(guī)則。

ShortPath               MS-DOS 類型的文件夾的名字，遵循 8.3 的命名規(guī)則。

Size                 文件夾的大小，單位是 bytes，包含子文件和子文件夾的大小在內。

SubFolders              第一層的子文件夾。在 Subfolders 中的子文件夾不在此列中。

Type           對于文件夾的描述

※列舉文件夾的屬性

為了得到一個文件夾的屬性，一個腳本必須：

1.創(chuàng)建一個 FSO 實例

2.用 GetFolder 的方法綁定特定文件夾

3.用 Echo 的方法顯示屬性。

當你對一個文件夾的屬性進行操作的時候，注意文件的屬性和子文件夾的屬性是以集合的形式返回的，不是單獨返回一個的。此外Attributes 屬性返回一個屬性值。

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   Set objFolder = objFSO.GetFolder("C:\FSO")

3   Wscript.Echo "Date created: " & objFolder.DateCreated

4   Wscript.Echo "Date last accessed: " & objFolder.DateLastAccessed

5   Wscript.Echo "Date last modified: " & objFolder.DateLastModified

6   Wscript.Echo "Drive: " & objFolder.Drive

7   Wscript.Echo "Is root folder: " & objFolder.IsRootFolder

8   Wscript.Echo "Name: " & objFolder.Name

9   Wscript.Echo "Parent folder: " & objFolder.ParentFolder

10   Wscript.Echo "Path: " & objFolder.Path

11    Wscript.Echo "Short name: " & objFolder.ShortName

12   Wscript.Echo "Short path: " & objFolder.ShortPath

13   Wscript.Echo "Size: " & objFolder.Size

14   Wscript.Echo "Type: " & objFolder.Type

※管理文件夾的屬性

文件系統(tǒng)支持屬性的定義。就是文件夾中和文件夾名字和文件夾大小無關的信息。例如如果你在 Windows 瀏覽器中右擊某個數據夾的時候，點 Properties 你就可以訪問文件夾的屬性了。

FSO 可以返回幾個關于文件夾信息的重要屬性。這些屬性和相應的值，列舉在下表中：

Hidden        2            隱藏，就是在 Windows 瀏覽器中不可見

System        4        表示它是一個系統(tǒng)文件夾。建議不要更改系統(tǒng)文件夾的內容。

Directory      16          應用到所有的文件夾的標準值。所有可以被 FSO 訪問的文件

夾讀有這個值，最小位 16。

Archive        32             存盤的屬性用在備份程序中，用來決定文件是否需要備份。

如果這個值 enabling 表示文件夾在下一次增量備份中會備份。如果

是disabling 表示不在下一次增量備份中備份

Compressed       2048     表明這個文件夾是否是壓縮的

雖然這些看起來很簡單，但是從

FSO返回的數據看起來會讓你感到很迷惑。例如，你返回一個文件夾的屬性值，你或許會看到20，但是這個值并不是像上面一樣的標準值。此外，你可能會獲得一個單獨的值，雖然這個文件夾有說有的屬性。這種情況是，腳本并不是返回如

2,4,16,32,2048 這樣的值，而只是返回一個 2102。這是因為這些值是以位圖的形式顯示的。

Note：對于屬性值，它返回和存儲的數據是以位圖的形式的。對于位圖你應該不會奇怪，比如后綴名為.bmp 的圖形文件

位圖看起來就是一系列的開關。如果特定的開關是關閉的，那么這個開關的值就是0，如果是開啟的，比如文件夾對象吧，它就具有上表中所列出的值。而位圖的值就是這些開關的值的總和。如果你用腳本查詢這個文件夾的屬性，腳本就返回一個值為 16.

與其相反，如果有三個開關是開啟的：隱藏（值是2）,Directory（值是16），壓縮(值是 2048).那么這個位圖的值應該是 2+16+2048，或者值是 2066。這個也是用腳本查詢的時候返回的值。位圖被設計成只是有一種辦法來獲取特定的值。得到值 2066 的方法只有一個就是壓縮和隱藏。你不可能通過別的數學方法來算得這樣的值。

這個設計可以返回值并且決定哪個開關沒有開哪個沒有開。這個可以允許你來判斷文件夾的哪個屬性設定了。如果你得到了這個 2066

的值，那么它的屬性就是隱藏壓縮的文件夾。幸運的是，你不必去作任何單獨的數字運算，你可以用邏輯與 AND 操作來決定哪個開關是否是on 還是 off。例如如下代碼查詢文件夾是否是隱藏的，如果是回顯一個信息框： Hidden folder

If objFolder.Attributes AND 2 Then

   Wscript.Echo "Hidden folder."

End If

或者：  If objFolder.Attributes AND 16 Then

下列腳本先綁定文件夾 C:\FSO，然后回顯文件夾屬性：

（譯者注：這個其實是挨個匹配的，所以你要是測試了兩個屬性，它都會顯示出來的。）

1    Set objFSO = CreateObject("Scripting.FileSystemObject")

2    Set objFolder = objFSO.GetFolder("C:\FSO")

3    If objFolder.Attributes AND 2 Then

4    Wscript.Echo "Hidden folder."

5    End If

6    If objFolder.Attributes AND 4 Then

7    Wscript.Echo "System folder."

8    End If

9    If objFolder.Attributes AND 16 Then

10   Wscript.Echo "Folder."

11   End If

12   If objFolder.Attributes AND 32 Then

13   Wscript.Echo "Archive bit set."

14   End If

15   If objFolder.Attributes AND 2048 Then

16   Wscript.Echo "Compressed folder."

17   End If

※改變文件夾屬性

文件夾的每個屬性可以看成一個個開關，如果關于隱藏的開關是ON 的，那么這個文件夾就是隱藏的，如果這個開關是 OFF

的，那么這個文件夾就不是隱藏的，你可以選擇打開或者關掉它們，對于文件夾的屬性也是如此：對于其它的開關，你可以將屬性設置為開或者設置為關，你可以用腳本來控制這些開關的，最簡單的控制屬性開關的辦法是用如下的程序：

1. 用 GetFolder 的方法來綁定到一個文件夾。

2. 檢查你需要更改的值。例如你想隱藏一個文件夾，看這個文件夾是否是已經隱藏了

3. 如果這個文件夾是隱藏的，用 XOR 操作來將開關轉換成非隱藏的。如果這個文件夾不是隱藏的，注意不要用

XOR，如果你用了，開關會被觸發(fā)，文件夾會中止于隱藏。例如，下列腳本用 AND 來判斷文件夾 C:\FSO 的隱藏屬性開關是否開著。如果它是開的，腳本用 XOR

操作來將開關關閉來顯示文件夾。

1      Set objFSO = CreateObject("Scripting.FileSystemObject")

2    Set objFolder = objFSO.GetFolder("C:\FSO")

3    If objFolder.Attributes AND 2 Then

4     objFolder.Attributes = objFolder.Attributes XOR 2

5    End If

除非很少的一些情況以外，文件夾用來作為單獨存放文件的地方。有時候，這些文件夾是系統(tǒng)需要的。例如操作系統(tǒng)希望在特定的文件夾內找到特定的文件。在其它的一些時候，文件夾是系統(tǒng)管理員管理計算機的一種工具也是用戶管理文件的工具。系統(tǒng)管理員可能希望將腳本放在叫做Scripts

的文件夾，將一些 trouble-shooting 的工具放在叫做 Diagnostic Tools 的文件夾。用戶或許將他們預算信息放在叫做 Budgets

的文件夾，而將薪水的信息放在叫做 Timecards

的文件夾。當然，文件夾一般是限制使用的，你必須知道這個文件夾是存放的是什么文件。系統(tǒng)管理員需要知道是不是有個特定的腳本存在 C:\Scripts 文件夾中，用戶需要知道是不是有個特定的窗體存在C:\Budgets 的文件夾中。文件夾對象包含了一些屬性可用來返回存儲在文件夾內文件集合的信息，為了得到這些信息，你的腳本必須：

1. 創(chuàng)建一個 FSO 對象實例。

2. 用 GetFolder 的方法來綁定到一個適當的文件夾。

3. 設置一個對象 reference 來指向文件夾的屬性

4. 用 For Each 循環(huán)來列舉出所有的文件和他們的屬性。腳本不必去綁定到每一個單獨的文件去獲得文件的信息。

在下列腳本中返回在文件夾 C:\FSO 下所有文件的信息并且回顯他們的名字和大?。?/p>

1  Set objFSO = CreateObject("Scripting.FileSystemObject")

2    Set objFolder = objFSO.GetFolder("C:\FSO")

3    Set colFiles = objFolder.Files

4    For Each objFile in colFiles

5     Wscript.Echo objFile.Name, objFile.Size

6   Next

對于大多數返回的集合來說，你不能控制輸出信息的順序。就是說你不能將輸出的格式定義為按照名字，按照大小或者其它別的原則。如果你想讓輸出的東西按照特定的格式，你就必須將他們拷貝到數組，目錄或者一個 disconnected recordset 然后將他們分類排列。

Top-level 子文件夾是直接在文件夾下面的。在子文件夾中的子文件夾不在這個范圍之內。例如，在下例中，只有 Subfolder1 Subfolder2

是文件夾 scripts 的 top-level 的子文件夾。所以，如果用 Subfolders 這個屬性來返回值的話，就只是會返回 Subfolder1 和Subfolder2

為了得到一個子文件夾的集合，你的腳本必須：

1. 創(chuàng)建一個 FSO 實例

2. 用 GetFolder 的方法綁定到一個文件夾。

3. 創(chuàng)建一個對象 reference 來表示 Subfolders 屬性。這個是一個集合對象，因為它含有很多個對象。

在得到了對象 reference 這樣一個集合之后，你可以用一個 For Each 循環(huán)來列舉出子文件夾。下列腳本綁定到文件夾

C:\FSO，然后返回子文件夾的大小和名字。除了文件夾的名字之外，你可以返回信息。

1 Set objFSO = CreateObject("Scripting.FileSystemObject")

2   Set objFolder = objFSO.GetFolder("C:\FSO")

3   Set colSubfolders = objFolder.Subfolders

4   For Each objSubfolder in colSubfolders

5     Wscript.Echo objSubfolder.Name, objSubfolder.Size

6   Next

和你的文件系統(tǒng)的設計有關，有時知道 top-level

的子文件夾就可以提供足夠的文件夾結構的信息。在多數文件系統(tǒng)中，文件夾是嵌套的，或者是被嵌套的。關于子文件夾的集合可以告訴你C:\Accounting 包含兩個子文件夾 2001、2002，但是它不能告訴你他們的子文件夾的信息。

幸運的是，你可以用遞歸來查詢一系列子文件夾的的信息。例如用 Subfolders 屬性返回了一些 top-level 的子文件夾：

為返回完整的一系列子文件夾的信息，你需要用遞歸函數。這個函數用來調用它自己。下面腳本可以列舉出文件夾的所有子文件夾：

1. 創(chuàng)建一個 FSO 對象實例

2. 用 GetFolder 的方法來綁定到文件夾 C:\Scripts。GetFolder 的方法用來返回文件夾對象    C:\Scripts.然后這個

C:\Scripts 作為遞歸子函數 ShowSubFolders 的參數。這個子程序會列舉出所有的 C:\Scripts 下的子文件夾。返回一個包含在

C：\Scripts 下所有子文件夾的信息。這個集合有兩個值：Subfolder1 和Subfolder 2.

4. 返回第一個參數的路徑 Subfolder1。這個子程序用這個來作為參數將它輸入給它自身。換句話說，腳本現在調用 ShowSubFolders，并且參數是 Subfolder1。

5. 返回在 Subfolder1 中的所有參數。這個集合有兩個值：Subfolder1A and Subfolder 1B.

6. 回顯第一個集合的路徑，Subfolder1A。子程序用這個來作為參數調用自己。換句話說，就是用 ShowSubFolders 這個函數，那么它的參數是 Subfolder1A 來作參數。

7. 繼續(xù)執(zhí)行下一個參數。因為在 Subfolder1A 中沒有了子文件夾。這個子程序用Subfolder1B 作為參數。

8. .完成了關于文件夾 Subfolder1 的循環(huán)。這個過程結束在 Subfolder1B 沒有子文件夾。腳本然后用 Subfolder2

來作為參數，并且重復上面整個過程。

1 Set FSO = CreateObject("Scripting.FileSystemObject")

2    ShowSubfolders FSO.GetFolder("C:\Scripts")

3    Sub ShowSubFolders(Folder)

4     For Each Subfolder in Folder.SubFolders

5     Wscript.Echo Subfolder.Path

6     ShowSubFolders Subfolder

7     Next

8    End Sub

當用 CScript 運行的時候，命令行中顯示如下：

C:\scripts\Subfolder 1

C:\scripts\Subfolder 1\Subfolder 1A

C:\scripts\Subfolder 1\Subfolder 1B

C:\scripts\Subfolder 2

C:\scripts\Subfolder 2\Subfolder 2A

C:\scripts\Subfolder 2\Subfolder 2A\Subfolder 2A-1

C:\scripts\Subfolder 2\Subfolder 2B

C:\scripts\Subfolder 2\Subfolder 2C

為了獲得完整的文件夾列表，你可以從根文件夾查起：比如 C:\ 

Binding to a File 

FSO 給你提供了一些方法，比如 CopyFile,DeleteFile

允許你的腳本不用綁定一個特定的文件就可以對文件實例進行操作。而其它的任務，就需要文件對象。比如，為了獲得一些屬性，你的腳本首先就需要綁定到一個文件，然后再獲得文件的屬性。GetFile方法允許你綁定到一個獨立的文件。為了做到這點，你先創(chuàng)建一個 FSO 實例，然后創(chuàng)建一個文件對象。當你用 GetFile 方法的時候，你必須：1、確定文件的路徑：這個路徑可以是一個本地路徑，也可以是一個 UNC 路徑（例如：\\accounting\receivables\scriptlog.txt）在路徑當中你不能用通配符也不能有多個文件。用 GetFile 方法你在同一個時刻只能綁定一個單獨的文件。2、當綁定的對象分配給一個變量的時候就要用到 Set 這個關鍵詞。 

例如，下面腳本綁定到了文件：C:\FSO\Scriptlog.txt

1 Set objFSO = CreateObject("Scripting.FileSystemObject")

2   objFSO.GetFile("C:\FSO\ScriptLog.txt")

一般來講，你最好用絕對路徑來作 GetFile 的參數。這樣確保腳本總是可以在文件中運行。但是，用相對路徑也是可以的。例如，如下的腳本代碼會綁定到

Scriptlog.txt 會成功，因為腳本和這個文件在同一個文件夾里面： 

objFSO.GetFile("ScriptLog.txt")

同樣，下面的代碼實例如果這個腳本和這個文件在同一個文件夾也會綁定到 Scriptlog.txt：

objFSO.GetFile(".\ScriptLog.txt")

注意：FSO 不會用路徑環(huán)境信息去搜索文件。例如，你可以在命令行中敲如 calc.exe 來打開計算機，而無論你當前的目錄是在哪里，因為操作系統(tǒng)默認的情況下去搜索所有的文件的。但是用這個GetFile方法的時候，它不是這樣的工作的。

如下腳本除非是在文件夾C:\Windows\System32 的文件夾下，否則都不會運行成功的。 

objFSO.GetFile("calc.exe")

有時知道文件是否存在是十分重要的，這個可以作為軟件清單的一部分。例如你或許希望檢查所有的郵件服務器來看特定的腳本是否存在。用腳本來實現系統(tǒng)管理任務來說，知道腳本存在與否很重要的。比如你或許希望當你復制、移動、刪除或者操作不存在的文件的時候，腳本報錯。為了避免出現錯誤，你可以用 FileExists方法來檢查文件是否存在。FileExists 方法要求一個單獨的參數：文件的路徑，然后返回一個特定的 Boolean 值：如果文件存在，返回的是 True，如果文件不存在，返回的是 False。

如下面腳本用 FileExists 方法來檢查文件 C:\FSO\Scriptlog.txt 是否存在，如果存在，用 GetFile 方法來綁定到這個文件，如果不存在，腳本回顯一個 message“file does not exist”

1     Set objFSO = CreateObject("Scripting.FileSystemObject")

2     If objFSO.FileExists("C:\FSO\ScriptLog.txt") Then

3     Set objFile = objFSO.GetFile("C:\FSO\ScriptLog.txt")

4     Else 

5     Wscript.Echo "File does not exist.?

6     End If 

你不能用通配符來檢查文件夾中特定類型的文件是否存在，你也不能用通配符拉來檢查文件夾中所有的文件。如下面腳本，無論在文件夾

C:\FSO\下存在多少文件，都不會報錯出來，而是總是返回一個 False. 

WScript.Echo objFSO.FileExists("C:\FSO\*.*")

如果你希望遵循一些條件原則檢查一些文件而不是基于路徑，你有下面兩個選擇：

1、用 GetFolder

對象來綁定一個文件夾，然后返回文件的屬性，這樣重復操作直到篩選出你感興趣的。例如，你可以列舉出所有的文件和文件的擴展名，然后跟蹤看有多少個后綴名    

為.doc 的文件。

2、用 WMI，它允許你創(chuàng)建更多的目標查詢。比如選出所有后綴名為.doc 的文件。你可以用計數的辦法來返回你要的特定的條目。如果數值是 0，那么，最少有一個是.doc 的文件。

 Deleting a File 

用 FSO 來創(chuàng)建腳本刪除文件讓你可以自動執(zhí)行類似與磁盤清理之類的操作。例如，你可以用腳本定期查詢和刪除所有的臨時文件。你也可以依照一些規(guī)則來刪除文件，比如刪除六個月都沒有被訪問的文件，或者特定的后綴名的文件，比如（.bmp 或者.mp3）你可以首先創(chuàng)建 FSO 對象實例，然后調用 DeleteFile 方法來刪除文件，輸入文件路徑作為參數。 

如下面腳本刪除了文件 C:\FSO\Scriptlog.txt

1     Set objFSO = CreateObject("Scripting.FileSystemObject")

2   objFSO.DeleteFile("C:\FSO\ScriptLog.txt")

默認的情況下，DeleteFile 方法不會刪除只讀文件。事實上，當你嘗試刪除一個只讀文件時，腳本會報錯出來。為了避免這樣的錯誤出現，如想刪除只讀文件的話，需添加強制參數，當強制參數設成 True

的時候，那么 DeleteFile 可以刪除任何文件。如下面這行代碼可以刪除文件 Scriptlog.txt，即使它只是一個只讀文件。

1、 objFSO.DeleteFile("C:\FSO\ScriptLog.txt", True)

2、 Deleting a Set of Files

有時候你希望刪除特定的、單獨的文件。更有可能的是你可能想用腳本來刪除一系列的文件。如在周末你或許想刪除一些存盤了的日志文件或所有的臨時文件。你可以通過通配符來刪除一個文件夾之內的一些文件。但是你不能用 DeleteFile 方法來直接刪除多個文件夾內部的文件。你可以通過用篩選每個數據夾的辦法來逐個刪除每個文件夾內部的文件。如果你想刪除多個文件夾內部的特定類型的文件（比如刪除計算機上全部的.TMP 文件）你應該用 WMI 而不是用 FSO。為了刪除一系列文件，調用 DeleteFile 方法，根據文件的名字或者后綴名添加通配符來提供文件夾的路徑。例如，下面的代碼用來刪除文件夾 C:\FSO 文件夾下的所有后綴名為.doc 的文件。

objFSO.DeleteFile("C:\FSO\*.doc")

下面的這行代碼用來刪除所有文件名帶有 log 的文件：

objFSO.DeleteFile("C:\FSO\*log.* ")

正如前面提到的那樣，DeleteFile 方法不刪除標記為只讀的文件。如果你的腳本嘗試去刪除一個只讀的文檔，腳本會報錯，雖然你用了 On Error Resume Next 語句。例如你想刪除 1000 個 txt 文件，并且只有一個文件標記為只讀了。當腳本嘗試去刪除這個文件的時候，會產生一個腳本運行的錯誤，這個 DeleteFile 方法中止。腳本不去嘗試去刪除其它的文件，雖然其它的文件不是只讀的。因為這個原因，你可以用可選擇的：強制參數，將它的值設置成 True。當這個參數設置成 True 的時候，DeleteFile 方法可以刪除只讀文件。當這個參數被設置成 False 的時候，就不能刪除只讀文件。

下面腳本用來刪除文件夾 C:\FSO 下的所有文件，為了確保刪除包括只讀文件在內的文件，強制參數被設置成 True。并且使用了這個 DeleteReadOnly 常量。

1   Const DeleteReadOnly = True

2   Set objFSO = CreateObject("Scripting.FileSystemObject")

3   objFSO.DeleteFile("C:\FSO\*.txt"), DeleteReadOnly

如果你想刪除所有不是只讀的文件怎么辦呢？在這種情況下，你可以返回一個集合，用文件屬性來獲得文件屬性，是否為只讀，如果是就不刪除，否則就刪除。

Copying a File 

拷貝文件，無論是從計算機上的一個文件夾到另外一個文件夾還是從一個計算機到另外一個計算機，都是一個非常常見的管理任務。如你希望拷貝一個監(jiān)視的腳本到你所有的服務器上面來取代過去的 DLL 文件。CopyFile方法提供了這種任務管理的辦法。CopyFile 方法需要兩個必備參數和一個可選的參數：

1、Source － 要拷貝的文件的源文件的路徑。

2、Destination — 目標文件夾的路徑。為了確保在目標文件夾也是同樣的名字，將一個脫尾符放在文件夾的結束之前(“ \ ”)

  objFSO.CopyFile "C:\FSO\ScriptLog.txt" , "D:\Archive\"

  如果你想重新命名該文件，你可以將全路徑寫成如下的格式：

  objFSO.CopyFile "C:\FSO\ScriptLog.txt" , "D:\Archive\NewFileName.txt"   如果目標文件夾不存在，則會自動創(chuàng)建。

3、Overwrite可選。默認情況下，CopyFile

方法不能復制到目標文件夾存在的同名文件。這導致錯誤。比如你要更高的版本覆蓋存在的文件，那么將這個參數設置成 True。下面腳本拷貝文件 C:\FSO\Scriptlog.txt 到文件夾 D:\Archive。

   The original file, C:\FSO\ScriptLog.txt.

   The copied file, D:\Archive\ScriptLog.txt.

為了保證拷貝的正常進行，即使存在 D:\Archive\Scriptlog.txt，腳本將可選參數 Overwrite設置成 True（用常量 OverWriteExisting）

1 Const OverwriteExisting = True

2 Set objFSO = CreateObject("Scripting.FileSystemObject")

3 objFSO.CopyFile "C:\FSO\ScriptLog.txt" , "D:\Archive\", overwriteExisting 

當你確定一個目標文件夾的時候，脫尾的反斜線是十分必要的。（例如D:\Archive\）如果你的反斜線在，那么文件會被拷貝到 Archive

文件夾，如果反斜線不在的話，腳本的 CopyFile嘗試去建立一個叫做 D:\Achive 的文件夾。如果這個文件夾存在，那么會產生一個”Permission denied Error”的錯誤出來，拷貝的進程會失敗的。這個對于只讀文件來說也是錯誤的，雖然你可能將強制參數設置成

True。如果沒有反斜線，你必須先將原來的文件刪除，然后再調用CopyFile 方法來實現。

Copying a Set of Files

通配符提供了一種拷貝整個文件夾中所有的文件的方法。你可以用腳本復制一些具有共同參數的文件。例如下列腳本拷貝在 C:\FSO 中所有的 txt 文件到 D:\Archive.

1 Const OverwriteExisting = True

2 Set objFSO = CreateObject("Scripting.FileSystemObject")

3 objFSO.CopyFile "C:\FSO\*.txt" , "D:\Archive\" , OverwriteExisting

在 CopyFile 的方法中添加通配符來拷貝文件的時候，只是拷貝當前文件夾的文件。而用CopyFolder

的方法，正好相反，它也拷貝子文件夾的信息和文件。如下的腳本代碼語句拷貝文件夾 C:\FSO 中所有的文件，而不拷貝子文件夾的信息。

objFSO.CopyFile "C:\FSO\*.*" , "D:\Archive\"

Moving a File 

如你的磁盤空間很低了，你或許希望將文件移動到一個新的位置；如果你的計算機換了規(guī)則，你或許希望移動特定的診斷工具取代原來的。在其它的一些情況下，你或許不希望存在這個文件的副本，而是將它移動到一個新的位置。MoveFile

方法讓你將文件從一個地方移動到另外一個地方。MoveFile 方法和 CopyFile 的方法類似，你需要創(chuàng)建一個 FSO 對象，然后調用 MoveFile

的方法，需要兩個參數：

1、需要移動文件的完整路徑

2、需要移動到的目標文件夾的路徑，包括脫尾符(反斜線)

下例中腳本將 C:\FSO\Scriptlog.log 移動到 D 盤的 Archive 文件夾 

1     Set objFSO = CreateObject("Scripting.FileSystemObject")

2     objFSO.MoveFile "C:\FSO\ScriptLog.log" , "D:\Archive\"

Moving a Set of Files

你也可以用通配符來用一個操作移動多個文件。如為移動所有在文件夾 FSO 中以 data開頭的文件，你可以用以下的參數： C:\FSO\Data*.*

通配符可以用來移動特定的文件。因為文件的類型一般是用后綴名來標識的。如下例中腳本移動所有的日志文件到 D:\Archive

1 Set objFSO = CreateObject("Scripting.FileSystemObject")

2   objFSO.MoveFile "C:\FSO\*.log" , "D:\Archive\"

Renaming a File 

FSO 并沒有提供一種直接的方法來重新命名一個文件。但是和 MoveFolder 的方法可以重新命名文件夾一樣，你也可以用 MoveFile

的方法來重新命名文件。為了重新命名一個文件，你可以用 MoveFile 的方法，但是目標文件夾應為當前的文件夾。

如在下例腳本中，將Scriptlog.txt 重新命名為 Backuplog.txt。而在技術上是腳本實際上將 C:\FSO\Scriptlog.txt 移動到一個新的路徑 C:\FSO\Backuplog.txt，結果是將文件重新命名了。

1 Set objFSO = CreateObject("Scripting.FileSystemObject")

2     objFSO.MoveFile "C:\FSO\ScriptLog.txt" , "C:\FSO\BackupLog.txt" 

 文件有些屬性對于文件的管理來說十分重要，如屬性 DateLastAccssed 告訴你最后打開這個文件的日期。屬性Size告訴你文件有多少個 bytes，系統(tǒng)管理員可以通過 windows 資源管理器或者命令行工具去訪問文件的屬性。雖然這些工具可以返回計算機上文件的信息，但是他們不是被設計成用來保存和操作文件屬性的。此外，這些工具大多功能有限，不能使系統(tǒng)管理員很好的通過屬性來周期性的清理磁盤或者尋找出滿足特定屬性的文件集合。

幸運的是，你可以通過 FSO 來獲得計算機上任何文件的詳細信息。和其它的工具相比，FSO可以讓你查詢一個文件或者一組文件的信息。

Attributes            文件的位圖屬性。

DateCreated          文件的創(chuàng)建日期。

DateLastAccessed           數據的最后訪問日期。

DateLastModified       數據的最后更改日期。

Drive                 磁盤驅動器和托尾符（例如：C:）代表文件存在的磁盤上。

Name                     文件的名字，不包含文件的路徑

ParentFolder           父文件夾的名字。例如，C:\Windows\System32\Scrrun.dll

的父文件夾名字是 Windows

Path                文件的路徑，比如 C:\Windows\System32\Scrrun.dll

ShortName             MS-DOS類型的文件名，符合8.3 命名規(guī)則的。

ShortPath            MS-DOS-style 文件名字。符合 8.3 命名規(guī)則的。

Size                    文件的大小，單位是 bytes

Type                    文件類型，是在注冊表區(qū)中對于此文件類型的字符串描述。

為了訪問這些屬性，你必須：

1. 創(chuàng)建一個 FSO 對象實例。

2. 用 GetFile 方法創(chuàng)建一個對象的 reference。腳本必須給 GetFile 提供文件的路徑參數。

3. 用 Echo（或者其它的處理辦法）來表達出文件的屬性。

如下面的腳本用 GetFile 的方法來綁定到文件 C:\Windows\System32\Scrrun.dll 然后返回一些它的屬性：

1 Set objFSO = CreateObject("Scripting.FileSystemObject")

2     Set objFile = objFSO.GetFile("c:\windows\system32\scrrun.dll")

3     Wscript.Echo "Date created: " & objFile.DateCreated

4     Wscript.Echo "Date last accessed: " & objFile.DateLastAccessed

5     Wscript.Echo "Date last modified: " & objFile.DateLastModified

6     Wscript.Echo "Drive: " & objFile.Drive

7     Wscript.Echo "Name: " & objFile.Name

8     Wscript.Echo "Parent folder: " & objFile.ParentFolder

9     Wscript.Echo "Path: " & objFile.Path

10 Wscript.Echo "Short name: " & objFile.ShortName

11 Wscript.Echo "Short path: " & objFile.ShortPath

12 Wscript.Echo "Size: " & objFile.Size

13 Wscript.Echo "Type: " & objFile.Type

和文件夾一樣，文件有些屬性可以通過 FSO 返回和配置，有些屬性比如位圖屬性就不能通過 FSO 來獲得的。

Normal 0           沒有這樣的屬性設置為 True。？？

Read-only  1       文件為只讀。

Hidden      2       文件在 Windows 瀏覽器中是隱藏的。

System      4       文件是操作系統(tǒng)必須的。

Archive       32      存盤，文件標記為需要備份的。

Alias         64      此文件是其它文件的快捷方式

Compressed  2048    此文件是壓縮的。

想獲得文件的這些屬性，用GetFile 方法來綁定一個文件，在你創(chuàng)建完了這個文件對象的reference

之后，你可以用邏輯與操作來決定這些屬性。如果沒有任何屬性被設置了，那么這個值就是 0。如下面腳本綁定了文件 C:\FSO\Scriptlog.txt

然后檢查每個屬性并用FSO 返回屬性的值。

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   Set objFile = objFSO.GetFile("C:\FSO\ScriptLog.txt")

3   If objFile.Attributes AND 0 Then

4   Wscript.Echo "No attributes set."

5   End If

6   If objFile.Attributes AND 1 Then

7   Wscript.Echo "Read-only."

8   End If

9   If objFile.Attributes AND 2 Then

10  Wscript.Echo "Hidden file."

11  End If

12  If objFile.Attributes AND 4 Then

13  Wscript.Echo "System file."

14  End If

15  If objFile.Attributes AND 32 Then

16  Wscript.Echo "Archive bit set."

17  End If

18  If objFile.Attributes AND 64 Then

19  Wscript.Echo "Link or shortcut."

20  End If

21  If objFile.Attributes AND 2048 Then

22  Wscript.Echo "Compressed file."

23  End If

Configuring File Attributes

除了列舉文件的屬性之外，FSO 提供了配置如下屬性的一些辦法：

1、ReadOnly 2、Hidden 3、System 4、Archive

為了配置文件的這些屬性，腳本可以用如下的進程：

1. 用 GetFile 的方法綁定一個文件。

2. 檢查你要更改的文件的屬性。如你想將一個文件設置成只讀的那么就檢查它是否是已經是已讀了。

3. 如果不是只讀的，那么用邏輯 XOR 操作來觸發(fā)這個開關。這樣可以使文件變成只讀的。但    是如果文件已經是只讀的，那么不要用邏輯 XOR

操作，如果你用了，那么這個屬性就被移掉了。

下面腳本用 AND 操作來檢查只讀開關是否已經打開，從而確定文件C:\FSO\TestScript.vbs是否為只讀。如果為只讀，腳本用 XOR

操作來將其改成非只讀的。

1 Set objFSO = CreateObject("Scripting.FileSystemObject")

2   Set objFile = objFSO.GetFile("C:\FSO\TestScript.vbs")

3   If objFile.Attributes AND 1 Then

4     objFile.Attributes = objFile.Attributes XOR 1

5   End If

你也用如下的語句來同時去更改系統(tǒng)、存盤、隱藏等屬性

objFile.Attributes = objFile.Attributes AND 0

Creating Text Files

FSO 讓你可以用現存在的文本工作，也可以讓你自己創(chuàng)建腳本。為了創(chuàng)建一個新的文本文件，簡單的創(chuàng)建一個 FSO 對象，然后調用 CreateTextFile 方法，輸入完整的文件路徑信息作為這個方法的參數。

例如，如下的腳本代碼在文件夾 C:\FSO 中創(chuàng)建了一個 Scriptlog.txt 的文件：

1 Set objFSO = CreateObject("Scripting.FileSystemObject")

2   Set objFile = objFSO.CreateTextFile("C:\FSO\ScriptLog.txt")

如果這個文件存在，那么 CreateTextFile 方法會創(chuàng)建一個。如果這個文件已經存在，那么CreateTextFile 方法會復寫存在的文本文件，而以新的空白的文件取代它。如果你希望這個文件不被取代，那么就用一個可以選擇 Overwrite 的參數。當這個參數設置成 False 的時候，攢在的文件就不被復寫。當這個參數被設置成 True（默認的是 True），那么就會復寫存在的文件。例如，如下的腳本如果創(chuàng)建的文件存在的話就不會復寫。

 Set objFile = objFSO.CreateTextFile("C:\FSO\ScriptLog.txt", False)

如果你將參數設置成False，并且文件存在，那么就會有一個運行的錯誤。因為如此，你可以檢查文件是否存在，如果存在，那么就作其它的操作，例如允許用戶更改一個新的文件名。

Creating File Names Within the Script

防止文件存在產生錯誤的方法是用腳本給文本文件生成一個名字。因為文件名字生成器并不創(chuàng)建一個有意義的名字，這對于你想在未來要命名的日志和其它文件來說不是一個好的辦法。但是，這個對于需要臨時文件的腳本來說保證了有個特定的文件名。例如，你或許想讓你的腳本將數據保存在HTML 或者 XML 格式，然后將這些數據在 WEB 瀏覽器中顯示，然后將這個臨時文件在web 瀏覽器關掉時刪除。在這種情況下，你可以用GetTempName 方法來生成一個特有的文件名。

為了生成一個特別的文件名，腳本首先要創(chuàng)建一個 FSO 對象實例然后調用 GetTempName 方法(不用參數。)例如在 4.33 中的腳本用一個 For Next 循環(huán)來隨機生成 10 文件名字。

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   For i = 1 to 10

3     strTempFile = objFSO.GetTempName

4     Wscript.Echo strTempFile

5   Next

用 GetTempName 來生成文件的名字生成的不是唯一的。部分原因是生成名稱的算法，部  分是因為可能的名字的數量是有限的。文件名字被限制為 8 個字節(jié)，而且前三個字節(jié)規(guī)定為  rad，例如，你用腳本來創(chuàng)建 10000 個文件名字，在第 9894 個文件名字之后就不再是唯一的了，剩下的 106 個 53 對是復制的。

在 4.34 中的示例腳本用 GetTempName 方法來創(chuàng)建一個文件，腳本必須：

1. 創(chuàng)建一個 FSO 對象實例。

2. 創(chuàng)建一個給文件夾 C:\FSO 的變量叫做 strPath.

3. 用 GetTempName 方法來生成一個單獨的文件名子。

4. 用 BuildPath 的方法來合并文件夾名字和文件名字來創(chuàng)建一個完成的臨時文件的名字。這個    整個路徑存儲在 strFullName 變量中。

5. 調用 CreateTextFile 方法，用 strFullName 來作參數。

6. 在創(chuàng)建了這個文件之后，關閉這個文件。在生產環(huán)境中，大多數情況下，你可能要向里面寫    了數據之后再關閉它。

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   strPath = "C:\FSO"

3   strFileName = objFSO.GetTempName

4   strFullName = objFSO.BuildPath(strPath, strFileName)

5   Set objFile = objFSO.CreateTextFile(strFullName)

6   objFile.Close

Opening Text Files

用文本文件來工作有三個主要的步驟。在你可以作其它的事情之前，你必須打開文本文件。這個你可以打開存在的文件或者創(chuàng)建一個新的文本文件，創(chuàng)建結束之后，默認文件是打開的。每個方法都是返回一個TextStream 對象實例。

在你獲得了 TextStream 對象之后，你可以向這個文件中寫或者讀這個文件。但是你不能向同一個文件讀和寫。換句話說，在同一個操作中，你不能打開一個文件，讀這個文件然后再向這個文件中寫東西。你必須讀完這個文件后關閉，然后再打開這個文件，寫入數據，然后關閉。

 當你打開一個存在的文件，這個文件要么是準備好被讀的，要么是準備好被寫的。如果你創(chuàng)建一個新的文本文件，這個文本文件只是被讀的，沒有什么其它原因的話，它沒有內容去被讀。最后，你要去關閉這個文本文件，雖然它不是必須的，因為在腳本結束的時候，它會自動關閉，但是這個對于程序實踐來說是個好的辦法。

為了打開一個文本文件：

1. 創(chuàng)建一個 FSO 對象實例。

2. 用:OpenTextFile 來打開一個文本文件。這個 OpenTextFile 需要兩個參數，一個是一個文   件的路徑，另外一個是跟著的參數：

      For reading (parameter value = 1, constant = ForReading).

     文件被打開之后只是被用來為讀作準備的，為了寫這個文件，你必須再一次的打開文件，用參數 ForWriting 或者 ForAppending。

      For writing (parameter value 2, constant = ForWriting).

     文件被打開，并且寫入的數據覆蓋了原來存在的數據，就是說舊的數據被刪除，新的被添加。用這個方法用新的數據來代替存在的數據。

     For appending (parameter value 8, constant = ForAppending).

     文件在這種模式下打開，并且新的數據添加到文件的末尾。用這個方法向存在的文件中添加新的數據。

當打開文件的時候，你必須使用適當的參數。當你用讀的模式打開一個文件而試圖向里面寫東西的時候，你會收到一個 bad file mode

的錯誤。你如果試圖打開一個非文本文件的話也會收到同樣的錯誤的。你可以直接用數值（比如 1 代表寫）或者創(chuàng)建一個常量然后賦值給它適當的值。例如，如下的兩種方法都可以打開一個文件并且準備被讀：

Const ForReading = 1

Set objFSO = CreateObject("Scripting.FileSystemObject")

Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", ForReading)

Set objFile2 = objFSO.OpenTextFile("C:\FSO\ScriptLog2.txt", 1)

但是在沒有定義這個常量的時候，你不能直接用。這是因為事實上 VB 腳本并沒有這些 COM 對象常量。如下的腳本會返回一個 invalid procedure call or argument 的錯誤并且失敗。這是因為ForReading 這個常量并沒有顯式的定義。因為它沒有定義，所以這變量默認情況下被賦值為 0，而 0 對于 OpenTextFile 來說并不是一個合法的參數：

Set objFSO = CreateObject("Scripting.FileSystemObject")

Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", ForReading)

 在 4.35 中的腳本打開了 C:\FSO\Scriptlog.txt 準備讀，用了用戶自己定義的變量，并且賦值為 1.

Listing 4.35 Opening a Text File for Reading

1 Const ForReading = 1

2 Set objFSO = CreateObject("Scripting.FileSystemObject")

3 Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", ForReading)

Closing Text Files

所有的用腳本打開的文本文件在腳本結束的時候會自動關閉。因為如此，比不是必須的去顯式的關閉一個文本文件。然而，關閉這個文本文件卻是一個很好的程序實踐并且在下面的一些情況下，如果不關閉文件的話，會產生一些錯誤。

Reread the file.

有些時候你或許希望用一個腳本多次讀一個文件。你或許打開一個文本文件然后將它所有的內容全部保存給一個字符串變量，然后搜索這個字符串來查找特定的錯誤的代碼。當這個錯誤找到了，你再逐行去讀取文件，提煉出有錯誤的每一行。如果你嘗試多次去讀一個文件，你不會收到你期待的結果，而是會遇到一個運行的錯誤。例如下的腳本讀取一個文本文件，返回文件的內容到屏幕，然后嘗試重復這樣的過程：

  Set objFSO = CreateObject("Scripting.FileSystemObject")

  Set objFSO = CreateObject("Scripting.FileSystemObject")

  Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", 1)

  Wscript.Echo "Reading file the first time:"

  strContents = objFile.ReadAll

  Wscript.Echo strContents

  Wscript.Echo "Reading file the second time:"

  Do While objFile.AtEndOfStream = False

      strLine = objFile.ReadLine

      Wscript.Echo strLine

  Loop

  當在 cscript 下運行的是命令行的信息如下：

  Reading file the first time:

  File line 1.

  File line 2.

  File line 3.

  Reading file the second time:

  第一次文件是被讀取的，內容存儲在變量 strContents 上，第二次，文件讀取的時候，沒什有數據回顯在屏幕上，這是因為文件已經到達了文件的末尾，沒有其它的數據給你讀了。為了讀取這個數據，你必須關閉這個文件然后重新打開它。你不能在讀到文件的末尾之后去跳到文件的開頭去了。TextStreamObject.Close 方法用來關閉一個文本文件。例如，在 4.36 中的腳本創(chuàng)建一個FSO對象實例，然后打開一個文本文件，然后在立即關閉了。為了訪問文件的內容，你必須再一次的調用 OpenTextFile 方法去重新打開這個文件。

Listing 4.36 Opening and Closing a Text File

1  Set objFSO = CreateObject("Scripting.FileSystemObject")

2  Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", 1)

3  objFile.Close

Reading Text Files

在許多的企業(yè)腳本中，讀取文本文件的內容是個標準進程，你可以用這個功能來讀取命令行的參數。例如，你的文本文件包含了計算機名字的列表，腳本審計成讀取這個列表，然后在每個計算機上運行這個腳本。搜索滿足特定條件的日志文件。例如，你或許想找所有有錯誤的日志。將日志文件中添加內容并且匯入到數據庫。例如，你或許有一個服務或者程序來保存信息到特定存文本文件格式。然后你用腳本來讀取這個文件拷貝相關的信息到數據庫中。

 可以用 FSO 來都讀取文本文件的內容，但是有以下幾點你需要牢記：FSO 只能讀取 ASCII 的文本文件。你不能用 FSO 讀取unicode 或者

binary 文件格式的文件，比如 microsoft word 或者是 Microsoft excel .用 FSO讀取文本文件的時候，只能有一種方式：從前到后。此外，FSO 讀取文件的時候是逐行讀取的。如果你試圖返回前面的行，你必須從開始再重新讀取，直到特定的行。

你不能打開一個文件同時用來讀和寫。如果你打開一個文件是為了讀的，那么你想修改文件內容的時候，你必須重新打開文件。如果你嘗試在寫的模式下讀取文件，那么你會收到一個bad file mode 的錯誤。

還有讀取特定的字符然后停止也是我們常用的技巧。例如，如下的命令會讀取第一行的前 12 個字符Alerter.Shar，并且將它賦值給變量

strText，然后停止：strText = objTextFile.Read(12)

ReadLine 讀取文本文件中每行的信息然后在到達新的一行的之前停止。例如，如下的命令讀取第一行并且將它賦值給變量strText，然后停止。strText = objTextFile.ReadLine

為了逐行讀取整個文件的內容，將 ReadLine 放在一個循環(huán)中。

ReadAll    Reads the entire contents of a text file into a variable.

Skip       跳過特定的數目的字符之后停止。例如，如下的命令面跳過前面的 12 字節(jié)，后操作都說從第 13 個字符開始。

objTextFile.Skip(12)

SkipLine   跳過一整行。例如，如下的代碼先讀第一行，然后讀取第三行。跳過了第二行

   strText = objTextFile.Readline

   objTextFile.SkipLine

   strText = objTextFile.Readline

 雖然在單獨的一個字符串中尋找東西是很簡單，但是不是要求特別快。用 ReadAll 方法在讀取近 6000 行的測試文件的時候，每秒鐘搜索大約 388kb。逐行讀取的話也會小于一分鐘的。

為了用 ReadAll 方法，打開一個文本文文件，然后調用 ReadAll 方法（不用參數的）例如在 4.38的腳本，打開文件C:\FSO\Scriptlog.txt，然后讀取文件的內容，蔣數據存儲在變量strContents 中，腳本然后回顯這個變量的值，就是回顯了文本文件的內容。

Listing 4.38 Reading a Text File Using the ReadAll Method

1 Const ForReading = 1

2 Set objFSO = CreateObject("Scripting.FileSystemObject")

3 Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", ForReading)

4 strContents = objFile.ReadAll

5 Wscript.Echo strContents

6 objFile.Close

Reading a Text File Line by Line

為了達到系統(tǒng)管理的目的，文本文件有的時候像一個扁平的上數據庫一樣的工作。每一行代表數據庫的一個紀錄。例如，腳本經常在文本文件中讀取服務器的名字，然后針對這些服務器來執(zhí)行操作。在這些情況下，文本文件看起來和下面這些差不多的：

atl-dc-01

atl-dc-02

atl-dc-03

atl-dc-04

當文本文件當做扁平數據庫的時候，腳本被用來讀取每個紀錄然后針對每個紀錄作一些工作。例如，一個腳本或許讀取第一個計算機名子，連接到它，實現一些功能。然后這個腳本讀取第二個計算機的名字，連接到它，然后實現同樣的功能。這個進程直到讀取完了所有的計算機名字，然后結束。 

ReadLine 方法可以讓你的腳本讀取文本文件中單個的行。為了這個方法，打開一個文本文件，然后用一個 Do Loop 循環(huán)直到文件的

AtEndOfStream 屬性為真。在這個循環(huán)中，調用ReadLine

方法，存儲第一行的內容到一個變量，然后作一些動作。當腳本執(zhí)行循環(huán)的時候，熱它自動丟棄第一行的內容讀取第二行的內容到這個變量。這個過程持續(xù)進行直到文件的結束。

例如，在 4.39 中的腳本打開文件 C:\FSO\Serverlist.txt 然后逐行讀取整個文件，將內容回顯在屏幕上：

Listing 4.39 Reading a Text File Using the ReadLine Method

1 Set objFSO = CreateObject("Scripting.FileSystemObject")

2   Set objFile = objFSO.OpenTextFile("C:\FSO\ServerList.txt", 1)

3   Do Until objFile.AtEndOfStream

4     strLine = objFile.ReadLine

5     Wscript.Echo strLine

6   Loop

7   objFile.Close

"Reading" a Text File from the Bottom to the Top

正如前面提到的，FSO 只能從文本文件的前面讀到后面，你不能從后面向前面讀。這個對于日志文件來說有一些問題，大部分的日志文件是按照日期格式來寫的，它的最開始的第一個日志被紀錄在第一行，第二個紀錄紀錄在第二行，依次類推。這就以為著你感興趣的事情，最新的日志往往在文件末尾。

有的時候你希望按照反日期的順序來顯示信息，就是最近的紀錄最先顯示，最舊的紀錄最后顯示。雖然你不能從后面先前的讀取文本文件，但是你要可以實現上面的目的，腳本必須： 

1. 創(chuàng)建一個數組來存儲文本文件的每行信息

2. 用 ReadLine 的方法讀取文本文件的每行信息，然后將每行的信息作為數組的一個獨立的元    素存儲在數組中。

3. 在屏幕上顯示數組的信息，從數組的最后面開始，向前顯示。

例如，在 4.40 中的腳本讀取文件 C:\FSO\Scriptlog.txt 的信息，然后將每行的信息作為數組

的一個元素存儲在數組 arrFileLine 中。在整個文件被讀了之后，從數組的最后一個開始回顯數組的信息。為了做到這點，用了一個 for

循環(huán)，從數組的最后一個元素，the upper bound of array 逐漸增長到第一個元素，the lower bound of array

1 Dim arrFileLines()

2     i = 0

3     Set objFSO = CreateObject("Scripting.FileSystemObject")

4     Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", 1)

5     Do Until objFile.AtEndOfStream

6      Redim Preserve arrFileLines(i)

7      arrFileLines(i) = objFile.ReadLine

8      i = i + 1

9     Loop

10    objFile.Close

11    For l = Ubound(arrFileLines) to LBound(arrFileLines) Step -1

12     Wscript.Echo arrFileLines(l)

13    Next

如果文件的內容和下面的一樣：

6/19/2002 Success

6/20/2002    Failure

6/21/2002    Failure

6/22/2002    Failure

6/23/2002    Success

那么在屏幕上回顯的信息如下:

6/23/2002 Success

6/22/2002     Failure

6/21/2002     Failure

6/20/2002     Failure

6/19/2002     Success

Reading a Text File Character by Character

在一些定寬的文本文件中，區(qū)域是受長度的限制的。第一個 field1 或許包含 15 個字節(jié)，第 2個 field 或許含有十個，依次類推。那么這樣的文件看起來和下面的差不多：

Server Value Status

atl-dc-0119345   OK

atl-printserver-02    00042  OK

atl-win2kpro-0500000   Failed

在有些情況下，你或許只是想獲得 values 的值或者只是想獲得 status 的信息。這個 value 的信息，容易表明。Values 總是從第 26

個字符開始，不超過 5 個字符。為了獲得這些值，你只需要獲得第 26,27,28,29,30 個字符的信息。

方法 Read 允許你讀取特定數目的字節(jié)。它的一個單獨的參數就是你要讀的字節(jié)的個數。例如，如下的腳本代碼示例，讀取后面的 7 個字節(jié)，并將讀取的值存給變量 strCharacters:

strCharacters = objFile.Read(7)

用 Skip 和 SkipLine 方法，你可以獲得文本文件中你選擇的特定字符。例如，在腳本 4.41 中只是讀取每行的第 6 個字節(jié)。為了做到這點，腳本必須：

1. 跳過每行前面五個字節(jié)用 Skip(5)

2. 用 Read(1)讀取第 6 個字節(jié)

3. 跳到下面一行。

Listing 4.41 Reading a Fixed-Width Text File

1   Set objFSO = CreateObject("Scripting.FileSystemObject")

2   Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", 1)

3   Do Until objFile.AtEndOfStream

4    objFile.Skip(5)

5    strCharacters = objFile.Read(1)

6    Wscript.Echo strCharacters

7    objFile.SkipLine

8   Loop

為了更好說明腳本是如何工作的，我們假設腳本文件 C:\FSO\Scriptlog.txt 看起來是如下的樣子的：

XXXXX1XXXXXXXXXXXXXX

XXXXX2XXXXXXXXXXXXXXXXXXX

XXXXX3XXXXXXXXXXXXx

XXXXX4XXXXXXXXXXXXXXXXXXXXXXXXX

對于這個文件的每行，前面的五個字符都是 x，第六個是數字，后面是隨機數量的 x。當腳本4.41 運行的時候，腳本會：

1. 打開文本文件從第一行開始讀起。

2. 跳過前面五個字符。

3. 用 Read 載方法讀取第六個字符

4. 回顯字符在屏幕上

5. 跳到下面一行重復上面的進程，直到腳本運行結束。.

Writing to Text Files

像文本文件中寫入數據是寫系統(tǒng)管理腳本的另外一個強大的功用。文本文件提供了一種方法可以讓你將腳本獲得的輸入存儲在其中。輸入可以替代現有的文字或者是添加到現有的文字后面。文本文文件也可以紀錄腳本的執(zhí)行情況。這個對于debug 腳本來說費城有用。將腳本的執(zhí)行紀錄放在一個文本文件中，你可以過陣子來察看這個日志去決定腳本實際執(zhí)行了哪些而哪些沒有執(zhí)行。FSO 給你提供了向文本文件中寫如數據的能力。為了用 FSO 腳本向一個文本文件中寫入數據，你必須：

1. 創(chuàng)建一個 FSO 對象實例。

2. 用 OpenTextFile 方法打開這個文本文件，你可以以兩種方法打開：

For writing (parameter value 2, constant = ForWriting).

在這個模式下，寫入新的數據會覆蓋舊的數據。（舊的數據會被刪除，新的數據添加上去。）

用這個模式，是將存在的文件換上新的內容。

For appending (parameter value 8, constant = ForAppending).

在這種模式下，數據寫在原來文件的末尾。用這種模式向現有的文件中添加數據。

3. 用或者 Write,WriteLine,WriteBlankLine 方法來向文本文件中寫入數據。

4. 關閉文本文件

向文本文件中寫數據的三種方法在表格 4.9 中：

Table 4.9 Write Methods Available to the FileSystemObject

Method Description

Write 向文本文件中寫入數據，不是添加文件到末尾。不會自動換行。

例如，如下代碼寫入兩個單獨的字符串：

objFile.Write ("This is line 1.")

objFile.Write ("This is line 2.")

MethodDescription

返回的數據類似如下：

This is line 1.This is line 2.

WriteLine   向文本文件中寫入數據后添加一個換行符號，然后區(qū)自動換行的。

比如，如下的代碼：

objFile.WriteLine ("This is line 1.")

objFile.WriteLine ("This is line 2.")

結果輸出的信息如下：

This is line 1.

This is line 2.

WriteBlankLines 向文本文件中寫入特定數目空白的行。例如如下的代碼向文本文件中寫入兩行獨立的文字，然后用空白的行分開：

objFile.Writeline ("This is line 1.")

objFile.WriteBlankLines(1)

objFile.Writeline ("This is line 2.")

輸出的結果如下：

This is line 1.

This is line 2.

除了在表格 4.9 中的方法之外，VB 腳本提供了常量 VbTab 來向文本文件中寫入。VbTab

向兩個字符中插入一個空格。為了創(chuàng)建一個空格分隔的文件，代碼和下面的類似：

objTextFile.WriteLine(objService.DisplayName & vbTab & objService.State)

FSO 的一個弱點就是它不能直接修改特定的行的信息。你不能寫類似下面的命令：跳過到第五行，更改一些數據，然后保存成新的文件。為了修改在一個十行文件中的第五行，你的腳本必須

 1. .讀取整個 10 行

2. .將 1-4 行寫回文件。

3. 寫入修改好的第五行的內容。

4. 寫入第 6 行到第 10 行的內容。

Overwriting Existing Data

在系統(tǒng)管理中，簡潔是一種美德。例如，假如你的腳本每天晚上運行，在你的 DC 上從事件日志中獲得日志，將這些事件寫入數據庫中，紀錄哪個計算機可以成功的連接到，哪個不可以?；谝恍v史的目的，你或許希望跟蹤明年一整年的所有成功和失敗的紀錄。這個對于腳本剛開始生效和網絡不穩(wěn)定的情況下來說，都是非常重要的。從另外的情況來說，你或許只是希望剛才腳本運行的時候發(fā)生了什么。換句話說說，你不是希望要一個日志中過去的 365 天的信息，而是要距離最近的信息。它讓你可以很快的打開文件并且查找看腳本是否按照計劃的運行。

當你的文本文件用 ForWriting 模式打開的，任何寫入的新的數據會替代原來存在的文件。例如，假如你的文本文件里面存儲了整個莎士比亞的故事全集，但是你用腳本以 ForWriting 模式打開了這個文本，并且向里面寫了一個字母 a，那么當你的這個文件寫完關閉之后，它就只是包含一個字母 a，原來的數據就全部丟失了。

這個腳本以 ForWriting 模式打開腳本 C:\FSO\Scriptlog.txt 然后將當前的日期和時間寫入文件。每當腳本運行的時候，舊的時間和日期被新的取代，這個文本文件就永遠只是有單獨的一個日期的值。

Listing 4.42 Overwriting Existing Data

1 Const ForWriting = 2

2 Set objFSO = CreateObject("Scripting.FileSystemObject")

3 Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", ForWriting)

4 objFile.Write Now

5 objFile.Close

Appending New Data to Existing Data

許多腳本被設計成為在特定的時間間隔的時候運行，收據數據，保存數據。這些腳本的是用來分析趨勢或者在過去的時間內部的使用情況。在這些情況下，你就不希望刪除現在存在的數據而去替代成新的數據。 

例如，假如你用你的腳本監(jiān)視進程使用量。在任何一個時間點上，進程的使用量應該是在 0 到100 之間的一個值，對于它自己來說，單個的值沒有什么意義。為了獲得進程使用的一個完整的圖景，你需要重復不斷的監(jiān)視使用情況并紀錄它的值。如果你的進程在每幾秒鐘之內返回的數據是9%,17%,92%,90%,79%,88%,91%那么你的進程使用是非常高的。這個就可以對比出這個時間內的使用情況。

 如果以 ForAppending 的模式打開一個文件，你可以使數據不是覆蓋現有的數據，它的數據是添加到文件的底部。例如，在 4.43 中的腳本打開一個文本文件，并且將當前的日期和時間寫入文件。因為是以 ForAppending

的模式打開的文件，當前的日期會卸載文件的底部。如果你在不同的時候分別運行腳本，你的腳本結束時候大約如下面的信息： 

6/25/2002 8:49:47 AM

6/25/2002 8:49:48 AM

6/25/2002 8:50:33 AM

6/25/2002 8:50:35 AM

Listing 4.43 Appending Data to a Text File

1 Const ForAppending = 8

2 Set objFSO = CreateObject("Scripting.FileSystemObject")

3 Set objFile = objFSO.OpenTextFile("C:\FSO\ScriptLog.txt", ForAppending)

4 objFile.WriteLine Now

5 objFile.Close

上面的腳本用 WriteLine 方法寫入數據保證每個日期都是獨占一行的。如果這個腳本用 Write

的方法來寫的話，那么這個腳本運行結束的時候，數據寫在一起，如下的樣子：

6/25/2002 8:49:47 AM6/25/2002 8:49:48 AM6/25/2002 8:50:33 AM6/25/2002 8:50:35 AM

腳本經常用來從外面的源獲得信息，例如從文本文件或者數據庫文件。在這些信息獲得之后，它將被存儲到它的內存中，然后用腳本來更改它。例如將信息存儲在一個變量中，或者存儲在一個數組中。同樣，這些信息可以存儲在Dictionary 對象中。Dictionary 就好象一個數組一樣。不同的是，它用叫做鍵對(key-item pairs)來存儲信息，而數組用數字值來存儲。例如，一個一維的數組存儲州的首府像下面這樣：

0 - Olympia

1 - Salem

2 - Sacramento

于其相反，Dictionary 存儲信息像如下的格式：

Washington – Olympia

Oregon - Salem

California - Sacramento

如果你的命令行只是要求輸入一個參數，比如計算機名字，你可以用數組來完成這樣的工作。但是，Dictionary 提供了比數組更加多的功能。特別指出的是，Dictionary 不要求一個腳本確定需要存儲的元素的數目。在數組中，你必須確定數組的大小，或者當添加數據的時候重新變更數組的大小。知道每個值對應的 index。在Dictionary 中，值可以通過 key 或者 item 自身來訪問。

這樣，當管理員用腳本從外部獲得信息，比如獲得計算機的名字，然后存儲在內存中以備使用的時候，Dictionary 就成了一個理想的工具。

Creating a Dictionary

因為 Dictionary 是一個 COM 對象，你必須用其它的 COM 對象那樣去初始化它。如下的代碼創(chuàng)建一個 Dictionary 對象。

Set objDictionary = CreateObject("Scripting.Dictionary")

當創(chuàng)建完了一個 Dictionary 對象之后，你可以配置 Dictionary 的屬性或者向其內部添加元素。

Configuring Dictionary Properties

Dictionary 只有一個配置的屬性，CompareMode,它對于要添加哪個 KEY 或者不能添加哪個 KEY起著非常重要的作用。（檢查 key 是否存在在 Dictionary 中也是十分重要的）默認的情況下，Dictionary 是被創(chuàng)建成二進制模式，基于 ASCII 的值。知道這個很重要，因為在ASCII 中，大寫和小寫字符是不同的。在二進制中，如下的兩個服務可以同時被添加進來：

alerter

ALERTER

換句話說，在二進制模式下，你可能因為大小寫不同而添加進來很多個同樣的 item。這樣就難于搜索了。如果你想查找 Alerter 這個KEY，你可能得到它不存在，因為沒有和它大小寫完全一樣的值。這樣你可能向一個 Dictionary 添加同樣的 item。當一個 Dictionary 被配置成text 模式的時候，大小寫被認為是一樣的，這樣可以除去同樣的 key，你的 Dictionary 如果存在 alerter 的話，你就不能向其中添加另外一個叫做 ALERTER 的 key。無論你搜索 alerter 還是 ALERTER，都會找到叫做 Alerter 的 key。

為了配置 Dictionary 的模式，首先創(chuàng)建一個 Dictionary 對象實例，然后配置它的屬性為如下的值：

0－設置成為二進制模式，這個是默認選項。

1 – 設置成 text 模式。

例如，如下的 4.44 的腳本設置 Dictionary 成 text 模式：

Listing 4.44 Configuring the Dictionary Object

1 Const TextMode = 1

2   Set objDictionary = CreateObject("Scripting.Dictionary")

3   objDictionary.CompareMode = TextMode

在 Dictionary 有任何元素的時候，你不能更改 Dictionary 的 CompareMode 屬性。這是因為，二進制允許大小寫的區(qū)分，例如，如下的

keys 每個代表了不同 key，因為 Dictionary 是基于二進制格式的：

apple

Apple

APPLE

在 text 模式下，這些 keys 是一致的。如果你將這些元素存儲在二進制格式，那么沒有什么問題，但是存儲在 text 模式下的時候，Dictionary

就突然之間有三個同樣的 keys，它就會失敗了。

如果你想配置 Dictionary 的模式，那么事先移走 Dictionary 中所有的元素。

Adding Key-Item Pairs to a Dictionary

在創(chuàng)建了 Dictionary 對象實例之后，你可以用 add 方法向 Dictionary 添加 key-item 對。Add方法需要兩個參數，必須按照如下順序并且用逗號分開：  Key name ,   Item value

例如，在腳本 4.45 中，創(chuàng)建了一個 Dictionary 對象，然后添加一些類似于表格 4.10 中的key-item 對。

Table 4.10 Sample Key-Item Pairs

Key Item

Printer 1 Printing

Printer 2Offline

Printer 3Printing

Listing 4.45 Adding Key-Item Pairs to a Dictionary

1   Set objDictionary = CreateObject("Scripting.Dictionary")

2   objDictionary.Add "Printer 1", "Printing"

3   objDictionary.Add "Printer 2", "Offline"

4   objDictionary.Add "Printer 3", "Printing"

Dictionary 的 key 必須是唯一的。例如，如下的兩個語句會產生一個運行的錯誤出來。在第一行被編譯之后，叫做 printer 1 的 key 已經存在于 Dictionary 中了：

objDictionary.Add "Printer 1", "Printing"

objDictionary.Add "Printer 1", "Offline"

 Inadvertently Adding a Key to a Dictionary

使用 Dictionary 對象的一個潛在的問題是，你如果去訪問一個在 Dictionary 中不存在的元素的時候，它不產生一個錯誤，而是將這個不存在的元素添加到 Dictionary 中去了?？聪旅娴哪_本示例，它創(chuàng)建了一個

Dictionary，添加了三對 key-item，然后嘗試去回顯不存在的item,printer 4:

Set objDictionary = CreateObject("Scripting.Dictionary")

objDictionary.Add "Printer 1", "Printing"

objDictionary.Add "Printer 2", "Offline"

objDictionary.Add "Printer 3", "Printing"

Wscript.Echo objDictionary.Item("Printer 4")

當腳本嘗試去回顯不存在的 item 的時候，沒有任何運行錯誤發(fā)生，而是創(chuàng)建了一個新的 key，printer 4，并被添加到了 Dictionary 中，它的對象的 item 的值是 null。

為了避免這樣的錯誤發(fā)生，在訪問 item 的值的時候，去檢查它是否存在。

Manipulating Keys and Items in a Dictionary

作為 Dictionary 本身而言，它的用途很少。一個 Dictionary 只有在訪問它的 item,列舉它的item，或者修改它的 item 的時候，才變得有用。在你創(chuàng)建了一個 Dictionary 之后，你可能作如下的一些事情：

確定在這個 dictionary 中有多少對 key-item 對列舉出在 dictionary 的 keys 和或者 item。

決定在 Dictionary 是否存在特定的 key修改在 Dictionary 中的 key 或者 item 的值從 Dictionary 中移除特定 key-item 對。

所有這些任務都可以通過在 RunTime Library 中提供的屬性方法來實現。

Determining the Number of Key-Item Pairs in a Dictionary

和其它的許多集合一樣，Dictionary 有一個 count 屬性用來返回在這個集合中的 key-item 對的數量。在腳本 4.46 中創(chuàng)建了是個

Dictionary 對象，然后添加三個 key-item 對，回顯這個Dictionary 的 count 屬性的值。

Listing 4.46 Determining the Number of Key-Item Pairs in a Dictionary

1  Set objDictionary = CreateObject(“Scripting.Dictionary”)

2    objDictionary.Add “Printer 1”, “Printing”

3    objDictionary.Add “Printer 2”, “Offline”

4    objDictionary.Add “Printer 3”, “Printing”

5    Wscript.Echo objDictionary.Count

當腳本運行的時候，會顯示一個值 3

Enumerating Keys and Items in a Dictionary

Dictionary 被設計成用來暫時的存儲信息。任何存在 Dictionary

中的信息都是作為臨時用的，沒有用來長期存儲的。它一般是用來臨時放信息，然后在腳本中在重新調用他們。例如，你有個存儲了服務器名稱清單的Dictionary，然后在后面的腳本中連到這些服務器上，并且獲得相應的信息。結果是，你每次連接到一個服務器的時候，你都必須去調用 Dictionary中的信息。

Keys items 的方法可以用來返回他們的組成集合，或者的單獨的返回或者全部返回在Dictionary 中的 item-key 的信息。在你用了其中的一個方法之后，你可以用 For Each 循環(huán)列舉除在數組中所有的 key-item。

例如在 4.47 中的腳本創(chuàng)建一個簡單的 Dictionary，添加三對 keys-item，在這個 Dictionary 創(chuàng)建結束之后，腳本用 keys 方法來列舉出所有的 keys，然后用 items 方法來返回所有的 items

Listing 4.47 Enumerating Keys and Items in a Dictionary

1    Set objDictionary = CreateObject("Scripting.Dictionary")

2    objDictionary.Add "Printer 1", "Printing"

3    objDictionary.Add "Printer 2", "Offline"

4    objDictionary.Add "Printer 3", "Printing"

5

6    colKeys = objDictionary.Keys

7    For Each strKey in colKeys

8    Wscript.Echo strKey

9    Next

10

11   colItems = objDictionary.Items

12   For Each strItem in colItems

13   Wscript.Echo strItem

14   Next

當腳本在 CScript 下運行的時候，命令行的信息如下：

Printer 1

Printer 2

Printer 3

Printing

Offline

Printing

為了顯示特定的 item 的值，用 item 方法，例如，如下的代碼語句顯示了 key 是 printer 3 的item 的值：

Wscript.Echo objDictionary.Item("Printer 3")

Verifying the Existence of a Specific Key

Dictionary 的一個比數組更加優(yōu)秀和標準的優(yōu)點是你可以快速的找到特定的 key 是否存在。例如，假如你有一定的文件 list 安裝在一個計算機上，并且你向搜索這個 list，來保證特定的dll文件已經安裝了。你用集合或者數組，除非你系統(tǒng)的搜索整個數組否則你沒有方法來確定特定的一個文件是否存在了。但是用 Dictionary 你可以 Exists 方法來檢查給定的 key 是否存在。用Exists 方法只是需要一個參數，（需要查詢的 key 的名字），然后返回一個 Boolean 的值，如果是真的值，表明這個 key 存在，如果是否，則不存在。

例如，在腳本 4.48 中創(chuàng)建一個 Dictionary 對象，添加三對元素，然后腳本檢查叫做 key 的關鍵詞是否存在，并且回顯其結果。

Listing 4.48 Verifying the Existence of a Dictionary Key

1 Set objDictionary = CreateObject("Scripting.Dictionary")

2   objDictionary.Add "Printer 1", "Printing"

3   objDictionary.Add "Printer 2", "Offline"

4   objDictionary.Add "Printer 3", "Printing"

5   If objDictionary.Exists("Printer 4") Then

6   Wscript.Echo "Printer 4 is in the Dictionary."

7   Else

8   Wscript.Echo "Printer 4 is not in the Dictionary."

9   End If

當腳本運行的時候，會有 printer 4 is not in the Dictionary 的消息出現在屏幕上.

Modifying an Item in a Dictionary

添加到 Dictionary 中的 item 不是一成不變的，事實上，你可以在任何的時間去更改它。這個功能可以讓你紀錄腳本的運行情況。例如，你的Dictionary 是個關于服務器名稱的列表區(qū)，每次你的腳本對應的服務器運行結束之后，你可以更改它對應的 item 值來標識它的狀態(tài)。在腳本中止之前，你可以將狀態(tài)列出來看腳本運行成功與否的。在 4.49 中的腳本創(chuàng)建了一個具有三個 keys 的 Dictionary，這三個key 分貝為 atl-dc-01,atl-dc-02,atl-dc-03，每個的 item 都是設置成 no status，這個表明針對這個服務器的狀態(tài)信息還沒有獲得。然后回顯他們的 item的信息。

在這個 Dictionary 被創(chuàng)建之后，用 item 方法以 key 作為參數更改這些 item 的值。例如，如下的腳本代碼語句更改 key  atl-dc-01 的 item 為 available::

objDictionary.Item("atl-dc-01") = "Available"

在這三個 items 的值被更改了之后，新的 item 被回顯出在屏幕上：

Listing 4.49 Modifying the Value of a Dictionary Item

1Set objDictionary = CreateObject("Scripting.Dictionary")

2objDictionary.Add "atl-dc-01", "No status"

3objDictionary.Add "atl-dc-02", "No status"

4objDictionary.Add "atl-dc-03", "No status"

5

6colKeys = objDictionary.Keys

7For Each strKey in colKeys

8Wscript.Echo strKey, objDictionary.Item(strKey)

9Next

10

11    objDictionary.Item("atl-dc-01") = "Available"

12    objDictionary.Item("atl-dc-02") = "Available"

13    objDictionary.Item("atl-dc-03") = "Unavailable"

14

15    colKeys = objDictionary.Keys

16    For Each strKey in colKeys

17    Wscript.Echo strKey, objDictionary.Item(strKey)

18    Next

當在 Cscript 下運行這個的時候，命令行中的信息如下：

atl-dc-01 No status

atl-dc-02 No status

atl-dc-03 No status

atl-dc-01 Available

atl-dc-02 Available

atl-dc-03 Unavailable

Removing Key-Item Pairs from a Dictionary

Key-item 對也可以從 Dictionary 中移走，Script Runtime Library 提供了移走 key-item 對的兩種方法：

   RemoveAll, 移走所有的 key-item 對

   Remove, 從 Dictionary 移走特定的 key-item 的值。

 Removing All Key-Item Pairs from a Dictionary

你或許有一些腳本，比如監(jiān)視的腳本，作著同樣的動作，將信息存在一個 Dictionary 中，然后要么在屏幕上顯示這些信息，要么將這些信息存儲在文本文件中或者數據庫中。然后，腳本停止幾分鐘，收集更新了之后的信息，就這樣不確定的進行下去了。

如果你用 Dictionary 來作為臨時的數據存儲收集信息數據，你可能希望在收取新的信息之前清空 Dictionary 的內容。為了做到這點，你可以用方法RemoveAll 來移走所有的 Dictionary中的 key-item 對。例如，在 4.50 中的腳本創(chuàng)建了一個含有三個元素的 Dictionary，然后顯示 Dictionary 的 keys，腳本用 RemoveAll 方法移走所有的 key-item對，Dictionary.RemoveAll 為了檢查元素是否被移走，在此回顯 Dictionary 中 key 的信息Listing 4.50 Removing All the Key-Item Pairs in a Dictionary

1    Set objDictionary = CreateObject("Scripting.Dictionary")

2    objDictionary.Add "Printer 1", "Printing"

3    objDictionary.Add "Printer 2", "Offline"

4    objDictionary.Add "Printer 3", "Printing"

5    colKeys = objDictionary.Keys

6    Wscript.Echo "First run: "

7    For Each strKey in colKeys

8Wscript.Echo strKey

9    Next

10   objDictionary.RemoveAll

11   colKeys = objDictionary.Keys

12   Wscript.Echo VbCrLf & "Second run: "

13   For Each strKey in colKeys

14    Wscript.Echo strKey

15   Next

當腳本在 CScript 運行的時候，如下的信息顯示在命令行中。和你看見的一樣，第二次輸出的時候是空的，因為 Dictionary 已經沒有任何的 keys 了。

First run:

Printer 1

Printer 2

Printer 3

Second run:

Removing a Specific Key-Item Pair from a Dictionary

和移走所有的 key-item 對不同，你有的時候可能向移走一個單獨的 key 和item。例如，假如你的腳本來從一系列的計算機上獲得時間日志。腳本被設計成嘗試聯(lián)系每個計算機跟蹤每個成功和失敗。如果不能連接到計算機上，腳本嘗試重新連接，知道連接到計算機并獲得所有的日志信息。在這個假想的情況下，可能你的

Dictionary 中有如下的 keys：

atl-dc-01

atl-dc-02

atl-dc-03

atl-dc-04

atl-dc-05

當腳本運行的時候，它可能不能連接到計算機

atl-dc-03,atl-dc-04，在這種情況下，腳本去嘗試重新連接這些計算機。但是腳本怎么知道哪個計算機需要連接，哪個不需要那？

一個解決的辦法就是簡單的移走已經成功連接的計算機。在第一段腳本被編譯結束之后，那這個Dictionary 中只是包含如下的元素：

atl-dc-03

atl-dc-04

一旦一個計算機連接成功，就從 Dictionary 中移走這個元素，這樣，如果 Dictionary 中不再含有任何元素的時候，那么所有的計算機就都連接成功了，腳本運行結束了。

為了移走單個的元素，用 Remove 方法，輸入 key 的名字作為唯一的參數。例如如下的腳本語句移走了 key 為 atl-dc-02 的 key 和它對應的item。

objDictionary.Remove("atl-dc-02")

在 4.51 中的腳本創(chuàng)建一個有三個元素的 Dictionary 對象，回顯所有的 keys。然后移走 key為 printer 2 的 key 和它的item，然后再次回顯 Dictionary 的 keys：

Listing 4.51 Removing a Specified Key-Item Pair from a Dictionary

1    Set objDictionary = CreateObject("Scripting.Dictionary")

2    objDictionary.Add "Printer 1", "Printing"

3    objDictionary.Add "Printer 2", "Offline"

4    objDictionary.Add "Printer 3", "Printing"

5    colKeys = objDictionary.Keys

6    Wscript.Echo "First run: "

7    For Each strKey in colKeys

8Wscript.Echo strKey

9    Next

10   objDictionary.Remove("Printer 2")

11   colKeys = objDictionary.Keys

12   Wscript.Echo VbCrLf & "Second run: "

13   For Each strKey in colKeys

14    Wscript.Echo strKey

15   Next

當腳本在 CScript 運行的時候，在命令行中顯示如下：

First run:

Printer 1

Printer 2

Printer 3

Second run:

Printer 1

Printer 3

在第二段腳本編譯的末尾，printer 2 已經不再存在于 Dictionary 中了。