{"id":52203,"date":"2009-10-21T00:01:00","date_gmt":"2009-10-21T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2009\/10\/21\/hey-scripting-guy-part-1-how-can-i-update-many-office-word-documents-at-once\/"},"modified":"2009-10-21T00:01:00","modified_gmt":"2009-10-21T00:01:00","slug":"hey-scripting-guy-part-1-how-can-i-update-many-office-word-documents-at-once","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-part-1-how-can-i-update-many-office-word-documents-at-once\/","title":{"rendered":"Hey, Scripting Guy! Part 1: How Can I Update Many Office Word Documents at Once?"},"content":{"rendered":"

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

(Editor’s note<\/strong>: This is part 1 of a two-part article originally intended for TechNet Magazine<\/em>. Part 2 will be published tomorrow.) 
 <\/p>\n

Little clouds of dust rise from the ground like miniature tornados carrying powdery sand that drifts along lazily on a nearly still breeze. The tires that support the ancient bus grind well-worn rocks and produce more powdery sand that readily fills any void created by previous traffic. Hushed voices leave words that hang in the air like the soft dust that clings to anything moist. The approach to Saqqara follows an ancient route along winding canals, date palms, and camels. The short ride from bustling Cairo scrolls me back thousands of years as I enter the temple complex of Djoser. Across the complex, rising with the seeming force of eternity stands the step pyramid of Djoser. I hold my breath as I stand in wonderment at the massive structure that has remained for more than 3,000 years. As I close my eyes, a breeze seems to pick up and for a few moments I am transported back to the time when this complex was new and served the impressive gateway for which it had been designed. I stand as one more point on a vast time continuum. <\/p>\n

Few things seem to remain for multiple millennia, and those that do gain traction from the current milieu will not emerge from the world of information technology. Documents are often out of date before the virtual ink dries on the screen of the laptop. Web sites come and go, and migrate from URL to URL. Product names change, and so do the names of features that persist from version to version. In a rapidly changing world, how can you keep your documentation up to date? Using Microsoft Office Word, you can use the find-and-replace tool to change all instances of a word or phrase with another word or phrase of your choosing. But what do you do when you have hundreds of Word documents that need to be inspected and updated? This is where scripting comes in.<\/p>\n

The complete ReplaceWordsLogResults.ps1 script is seen here. <\/p>\n

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

# ————————————————————————
# NAME: ReplaceWordsLogResults.ps1
# AUTHOR: ed wilson, Microsoft
# DATE: 8\/11\/2009
#
# KEYWORDS: Word.Application
#
# COMMENTS: This script replaces a word in a document file
# with another word or phrase.
#
# TNM
# ————————————————————————
Param(
 <\/span>$path = “C:datafso”
)#end param<\/p>\n

# *** Functions here ***
Function Get-WordSelection([string]$file,[boolean]$visible)
{
 <\/span>$script:Word = New-Object -ComObject word.application
 <\/span>$Word.Visible = $visible
 <\/span>$script:doc = $Word.Documents.Open($file)
 <\/span>$script:selection = $Word.Selection
 <\/span>} #end function Get-WordSelection
 <\/span>
 <\/span>Function New-LogObject ($document, $replaced)
 <\/span>{
 <\/span>$logObject = New-Object psobject
 <\/span>$logObject | Add-Member -MemberType noteProperty -Name “document” -Value $document
 <\/span>$logObject | Add-Member -MemberType scriptProperty -Name “replaced” -Value { $rtn }
 <\/span>$logObject | Add-Member -MemberType scriptProperty -Name “date” -value { get-date -uformat “%Y\/%m\/%d” }
 <\/span>$logObject | Add-Member -MemberType scriptProperty -Name “user” -value { $env:username }
 <\/span>$Script:doc.Save()
 <\/span>$Script:doc.close()
 <\/span>$logObject
 <\/span>} # end function new-logobject<\/p>\n

# *** Entry to Script ***<\/p>\n

$files = Get-ChildItem -Path $path -Include *.doc,*.docx -Recurse
$wordHash = @{“misspelled” = “spelled incorrectly” ; “done”=”finished”}
$logfile = “ReplaceResults.csv”
$i=0
$ReplaceAll = 2
$FindContinue = 1
$MatchCase = $False
$MatchWholeWord = $True
$MatchWildcards = $False
$MatchSoundsLike = $False
$MatchAllWordForms = $False
$Forward = $True
$Wrap = $FindContinue
$Format = $False<\/p>\n

$files | ForEach-Object {
  <\/span>$file = $_.fullname
  <\/span>$i ++
  <\/span>write-progress -activity “Searching For Word documents” `
 <\/span>-status “Progress:” -percentcomplete ($i\/$files.count*100)
 <\/span>
 <\/span>Get-WordSelection -file $_.fullname -visible $false
 <\/span>
 <\/span>foreach($FindText in $wordHash.keys)
 <\/span>{
  <\/span>$rtn = $Script:Selection.Find.Execute($FindText,$MatchCase,
   <\/span>$MatchWholeWord,$MatchWildcards,$MatchSoundsLike,
   <\/span>$MatchAllWordForms,$Forward,$Wrap,$Format,
   <\/span>$wordHash.$FindText,$ReplaceAll)
 <\/span>} #end foreach findtext
 <\/span>
 <\/span>New-LogObject -document $file -replaced $rtn
} | Export-Csv -Path (join-path -Path $path -ChildPath $logfile) -NoTypeInformation<\/p>\n

$Script:word.quit()<\/p>\n

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

The first thing the ReplaceWordsLogResults.ps1 script does is create a command-line parameter named path<\/b> to allow you to specify the directory to search for Word documents. The Param<\/b> keyword is used to create the parameter. To use the parameter from the Windows PowerShell console, you specify the name of the script and the path you wish to search. This is seen here: <\/p>\n

ReplaceWordsLogResults.ps1 –path c:mydirectory<\/p>\n

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

The param<\/b> statement is shown here: <\/p>\n

Param(
 <\/span>$path = “C:datafso”
)#end param<\/p>\n

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

The first function that is created is the Get-WordSelection<\/b> function. It receives two inputs when it is called from within the script. The first parameter is the file<\/b> parameter and the second parameter is the Boolean visible<\/b> parameter. The file<\/b> parameter contains the path to a Word document that will be processed. The visible<\/b> parameter is used to indicate whether the Word document will be visible while it is being scanned. The variables that are created inside the Get-WordSelection<\/b> are marked with the script scope. This means the variables will be available anywhere within the ReplaceWordsLogResults.ps1 script. The Word.Application object<\/font><\/a> is the main object that is used when automating Microsoft Word. It is used to obtain the Documents collection object<\/font><\/a> to open the Word document. It will also be used to exit the Word application after all the Word documents have been processed. This portion of the Get-WordSelection<\/b> function is seen here: <\/p>\n

Function Get-WordSelection([string]$file,[boolean]$visible)
{
 <\/span>$script:Word = New-Object -ComObject word.application
 <\/span>$Word.Visible = $visible
 <\/span>$script:doc = $Word.Documents.Open($file)<\/p>\n

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

To work with the text inside the Word document, you will need to obtain a Selection<\/b> object. The easiest way to obtain a Selection object<\/a> is to query the selection<\/b> property from the Word application object. The returned Selection<\/b> object will need to be used outside the Get-WordSelection<\/b> function. The variable that is created to hold the Selection<\/b> object is therefore created with a script-level scope. This is seen here: <\/p>\n

 <\/span>$script:selection = $Word.Selection
 <\/span>} #end function Get-WordSelection <\/p>\n

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

Because the ReplaceWordsLogResults.ps1 script will need to create a log that is used to track the progress of the changes made to the Word documents in the target folder, a function named New-LogObject<\/b> is created. It receives two parameters: the path to the document being scanned and a Boolean value that indicates if changes were made to it. This is seen here: <\/p>\n

 <\/span>Function New-LogObject ($document, $replaced)
 <\/span>{<\/p>\n

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

The log<\/b> object that is created is an instance of a PSObject. The New-Object<\/b> cmdlet is used to create the object. The returned object is stored in the variable $logObject<\/b>: <\/p>\n

 <\/span>$logObject = New-Object psobject <\/p>\n

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

Four properties are added to the $logObject<\/b>. The Add-Member<\/b> cmdlet is used to add the members to the object. The first two properties are passed to the New-LogObject<\/b> function when it is called. The Date<\/b> property is created by using the Get-Date<\/b> cmdlet, and the user name is pulled from the environmental drive. This is seen here:<\/p>\n

 <\/span>$logObject | Add-Member -MemberType noteProperty -Name “document” -Value $document<\/p>\n

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

 <\/span>$logObject | Add-Member -MemberType scriptProperty -Name “replaced” -Value { $rtn }<\/p>\n

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

 <\/span>$logObject | Add-Member -MemberType scriptProperty -Name “date” -value { get-date -uformat “%Y\/%m\/%d” }<\/p>\n

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

 <\/span>$logObject | Add-Member -MemberType scriptProperty -Name “user” -value { $env:username }<\/p>\n

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

The Word document is saved and closed by using the appropriate methods from the Word Document object<\/font><\/a>. The newly created object is then emitted back to the calling script. This is seen here: <\/p>\n

 <\/span>$Script:doc.Save()<\/p>\n

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

 <\/span>$Script:doc.close()<\/p>\n

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

 <\/span>$logObject<\/p>\n

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

<<\/p>\n

p style=”MARGIN: 4pt 0in 7pt; BACKGROUND: #d9d9d9; mso-background-themecolor: background1; mso-background-themeshade: 217″ class=”CodeBlock”> <\/span>} # end function new-logobject<\/p>\n

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


Join us tomorrow for part 2, the conclusion to this post about updating many Word documents at once. In the meantime, follow us on Twitter<\/font><\/span><\/a> or Facebook<\/font><\/span><\/a>. If you have any questions, send e-mail to us at scripter@microsoft.com<\/font><\/span><\/a> or post your questions on the Official Scripting Guys Forum<\/a>. See you on Monday. Peace!<\/p>\n

Ed Wilson and Craig Liebendorfer, Scripting Guys<\/p>\n

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

 <\/p>\n","protected":false},"excerpt":{"rendered":"

(Editor’s note: This is part 1 of a two-part article originally intended for TechNet Magazine. Part 2 will be published tomorrow.)   Little clouds of dust rise from the ground like miniature tornados carrying powdery sand that drifts along lazily on a nearly still breeze. The tires that support the ancient bus grind well-worn rocks and […]<\/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-52203","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":"

(Editor’s note: This is part 1 of a two-part article originally intended for TechNet Magazine. Part 2 will be published tomorrow.)   Little clouds of dust rise from the ground like miniature tornados carrying powdery sand that drifts along lazily on a nearly still breeze. The tires that support the ancient bus grind well-worn rocks and […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/52203","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=52203"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/52203\/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=52203"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=52203"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=52203"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}