PowerShell: Convert String to Integer

When processing values in PowerShell that appear to be numbers, they actually may be string values. This is a common issue, especially when importing data from forms, CSV files, or external systems into PowerShell. This can result in errors and unexpected behavior within PowerShell scripts. Therefore, it is essential to identify the data type of PowerShell variables and convert strings to integer values if required.

Understanding PowerShell DataTypes

Unlike other languages, PowerShell uses dynamic data typing instead of strong data typing. This means that PowerShell automatically determines the object type when the object is created.

For example, let’s create two sample variables and assign the same value:

$a = 1
$b = '1'

To check the data type of a variable in PowerShell, use the GetType() method:

$a.GetType()
$b.GetType()

As you can see, PowerShell automatically assigned $a as an Int32 (32-bit integer) and $b as a String.

To avoid PowerShell inferring the wrong data types based on the values of variables, you should set the type explicitly when creating the variable. For example, to create a variable which can contain only integer values, use:

[int]$var = "123"

However, data from external sources cannot always be guaranteed to be of type `Int32`. For example, if you try to explicitly assign a string value to a numeric variable or try to perform other numeric operation, you get an error:

[int]$var = 'Ten'

MetadataError: Cannot convert value “Ten” to type “System.Int32”. Error: “The input string ‘Ten’ was not in a correct format.”

In such cases, the resulting value must be converted to an integer first.

How to Convert String to Integer in PowerShell

There are several ways to convert a [string] value to an [int] in PowerShell.

Let’s say you have a variable containing a string (type System.String):

$stringN = "777"

To check the data type of a variable, run:

$stringN.GetType().FullName

The screenshot below confirms that “777” is stored as a string value rather than a numeric data type.

Using Strongly Typed Int Variables

If you don’t need to handle exceptions, you can use a strongly typed variable for simple conversions. Use the following format to create a variable that can only contain numeric values:

[int]$stringN

This is the simplest and fastest way to convert, but it may throw a RuntimeException if the data type cannot be converted to an integer. Therefore, it is recommended to use it for verified input data.

Using [int]::Parse()

You can convert a string to an integer using the standard .NET [int]::Parse() method:

[int]::Parse($stringN)

When parsing formatted numeric strings, you need to specify the culture explicitly instead of relying on the server’s current culture (this is especially important for scripts that process CSV files, API responses, or data generated on systems with different regional settings):

$culture = [System.Globalization.CultureInfo]::InvariantCulture

[int]::Parse($stringN, $culture)

Using an explicit culture makes numeric parsing predictable across systems with different regional settings:

$value = '120830200'

[int]::Parse(
$value,
[System.Globalization.NumberStyles]::Integer,
[System.Globalization.CultureInfo]::InvariantCulture
)

Using [int]::TryParse()

When working with user input, CSV files, APIs (or other untrusted data sources), in many cases it is better to use the .NET TryParse() method.

Unlike [int]::Parse(), the TryParse() method does not throw an exception when conversion fails. Instead, it returns True or False, making it ideal for validation and production scripts.

Here is a basic syntax:

$result = 0

[int]::TryParse($stringN, [ref]$result)

For culture-sensitive input, you should use the overload that accepts NumberStyles and an explicit CultureInfo:

$result = 0

[int]::TryParse(
$stringN,
[System.Globalization.NumberStyles]::Integer,
[System.Globalization.CultureInfo]::InvariantCulture,
[ref]$result
)

Now let’s take a look at the following example:

$stringN = "777"

$result = 0

if ([int]::TryParse($stringN, [ref]$result)) {
$result
}
else {
"Invalid integer"
}

In case the conversion succeeds, the parsed integer is stored in the $result variable. In case the conversion fails, no exception is generated.

Here are the benefits in case you are using TryParse():

• No exceptions on invalid input
• No need for try/catch blocks
• Fast performance
• Ideal for user input validation
• Often used in production PowerShell scripts

Using -as [int] Operator

You can instantly convert a string to a number using the <value> -as [datatype] statement. Although performance differences are negligible in most scripts, the -as operator is often preferred because it returns $null instead of throwing an exception when conversion fails.

$stringN -as [int]

It is a convenient option for simple conversions because it returns $null when conversion fails.

Using [convert]::ToInt32()

[convert]::ToInt32() method:

[convert]::ToInt32($stringN)

This conversion method is recommended when the input is unknown, for example when it comes from an API or database. It correctly handles $null values without crashing.

Tip: The [convert] class allows you to convert a value not only to Int32, but also to other integer data types:

• [convert]::ToInt16 — Signed 16-bit integer (short)
• [convert]::ToInt64() — Signed 64-bit integer (long)
• [convert]::ToUInt32() — Unsigned 32-bit integer (uint)
• [convert]::ToUInt64() — Unsigned 64-bit integer (ulong)

Which String to Integer Conversion Method Should You Use?

The following comparison table will help you decide which method to use for converting data from string to int in your scripts:

How to Validate Integer Input in PowerShell Scripts

It is sometimes necessary to check whether the value entered by the user or any other source is an integer. The following PowerShell function can be used to validate integer input in PowerShell scripts. This function takes an input value and checks whether it corresponds to the Integer32 data type after conversion.

function Test-Integer {
param(
[string]$Value
)

$result = 0
return [int]::TryParse($Value, [ref]$result)
}

# Usage example
if (Test-Integer "777") {
"Valid integer"
}
else {
"Not a valid integer"
}

Converting Formatted String to Integer

Sometimes the supposed numeric value is shown as a formatted string, such as those with “,” for thousands notation.

$value1 = "120,830,200"

$value2 = "120,830,200 (bytes)"

You understand these values, but none of the string-to-integer conversion methods we learned will work because these are not purely numbers.

For a formatted numeric string, you should prefer culture-aware parsing instead of manually removing thousands separators:

$value1 = "120,830,200"

[int]::Parse(
$value1,
[System.Globalization.NumberStyles]::Integer -bor
[System.Globalization.NumberStyles]::AllowThousands,
[System.Globalization.CultureInfo]::InvariantCulture
)

Since the values have been cleaned up, you can now convert them to integers using any methods we discussed.

The same approach can be used with TryParse() when invalid input should be handled without throwing an exception:

$result = 0

if ([int]::TryParse(
$value1,
[System.Globalization.NumberStyles]::Integer -bor
[System.Globalization.NumberStyles]::AllowThousands,
[System.Globalization.CultureInfo]::InvariantCulture,
[ref]$result
)) {
$result
}
else {
"Invalid integer"
}

An advanced Regex with the “-replace” can be used to extract digits only from the input (removes all non-digits \D):

[int]("120,830,200 (bytes)" -replace '\D','')

Note that this regex approach is useful for extracting digits from mixed text, but you should not use it as a general-purpose numeric parser. Note that it removes signs, decimal separators, and other formatting info.

Wrapping Up

We explored multiple methods when converting strings to integers, each providing similar results. These methods include strong typing, using static methods like [int]::Parse(), employing the -as [int] statement, and using methods from the [convert] class. For simple scripts, the -as [int] operator provides safe conversion without exceptions. For production code that requires strict validation, we recommend using [int]::TryParse().

$var.GetType()

[int]$stringN

$stringN -as [int]