{"id":53923,"date":"2009-04-21T23:15:00","date_gmt":"2009-04-21T23:15:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2009\/04\/21\/hey-scripting-guy-windows-powershell-and-pipelining\/"},"modified":"2009-04-21T23:15:00","modified_gmt":"2009-04-21T23:15:00","slug":"hey-scripting-guy-windows-powershell-and-pipelining","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-windows-powershell-and-pipelining\/","title":{"rendered":"Hey, Scripting Guy! Windows PowerShell and Pipelining"},"content":{"rendered":"

\"Hey, <\/H2>\n

Hey, Scripting Guy! I have seen you refer to this term pipeline<\/I> many times since you started writing Windows PowerShell articles. What is up with that? Why don’t you just store things in a variable and then walk through the contents of the variable when you are working with Windows PowerShell? This is the way that we did it in VBScript, and it has worked fine for almost a decade. Can you explain what is so great about a pipeline (other than for economically transporting large amounts of liquid materials over great distances)?

– YH<\/P>\"Spacer\"\"Hey, \n

Hi YH,<\/P>\n

Ed here. And I’m bummed you stole my smart alec remark. One of my hobbies is woodworking. I enjoy making sawdust out in my woodworking shop. It is completely relaxing, and when I am finished with a piece of furniture, there is a real sense of pride and accomplishment. The skills I use in my shop are completely different from the kind of skills used to write a script or to write a book. It is a good way to relax. I have been playing around with wood since I was a kid, and therefore I have many years of experience in making things from wood. When I first started out, my dad showed me how to take two skinny boards and make one large board. You join the straightest side of each board, evenly spread glue on the freshly joined boards, and carefully put them in a set of clamps and tighten the clamps. You must do this both quickly and carefully as glue starts to harden in a few minutes (depending of course on the kind of glue you are using) and glue is slippery, meaning that it is easy for the boards to become misaligned. Both facts are a challenge for a 10-year-old boy. As I grew older my interest in woodworking continued, and I began watching a guy named Norm Abrams on the New Yankee Workshop<\/A> (Norm: If you are reading this, send e-mail to scripter@microsoft.com<\/A>, and I will send you an autographed copy of the Microsoft Press Windows PowerShell Script Guide<\/A> book.) Norm is my hero. I even wear a flannel shirt when I am making sawdust out in my shop. He introduced me to a tool called a plate joiner<\/A> that is used to put biscuits in a board. The main advantage of biscuits is that they help you align two boards when you are gluing two boards.<\/P>\n

YH, you asked about how to work with the pipeline, and this article is \u201cHey, Scripting Guy!\u201d and not \u201cHey, Woodworking Guy!\u201d So let’s start scripting.<\/P>\n\n<\/THEAD>\n\n\n
\n

This week we will be looking at the basics of Windows PowerShell. Windows PowerShell is installed by default on Windows 7 and Windows Server 2008 R2. It is an optional installation on Windows Server 2008 and a download for Windows Vista<\/A>, Windows XP<\/A>, and Windows Server 2003<\/A>. The Windows PowerShell Scripting Hub<\/A> is a good place to get started with Windows PowerShell.<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n

<\/DIV>\n

In the SearchTextFileForSpecificWord.vbs<\/B> script, we create an instance of the Scripting.FileSystemObject<\/B>, open the file, and store the resulting textstream<\/B> object in the file<\/B> variable. We then use the Do\u2026Until\u2026Loop<\/B> statement to work our way through the textstream<\/B> object. Inside the loop we read one line at a time from the textstream<\/B>. As soon as we have a specific line, we use the InStr<\/B> statement to see whether a specific word is found. If it is, we display the sentence on the screen. The SearchTextFileForSpecificWord.vbs<\/B> script is seen here:<\/P>

filepath = “C:\\fso\\testFile.txt”\nword = “text”\nset fso = CreateObject(“Scripting.FileSystemObject”)\nSet file = fso.OpenTextFile(filepath)<\/p>\n
Do Until file.AtEndOfStream\n line = file.ReadLine\n If InStr(line, word) Then\n  WScript.Echo line\n End If\nLoop\n<\/PRE>\n
This technique of using the ReadLine<\/B> method is very efficient and is the recommended way to work with large files. The other way of reading content from a text file in VBScript is the ReadAll<\/B> method. The problem with using the ReadAll<\/B> method is that it stores the contents of a text file in memory. This is not a problem if the file is small, but for a very large file that it would consume a very large amount of memory. In addition to the memory consumption issue, if you plan on working with the file one line at a time, which is one of the main reasons for reading a text file, you now have to contrive artificial methods to work your way through the file. When we use the ReadLine<\/B> method from the TextStream<\/B> object, the process is similar to pipelining in Windows PowerShell. <\/P>\n
With Windows PowerShell, we do not have to write a script to do the same thing the SearchTextFileForSpecificWord.vbs<\/B> does. We can, in fact, perform the operation in just three lines of code: <\/P>
PS C:\\> $filepath = “C:\\fso\\TestFile.txt”\nPS C:\\> $word = “text”\nPS C:\\> Get-Content -Path $filepath | ForEach-Object {if($_ -match $word){$_}}\n<\/PRE>\n
When we run the commands, we are given the output shown here:<\/P>\"Image \n
 <\/P>\n
Before we get too far, let’s examine the TestFile.txt<\/B> file. This will give us a better idea of what we are working with. The file is seen here:<\/P>\"Image \n
 <\/P>\n
The first two lines that were typed into the Windows PowerShell console assign string values to variables. This serves the same purpose as the first two lines of the SearchTextFileForSpecificWord.vbs<\/B> script. The last line we typed in the Windows PowerShell console is actually two separate commands. The first one reads the contents of the text file. This is the same as creating an instance of the Scripting.FileSystemObject<\/B>, opening the text file by using the Do\u2026While\u2026Loop<\/B> construction, and then calling the ReadLine<\/B> method. Here is the Get-Content<\/B> command:<\/P>
Get-Content -Path $filepath<\/PRE>\n
The results of the Get-Content<\/B> cmdlet are pipelined to the ForEach-Object<\/B> cmdlet. The ForEach-Object<\/B> cmdlet enables us to work inside the pipeline to examine individual lines as they come across the pipe. The variable $_<\/B> is an automatic variable that is created when we are working with a pipeline. It is used to enable us to work with a specific item when it is located on the pipeline. In VBScript you use the If\u2026Then\u2026End If<\/B> construction. In Windows PowerShell, we use an If(\u2026){\u2026}<\/B> construction. The two serve the same purpose\u2014decision making. In VBScript the condition that is evaluated goes between the If<\/B> and the Then<\/B> statement. In Windows PowerShell, the condition that is evaluated goes between two parentheses. In VBScript the action that is taken when a condition is matched goes between the Then<\/B> and the End If<\/B> statements. In Windows PowerShell, the action that is matched goes between a pair of braces. <\/P>\n
In VBScipt we use the Instr<\/B> function to look inside the sentence to see whether a match could be found. In Windows PowerShell, we use the \u2013match<\/B> operator. In VBScript we use the Wscript.Echo<\/B> command to display the matching sentence on the screen, and in Windows PowerShell we only need to call the $_<\/B> variable and it is automatically displayed. <\/P>\n
Of course we do not have to use the Get-Content<\/B> cmdlet if we do not want to, because Windows PowerShell has a cmdlet called Select-String<\/B> that will look inside a text file and retrieve the matching lines of text. Our three lines of code, seen earlier, could therefore be shortened to this one-line command:<\/P>
PS C:\\> Select-String -Path C:\\fso\\TestFile.txt -Pattern “text”<\/PRE>\n
The results of this command are shown here:<\/P>\"Image \n
 <\/P>\n
One of the things we really like to do with Windows PowerShell is to use the formatting cmdlets. There are three formatting cmdlets that are especially helpful. They are listed here, in the reverse order in which I use them:<\/P>\n\n\n\n\n\n
\u2022<\/TD>\n\n
Format-Wide<\/P><\/TD><\/TR>\n
\u2022<\/TD>\n\n
Format-Table<\/P><\/TD><\/TR>\n
\u2022<\/TD>\n\n
Format-List<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n
Let’s consider using the Format-Wide<\/B> cmdlet. Format-Wide<\/B> is useful when you want to display a single property across multiple columns. This might be because you want to have a list of all process names that are currently running on the server. Such a command would resemble the following:<\/P>
PS C:\\> Get-Process | Format-Wide -Property name \u2013AutoSize<\/PRE>\n
The first thing we do is use the Get-Process<\/B> cmdlet to return all the processes that are running on the computer. We pipeline the process objects to the Format-Wide<\/B> cmdlet. We use the \u2013property<\/B> parameter to select the name of each process, and we use the \u2013autosize<\/B> parameter to tell Format-Wide<\/B> to use as many columns as possible in the Windows PowerShell console without truncating any of the process names. We can see the results of this command here:<\/P>\"Image \n
 <\/P>\n
If we were interested in between two and four properties from the processes, we could use the Format-Table<\/B> cmdlet. The command might resemble the following:<\/P>
PS C:\\> Get-Process | Format-Table -Property Name, Path, Id \u2013AutoSize<\/PRE>\n
We use the Get-Process<\/B> cmdlet and pipeline the processes to the Format-Table<\/B> cmdlet. We select three properties from the process objects: name, path and Id. The Format-Table<\/B> cmdlet has an \u2013autosize<\/B> parameter exactly as the Format-Wide<\/B> cmdlet does. This helps arrange the columns in such a way that we do not waste space inside the console. As shown in the following image, because of the length of some paths to process executables, the \u2013autosize<\/B> parameter had no effect in this example. As a best practice I always include the parameter when I am unsure of what the output will actually resemble. <\/P>\"Image \n
 <\/P>\n
The format cmdlet I use the most is the Format-List<\/B> cmdlet. This is because it is the best way to display lots of information. It is also a good way to see what kind of data might be returned by a particular command. Armed with this information, I then determine whether I want to focus on a more select group of properties and perhaps output the data as a table or just leave it in a list. When you use the Format-List<\/B>, I will usually use the wildcard *<\/B> to select all the properties from the objects. Here is an example of obtaining all the property information from all our processes:<\/P>
PS C:\\> Get-Process | Format-List -Property *<\/PRE>\n
We will be unable to show you a picture of all the data that is returned by this command. This is because there is too much information to fit on a single screen. A small sampling of the information is shown here:<\/P>\"Image \n
 <\/P>\n
There is so much information that all the properties and their values for a single process will not fit on a single screen. When you work with the Format-List<\/B> cmdlet, if you want to look through all the data, you can pipeline the information to more. This works in the same manner as it did in the old command shell. If we were to use shortcut names (also known as aliases), we have a very compact command at our disposal. As shown here, gps<\/B> is an alias for the Get-Process<\/B> cmdlet. The fl<\/B> command is an alias for Format-List<\/B>. Because the first parameter of the Format-List<\/B> cmdlet is the \u2013property<\/B> parameter, we can leave it out and not type it. We then pipeline the results to more<\/B>, which will cause the information to be displayed one page at a time. This is shown here:<\/P>
PS C:\\> gps | fl * | more<\/PRE>\n
This concludes our look today at pipelining. As you have undoubtedly seen, the ability to pipeline the results of one command into another command provides us with powerful alternatives to storing everything in a variable. These techniques are not only for working interactively at the command line, but also are best practices when you write scripts. We will continue our discussion of Windows PowerShell basics tomorrow. Until then, take care.<\/P>\n
 <\/P>\n
Ed Wilson and Craig Liebendorfer, Scripting Guys<\/B><\/P><\/p>\n","protected":false},"excerpt":{"rendered":"
Hey, Scripting Guy! I have seen you refer to this term pipeline many times since you started writing Windows PowerShell articles. What is up with that? Why don’t you just store things in a variable and then walk through the contents of the variable when you are working with Windows PowerShell? This is the way […]<\/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":[51,3,4,45],"class_list":["post-53923","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell"],"acf":[],"blog_post_summary":"
Hey, Scripting Guy! I have seen you refer to this term pipeline many times since you started writing Windows PowerShell articles. What is up with that? Why don’t you just store things in a variable and then walk through the contents of the variable when you are working with Windows PowerShell? This is the way […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/53923","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=53923"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/53923\/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=53923"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=53923"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=53923"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}