powershell hashtable using key named length

powershell hashtable contains key
powershell hashtable get value by key
powershell hashtable multiple values
powershell hashtable check if key exists
foreach hashtable powershell
powershell hashtable parameter
powershell dictionary
powershell foreach add to hash table

I'm got a problem parsing a file with key value pairs when one of the keys is named "length". Piping the content to ConvertFrom-StringData creates a hashtable with the key called "length" but, when I try to access it, I get the length of the table instead. Turns out this is because ConvertFrom-StringData is returning an array of hashtables and Length is the length of the array (6 in this case).

Any idea how to get around this? For a regular hashtable you can create a key called length and access it just fine ($tmp[1].length gives 1000um as it should). I won't usually know the index of the "length" field in the file, however.

> $tmp = Get-Content "Sample Settings.txt"

> $tmp
device=Hall bar
length=1000um
width=500um
thickness=8nm
system=PPMS
field=Perpendicular

> $tmp = $tmp | ConvertFrom-StringData

> $tmp

Name                           Value                                                                                                                                                                                            
----                           -----                                                                                                                                                                                            
device                         Hall bar                                                                                                                                                                                         
length                         1000um                                                                                                                                                                                           
width                          500um                                                                                                                                                                                            
thickness                      8nm                                                                                                                                                                                              
system                         PPMS                                                                                                                                                                                             
field                          Perpendicular                                                                                                                                                                                    

> $tmp.length
6

> $tmp[1].length
1000um

> $tmp.GetType()

IsPublic IsSerial Name                                     BaseType                                                                                                                                                             
-------- -------- ----                                     --------                                                                                                                                                             
True     True     Object[]                                 System.Array

> $tmp[0].GetType()

IsPublic IsSerial Name                                     BaseType                                                                                                                                                             
-------- -------- ----                                     --------                                                                                                                                                             
True     True     Hashtable                                System.Object  

To get regular hashtable, use -Raw switch as follows:

$tmp = Get-Content "Sample Settings.txt" -Raw | ConvertFrom-StringData

Then:

$tmp
<#
Name                           Value                                           
----                           -----                                           
device                         Hall bar                                        
thickness                      8nm                                             
field                          Perpendicular                                   
width                          500um                                           
system                         PPMS                                            
length                         1000um                                          
<##>

$tmp.gettype().Name
# Hashtable

$tmp.Count
# 6

$tmp.length
# 1000um

about_Hash_Tables, A hash table, also known as a dictionary or associative array, is a compact data structure that stores one or more key/value pairs. For example  @{} declares an HashTable whereas @() declares an Array. You can use $user.count to find the length of you HashTable. If you do: $user | get-member you can see all the methods and properties of an object. $user.gettype() return the type of the object you have.

Use IndexOf() to get the index and then use it to get the value:

$li = $tmp.keys.IndexOf('length')
$tmp[$li].length

Everything you wanted to know about hashtables, The person's name is the key and their age is the value that I want to save. Using the brackets for access. Another common way to use hashtables in Powershell is to hold a collection of properties where the key is the name of the property. I’ll step into that idea in this next example. Property based access. The use of property based access changes the dynamics of hashtables and how you can use them in Powershell.

Use -replace with a RegEx to prepend length with a string (here my):

> $tmp = $tmp -replace '^(?=length)','my' | convertfrom-stringdata
> $tmp
Name                           Value
----                           -----
device                         Hall bar
mylength                       1000um
width                          500um
thickness                      8nm
system                         PPMS
field                          Perpendicular

> $tmp.mylength
1000um

(?=..) is a zero length look ahead assertion

Windows PowerShell Desired State Configuration Revealed, We can examine the length or count of items in an array by looking at the Count or key in the hash table, you can do so by using the following: $hash["Name"]  Hashtable stores key/value pairs in a hash table. When using a Hashtable, you specify an object that is used as a key, and the value that you want linked to that key. Generally we used String or numbers as keys. This tutorial introduces how to declare hashtable variables, create hashtables, and process hashtable using its methods.

Powershell - Hashtables, Powershell - Hashtables - Hashtable stores key/value pairs in a hash table. When using a Hashtable, you specify an object that is used as a key, and the value that you want linked to tha. Name Value ---- ----- ID 1 Color Blue Shape Square. The hashtable values are accessed Number write-host("print Size") $​hash. LONG DESCRIPTION A hash table, also known as a dictionary or associative array, is a compact data structure that stores one or more key/value pairs. For example, a hash table might contain a series of IP addresses and computer names, where the IP addresses are the keys and the computer names are the values, or vice versa.

Windows PowerShell 2 For Dummies, If you want just the Name and Length properties to be displayed, you can use the Select-Object This hash table must consist of at least two key/value pairs. The way to learn PowerShell is to browse and nibble, rather than to sit down to a formal five-course meal. In his continuing series on Powershell one-liners, Michael Sorens provides Fast Food for busy professionals who want results quickly and aren't too faddy. Part 3 has, as its tasty confections, collections, hashtables, arrays and strings.

Chapter 4. Arrays and Hashtables, Mode LastWriteTime Length Name So if you output an element from the array to the console, PowerShell will automatically convert the object into text:. PowerShell Hashtable is a compact data structure that stores key/value pairs in a hash table. In other words, a hashtable is an associative array or a dictionary with a key-value pair. A key/value pair is essentially a set of two elements that are related in some manner.

Comments
  • the contents of your txt file might be useful. since $tmp is an array, you should treat it as such. array indexing, foreach, etc.
  • The output from the Get-Content command at the top is what it looks like.
  • Apologies for that oversight.
  • Brilliant. I knew there had to be an easy way to do this. Thanks!