{"id":17991,"date":"2010-06-21T00:01:00","date_gmt":"2010-06-21T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2010\/06\/21\/hey-scripting-guy-how-can-i-count-the-words-in-a-bunch-of-microsoft-word-documents\/"},"modified":"2010-06-21T00:01:00","modified_gmt":"2010-06-21T00:01:00","slug":"hey-scripting-guy-how-can-i-count-the-words-in-a-bunch-of-microsoft-word-documents","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-how-can-i-count-the-words-in-a-bunch-of-microsoft-word-documents\/","title":{"rendered":"Hey, Scripting Guy! How Can I Count the Words in a Bunch of Microsoft Word Documents?"},"content":{"rendered":"

<\/p>\n

\"Bookmark<\/a><\/p>\n

 <\/p>\n

\"Hey,<\/p>\n

Hey, Scripting Guy! I need to be able to use Windows PowerShell 2.0 to count the number of words in a bunch of Microsoft Word documents. All of the documents are stored in a specific folder, but there are a mixture of Microsoft Word 2010 and Microsoft Word 2007 documents and older document types in the same folder. Our company has recently opened an office in South America, and we need to have these documents translated into Spanish. To obtain a quotation from the translation service, I need to tell them how many words are contained in the documents. <\/p>\n

If it were just a few documents, I would perform this action manually, but there are a lot of files. I am a Human Resources (HR) manager, and not a real IT pro. I have been reading the Hey, Scripting Guy! posts for years not only because you are funny, but also because scripting makes me a more efficient power user. I have searched the Internet, but have not found a script that will do this. Help me, Scripting Guy! Help!. <\/p>\n

— AS<\/p>\n

 <\/p>\n

\"Hey,<\/p>\n

Hello AS, <\/p>\n

Microsoft Scripting Guy Ed Wilson here. I was out and about this morning, and stopped by to see my friend who owns a scuba shop. He loves to read, and we swap books from time to time. After discussing the merits of various translations of the Three Musketeers, we got down to talking about scuba diving. He is planning a trip to Cozumel, Mexico, in the next few weeks, and he is really looking forward to the trip. I went with his group on the last trip. Sadly, ear problems have me grounded for now and I am going to miss this trip. The diving down there is awesome with visibility that extends for more than 100 feet and water that is around 82 degrees or so this time of year. In addition to some excellent drift diving, there are also some really nice coral formations with white sand and friendly sea creatures such as the giant grouper seen here.<\/p>\n

\"Photo<\/a> <\/p>\n

AS, per your request, I wrote the CountNumberOfWordsInDocuments.ps1 script that you described in your email message. The script will retrieve the number of words in documents that are in one or more folders. To use the CountNumberOfWordsInDocuments.ps1 script, you will need to modify the path to the folder. The complete script is shown here. <\/p>\n

CountNumberOfWordsInDocuments.ps1<\/strong><\/p>\n

$intDocs = $intWords = $null
$path = “C:\\data\\ScriptingGuys”
$application = New-Object -ComObject word.application
$application.visible = $false
Get-ChildItem -Path $path -include *.doc,*.docx -Recurse |
ForEach-Object {
“Processing $($_.fullname)”
$document = $application.documents.open($_.fullname)
$intWords += $document.words.count
$intDocs ++
$document.close() | out-null
}
$application.quit()
$application = $null
[gc]::collect()
[gc]::WaitForPendingFinalizers()
“There are $intDocs documents in the $path folder.
They contain a total of $intWords words.”<\/span><\/p>\n

The first thing that needs to be done is to initialize a few variables. The first two variables, $intDocs<\/b> and $intWords<\/b>, are counter variables that are used to keep track of the number of documents processed and the number of words that those documents contain. Because it is possible you may wish to run the script more than once, it is a best practice to initialize those variables. The easiest way to do this is to set them equal to $null<\/b>—<\/b>each time the script runs, if the variable exists it will be assigned the value $null<\/b>. If the variable does not exist, it will be created and assigned the value of $null<\/b>. I love the “equals equals” type of syntax because it is a quick and efficient way of initializing multiple variables. For example, if I had three variables $a<\/b>, $b<\/b>, and $c<\/b> that I wanted to initialize with the value of 1, I could do it as shown here. Notice that if a variable does not exist, such as $d<\/b> in this example, no value is displayed. <\/p>\n

PS C:\\> $a=$b=$c=1
PS C:\\> $a
1
PS C:\\> $b
1
PS C:\\> $c
1
PS C:\\> $d
PS C:\\><\/span><\/p>\n

In addition to initializing the counter variables, I also assign a value for the path that contains all of the document files. This folder, which is shown in the following image, contains a large number of subfolders and sub-subfolders. This portion of the script is shown here:<\/p>\n

$intDocs = $intWords = $null
$path = “C:\\data\\ScriptingGuys”<\/span><\/p>\n

\"Image<\/a> <\/p>\n

The next thing we must do is create the word.application<\/b> object. The application<\/b> object for Microsoft Word is created whenever a script needs to perform automation. This object is used when working with the Microsoft Word application, and therefore has a number of methods and properties that perform things such as opening documents, closing the application, sizing the window, or even creating a list of keyboard shortcuts for Microsoft Word (something we will look at on Wednesday this week). <\/p>\n

$application = New-Object -ComObject word.application<\/span> <\/p>\n

After the word.application<\/b> object has been created and stored in the $application<\/b> variable, the visible<\/b> property is set to $false<\/b>. This will prevent the application from appearing while each document is opened and the number of words counted. The only thing to remember when setting the application<\/b> object to not visible<\/b> is that the quit<\/b> method must be called to ensure that dozens of copies of Winword.exe are not left running and eating up resources. At 50–70 megabytes of memory each, it does not take too long before leftover processes begin to impact performance. By not requiring Microsoft Word to be visible and to display each document as it is processed, the script will run significantly quicker. This line of code is shown here:<\/p>\n

$application.visible = $false<\/span><\/p>\n

The Get-ChildItem<\/b> cmdlet is used to retrieve all the document files in one or more folders that are specified in the $path<\/b> variable. The –recurse<\/b> parameter is used to include the directory and subdirectories. Each system.io.fileinfo<\/b> object that is retrieved by the Get-ChildItem<\/b> cmdlet is piped to the Foreach-Object<\/b> cmdlet. Because Windows PowerShell passes objects instead of text, each Microsoft Word document that is discovered by the Get-ChildItem<\/b> is represented by an instance of the system.io.fileinfo<\/b> .NET Framework class. The members of this class are shown here:<\/p>\n

<\/span><\/p>\n

PS C:\\> Get-Item C:\\fso\\HSG-6-1-10.Doc | get-member <\/p>\n

   <\/span>TypeName: System.IO.FileInfo <\/p>\n

Name                      <\/span>MemberType     <\/span>Definition
—-                      <\/span>———-     <\/span>———-
Mode                      <\/span>CodeProperty   <\/span>System.String Mode{get=Mode;}
AppendText                <\/span>Method         <\/span>System.IO.StreamWriter AppendText()
CopyTo                    <\/span>Method         <\/span>System.IO.FileInfo CopyTo(string destFil…
Create                    <\/span>Method         <\/span>System.IO.FileStream Create()
CreateObjRef              <\/span>Method         <\/span>System.Runtime.Remoting.ObjRef CreateObj…
CreateText                <\/span>Method         <\/span>System.IO.StreamWriter CreateText()
Decrypt                   <\/span>Method         <\/span>System.Void Decrypt()
Delete                    <\/span>Method         <\/span>System.Void Delete()
Encrypt                   <\/span>Method         <\/span>System.Void Encrypt()
Equals                    <\/span>Method         <\/span>bool Equals(System.Object obj)
GetAccessControl          <\/span>Method         <\/span>System.Security.AccessControl.FileSecuri…
GetHashCode               <\/span>Method         <\/span>int GetHashCode()
GetLifetimeService        <\/span>Method         <\/span>System.Object GetLifetimeService()
GetObjectData             <\/span>Method         <\/span>System.Void GetObjectData(System.Runtime…
GetType                   <\/span>Method         <\/span>type GetType()
InitializeLifetimeService Method         <\/span>System.Object InitializeLifetimeService()
MoveTo                    <\/span>Method         <\/span>System.Void MoveTo(string destFileName)
Open                      <\/span>Method         <\/span>System.IO.FileStream Open(System.IO.File…
OpenRead           <\/span>       <\/span>Method         <\/span>System.IO.FileStream OpenRead()
OpenText                  <\/span>Method         <\/span>System.IO.StreamReader OpenText()
OpenWrite                 <\/span>Method         <\/span>System.IO.FileStream OpenWrite()
Refresh                   <\/span>Method         <\/span>System.Void Refresh()
Replace                   <\/span>Method         <\/span>System.IO.FileInfo Replace(string destin…
SetAccessControl          <\/span>Method         <\/span>System.Void SetAccessControl(System.Secu…
ToString                  <\/span>Method         <\/span>string ToString()
PSChildName      <\/span>         <\/span>NoteProperty   <\/span>System.String PSChildName=HSG-6-1-10.Doc
PSDrive                   <\/span>NoteProperty   <\/span>System.Management.Automation.PSDriveInfo…
PSIsContainer             <\/span>NoteProperty   <\/span>System.Boolean PSIsContainer=False
PSParentPath              <\/span>NoteProperty   <\/span>System.String PSParentPath=Microsoft.Pow…
PSPath                    <\/span>NoteProperty   <\/span>System.String PSPath=Microsoft.PowerShel…
PSProvider                <\/span>NoteProperty   <\/span>System.Management.Automation.ProviderInf…
Attributes                <\/span>Property       <\/span>System.IO.FileAttributes Attributes {get…
CreationTime              <\/span>Property       <\/span>System.DateTime CreationTime {get;set;}
CreationTimeUtc           <\/span>Property       <\/span>System.DateTime CreationTimeUtc {get;set;}
Directory                 <\/span>Property   <\/span>    <\/span>System.IO.DirectoryInfo Directory {get;}
DirectoryName             <\/span>Property       <\/span>System.String DirectoryName {get;}
Exists                    <\/span>Property       <\/span>System.Boolean Exists {get;}
Extension                 <\/span>Property       <\/span>System.String Extension {get;}
FullName                  <\/span>Property       <\/span>System.String FullName {get;}
IsReadOnly                <\/span>Property       <\/span>System.Boolean IsReadOnly {get;set;}
LastAccessTime            <\/span>Property       <\/span>System.DateTime LastAccessTime {get;set;}
LastAccessTimeUtc         <\/span>Property       <\/span>System.DateTime LastAccessTimeUtc {get;s…
LastWriteTime             <\/span>Property       <\/span>System.DateTime LastWriteTime {get;set;}
LastWriteTimeUtc          <\/span>Property       <\/span>System.DateTime LastWriteTimeUtc {get;set;}
Length               <\/span>     <\/span>Property       <\/span>System.Int64 Length {get;}
Name                      <\/span>Property       <\/span>System.String Name {get;}
BaseName                  <\/span>ScriptProperty System.Object BaseName {get=if ($this.Ex…
VersionInfo               <\/span>ScriptProperty System.Object VersionInfo {get=[System.D…<\/span><\/span><\/span><\/p>\n<\/p>\n

 <\/p>\n

Inside the Foreach-Object<\/b> cmdlet, the members (both methods and properties) are available to use in processing each Microsoft Word document that has been discovered. In this script, I only need to use the fullname<\/b> property because it contains the path, the file name, and the file extension. There are four properties I routinely use when working with files: fullname<\/b>, name<\/b>, basename<\/b>, and extension<\/b>. By using the proper property from a system.io.fileinfo<\/b> object, it simplifies a number of string concatenation and string splitting issues that used to arise when working in VBScript. Each property is illustrated here:<\/p>\n

PS C:\\> (Get-Item C:\\fso\\HSG-6-1-10.Doc).fullname
C:\\fso\\HSG-6-1-10.Doc
PS C:\\> (Get-Item C:\\fso\\HSG-6-1-10.Doc).name
HSG-6-1-10.Doc
PS C:\\> (Get-Item C:\\fso\\HSG-6-1-10.Doc).basename
HSG-6-1-10
PS C:\\> (Get-Item C:\\fso\\HSG-6-1-10.Doc).extension
.Doc
PS C:\\><\/span><\/p>\n

To make it easier to keep track of these four properties, I decided to include them in Table 1. <\/p>\n

Table 1: Useful FileInfo properties<\/strong> <\/p>\n\n\n\n\n\n\n\n
\n

Property name<\/b><\/p>\n<\/td>\n

\n

Meaning<\/b><\/p>\n<\/td>\n

\n

Example<\/b><\/p>\n<\/td>\n<\/tr>\n

\n

fullname<\/p>\n<\/td>\n

\n

Path, filename and extension<\/p>\n<\/td>\n

\n

C:\\fso\\HSG-6-1-10.Doc<\/p>\n<\/td>\n<\/tr>\n

\n

name<\/p>\n<\/td>\n

\n

Filename and extension<\/p>\n<\/td>\n

\n

HSG-6-1-10.Doc<\/p>\n<\/td>\n<\/tr>\n

\n

basename<\/p>\n<\/td>\n

\n

Filename<\/p>\n<\/td>\n

\n

HSG-6-1-10<\/p>\n<\/td>\n<\/tr>\n

\n

extension<\/p>\n<\/td>\n

\n

Extension<\/p>\n<\/td>\n

\n

.Doc<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The section of the script that retrieves the Office 2007 and later Microsoft Word documents (.docx extension) and the legacy Microsoft Word documents (.doc extension) is shown here:<\/p>\n

Get-ChildItem -Path $path -include *.doc,*.docx -Recurse |
ForEach-Object {
“Processing $($_.fullname)”<\/span><\/p>\n

When opening a document, the complete path to the file is required; therefore, the fullname<\/b> property is used with the open<\/b> method from the documents<\/b> object. The returned document<\/b> object is stored in the $document<\/b> variable. This is shown here:<\/p>\n

$document = $application.documents.open($_.fullname)<\/span> <\/p>\n

The count<\/b> property from the words<\/b> collection object of the document<\/b> object is used to determine how many words are in the document. The $intWords<\/b> variable keeps a running tally of all the words from all of the documents that have been currently processed. To do this, the +=<\/b> operator is used. I love using the +=<\/b> operator because it is much easier than the way that VBScript required, which was to use i = i + wordCount<\/b>. Using the +=<\/b> operator is illustrated here:<\/p>\n

PS C:\\> $i = 5
PS C:\\> $i
5
PS C:\\> $i += 5
PS C:\\> $i
10
PS C:\\><\/span><\/p>\n

If you do not like using the +=<\/b> operator, you can still use the VBScript way of incrementing a counter (I know this is not really<\/i> just VBScript syntax and that in fact lots of other programming languages use this syntax. I am just calling it a VBScript way of doing things for convenience and to distinguish it from the +=<\/b> operator). This is shown here:<\/p>\n

PS C:\\> $i = 5
PS C:\\> $i = $i + 5
PS C:\\> $i
10
PS C:\\><\/span><\/p>\n

The word count is stored in the $intWords<\/b> variable, as shown here:<\/p>\n

$intWords += $document.words.count<\/span><\/p>\n

A running count of all the documents that have been processed in the script is stored in the $intDocs<\/b> variable. If I love using the +=<\/b> operator, I really love using the ++<\/b> operator. This operator will take the current value stored in a variable and increment it by one, and then store the value back in the variable. This is illustrated here:<\/p>\n

PS C:\\> $i = 5
PS C:\\> $i ++
PS C:\\> $i
6
PS C:\\><\/span><\/p>\n

The ++<\/b> operator is the same as stating that i = i + 1. This is shown here:<\/p>\n

PS C:\\> $i = 5
PS C:\\> $i = $i + 1
PS C:\\> $i
6
PS C:\\><\/span><\/p>\n

The ++<\/b> operator is much more compact. Its use in the script is shown here:<\/p>\n

$intDocs ++<\/span><\/p>\n

The close<\/b> method from the document<\/b> object is used to close the current document. To prevent cluttering the screen, the results are piped to the Out-Null<\/b> cmdlet. This is shown here:<\/p>\n

$document.close() | out-null<\/span><\/p>\n

}<\/span><\/p>\n

The quit<\/b> method of the application object is called. Next, the $application<\/b> variable is set to $null<\/b>, and garbage collection is called. This is shown here:<\/p>\n

$application.quit()
$application = $null
[gc]::collect()
[gc]::WaitForPendingFinalizers()<\/span><\/p>\n

The number of documents and the number of words is displayed on the screen. This is shown here:<\/p>\n

“There are $intDocs documents in the $path folder.
They contain a total of $intWords words.”<\/span><\/p>\n

 <\/p>\n

AS, that is all there is to using Microsoft Word to count the number of words contained in DOC files. Microsoft Office Week will continue tomorrow. <\/p>\n

If you want to know exactly what we will be looking at tomorrow, follow us on Twitter<\/a> or Facebook<\/a>. If you have any questions, send e-mail to us at scripter@microsoft.com<\/a>, or post your questions on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

Ed Wilson and Craig Liebendorfer, Scripting Guys<\/b><\/p>\n","protected":false},"excerpt":{"rendered":"

  Hey, Scripting Guy! I need to be able to use Windows PowerShell 2.0 to count the number of words in a bunch of Microsoft Word documents. All of the documents are stored in a specific folder, but there are a mixture of Microsoft Word 2010 and Microsoft Word 2007 documents and older document types […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[84,49,3,45],"class_list":["post-17991","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-microsoft-word","tag-office","tag-scripting-guy","tag-windows-powershell"],"acf":[],"blog_post_summary":"

  Hey, Scripting Guy! I need to be able to use Windows PowerShell 2.0 to count the number of words in a bunch of Microsoft Word documents. All of the documents are stored in a specific folder, but there are a mixture of Microsoft Word 2010 and Microsoft Word 2007 documents and older document types […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/17991","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=17991"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/17991\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=17991"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=17991"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=17991"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}