{"id":13421,"date":"2011-07-05T00:01:00","date_gmt":"2011-07-05T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2011\/07\/05\/automatically-create-a-powershell-hash-table\/"},"modified":"2011-07-05T00:01:00","modified_gmt":"2011-07-05T00:01:00","slug":"automatically-create-a-powershell-hash-table","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/automatically-create-a-powershell-hash-table\/","title":{"rendered":"Automatically Create a PowerShell Hash Table"},"content":{"rendered":"

Summary<\/b>: Learn how to automatically create a Windows PowerShell hash table and extra process data.<\/p>\n

 <\/p>\n

\"Hey,Hey, Scripting Guy! I thought your article introducing hash tables<\/a> was pretty interesting. I was wondering how I might populate a hash table. Can you explain how to do this easily?<\/p>\n

—AC<\/p>\n

 <\/p>\n

\"Hey, Hello AC,<\/p>\n

Microsoft Scripting Guy Ed Wilson here. This is a pretty cool time of the year down here in Charlotte, North Carolina. Well, not literally cool, but figuratively anyway. The thing that is so nice is that fresh peaches are showing up everywhere. This is because locally grown peaches from South Carolina and from Georgia are easily obtained.<\/p>\n

AC, if I need to populate a hash table with two or three key\/value pairs, I generally do it manually and separate each key\/value pair with a semicolon. One thing to note is that while the value <\/i>portion requires quotation marks, the key portion does not. In the last key\/value pair, I illustrate this. The code to create three key\/value pairs, assign them to a hash table stored in the variable $hash<\/i>, and then display the contents of that variable is shown here:<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash = @{“key1″=”value1″;”key2″=”value2″;key3=”value3”}<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash <\/p>\n

Name               Value<\/p>\n

—-                   —–<\/p>\n

key3                  value3<\/p>\n

key2                  value2<\/p>\n

key1                  value1<\/p>\n

 <\/p>\n

If I want to retrieve a specific key, I use the item<\/b> method as shown here.<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash.Item(“key2”)<\/p>\n

value2<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash.Item(“key3”)<\/p>\n

value3<\/p>\n

One of the things I like to do is to create an empty hash table and assign it to a variable. I will do this whether I am working in the Windows PowerShell console or using the Windows PowerShell ISE. To create an empty hash table, I use the @ sign followed by an opening and a closing brace. The three characters are assigned to a variable. This technique appears here:<\/p>\n

$hash = @{}<\/p>\n

An empty hash table object is created and is stored in the variable. This is verified by piping the object stored in the variable to the Get-Member<\/b> cmdlet. The technique to retrieve the members appears here.<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash | Get-Member <\/p>\n

TypeName: System.Collections.Hashtable <\/p>\n

Name                           MemberType                             Definition<\/p>\n

—-                               ———-                                    ———-<\/p>\n

Add                              Method                                     System.Void Add(System.Object key, System.Object value)<\/p>\n

Clear                             Method                                     System.Void Clear()<\/p>\n

Clone                            Method                                     System.Object Clone()<\/p>\n

Contains                        Method                                     bool Contains(System.Object key)<\/p>\n

ContainsKey                   Method                                     bool ContainsKey(System.Object key)<\/p>\n

ContainsValue                Method                                     bool ContainsValue(System.Object value)<\/p>\n

CopyTo                         Method                                     System.Void CopyTo(array array, int arrayIndex)<\/p>\n

Equals                           Method                                     bool Equals(System.Object obj)<\/p>\n

GetEnumerator              Method                                     System.Collections.IDictionaryEnumerator GetEnumerator()<\/p>\n

GetHashCode                Method                                     int GetHashCode()<\/p>\n

GetObjectData               Method                                     System.Void GetObjectData(System.Runtime.Serialization.SerializationInfo inf…<\/p>\n

GetType                        Method                                     type GetType()<\/p>\n

OnDeserialization           Method                                     System.Void OnDeserialization(System.Object sender)<\/p>\n

Remove                         Method                                     System.Void Remove(System.Object key)<\/p>\n

ToString                        Method                                     string ToString()<\/p>\n

Item                              ParameterizedProperty               System.Object Item(System.Object key) {get;set;}<\/p>\n

Count                            Property                                    System.Int32 Count {get;}<\/p>\n

IsFixedSize                     Property                                    System.Boolean IsFixedSize {get;}<\/p>\n

IsReadOnly                    Property                                    System.Boolean IsReadOnly {get;}<\/p>\n

IsSynchronized               Property                                    System.Boolean IsSynchronized {get;}<\/p>\n

Keys                              Property                                    System.Collections.ICollection Keys {get;}<\/p>\n

SyncRoot                       Property                                    System.Object SyncRoot {get;}<\/p>\n

Values                           Property                                    System.Collections.ICollection Values {get;}<\/p>\n

After I have an empty hash table, I use the add<\/b> <\/i>method to populate the hash table with key\/value pairs. The first thing I do is create an array of 100 integers by using the range<\/b> operator. Next, I use the percentage sign (which is the alias for the ForEach-Object<\/b> cmdlet) and call the add<\/b> method. As previously discussed, the key<\/b> property does not require quotation marks, but the value<\/b> property does require them. The code to add 100 integers as key\/value pairs to a hash table is shown in the following code:<\/p>\n

1..100 | % { $hash.Add($_,”$_”) }<\/p>\n

To empty a hash table and permit reuse of the hash table, use the clear<\/b> <\/i>method. To verify that the hash table is empty, use the count<\/b> property. The technique of clearing the hash table of data and verifying that it is empty is shown here:<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash.Clear()<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash.Count<\/p>\n

0<\/p>\n

Now that I have an empty hash table, I am going to populate it with the process ID and the process name of every running process on my system. Because it is likely that there could be more than one process with the same name (svchost<\/i>, for example), I use the process ID (PID) as the key<\/b> property and the name of the process as the associated value. The process information is easily obtained by using the Get-Process<\/b> cmdlet.<\/p>\n

Get-Process | % { $hash.Add($_.id,$_.name) }<\/p>\n

When working with a hash table, I often need to look at only the keys. To get a listing of only the keys, use the keys<\/b> property. This is illustrated in the following code where the keys<\/b> property is used retrieve all of the keys and the Select-Object<\/b> cmdlet (select<\/b> is an alias for the Select-Object<\/b> cmdlet) is used to limit the results to the first four keys:<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash.Keys | select -First 4<\/p>\n

2620<\/p>\n

1652<\/p>\n

1412<\/p>\n

4040<\/p>\n

In the same manner, the values of a hash table can be obtained by using the values<\/b> property. As you will remember, the value<\/b> property of a hash table does not need to be unique. In the example of processes running on my computer, I know this is a case.<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash.count<\/p>\n

64<\/p>\n

PS C:\\Users\\ed.WOODGROVE> ($hash.Values | select -Unique | Measure-Object).count<\/p>\n

50<\/p>\n

The 64 running processes appear in Task Manager. As shown in the following figure, there are a number of duplicate processes.<\/p>\n

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

The values<\/b> property of the hash table returns all of the values that are associated with the key\/value pairs. The count<\/b> <\/i>property tells me how many key\/value pairs exist. By taking the collection of values and piping the results to the Select-Object<\/b> cmdlet, I can use the unique<\/b> switch to obtain only the unique items. I can then send the resulting collection of unique values to the Measure-Object<\/b> cmdlet and choose the count<\/b> property. The result tells me how many unique processes are running. The code and associated output to do this are shown here:<\/p>\n

PS C:\\Users\\ed.WOODGROVE> $hash.count<\/p>\n

64<\/p>\n

PS C:\\Users\\ed.WOODGROVE> ($hash.Values | select -Unique | Measure-Object).count<\/p>\n

50<\/p>\n

I might like to see which processes have duplicates. In addition, I might like to see how many instances of each process are running. A reasonable list might include the top ten instances of these processes. To do this, I use the values<\/b> <\/i>property to return a list of all the values stored in the hash table, and I group them by value. Next, I sort them by the value of the count<\/b> property, and choose the first 10 instances. (In the following command group<\/strong>, sort<\/b> and select<\/b> are aliases for Group-Object<\/b>, Sort-Object<\/b>, and Select-Object<\/b> respectively). The command and associated output are shown here:<\/p>\n

PS C > $hash.values | group -NoElement | sort count -Descending | select -First 10<\/p>\n

Count    Name<\/p>\n

—–      —-<\/p>\n

   11      svchost<\/p>\n

    3      iexplore<\/p>\n

    2      csrss<\/p>\n

    2      conhost<\/p>\n

    1      IAStorDataMgrSvc<\/p>\n

    1      SearchFilterHost<\/p>\n

    1      sqlwriter<\/p>\n

    1      SnagPriv<\/p>\n

    1      dwm<\/p>\n

    1      explorer<\/p>\n

AC, that is all there is to using hash tables. Hash Table Week will continue tomorrow when I will talk about using hash tables to filter lists.<\/p>\n

 <\/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

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

Summary: Learn how to automatically create a Windows PowerShell hash table and extra process data.   Hey, Scripting Guy! I thought your article introducing hash tables was pretty interesting. I was wondering how I might populate a hash table. Can you explain how to do this easily? —AC    Hello AC, Microsoft Scripting Guy Ed […]<\/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":[18,51,3,4,45],"class_list":["post-13421","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-arrays-hash-tables-and-dictionary-objects","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-windows-powershell"],"acf":[],"blog_post_summary":"

Summary: Learn how to automatically create a Windows PowerShell hash table and extra process data.   Hey, Scripting Guy! I thought your article introducing hash tables was pretty interesting. I was wondering how I might populate a hash table. Can you explain how to do this easily? —AC    Hello AC, Microsoft Scripting Guy Ed […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/13421","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=13421"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/13421\/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=13421"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=13421"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=13421"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}