Variables (PowerShell) - Revision history

Sstrutt: Page deperciated

2013-06-21T14:42:52Z

Page deperciated

← Older revision		Revision as of 14:42, 21 June 2013
Line 1:		Line 1:
			{{Depreciated\|category=Variables_(PowerShell)}}

	__TOC__		__TOC__

Sstrutt: /* Arrays */ Minor example addition and Meta

2013-03-26T11:54:50Z

Arrays: Minor example addition and Meta

← Older revision		Revision as of 11:54, 26 March 2013
Line 307:		Line 307:
	== Arrays ==		== Arrays ==
	<source lang="powershell">		<source lang="powershell">
	$array = @() # Create blank array		$array = @() # Create blank array
	$array += 34 # Add value to end of array		$array = @("one", "two", 3) # Create an array with some values
			$array += 34 # Add value to end of array
	</source>		</source>

Sstrutt: /* IP Address */ Typo fix

2012-07-26T15:08:30Z

IP Address: Typo fix

← Older revision		Revision as of 15:08, 26 July 2012
Line 462:		Line 462:
	To confirm a supplied address is valid...		To confirm a supplied address is valid...
	<source lang="powershell">		<source lang="powershell">
	if ([System.Net.IPAddress]::TryParse($~~IP-to-test~~) {		if ( [System.Net.IPAddress]::TryParse($IP2test) ) {
	Write-Host "$~~IP-to-test~~ is a valid address"		Write-Host "$IP2test is a valid address"
	}		}
	</source>		</source>

Sstrutt: /* IP Address */ Added link to MS page

2012-07-26T15:06:57Z

IP Address: Added link to MS page

← Older revision		Revision as of 15:06, 26 July 2012
Line 453:		Line 453:

	=== IP Address ===		=== IP Address ===
			The object structure: http://msdn.microsoft.com/en-us/library/system.net.ipaddress

	To create an IP address object...		To create an IP address object...
	<source lang="powershell">		<source lang="powershell">

Sstrutt: /* Datetime */ Turned into subsection of "Object Types" (new heading) and added "IP Address"

2012-07-26T15:01:09Z

Datetime: Turned into subsection of "Object Types" (new heading) and added "IP Address"

← Older revision		Revision as of 15:01, 26 July 2012
Line 392:		Line 392:
	</source>		</source>

	== Datetime ==		== Object Types ==
			=== Datetime ===
	The object structure: http://msdn.microsoft.com/en-us/library/system.datetime.aspx		The object structure: http://msdn.microsoft.com/en-us/library/system.datetime.aspx

	=== Improper (US) Formatting ===		==== Improper (US) Formatting ====
	Be aware that if you live somewhere dates are normally formatted properly (eg not the USA), then PowerShell (or probably the underlying DateTime object type as this sort of problem seems to rear its head at unexpected moments when working on Windows) has a nasty habit of returning a string formatted with day and month swapped around when coming from a script.		Be aware that if you live somewhere dates are normally formatted properly (eg not the USA), then PowerShell (or probably the underlying DateTime object type as this sort of problem seems to rear its head at unexpected moments when working on Windows) has a nasty habit of returning a string formatted with day and month swapped around when coming from a script.

Line 402:		Line 403:
	If your dates are getting mixed up, it may not be your mistake, and it may be that you've fallen fowl of the problem as well.		If your dates are getting mixed up, it may not be your mistake, and it may be that you've fallen fowl of the problem as well.

	=== Formatting ===		==== Formatting ====
	To control how a DateTime is displayed you can pass it through <code> Get-Date </code> with the '''<code> -uFormat </code>''' option...		To control how a DateTime is displayed you can pass it through <code> Get-Date </code> with the '''<code> -uFormat </code>''' option...
	<source lang="powershell">Get-Date $datetime -uFormat "%R hrs, %a %d %b %Y"</source>		<source lang="powershell">Get-Date $datetime -uFormat "%R hrs, %a %d %b %Y"</source>
Line 438:		Line 439:
	For the full list of formatting options see http://technet.microsoft.com/en-us/library/ee692801.aspx, and even more detail at http://msdn.microsoft.com/en-us/library/system.globalization.datetimeformatinfo.aspx		For the full list of formatting options see http://technet.microsoft.com/en-us/library/ee692801.aspx, and even more detail at http://msdn.microsoft.com/en-us/library/system.globalization.datetimeformatinfo.aspx

	=== Converters ===		==== Converters ====
	<source lang="powershell">		<source lang="powershell">
	function ConvertLocalToUnix([datetime]$datetime)		function ConvertLocalToUnix([datetime]$datetime)
Line 448:		Line 449:
	{		{
	[timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970').AddSeconds($sincepoch))		[timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970').AddSeconds($sincepoch))
			}
			</source>

			=== IP Address ===
			To create an IP address object...
			<source lang="powershell">
			$ip = [System.Net.IPAddress]::Parse("192.168.1.123")
			</source>

			To confirm a supplied address is valid...
			<source lang="powershell">
			if ([System.Net.IPAddress]::TryParse($IP-to-test) {
			Write-Host "$IP-to-test is a valid address"
	}		}
	</source>		</source>

Sstrutt: /* Macros / Built-in Variables */ Added $env

2012-06-07T13:45:20Z

Macros / Built-in Variables: Added $env

← Older revision		Revision as of 13:45, 7 June 2012
Line 460:		Line 460:

	== Macros / Built-in Variables ==		== Macros / Built-in Variables ==

	{\|class="vwikitable"		{\|class="vwikitable"
	\|-		\|-
	! Variable !! Description		! Variable !! Description
	\|-		\|-
	\| <code> $_ </code> \|\| ~~Either~~		\| <code> $_ </code> \|\| Variable passed through pipeline from previous command
	\|-		\|-
	\| <code> $? </code> \|\| Success/failure of previous statement - see [[#Basic_Error_Handler\|Basic_Error_Handler]]		\| <code> $? </code> \|\| Success/failure of previous statement - see [[#Basic_Error_Handler\|Basic_Error_Handler]]
Line 475:		Line 474:
	\| <code> $foreach </code> \|\| Enumerator in a foreach loop		\| <code> $foreach </code> \|\| Enumerator in a foreach loop
	\|-		\|-
	\| <code> $Host </code> \|\| Information about the machine being executed on		\| <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]]		\| <code> $args </code> \|\| Array of arguments passed to a script - see [[#Script_Arguments\|Script_Arguments]]
	\|}		\|}

			=== $env ===
			This object contains all local system environment variables. For example '''<code>$env:COMPUTERNAME</code>''' provides you with the local system's computer name.

			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:PowerShell]]

Sstrutt: /* Array Types */ Update ArrayList create example

2012-05-16T09:17:09Z

Array Types: Update ArrayList create example

← Older revision		Revision as of 09:17, 16 May 2012
Line 381:		Line 381:
	To force the creation of a .NET array from a PowerShell CmdLet, create one in a fashion such as this...		To force the creation of a .NET array from a PowerShell CmdLet, create one in a fashion such as this...
	<source lang="powershell">		<source lang="powershell">
	$a = New-Object System.Collections.ArrayList(,(Get-Content test.txt))		$a = New-Object System.Collections.ArrayList # Empty array
			$a = New-Object System.Collections.ArrayList(,(Get-Content test.txt)) # Populated with contents of test.txt
	</source>		</source>

Sstrutt: /* Datetime */ Minor rewording

2012-04-24T08:33:35Z

Datetime: Minor rewording

← Older revision		Revision as of 08:33, 24 April 2012
Line 395:		Line 395:

	=== Improper (US) Formatting ===		=== Improper (US) Formatting ===
	Be aware that if you live somewhere dates are normally formatted properly (eg not the USA), then ~~Powershell~~ (or the underlying DateTime object type) has a nasty habit of returning a string formatted with day and month swapped around when coming from a script.		Be aware that if you live somewhere dates are normally formatted properly (eg not the USA), then PowerShell (or probably the underlying DateTime object type as this sort of problem seems to rear its head at unexpected moments when working on Windows) has a nasty habit of returning a string formatted with day and month swapped around when coming from a script.

	If you do a <code> Get-Date </code> it all looks fine, but then you output a DateTime object in a script to some text and its wrong. Add the <code> .ToString() </code> method to the end at it'll sort itself, though quite why when Powershell is converting the object into a string anyway, the object ~~needs~~ to be explicitly told to fix the issue, seems a bit superfluous.		If you do a <code> Get-Date </code> it all looks fine, but then you output a DateTime object in a script to some text and its wrong. Add the <code> .ToString() </code> method to the end at it'll sort itself, though quite why when Powershell is converting the object into a string anyway in order to display, should the object need to be explicitly told to fix the issue, seems a bit superfluous. I obviously don't understand what the underlying bug is!

			If your dates are getting mixed up, it may not be your mistake, and it may be that you've fallen fowl of the problem as well.

	=== Formatting ===		=== Formatting ===

Sstrutt: Initial creation - content from depreciated PowerShell page with a bit of reformatting

2012-04-20T14:21:06Z

Initial creation - content from depreciated PowerShell page with a bit of reformatting

New page

__TOC__

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> [bool] </code> || True / false
|-
| <code> [single] </code> || Single-precision 32-bit floating point number
|-
| <code> [double] </code> || Double-precision 64-bit floating point number
|-
| <code> [byte] </code> || 8-bit unsigned character
|-
| <code> [int] </code> || 32-bit integer
|-
| <code> [long] </code> || 64-bit integer
|-
| <code> [decimal] </code> || 128-bit decimal
|-
| <code> [char] </code> || Single character
|-
| <code> [string] </code> || String of characters
|-
| <code> [datetime] </code> || Date and time
|-
| <code> [timespan] </code> || Time
|-
| <code> [xml] </code> || XML object
|-
| <code> [array] </code> || Array
|-
| <code> [wmi] </code> || Windows Management Instrumentation (WMI) instance or collection
|-
| <code> [wmiclass] </code> || WMI class
|-
| <code> [adsi] </code> || Active Directory Services object
|-
| <code> [Boolean] </code> || True or False value
|}

== 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>

== Strings ==
Basic manipulation tasks can be carried out by using the string object's methods, eg <code> "string".PadRight(10) </code>, see <code> Get-Member -InputObject "Text" </code> for full details.

=== Concatenation + ===
<source lang="powershell">
$strAB = $strA + $strB
</source>

=== Interpolation ===
Interpolation allows variables to be embedded into a string and to be resolved into their actual values. This works between double quotes, but not between single quotes...
<source lang="powershell">
PS E:\> $sub = "replaced"
PS E:\> Write-Output "Variable has been $sub"
Variable has been replaced
PS E:\> Write-Output 'Variable has been $sub'
Variable has been $sub
</source>

=== Search ===
To search for specific text in a string...
<source lang="powershell">
if (Select-String -InputObject $text -Pattern "StringToFind" -Quiet)
{
# StringToFind found in $text
}
</source>

=== Match (basic) ===
To do a basic search/match...
<source lang="powershell">
if ($res.Contains("Success")) {
# String did contain
} else {
# Didn't
}
</source>
...which is much preferable to...
<source lang="powershell">
if ($res.CompareTo("Success")) {
# Didn't match (CompareTo returns 1 if comparison fails !)
} else {
# Did match
}
</source>

=== Match (extract) ===
To extract text that matches a regex...
<source lang="powershell">
$res = [regex]::matches($line, "\d{4}-[A-Za-z]{3}-Week\d{1}.log")
if (-not $res.Count)
{
# No matches found
} else {
$res1 = $res.Item(1).Value # 1st match to regex
}
</source>
See [[Regular Expressions]] for further info on regex stuff.

=== Replace ===
Basic find and replace can be done with a string's Replace method, eg to replace "\" with "\\" in the $query variable...
<source lang="powershell"> $query = $query.Replace("\", "\\") </source>
For proper regular expressions support, use the following syntax
<source lang="powershell"> $query = [regex]::Replace($query, "search", "replace") </source>

=== Strip Whitespace ===
<source lang="powershell"> $string = $string.TrimEnd() </source>

== Escape Characters ==
{|class="vwikitable"
|-
! Text !! Description
|-
| <code> `0 </code> || Null
|-
| <code> `a </code> || Bell/system beep
|-
| <code> `b </code> || Backspace
|-
| <code> `f </code> || Form feed
|-
| <code> `n </code> || New line
|-
| <code> `r </code> || Carriage return
|-
| <code> `t </code> || Tab (horizontal)
|-
| <code> `v </code> || Vertical tab
|-
| <code> `' </code> || '
|-
| <code> `" </code> || "
|}

== Arrays ==
<source lang="powershell">
$array = @() # Create blank array
$array += 34 # Add value to end of array
</source>

To create an array (table) with column headings, initialise an array, then create a ''row'' variable with the column headings and add this ''row'' to the array. This is convenient when building a table of data within a loop eg
<source lang="powershell">
$table = @()
foreach ($instance in $set) {
$row = "" | Select Heading1, Heading2, Heading3
$row.Heading1 = "something"
$row.Heading2 = "like"
$row.Heading3 = "this"
$table += $row
}
</source>

=== Add rows to an array ===
<source lang="powershell">
> $array = @()
> $row = "" | Select h1,h2,h3
> $row.h1 = "esx1"
> $row.h2 = "HBA1"
> $row.h3 = "LUN1"
> $array = $array + $row
> $row = "" | Select h1,h2,h3
> $row.h1 = "esx2"
> $row.h2 = "HBA1"
> $row.h3 = "LUN2"
> $array = $array + $row
> $array

h1 h2 h3
-- -- --
esx1 HBA1 LUN1
esx2 HBA1 LUN2
</source>

=== Select row from array ===
Using above array as example...
<source lang="powershell">
> if (($array |?{$_.h1 -eq "esx2"})) {"true"} else {"false"}
true
> if (($array |?{$_.h1 -eq "esx3"})) {"true"} else {"false"}
false
> $array |?{$_.h1 -eq "esx2"}

h1 h2 h3
-- -- --
esx2 HBA1 LUN2

> $array |?{$_.h1 -eq "esx2"} | Select -ExpandProperty h2
HBA1
</source>

=== Array Types ===
.NET Array Lists are far more flexible than PowerShell arrays. With ArrayLists you can easily Add and Remove members and generally enjoy much more flexibility when it comes to manipulating its contents. Despite showing a full range of available methods (when piped through a <code>Get-Member</code>), PS arrays generally don't have many available methods. To confirm the type that you have...

<source lang="powershell">
> $ArrayList.gettype()

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

> $PSArray.gettype()

IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Object[] System.Array
</source>

To force the creation of a .NET array from a PowerShell CmdLet, create one in a fashion such as this...
<source lang="powershell">
$a = New-Object System.Collections.ArrayList(,(Get-Content test.txt))
</source>

== Hashtables ==
<source lang="powershell">
$hash = @{} # Create blank array
$hash["Name"] = "Value" # Add value to end of array
$hash.GetEnumerator() | Sort-Object -Property Name # Sort hashtable
</source>

== Datetime ==
The object structure: http://msdn.microsoft.com/en-us/library/system.datetime.aspx

=== Improper (US) Formatting ===
Be aware that if you live somewhere dates are normally formatted properly (eg not the USA), then Powershell (or the underlying DateTime object type) has a nasty habit of returning a string formatted with day and month swapped around when coming from a script.

If you do a <code> Get-Date </code> it all looks fine, but then you output a DateTime object in a script to some text and its wrong. Add the <code> .ToString() </code> method to the end at it'll sort itself, though quite why when Powershell is converting the object into a string anyway, the object needs to be explicitly told to fix the issue, seems a bit superfluous.

=== Formatting ===
To control how a DateTime is displayed you can pass it through <code> Get-Date </code> with the '''<code> -uFormat </code>''' option...
<source lang="powershell">Get-Date $datetime -uFormat "%R hrs, %a %d %b %Y"</source>

Useful formatting examples...
{|class="vwikitable"
|-
! uFormat Specifier !! Example
|-
| <code> %R hrs, %a %d %b %Y </code> || <code> 07:25 hrs, Fri 24 Dec 2010 </code>
|-
| <code> %Y-%m-%d </code> || <code> 2010-12-24 </code>
|}
For the full list of formatting options see http://msdn.microsoft.com/en-us/library/system.globalization.datetimeformatinfo.aspx

Or you can use the '''<code>ToString</code>''' method provided by the object, to convert the date. If you use a generic specifier you should get a local format output (though see note above about [[#Improper_.28US.29_Formatting|Improper (US) Formatting]] if things aren't behaving expected)...
<source lang="powershell">$datetime.ToString("s")</source>

Useful formatting examples...
{|class="vwikitable"
|-
! ToString Method Specifier !! UK-Centric Example Output
|-
| <code> <blank> </code> || <code> 17/02/2011 13:07:33 </code>
|-
| <code> d </code> || <code> 17/02/2011 </code>
|-
| <code> D </code> || <code> 17 February 2011 </code>
|-
| <code> yyyy-MM-dd HH:mm:ss </code> || <code> 2011-02-17 13:07:33 </code>
|-
| <code> HH:mm:ss.fff </code> || <code> 13:07:33.423 </code>
|}
For the full list of formatting options see http://technet.microsoft.com/en-us/library/ee692801.aspx, and even more detail at http://msdn.microsoft.com/en-us/library/system.globalization.datetimeformatinfo.aspx

=== Converters ===
<source lang="powershell">
function ConvertLocalToUnix([datetime]$datetime)
{
($datetime.ToUniversalTime() - ([datetime]'1/1/1970 00:00:00')).TotalSeconds
}

function ConvertUnixtoLocal($sincepoch)
{
[timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970').AddSeconds($sincepoch))
}
</source>

== Environment ==
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>

== Macros / Built-in Variables ==

{|class="vwikitable"
|-
! Variable !! Description
|-
| <code> $_ </code> || Either
|-
| <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
|-
| <code> $args </code> || Array of arguments passed to a script - see [[#Script_Arguments|Script_Arguments]]
|}

[[category:PowerShell]]