PowerShell Type operators are used to verify the type of the operand. Are you aware, each value we use in PowerShell has particular Type? These are the types similar to the types defined in .Net. Yes, because PowerShell is developed using .Net Framework.
These operators are allowed to verify the type of the operand. Through this Article, we are going to discuss usage of these operators.
This operator verifies whether the given operand is of specific type. The operand should be left side of the operator and the verified type should be mentioned in right hand side of the operator, enclosed in quotes (single (‘) or double (“) quotes).
It verifies the operand, and returns
True , if the operand is of mentioned type; otherwise, it returns
False as the return value.
For example, below statement verifies whether the string is of String type;
PS C:\> "PowerShell" -is "String"
Let’s verify the same with other type;
PS C:\> "PowerShell" -is "Object"
Why it showing
True, when we compare the string with Object type? Yes. Everything is derived from an Object class in .Net; string is also of Object type; hence the above statement returns the value
This operator works exactly opposite to
-is operator. It verifies whether the operand is NOT, of mentioned type. It also returns;
False as the return value.
PS C:\> 1234 -isNot "Int32"
This is interesting operator. It type casts from one type to another type. Let’s verify this with below example;
PS C:\> 1234 -is "String"
PS C:\> (1234 -as "String") -is "String"
Observe that, in first statement we did the type check; whether the number is of string type or not. The
-is operator, returns
False. And in the second statement, we type casts the number to string and verifies whether it is of type string; and it succeeds the check.
Does this check will succeed, always? Not necessarily. For example, when you attempt to type cast a string type to a numeric type, it will thrown an error, like below;
PS C:\> ("1680" -as 1680) Cannot convert the "1680" value of type "System.String" to type "System.Type". At line:1 char:1 + ("1680" -as 1680) + ~~~~~~~~~~~~~~~~~ + CategoryInfo : InvalidArgument: (:) , RuntimeException + FullyQualifiedErrorId : InvalidCastFromStringToType
So far, so good. But, how do we know the variable holds, what type of information? Good. We can check this through
This method returns the type information of the expression. By calling this method, we will come to know; what type the variable or value or the expression is. When the variable is declared, the value must be assigned to it; then only the type information will be captured. Otherwise, the variable is assigned with a null value; and when we call this method; PowerShell will throw the Error.
Here is an example, where it throws the InvalidOperation error;
PS C:\> $var PS C:\> $var.GetType() You cannot call a method on a null-valued expression. At line:1 char:1 + $var.GetType() + ~~~~~~~~~~~~~~ + CategoryInfo : InvalidOperation: (:) , RuntimeException + FullyQualifiedErrorId : InvokeMethodOnNull
Now, we assign a value to the variable
$var; and call the method
GetType() on it, to get the type information. The result looks like, below;
PS C:\> $var = (1, 2, 3) PS C:\> $var.GetType() IsPublic IsSerial Name BaseType -------- -------- ---- -------- True True Object System.Array
Type information is really useful when dealing with different types of data.