Summary<\/b>: Learn how to add, modify, or verify values in a Windows PowerShell array, and discover two easy techniques for sorting your array.<\/p>\n
![\"Hey,](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/29\/2019\/02\/q-for-powertip.jpg\")
Hey, Scripting Guy! I get that arrays are really simple in Windows PowerShell, but it seems that they are so simple that no one ever seems to tell us how to work with them. For example, I need to know how to add items to an array or how to change an item that is in an array. I have searched all over the Internet, and I cannot seem to find a straight answer. I know you guys seem to love hash tables, but that seems to be a lot of overhead for a simple array. Can you help?<\/p>\n
—PT<\/p>\n
![\"Hey,](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/29\/2019\/02\/a-for-powertip.jpg\")
Hello PT,<\/p>\n
Microsoft Scripting Guy, Ed Wilson, is here. You are right. You are also right, and unfortunately, you are right—but I can help solve that problem. OK, maybe I had better explain a bit. You are right, arrays in Windows PowerShell are simple, and in fact, they are so simple that many people do not bother to talk about how simple they are. It is also true that Windows PowerShell loves hash tables, but the same is true for arrays. In fact, Windows PowerShell loves arrays so much that they are incredibly easy to use.<\/p>\n
Note<\/b>: This is part two of a multiple blog series about working with arrays and hash tables for data storage. In yesterday’s Hey, Scripting Guy! Blog, Learn Simple Ways to Handle Windows PowerShell Arrays<\/a>,<\/i> I discussed creating arrays, indexing into arrays, and two techniques for walking through an array.<\/p>\n One of the interesting things about arrays in Windows PowerShell is they are able to hold different data types. For example, I can store numbers and strings in the same array as shown here.<\/p>\n PS C:\\> $a = 1,2,3,”four”<\/p>\n PS C:\\> $a<\/p>\n 1<\/p>\n 2<\/p>\n 3<\/p>\n Four<\/p>\n If I need to change an element in array, I can index into the array by using the square bracket and the index number. To find the upper boundary, I use the GetUpperBound<\/b> <\/i>method, and when I have that value, I can easily find the element I need to modify. This technique is shown here.<\/p>\n PS C:\\> $a.GetUpperBound(0)<\/p>\n 3<\/p>\n PS C:\\> $a[3] = 4<\/p>\n PS C:\\> $a<\/p>\n 1<\/p>\n 2<\/p>\n 3<\/p>\n 4<\/p>\n If I want to add an element to an existing array, it might make sense to choose the next index number, and attempt to assign a value in the same way that I change an existing value. When I do this, however, Windows PowerShell generates an out of range error message. This command and error message are shown here.<\/p>\n PS C:\\> $a[4] = 12<\/p>\n Array assignment failed because index ‘4’ was out of range.<\/p>\n At line:1 char:4<\/p>\n + $a[ <<<< 4] = 12<\/p>\n + CategoryInfo : InvalidOperation: (4:Int32) [], RuntimeException<\/p>\n + FullyQualifiedErrorId : IndexOutOfRange<\/p>\n The way to add a new element to an existing array is to use the += operator as shown here.<\/p>\n $a += 12<\/p>\n The commands to create an array, get the upper boundary of an array, change an element in an array, and add a new element to an array are shown here with their associated output.<\/p>\n One question that comes up from time-to-time is, “How do I know whether a value is contained in an array?” The answer is, once again, rather easy, “Use the Contains<\/b> <\/i>operator”. The following two commands use the previously created $a<\/b> array. In the first command, the number 12 is present, and the value True<\/b> <\/i>returns. In the second example, the array does not contain the number 14; and therefore, the returned value is False<\/b>.<\/i><\/p>\n PS C:\\> $a -contains 12<\/p>\n True<\/p>\n PS C:\\> $a -contains 14<\/p>\n False<\/p>\n PS C:\\><\/p>\n Now suppose I need to sort my array. There are actually two ways to do this. The first way to do this is to use the Sort-Object <\/b>cmdlet (Sort<\/b> is an alias for the Sort-Object <\/b>cmdlet). The second way to sort an array is to use the static Sort<\/b> <\/i>method from the System.Array <\/b>.NET Framework class.<\/p>\n The first technique I will discuss is also the easiest to use. It is the pipeline method. All that this technique requires is to pipe the array to the cmdlet. This technique is shown here.<\/p>\n PS C:\\> [int[]]$a = 1,5,7,2,12,4<\/p>\n PS C:\\> $a | Sort-Object<\/p>\n 1<\/p>\n 2<\/p>\n 4<\/p>\n 5<\/p>\n 7<\/p>\n 12<\/p>\n The thing to keep in mind is that this does not change the array, it merely changes the display output. If I want to modify the actual array, I need to write the results back to the original array. This technique is shown here.<\/p>\n PS C:\\> $a = $a | sort<\/p>\n PS C:\\> $a<\/p>\n 1<\/p>\n 2<\/p>\n 4<\/p>\n 5<\/p>\n 7<\/p>\n 12<\/p>\n The commands to create an array of integers, sort the results with the Sort-Object <\/b>cmdlet, and write the results back to the array are shown in the following image.<\/p>\n One of my favorite tricks is to create an array of numbers by using the Get-Random <\/b>cmdlet. To do this, I use Count<\/b> <\/i>to specify the number of values to select, and I use a range operator to create an array of numbers from which to choose. I then write the random values to a variable. This technique is shown here.<\/p>\n $rnd = Get-Random -Count 10 -InputObject (1..100000)<\/p>\n To sort the random numbers, I use the Sort<\/b> <\/i>static method from the System.Array <\/b>.NET Framework class. Because Sort<\/b> <\/i>is a static method, I need to use a double colon separator between the class name (in square brackets) and the method name. I supply the array of random numbers as an input value. This command is shown here.<\/p>\n [array]::sort($rnd)<\/p>\n What is really interesting is that the Sort<\/b> <\/i>static method, automatically writes the sorted values back to the array that is contained in the $rnd<\/b> variable. The commands to create a random array of numbers, display those values, sort the array, and display the sorted list are shown in the following image.<\/p>\n “So, what is the difference between the two ways to sort arrays,” you may ask. The difference is that the pipeline way of sorting is probably more intuitive to Windows PowerShell users. The other difference is that the static Sort<\/b> <\/i>method from the System.Array <\/b>class is way faster. To check this, I like to use the Measure-Command <\/b>cmdlet. To ensure I have a large enough data set that will take a decent amount of time to sort, I create two random arrays by using the commands that are shown here.<\/p>\n $arrayA = Get-Random -Count 1000000 -InputObject (1..1000000)<\/p>\n $arrayB = Get-Random -Count 1000000 -InputObject (1..1000000)<\/p>\n Next, I use the Measure-Command <\/b>cmdlet to measure the two ways of sorting arrays. The two commands are shown here.<\/p>\n Measure-Command -Expression { $arrayA = $arrayA | Sort-Object }<\/p>\n Measure-Command -Expression { [array]::Sort($arrayB) }<\/p>\n On my system (which is a fast computer), the first command takes a little over 40 seconds, whereas the second command takes a little more than 8 seconds. Therefore, the second command appears to be five times faster than the first command that uses the pipeline.<\/p>\n The commands that create the two random arrays use Measure-Command <\/b>to check the speed of the two commands, and they display the first two numbers in each of the newly sorted arrays, as shown in the following image.<\/p>\n Sorting arrays that contain multiple types<\/span><\/p>\n There is one more caveat when it comes to using the two sort methods. Because an array in Windows PowerShell can contain different types, the Sort-Object <\/b>method may be the preferred way of sorting objects. This is because in using the default comparer, the Sort<\/b> <\/i>static method fails when the array contains different types.<\/p>\n In the following example, I create an array that contains both integers and strings. I then pipe the array to the Sort-Object <\/b>cmdlet (using Sort<\/b> as the alias). Next, I attempt to use the static Sort<\/b> method from the System.Array <\/b>class, and that generates an error message.<\/p>\n PS C:\\> $array = 1,2,9,8,3,”four”,”tree”,”Cat”,”bat”<\/p>\n PS C:\\> $array | sort<\/p>\n 1<\/p>\n 2<\/p>\n 3<\/p>\n 8<\/p>\n 9<\/p>\n bat<\/p>\n Cat<\/p>\n four<\/p>\n tree<\/p>\n PS C:\\> [array]::sort($array)<\/p>\n Exception calling “Sort” with “1” argument(s): “Failed to compare two elements in the array.”<\/p>\n At line:1 char:14<\/p>\n + [array]::sort <<<< ($array)<\/p>\n + CategoryInfo : NotSpecified: (:) [], MethodInvocationException<\/p>\n + FullyQualifiedErrorId : DotNetMethodException<\/p>\n <\/p>\n PS C:\\><\/p>\n Because an array can contain other objects (besides strings and integers), I decide to perform one additional test, and I therefore store an instance of the System.Diagnostics.Process<\/b> .NET Framework class in the last element. This command is shown here.<\/p>\n PS C:\\> $array = 1,2,9,8,3,”four”,”tree”,”Cat”,”bat”,(get-process winword)<\/p>\n PS C:\\> $array<\/p>\n 1<\/p>\n 2<\/p>\n 9<\/p>\n 8<\/p>\n 3<\/p>\n four<\/p>\n tree<\/p>\n Cat<\/p>\n bat<\/p>\n <\/p>\n Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName<\/p>\n ——- —— —– —– —– —— — ———–<\/p>\n 463 62 41772 89736 369 39.17 4460 WINWORD<\/p>\n Next, I decide to sort the array. Once again, the Sort-Object<\/b> cmdlet comes through with no problems. This output is shown here.<\/p>\n PS C:\\> $array | sort<\/p>\n 1<\/p>\n 2<\/p>\n 3<\/p>\n 8<\/p>\n 9<\/p>\n bat<\/p>\n Cat<\/p>\n four<\/p>\n <\/p>\n Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName<\/p>\n ——- —— —– —– —– —— — ———–<\/p>\n 463 62 41772 89736 369 39.17 4460 WINWORD<\/p>\n tree<\/p>\n <\/p>\n <\/p>\n PS C:\\><\/p>\n <\/p>\n PT, that is all there is to modifying values in an array, adding to an array, checking to see if an array contains a specific value, and sorting the array. Array Week will continue tomorrow when I will store different types of objects in an array (including other arrays). It will be fun and educational. See ya!<\/p>\n I invite you to follow me on Twitter<\/a> and Facebook<\/a>. If you have any questions, send email to me 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, Microsoft Scripting Guy<\/b> <\/p>\n","protected":false},"excerpt":{"rendered":" Summary: Learn how to add, modify, or verify values in a Windows PowerShell array, and discover two easy techniques for sorting your array. Hey, Scripting Guy! I get that arrays are really simple in Windows PowerShell, but it seems that they are so simple that no one ever seems to tell us how to work […]<\/p>\n","protected":false},"author":596,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[292,51,3,4,45],"class_list":["post-11871","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-arrays-hashtables-and-dictionary-objects","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell"],"acf":[],"blog_post_summary":" Summary: Learn how to add, modify, or verify values in a Windows PowerShell array, and discover two easy techniques for sorting your array. Hey, Scripting Guy! I get that arrays are really simple in Windows PowerShell, but it seems that they are so simple that no one ever seems to tell us how to work […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/11871","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\/596"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=11871"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/11871\/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=11871"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=11871"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=11871"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Working with specific array elements<\/h2>\n
Changing element values<\/h2>\n
Adding a new element to an existing array<\/h2>\n
![\"Image](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/29\/2019\/02\/4760.hsg-12-6-11-01.png\" "\\"Image")
<\/a><\/p>\nSearching for a specific value in an array<\/h2>\n
Sorting an array<\/h2>\n
Use Sort and the pipeline<\/h2>\n
![\"Image](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/29\/2019\/02\/3716.hsg-12-6-11-02.png\" "\\"Image")
<\/a><\/p>\nUse Get-Random to create a random array<\/h2>\n
Use the static Sort <\/i>method<\/h2>\n
![\"Image](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/29\/2019\/02\/0083.hsg-12-6-11-03.png\" "\\"Image")
<\/a><\/p>\nMeasuring the difference in performance<\/h2>\n
![\"Image](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/29\/2019\/02\/6724.hsg-12-6-11-04.png\" "\\"Image")
<\/a><\/p>\n