Sstrutt: Initial creation - content from Variables page

2013-06-21T14:39:29Z

Initial creation - content from Variables page

New page

All variable names are prefixed with a <code>$</code>, and are case '''insensitive''' (though there's no reason to not use CamelBack notation if that floats your boat).

Apart from a few reserved words and characters there's little restriction on what can be used, though note that this flexibility can cause the occasional issue, whereby PowerShell gets confused as to where a variable name finishes. Variable names can be enclosed in <code> { } </code> in order to delimit them, eg <code>${varname}</code>.

'''PowerShell is all about manipulating objects, and all variables are objects.''' When you assign a value to a new variable, the type of object that it is (string, integer, etc) is automatically defined. Which is normally useful as you don't have to worry about what type of object/variable you want to create, PowerShell will work it out for you. However sometimes you need to force a variable to contain a specific data type to avoid errors or other problems down the line. Using a prefix of <code>[type]</code> achieves this...
<source lang="powershell"> [string]$result = $PingResult.Status </source>

== Data types ==
{|class="vwikitable"
|-
! Notation !! Data Type
|-
| <code> [adsi] </code> || Active Directory Services object
|-
| <code> [array] </code> || Array (see '''[[Arrays_(PowerShell)|Arrays]]''')
|-
| <code> [bool] </code> || True / false (can also be <code>[boolean]</code>)
|-
| <code> [byte] </code> || 8-bit unsigned character
|-
| <code> [char] </code> || Single character
|-
| <code> [datetime] </code> || Date and time (see '''[[Object_Types_(PowerShell)#Datetime|Datetime]]''')
|-
| <code> [decimal] </code> || 128-bit decimal
|-
| <code> [double] </code> || Double-precision 64-bit floating point number
|-
| <code> [int] </code> || 32-bit integer
|-
| <code> [long] </code> || 64-bit integer
|-
| <code> [single] </code> || Single-precision 32-bit floating point number
|-
| <code> [string] </code> || String of characters (see '''[[Strings_(PowerShell)|Strings]]''')
|-
| <code> [timespan] </code> || Duration of time
|-
| <code> [wmi] </code> || Windows Management Instrumentation (WMI) instance or collection
|-
| <code> [wmiclass] </code> || WMI class
|-
| <code> [xml] </code> || XML object
|}

== Variable Information ==
As PowerShell object (variables) tend to be black boxes that can contain anything or nothing, its often necessary to understand more about one. All objects contain Properties and Methods.
* Properties
** Are containers for data
* Methods
** Are in-built functions that allow an object to be manipulated.

=== Variable Type ===
To see the object type of a variable...
<source lang="powershell">
PS E:\> $var.GetType()
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Object[] System.Array
</source>

=== Variable Properties ===
Simple objects such as strings will contain only one property but complicated can contain many more, and even further objects. If you pipe an object through <code>Format-List</code> you get a fuller picture...

<source lang="powershell">
PS E:\> Get-WMIObject Win32_BIOS

SMBIOSBIOSVersion : 786F3 v01.16
Manufacturer : Hewlett-Packard
Name : Default System BIOS
SerialNumber : CPC123456J
Version : HPQOEM - 20090219

PS E:\> Get-WMIObject Win32_BIOS | Format-List *

Status : OK
Name : Default System BIOS
Caption : Default System BIOS
SMBIOSPresent : True
....TRUNCATED TO SAVE SPACE !!....
SMBIOSBIOSVersion : 786F3 v01.16
SMBIOSMajorVersion : 2
SMBIOSMinorVersion : 6
SoftwareElementID : Default System BIOS
SoftwareElementState : 3
TargetOperatingSystem : 0
Version : HPQOEM - 20090219
Scope : System.Management.ManagementScope
Path : \\LAPTOP1\root\cimv2:Win32_BIOS.Name="Default System BIOS",SoftwareElementID="Default System BI
OS",SoftwareElementState=3,TargetOperatingSystem=0,Version="HPQOEM - 20090219"
Options : System.Management.ObjectGetOptions
ClassPath : \\LAPTOP1\root\cimv2:Win32_BIOS
Properties : {BiosCharacteristics, BIOSVersion, BuildNumber, Caption...}
SystemProperties : {__GENUS, __CLASS, __SUPERCLASS, __DYNASTY...}
Qualifiers : {dynamic, Locale, provider, UUID}
Site :
Container :
</source>

=== Variable Properties and Methods ===
<source lang="powershell">
PS E:\ > $string | get-Member

TypeName: System.String

Name MemberType Definition
---- ---------- ----------
Clone Method System.Object Clone()
CompareTo Method int CompareTo(System.Object value), int CompareTo(string strB)
Contains Method bool Contains(string value)
CopyTo Method System.Void CopyTo(int sourceIndex, char[] destination, int destinationIndex,...
EndsWith Method bool EndsWith(string value), bool EndsWith(string value, System.StringCompari...
Equals Method bool Equals(System.Object obj), bool Equals(string value), bool Equals(string...
GetEnumerator Method System.CharEnumerator GetEnumerator()
....TRUNCATED TO SAVE SPACE !!....
ToString Method string ToString(), string ToString(System.IFormatProvider provider)
ToUpper Method string ToUpper(), string ToUpper(System.Globalization.CultureInfo culture)
ToUpperInvariant Method string ToUpperInvariant()
Trim Method string Trim(Params char[] trimChars), string Trim()
TrimEnd Method string TrimEnd(Params char[] trimChars)
TrimStart Method string TrimStart(Params char[] trimChars)
Chars ParameterizedProperty char Chars(int index) {get;}
Length Property System.Int32 Length {get;}
</source>

It's not uncommon for objects provided by API's to provide methods that are in fact objects themselves, you can end up with a lot of information being available once you're capable of drilling into them.

=== NULL ===
Checking whether a variable is NULL or not can be problematic. In that the easiest test doesn't always work.

Basic test for whether a variable exists or not, works in most cases...
<source lang="powershell">
if (!$var) {
"Variable is null"
}
</source>

If you expect your variable to be NULL or contain a positive number...
<source lang="powershell">
if ($var -gt 0) {
"Variable is NOT null"
}
</source>

Last resort test...
<source lang="powershell">
if ($var.gettype().ToString() -eq "System.DBNull") {
"Variable is null"
}
</source>

== Scope ==
Variables only fully exist within the scope of the script or function within which they are defined. Within functions local copies of a variable are available, but manipulating them has no effect on the real/master variable in the main scope, to get around this you can use <code>script</code> to enforce using the variable that's in the main script's scope...
<source lang="powershell">
function Local-Add($text) {
$List += $text
}

function Global-Add($text) {
$script:List += $text
}

$List = @()
$List += "Text message ONE"
$List.Length # List contains one entry
Local-Add "Text message TWO"
$List.Length # List still contains one entry
Global-Add "Text message THREE"
$List.Length # List now contains two entries
</source>

Similarly, you can create a variable within a function that has global scope...
<source lang="powershell">
function Create-Var {
if (!$TestVar) {
$script:TestVar = "stuff"
Write-Host 'Created $TestVar'
} else {
Write-Host '$TestVar already exists'
}
}

Create-Var
Create-Var
Write-Host '$TestVar contains [' $TestVar ']'
</source>
...which when run produces the following output...
Created $TestVar
$TestVar already exists
$TestVar contains [ stuff ]

You can achieve the same result by using the <code>Set-Variable</code> CmdLet with the <code>-Scope</code> parameter instead of <code>script</code>, for example...
<source lang="powershell">
function Create-Var {
if (!$TestVar) {
#$script:TestVar = "stuff"
Set-Variable -Name TestVar -Value "stuff" -Scope 1
Write-Host 'Created $TestVar'
} else {
Write-Host '$TestVar already exists'
}
}

Create-Var
Create-Var
Write-Host '$TestVar contains [' $TestVar ']'
</source>

== Macros / Built-in Variables ==
{|class="vwikitable"
|-
! Variable !! Description
|-
| <code> $_ </code> || Variable passed through pipeline from previous command
|-
| <code> $? </code> || Success/failure of previous statement - see [[#Basic_Error_Handler|Basic_Error_Handler]]
|-
| <code> $Error </code> || Last error - array of recent errors - see [[#$error|$error]]
|-
| <code> $LastExitCode </code> || Exit code of the last natively run application
|-
| <code> $foreach </code> || Enumerator in a foreach loop
|-
| <code> $Host </code> || Information about the machine being executed on (can also use <code>Get-Host</code>
|-
| <code> $args </code> || Array of arguments passed to a script - see [[#Script_Arguments|Script_Arguments]]
|}

=== Environment Variable ===
Environmental variables can be accessed via <code> $env </code>

<source lang="powershell">
$env:userprofile # User profile (eg C:\Users\joeblogs)
dir env: # Show all available variables
</source>

For a full list use...
<source lang="powershell">
Get-ChildItem env:
</source>

...or for some commonly used ones...
{|class="vwikitable"
|-
! Variable !! Description !! Example data
|-
| APPDATA || Application data path || C:\Users\RodHull\AppData\Roaming
|-
| COMPUTERNAME || Local System's hostname || LAPTOP-01
|-
| LOGONSERVER || Domain Controller Logged into || DC-SERVER-03
|-
| PROCESSOR_ARCHITECTURE || CPU Architecture || AMD64
|-
| USERDOMAIN || Logged in user's domain || DOMAIN.COM
|-
| USERNAME || Local System's hostname || rodhull
|}

[[category:PowerShell]]

Category:Variables (PowerShell) - Revision history

Sstrutt: Initial creation - content from Variables page