{"id":8141,"date":"2015-01-27T00:01:00","date_gmt":"2015-01-27T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2015\/01\/27\/working-with-fixed-number-sizes-in-powershell\/"},"modified":"2019-02-18T10:35:46","modified_gmt":"2019-02-18T17:35:46","slug":"working-with-fixed-number-sizes-in-powershell","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/working-with-fixed-number-sizes-in-powershell\/","title":{"rendered":"Working with Fixed Number Sizes in PowerShell"},"content":{"rendered":"

Summary<\/b>: Microsoft Scripting Guy, Ed Wilson, talks about working with fixed number sizes in Windows PowerShell.<\/span><\/p>\n

\"Hey, Hey, Scripting Guy! I have a script that returns a specific type of number, so I added a type constraint on the variable that holds the number. The problem is that sometimes when I run the script, I get errors. I cannot figure this out. Can you help me?<\/p>\n

—BG<\/p>\n

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

Microsoft Scripting Guy, Ed Wilson, is here. We have not had any snow this year here in Charlotte, North Carolina. This is good news, and of course, bad news. The good news is that because the city is rarely prepared for snow storms, any snow at all causes major problems. The bad news is that we do not get to see snow very often—maybe once every three or four years, if we are lucky. Personally, I enjoy looking at snow from the windows, but I really do not like it when I have to get outside in it. Snow causes lots of problems if you are not expecting it, and if you are not prepared for it.<\/p>\n

We run into much the same issue when it comes to constraining number types in Windows PowerShell. Because Windows PowerShell has a greatly enhanced adaptive-type system, and it can change the types of the objects that lay under the covers, one rarely needs to deal with things (such as a type mismatch) that plague other object-oriented languages.<\/p>\n

This, of course, has good and bad effects. At times, if I am not really paying attention, I can get tripped up if I am not expecting the object transformation. To be honest, this has only happened to me a couple of times, and it was usually because I was trying to do something pretty tricky in the first place. One way around this, is to place a type constraint on the object, and then force it to raise an error message when the change takes place. This can be helpful for spotting these sorts of changes.<\/p>\n

Note <\/b> To be clear, most of the time (in fact, I would say over 90 percent of the time), it is best to allow Windows PowerShell to manage the types.<\/p>\n

Changing number types<\/h2>\n

The default number type in Windows PowerShell is an Int<\/b>, and that is also an Int32<\/b>. If the number becomes too big, Windows PowerShell will change the number from an Int<\/b> to a Double<\/b>. I wrote the following script to illustrate the point:<\/p>\n

function get-double<\/p>\n

{<\/p>\n

 Param($a)<\/p>\n

  $b = $b + $a<\/p>\n

  "now $($b.gettype())"<\/p>\n

  if ($b -eq 'Infinity') {Return}<\/p>\n

  get-double $b<\/p>\n

}<\/p>\n

I load the function and call it by passing the number 2. This is shown here:<\/p>\n

Get-Double 2<\/p>\n

When I run the script, it runs for a few seconds and then stops when it reaches Infinity<\/b>. Part of the output is shown here:<\/p>\n

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

It is clear from the output that when Windows PowerShell reaches the maximum value of Int32<\/b>, it changes the type of number that is contained inside the variable $b<\/b> to a Double<\/b>. Most of the time, this is the behavior I want.<\/p>\n

Constraining the type of the number in a variable<\/h3>\n

But suppose that the value of $b<\/b> should never become greater than a certain value, and that number is an Int<\/b>. The script appears to work, but it takes a long time to complete. As I troubleshoot the script, I decide to constrain the value of $b<\/b> to a number type that makes sense for my script. I'm going to try an Int16<\/b>.<\/p>\n

In the following script, I use the type constraint [int16]<\/b> to ensure that the variable $b<\/b> only holds an Int16<\/b>.<\/p>\n

function get-int<\/p>\n

{<\/p>\n

 Param($a)<\/p>\n

 $erroractionpreference = "stop"<\/p>\n

  [int16]$b = $b + $a<\/p>\n

  "now $b"<\/p>\n

  get-int $b<\/p>\n

}<\/p>\n

If the value in $b<\/b> becomes greater than 32768, an error arises. Because the error that arises is not a terminating error, the script would run and run and run, but continue to display errors. That is not the behavior I want, so I changed the value of $errorActionPreference<\/b> from "continue"<\/b> to "stop"<\/b>. The output is shown here:<\/p>\n

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

By constraining the type of number that I store in the $b<\/b> variable, it becomes obvious that the problem with my script is that I am, somehow, getting a number that is too big. In reality, a problem such as that is usually traceable to one of the following:<\/p>\n