Windows PowerShell is the successor of the windows cmd language, which itself has its roots in the ms-dos Bat language. All recent versions of Windows offer PowerShell (PS). PS may be seen as Microsoft's answer to the shells common in Unix/Linux (such as csh, bash, etc.). Its name implies that Microsoft sees the shell as powerful, which it arguably is.

In these notes some important PS commands are listed and PowerShell's most notable feature, the object pipeline, is discussed. From the outset it is important to note that, in contrast to Linux/Unix, Windows PowerShell is completely case-insensitive.

The monospace text snippets below are valid PS and may be copied, pasted, and executed in a PowerShell- or a PowerShell_ISE-session. This is why the notes form a "Cheatsheet". As is common for cheatsheets, there is hardly any explanation, the examples speak for themselves. It must be stressed here that many of the basic PS commands are not at all orthogonal, so that many variant pipelines can lead to the same effect. Often an example is one out of a multitude of possibilities accomplishing the same task.

The last two sections are about search in and traversal of the Windows Registry by means of PowerShell.

Unrelated to PS

1. In the Windows (File) Explorer address bar enter cmd, powershell.exe, or powershell_ise and a corresponding window opens at the current directory (aka folder). This is most likely the shortest route to opening a cmd, ps, or ps_ise session from a given directory.
2. After hitting the start or search button in the windows taskbar type any of: Control Panel (in Dutch: Configuratiescherm), Regedit, PowerShell, or cmd. This opens a window with the name of the chosen program (Control Panel, Regedit, etc). Click on it once and the program chosen opens.
3. Adaptation of user environment variables: Control Panel/User Accounts/User Accounts/. Then left panel: change my environment variables. (Choose in Control Panel: view by category).
4. Adaptation of system environment variables. Choose in Control Panel: view by category. Then Control Panel/System and Security/System/Advanced System Settings. Button: Environment Variables. Set in panel system variable. Change is persistent, a change (see below) within PowerShell is volatile.
5. In a cmd session: setx sets persistent user environment variable. To unset: go to HKCU/environment (in the Registry) or to Control Panel/User Accounts.

To contents

About ISE

ISE stands for Integrated Scripting Environment. ISE—a standard part of Windows 10—is an editing and execution environment for PowerShell.

An important advantage of the use of ISE over pure PowerShell, is that ISE offers pop-up help: when the user is typing a command line, ISE often pops up a relevant list of methods and properties. By double clicking on an entry in the pop-up list, the entry is appended to the command line.

1. Upon the start of ISE, the script Microsoft.PowerShellISE_profile.ps1 is executed.
2. To protect ordinary users against malignant PS scripts, the execution of PowerShell scripts (including the ISE profile) must be allowed explicitly. This is done once and for all by issuing the command

                 Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
   

3. Allow execution of a script downloaded from the internet by:

                 unblock-file .\script.ps1
   

   where script is the name of the downloaded script (which is in the current directory).
4. Execution of a script requires that the scriptname is prefixed by its path. If the script is in the present folder use .\script.ps1, where script is the name of the script.
5. Set width and height of the ISE output pane by:

                 $Host.UI.RawUI.BufferSize = New-Object $Host.UI.RawUI.BufferSize.GetType().Fullname (150, 40)
   

   (The pure PS console does not allow shrinking of width).
6. Set ISE console fontsize by:

                 $Host.PrivateData.FontSize = 13
   

   (pure PS has a different $Host.PrivateData object).
7. Start PowerShell as administrator:

                 Start-Process PowerShell -Verb runAs
   

8. An important ISE tool for PowerShell learners is CTRL-J. This pops up a selection of code snippets. These are templates that give illustrative examples of PS syntax and can be used in scripts as a start points for further editing.

To contents

Cmdlets

      PS C:\Users\myname> Get-ChildItem 

The names of members (methods and properties) of an object can be obtained by piping the output of a cmdlet to Get-Member (see below). Any cmdlet parameter (aka flag) can be truncated to the extent that it is still unique. A few examples of cmdlets and their parameters:

   Get-Help                   # Gets help about a cmdlet,
                              # example: get-help get-help
   Get-PSdrive                # List available PSdrives, such
                              # as c:, env:, hklm:, hkcu:, alias:, etc.
   Get-ChildItem              # In the Registry: children are subkeys 
                              # of the current key. 
   Get-ChildItem              # In the File System: children are subfolders and filenames 
                              # of the current folder.
   Get-ChildItem -recurse     # Lists recursively all children
                              # of current PSdrive, Folder, or Registry key.
   Get-ChildItem -rec -force  # Include hidden folders
                              # (flag -hidden searches hidden directories only)
   (Get-ChildItem).name       # List names ('name' is an object property)
                              # of files and directories in current folder.
   Get-ChildItem  -name       # Equivalent to (Get-ChildItem).name
                              # 
   (Get-ChildItem).count      # Number of entries in the collection of objects returned by Get-ChildItem
                              # (count is a property of such a collection).

To contents

PSdrives

Standard one enters a PS session in the home folder (home directory) of the user. To switch a PS session to another PSdrive or folder and get the children of the new location, proceed as follows:
Switch to env:

    Set-Location env:                 # Prompt character becomes `Env:\>` 
                                      # (environment variables)
    Env:\> Get-Childitem              # Get all environment variables
                                      # 
    Env:\> Get-Childitem userprofile  # Get environment variable `userprofile`
                                      # (returns with: USERPROFILE C:\Users\user_name)

                            
    Env:\> Set-Location alias:        # Prompt character becomes Alias:\>
    Alias:\> Get-Childitem            # All children (i.e., all aliases)

   
    Alias:\> Set-Location C:\          # Prompt character becomes C:\>
                                       # 
    C:\> Set-Location $env:userprofile # Use environment variable `userprofile` to
                                       # switch to C:\Users\user_name (home folder of user).
    C:\Users\user_name>$alias:ls       # Get what alias 'ls' stands for
                                       # (namely Get-ChildItem)  

To contents

Pipelines

IMPORTANT:  Cmdlets pass objects through pipelines, not character streams as in Unix.

The pipeline character is | (ASCII 124). It must be followed by a command that can handle the output passed through the pipeline; usually this is a cmdlet. Example of a pipeline consisting of three stages:

   Get-ChildItem *.txt | Where-Object length -lt 1000 | Sort-Object length  

The output of Get-ChildItem flop.txt is an object and by the pipe

    Get-ChildItem flop.txt | Get-Member

Members are selected by a dot, as is usual in object-oriented languages. Thus, one can write:

   (Get-ChildItem flop.txt).name  # -> flop.txt

   (Get-ChildItem file.txt).LastWriteTime = Get-Date  # "touch" file.txt

The object created by a cmdlet depends in general on the cmdlet's parameters (flags). For example, by adding the flag -name

   (Get-ChildItem flop.txt -name).name  # -> null

The object that is passed through a pipeline is referred to by the automatic variable $_, which may be used only inside a script block. (A script block is a collection of statements enclosed in curly brackets.) Accordingly, a member named "member_name" of the object passed is referred to as $_.member_name.

The cmdlet Rename-Item may be used to change file names and file extensions. The old file name can be entered through a pipeline. The new name follows the parameter -newname

    "flop.txt" | Rename-Item  -newname flap.txt  # We now have a file named flap.txt in the folder

    Get-ChildItem flap.txt | Rename-Item -new {$_.name} # Renamed flap.txt to flap.txt

   Get-ChildItem flap.txt -name | Rename-Item -new {$_.name} # Error: parameter $_.name is null

When more than one object is outputted by a cmdlet in the pipeline, these objects are first stored in a temporary buffer. After the buffer is filled, the cmdlet in the next stage performs its task by looping over the buffer and reading the objects one by one. When this stage is not the last of the pipeline, the cmdlet puts its outputted objects in yet another temporary buffer that serves as the input for the next stage. An object that drops out at the end of the pipeline is usually written to screen by a screen writing method of the object. The concept of intermediate buffering is very important for the understanding of PowerShell pipelines.

For example in the following statement, Get-ChildItem fills a temporary buffer with objects that all have the property basename (which is also an object). The cmdlet Select-Object selects the basename properties and stores them in a yet another temporary buffer, which is passed to Sort-Object, which sorts the elements of the buffer and writes the names of the basename objects, i.e., Sort-Object writes the file names without file extension.

    Get-ChildItem | Select-Object basename | Sort-Object *

The use (or missing) of parameters of cmdlets that receive input in pipelines can generate unexpected errors. Example:

     Move-Item *.txt subdirectory

     Get-ChildItem *.txt | Move-Item ..\   # Error!

   Move-Item : The input object cannot be bound to any parameters for the command either because the command does not take
   pipeline input or the input and its properties do not match any of the parameters that take pipeline input.

    Get-ChildItem *.txt | Move-Item -destination ..\

To contents

Useful aliases

    ac = Add-Content                 # Example: ac -value 'The End' -path 'flop.txt'
                                     # (appends value to file)
    cat = gc = type = Get-Content    # Get the content of a file;
                                     # returns an array with one line per element
    cd = sl = Set-Location           # Change folder, Registry key, or PSdrive.
                                     # Example: cd env:, cd HKLM:
    cls = clear = Clear-Host         # Clears console
                                     #
    del = erase	= Remove-Item        # Remove files, registry keys, etc.
                                     #
    dir = gci = ls = Get-Childitem   # List children in current PSdrive, folder, Registry key
                                     #
    echo = write = Write-Output      # String to output array. Array is sent to console, into
                                     # pipeline, or redirected/appended to file
    foreach = % = Foreach-Object     # Only in pipeline: for each object crossing the pipeline
                                     # Do not confuse with language construct of the same name
    ft = Format-Table                # Example: ls *.jpg |ft directory, length, name -AutoSize  -Wrap 
                                     # 
    fl = Format-List                 # Example: ls env:Path |fl
                                     # (gives wrapped output of environment variable "Path")
    gal = Get-Alias                  # "Get-Alias -definition cmdlet", gives aliases of cmdlet
                                     # "Get-Alias [-name] alias", gives name of cmdlet called by alias
    gcm = Get-Command                # Get all commands (cmdlets, functions, and aliases).
                                     # gcm -CommandType Alias -> all aliases
    gm = Get-Member                  # Example: ls flop.txt | gm
                                     # (all members of object flop.txt)
    gp  = Get-ItemProperty           # In file system: gp * gives same output as ls *
                                     # In Registry: value entries (names and values)
    gpv  = Get-ItemPropertyValue     # In filesystem: get prop's of files. Ex: gpv *.txt basename (names of .txt files)
                                     # Ex: In HKCU:\SOFTWARE\Microsoft\Accessibility: gpv -name cursorsize (returns number)
    gv = Get-Variable                # Get names and values of
                                     # all session variables
    ni = New-Item                    # Create new file, directory, symbolic link, 
                                     # registry key, or registry entry	
    ps = gps = Get-Process           # List running processes.
                                     #
    pwd = gl = Get-Location          # Current directory (folder)
                                     # or Registry key
    ren = rni = Rename-Item          # Examples: ren report.doc report.txt
                                     # and: ls report.doc | ren -newname report.txt
    rmdir = rm = ri = Remove-Item    # Remove directories, files, registry keys, etc.
                                     #
    rv = Remove-Variable             # Remove variable (name without $ prefix, while
                                     # note that variable names must begin with $)
    select = Select-Object           # Select specified properties of piped object
                                     # Example: ps |select Processname | select -first 10
    sleep = Start-Sleep              # Sleep -sec 1
                                     # (sleep 1 second)
    sls    = Select-String           # Example: sls foo.txt -patt '^\S' (a regular expression
                                     # giving all lines that do not start with blank, tab, or EOL)
    where  = ? = Where-Object        # Only in pipeline.
                                     # Example: ls -recurse |? name -like '*Pict*'
    $env:userprofile = ~             # Example: cd ~ (change folder to home folder of user).							 

To contents

Example of a pipelined command

    Get-ChildItem -recurse -path *.dll | Where-Object {$_.length -lt 10000} |
       Sort-Object -property Length | Format-Table -property name, length, directory -wrap

    $a = ls -r *.dll |? length -lt 10000  # Store in $a all .dll files from current directory downward
                                          # with file sizes < 10000 bytes

    $a | sort length | ft  name, length, directory -w # Sort entries of array $a on file size (length) and tabulate
                                                      # formatted name, length, and directory

    ls -r *.dll |? length -lt 10000 |sort length |ft name, length, directory -w

To contents

More examples of pipelines

    ./program.exe < input.txt 

    cat input.txt | ./program.exe

    ls PSnotes.txt |fl *                          # Lists all properties: Directory, LastAccessTime, Basename, etc.
    ls PSnotes.txt |fl LastAccessTime, Basename   # Lists two properties: date/time of last access and file name.

    ls PSnotes.txt |ft LastAccessTime, Basename   # Tabulates date and time of last access and file name

To list the content of the lines in foo.out that begin with at least four spaces together with their sequence numbers use select-string (alias sls). The cmdlet has the parameter -pattern that specifies a regexp:

    sls foo.out -pattern '^[ ]{4,}' | ft linenumber, line

   sls *.txt  -patt 'was' |ft -wrap filename, linenumber, line

Find all directories called winx from the present directory downward (-rec). Inspect also hidden directories (-force) and suppress error messages (-ea 0):

    ls winx -dir -rec -force -ea 0 |ft

To contents

Examples Where-Object

As an example, list the basenames ending with the letter r in the current directory. Use the operator -match with a regexp and recall that the symbol $ indicates the end of a string:

    ls  |? basename -match 'r$'

    ls  |? basename -match 'r$' |ft basename

Example of the comparison operators: -in, -notmatch, -and, -notlike. The first statement below limits the list of 'svchost' and 'firefox' processes to the first 10 in total. The next statement uses a script block, which is the code snippet between curly brackets:

    ps |? ProcessName -in  "svchost", "firefox" | select -f 10 |ft processname,  PagedMemorySize
    ls |? {$_.name -notmatch 'e$' -and $_.name -notlike 'c*'}     # Names not ending on "e" (regexp) or beginning  with "c"

To contents

Examples ForEach-Object

    Get-Alias   |% {if ($_.name -match '^s') {Write-Host $_.name ' stands for: ' $_.definition}}

    sajb  stands for:  Start-Job
	    ...
    si  stands for:  Set-Item
	    ...
    sleep  stands for:  Start-Sleep
	    ...
    swmi  stands for:  Set-WMIInstance

Note that a list of aliases starting with 's' or 'S' can be obtained in a prescribed format from the shorter Where-Object (?) statements:

    Get-Alias |? name -match '^s'   # regexp
    Get-alias |? name -like 's*'    # string + wildcard

    gal s*

    ls *.txt  |% {Write-Host $_.name, " " -NoNewline;  (cat $_).count }

As yet another example, notice first that

    gal cat |? displayname

    Alias           cat -> Get-Content

    $reg = '-> (\w*)-'

    gal|? displayname -match '-> (\w*)-' |% {$matches[1]} |sort -unique

An example of foreach as a language construct:

    $letterArray = "a","b","c","d"
    foreach($letter in $letterArray){
       Write-Host -ForeGroundColor green $letter
    }

    $ff = ps firefox                  # Usually there is more than one firefox process active
    foreach($p in $ff) {$p.starttime}

    zaterdag 8 juni 2019 07:47:44
    zaterdag 8 juni 2019 13:53:41
    zaterdag 8 juni 2019 07:47:30
    zaterdag 8 juni 2019 07:47:28
    zaterdag 8 juni 2019 15:21:39
    zaterdag 8 juni 2019 13:42:46
    zaterdag 8 juni 2019 11:52:45

     (ps firefox).starttime

To contents

Select-String

Consider as a first example the statements

    $address = 'https://131.174.138.39/~pwormer/teachmat/PS_cheat_sheet.html'
    $parsed  = $address |sls -patt 'https://([0-9.]*)/(.*)$'

 
    $parsed.matches

    Groups   : {0, 1, 2}
    Success  : True
    Name     : 0
    Captures : {0}
    Index    : 0
    Length   : 60
    Value    : https://131.174.138.39/~pwormer/teachmat/PS_cheat_sheet.html

    $parsed.matches.groups[0].value : https://131.174.138.39/~pwormer/teachmat/PS_cheat_sheet.html
    $parsed.matches.groups[1].value : 131.174.138.39
    $parsed.matches.groups[2].value : ~pwormer/teachmat/PS_cheat_sheet.html

As another example, we remark that the present file, called PS_cheat_sheet.html, contains strings that are enclosed in <b> and </b>, i.e., the strings are displayed in bold face. We will now construct a PS pipeline that lists these strings. (The pipeline does not work correctly when bold text extends over different lines. Moreover, the search will be non-greedy, which means that only the first bold string in each line is returned). First we introduce a regular expression (regexp) that captures bold HTML text:

    $reg = '<b>(.*?)</b>'

    sls PS_cheat_sheet.html -patt $reg |% {$_.matches.groups[1].value}

As a final example we consider the file foo.txt with contents:

    In columns 20...25 (six columns) are positive, negative, and unsigned integers.
       101   xxxxx     -23    ddd
         20  ddd          +2     eee
     30    %^&&fghu     -100    ffff
       40    qawer       1000  fffqq
    And yet one more      1    unsigned number in column 23!

     $s=0; (sls foo.txt -patt '.{19}([0-9-+]{1,6})').matches |% {$s+= $_.groups[1].value}; $s

To contents

Create an item

• Folder (aka directory)
• File
• Link (symbolic or hard)
• Registry key
• Registry entry

    New-Item -ItemType SymbolicLink -Path C:\Users\paul\Bureaublad\manual -Target .\manual.txt 

    ni -ty sym -p C:\Users\paul\Bureaublad\manual -v manual.txt

Create more than one .txt file at once, example:

     'file1', 'file2',  'file3' |% {ni $_'.txt'}

    'dir1', 'dir2',  'dir3' |% {ni -ty dir $_}

To contents

Rename an item

    ren report.txt report.doc

    ren *.txt *.doc     # Error in PS!

The cmdlet rename-item can take piped input for the old name and recognizes the flag -newname for the new name. For example,

    'report.txt' | ren -newname report.doc

To change multiple names at once, one may use the -replace operator. Its syntax is:
     string -replace regexp, new_name
In string every substring that matches the regular expression regexp is replaced by new_name. For example,

     'report.txt' -replace '\.txt$', '.doc'  # -> 'report.doc'

    ls *.txt | ren -new { $_.name -replace '\.txt$','.doc' }

In the previous example the PS statement is considerably more difficult to memorize than the equivalent cmd statement. Because that happens more often, it is useful to mention that cmd /c invokes a cmd command from within Powershell (the flag /c stands for "command"). Thus,

    cmd /c rename *.doc *.pdf

     (ls *.doc).basename |% {ren .\$_.doc .\$_.pdf}

Note. The text with hyperlink -replace operator states explicitly that the first argument of -replace must be a regular expression. In the fourth example of

    get-help rename-item -examples

To contents

Datatypes

    [string]$s = 'Peanuts'    # Explicit declaration
    $s         = 4            # Assign new string '4'
    $s * 3                    # Gives 444 (triplicates the string)
    [int]$s    = 4            # Explicit change of type (to int32)
    $s * 3                    # Gives 12
    $s         = 'bear'       # Error --> Cannot convert value "bear" to type "System.Int32"
    [string]$s = 'bear'       # Explicit recasting is OK
    $s = [char]0x07           # Recasting is OK on RHS (hex-char 0x07 sounds "Bell", warning sound)

    'a', 'b', 'c', 'd' > letters.txt       # Each letter on a line in file letters.txt. Output in UTF-16 (!)
    [string]$letter = cat letters.txt      # Get-Content, assign to string
    $letter                                # --> a b c d   (a single string)
    $letter = [string](cat letters.txt)    # The same. Brackets are necessary to cast the output of the cmdlet

    set pi 3.14 -opt const    # Assign constant;  (No $ in set pi !)
    $pi                       # Gives 3.14       (Use $ in reference to the constant just set without $!)
    $pi        = 2            # -> Error: Cannot overwrite variable pi because it is read-only or constant.
    set pie $([math]::pi) -opt const
    $pie                      # -> 3.14159265358979

    $a = @('a', 'b')          # Array    (round brackets, colons as separators)
    $a += 'c'                 # Push 'c'
    $a += 'd'                 # Push 'd'
    $a                        #  --> a\n b\n c\n d  (vertical stack)
    $a.GetType()              #  --> True     True    Object[]      System.Array

    $arry = 1,2,3,4,5         # Array, $arry[0] is 1, $arry[$arry.length-1] is 5.
    $arry.GetType()           # --> True     True     Object[]      System.Array

    $assoc = @{one=1 ; two=2} # Associative array (curly brackets, semicolons as separators)
    $assoc.one                # -> 1
    $assoc['two']             # -> 2
    $assoc['three'] = 3       # Adds a member
    $assoc.four = 4           # Adds a member
    $assoc.GetType()          # --> True     True     Hashtable     System.Object
    $assoc                    #

       Name                           Value
       ----                           -----
       four                           4
       one                            1
       three                          3
       two                            2

To contents

Strings

      $five  = 5
      '3*$five'  -> 3*$five
      "3*$five"  -> 3*5 
      "$(3*5)" -> 15

1. "`n" gives the newline character.
2. The string "John Doe" can be appended to a file simply by "John Doe" >> out.txt. The file out.txt will be in UTF-16.
3. The cmdlet add-content (alias ac) writes to file by default in ANSI (Windows-1252), and allows specification of other encodings.

Here-strings
@' ... '@ (no expansion) and @" ... "@ (with expansion). Note that the openings @' and @" must start in column 1 and be on a single line. The same holds for the endings '@ and "@.

@'
    $a
    $(3*5)
'@

       $a
       $(3*5)

@"
    $a
    $(3*5)
"@

       Big Brother
       15

To contents

The formatting of strings

     "String containing format-items"  -f elements to be formatted separated by commas

    "{0, 0:f4} is rounded to 4 decimals" -f 12.34567       # -> 12.3457 is rounded to 4 decimals
    "12345 converted to hex is: {0,10:x}"  -f 12345        # -> 12345 converted to hex is:       3039
    "Prices are {0, 0:c} and {1, 8:c0}"  -f 12.3998, 1.99  # -> Prices are € 12,40 and      € 2

    {index[,alignment]:[formatString[number]]}

    $str = "One decimal:{1,5:n1}; two decimals:{0, 7:n2}; three decimals:{2, 10:n3}"
    Write-Host($str -f 2.141, 1.141, 3.141)

     One decimal:  1.1; two decimals:   2.14; three decimals:     3.141
                 |||||               |||||||                 ||||||||||

:c

Currency (output depends on the region set in Windows Control Panel: $, €, ...)

:d

Decimal. Only for integers (no decimals)

:e

Scientific (exp) notation

:f

Fixed point, n:fd gives field of length n and d digits after the decimal point. If n is too small the system adapts.

:g

Most compact generic format, fixed or scientific

:n

Number, includes decimal point and thousands separators (choice of dots or commas depend on the region set in Windows Control Panel)

:p

Percentage

:x

Hexadecimal format (only integers)

    gp *.ps1 |% {$_.length}

    gp *.ps1 |% {$_.length/1kb}     # Lengths in kilobyte

    gp *.ps1 |% { "{0, 31} {1, 6:f1}" -f $_.basename, ($_.length/1kb)}

    ls *.ps1 |ft basename, length

    "This is a valuable string" |gm

    $a = ("This is a valuable string").split(' ')

    $env:path.split(';')

To contents

Comparison

    'peanutbutter' -like 'nut'         # false
    'peanutbutter' -like '*nut*'       # true   (* is wildcard)
    'peanutbutter' -notlike '*nut*'    # false
    'peanutbutter' -notlike 'nut'      # true
    'peanutbutter' -match '[a-z]+'     # true   (regexp: all letters)
    'peanutbutter' -match 'r$'         # true   (regexp: last letter is r)
    'peanutbutter' -match '[A-Z]+'     # true   (PS is case insensitive)
    'peanutbutter' -cmatch '[A-Z]+'    # false  (cmatch  matches cases)
    'peanutbutter' -replace 'u', 'U'   # 'peanUtbUtter'

    (Get-FileHash .\UsefulApp.msi).Hash -eq (cat .\UsefulApp.msi.digest)[0]

To contents

Switch

    function f ($str) {
        Switch -casesensitive ($str) {
            'aap'  { write-host 'AAP'  }
            'noot' { write-host 'NOOT' }
            'mies' { write-host 'MIES' }
            'wim'  { write-host 'WIM'  }
            Default { "Unable to determine value of $str" }
        }
        "Statement after switch"
    }
    f('noot')    # --> NOOT \n Statement after switch
    f('Noot')    # Unable to determine value of Noot \n Statement after switch

To contents

Builtin classes

    [console]::beep(800, 1000)    # beep at 800 Hz for 1000 msec
    [console]::write([char]0x07)  # Write hex 07, that is, ring the bell (does not work under ISE)
    [console]::readkey()          # Return name of key + modifier(not under ISE)

    [math]::pi                    # 3.14159265358979
    [math]::cos([math]::pi)       # -1
    [math]::max(-1,  -4)          # -1
    [math]::pow(10,3)             # 1000

To contents

Random numbers

    Get-Random -min 0.0 -max 1.0  # Random nr between 0.0 and 1.0, see help Get-Random for bounds

   $rand = New-Object Random
   $rand | gm                # Gives methods of $rand, among which NextBytes

    [byte[]]$out = @(0,0,0,0) <-->  $out = New-Object Byte[] 4

    $rand.NextBytes($out)    # Fill array $out with 4 integer random numbers n: 0 -le n -le 255
    $out                     # To console

To contents

Errors

    # -ErrorAction Continue | Ignore | Inquire | SilentlyContinue | Stop
    # -ea            2      |    4   |    3    |       0          |   1

    ls -rec -ea 0 *.jpg  # all .jpg files in present and all subdirectories

As in many languages errors may be trapped. Enter Get-Help about_trap to see how. The very same info as web page is here: About trap.
Example of trapping:

    Trap [System.Exception] {
       "Command error trapped.`n$_" # Automatic variable '$_' contains system error msg; `n gives newline.
       continue                     # Suppress traceback, continue after erroneous statement
    }
    nonsenseString                  # Erroneous statement: unknown cmdlet, function or script.
    'Execution continues'

    try {
        An error                    # Illegal statement
    }
    catch {
       "An error occurred"
    }

    $error[0] | fl                   # The latest
    $error[$error.count-1] | fl      # The first

To contents

Functions

   gcm -commandtype function |select  verb -unique |sort verb|ft

Example of a user function:

   function Write-ToScreen($path, $name) {
        Write-Host $path, $name
   }

   function Write-ToScreen {
        param($path, $name)
        Write-Host $path, $name
   }

   Write-ToScreen -path roaming -name debug.txt    # --> roaming \n debug.txt

   Write-ToScreen roaming debug.txt        # Quotes are not required

   Write-ToScreen('roaming', 'debug.txt')  # Quotes are required

1. Write-Output.
2. A simple string reference.
3. The end of a pipeline (including a pipeline of one segment)..

   function list-no{
      write-output "first"
      "second"
      "third" |fl
   }
   $a = list-no     # Nothing to the console; output collected in return array $a
   $a               # --> first \nsecond \nthird  (vertically stacked)

   function list-yes{
      Write-Host "first"
      Out-Host -i "second"
   }
   $a = list-yes    # --> first \nsecond  (vertically stacked) to console
   $a               # No output

   function Write-Vars {
      $a = 'A';  $b = 'B'; $c = 'C'; $d = 'D'; $e = 'E';
      Write-Output $a           # To return array (including EOL chars)
      $e | fl                   # To return array
      Write-Host $b             # To console
      $c                        # To return array
      Out-Host -i $d            # To console
   }
   $f = Write-Vars      # 'B', 'D' to console; 'A', 'E', 'C' to $f
   $f                   # 'A', 'E', 'C' to console
   Write-Vars           # 'A', 'E', 'B', 'C', 'D' to console  (in order of assignment).
   Write-Vars > foo.out # 'B', 'D' to console; 'A', 'E', 'C' to foo.out

   function list-txt{ls *.txt}
   $a = list-txt  # No console output, output of ls returned.
   $a             # Info of .txt files to console
   list-txt  | ft name  # Only file names to console

   function list-txt{ls *.txt|write-host}
   $a = list-txt  # Long file names of .txt files to console, nothing to $a.
   $a             # No output, no returned parameters.

Function parameters can have a default value:

   function f  {
       param($c = "Pete")
       $c
   }
   f         # -> Pete
   f John    # -> John

   function Get-Pos {
       foreach ($p in $args) {
           Write-Host $p
       }
   }
   Get-Pos 1, 2, 'pink elephant',  icecream      # --> 1 2 pink elephant icecream

   Function Test-PipedValue {
       Process {
           Write-Host "name:  " $_.name,
                      "color: " $_.color
       }
   }

   $hash = @{name = 'Jean'; color = 'White'}
   $hash | Test-PipedValue   # --> name:   Jean color:  White

   function Test-Loop{
       process {
          Write $_    # alias of write-output, appends EOL char
       }
   }
   1, 2, 3, 4 | Test-Loop # --> 1\n 2\n 3\n \4

To contents

Scripts

The output of scripts is comparable to that of functions. That is, the command Write-Host writes immediately (and only) to the console, while Write-Output writes to a return array. After termination of the script it is decided what happens to the return array: redirected to a file or to the console. Create the script Measure-Text.ps1 containing the following 8 lines:

   # Begin Measure-Text.ps1
      Param ([string]$filename)                              # Script with one parameter, a string.
      Write-Output "`nStatistics of $filename `:"            # To return array
      cat $filename | measure -line -word -character|ft      # To return array, counts of lines, words, and chars
      Write-Host "You will hear a beep after 2 sec:"         # To console
      sleep -sec 2
      Write-Host 'Beep'; [console]::beep(800,1000);          # To console
   # End Measure-Text.ps1

   .\Measure-Txt.ps1 -filename .\Measure-Txt.ps1 > foo.out
   cat foo.out

   .\Measure-Txt.ps1 .\Measure-Txt.ps1

   function Display-Hello {
      "Hello, World"
      $global:a = 13
   }
   Display-Hello
   $a

To contents

Traversing the Windows Registry

• hkey_classes_root (hkcr)
• hkey_current_user (hkcu)
• hkey_local_machine (hklm)
• hkey_users (hku)
• hkey_current_config (hkcc)

   PS Microsoft.PowerShell.Core\Registry::HKCR>

   New-PSDrive -PSProvider registry -Root HKEY_CLASSES_ROOT -Name HKCR

   set ps 'PSChildName' -opt constant

   cd hkcu:\software

Now follows a list of examples that may be useful in inspecting/traversing the Registry:

   ls -rec -depth 1  -name    # Tabulate names of subkeys (children) and subsubkeys (grandchildren).
   gp *                       # Lists all value entries (name and value) in all subkeys plus a few PS variables that define
                              # three generations of the current path. Skips empty subkeys.
   ls 7-zip | gp              # Value entries (names and values) of the subkeys of 7-zip (plus a few PS variables).
   gp .                       # Lists value entries in present key. No output if present key is empty.
   gp * |ft $ps               # $ps='PSChildname' is a PS variable, returned by gp, that contains the name of subkey (child).
                              # Hence this tabulates names of all non-empty subkeys.
   gp microsoft               # No output because no value entry present in subkey 'microsoft' (is empty).
   gp RegisteredApplications  # Value entries (names and values) of hkcu:\software\RegisteredApplications + PS info
   gi *                       # Same as ls *; lists names of subkeys (also empty ones) and their value entries;
                              # no output when present key is endnode.
   gi .                       # Value entries of present key. Almost same info as 'gp .', but somewhat different format.
   gi .\Microsoft\Notepad     # Value entries of subkey
   gi .\microsoft\Notepad |fl *   # A subkey is an object, list its property names and values. One member is array 'Property'
   gi .\microsoft\Notepad |select -exp property # The content of array 'Property' in expanded form,
                                                # the array elements contain the names of value entries of the present key.

   ls * -rec -depth 1 -ea 4 | measure -line   # gives 35329 lines
   ls   -rec -depth 1 -ea 4 | measure -line   # gives   804 lines

   ls -rec -depth 1 |select name, property

   ls -rec -depth 1 |select name, property |% {$_.name; $_.property; "" }

To contents

Registry lookup

   ls -name -rec -depth 1 |% {$p=pwd; cd $_ -ea 4; pwd; cd $p; rv p}

   ls -name -rec -depth 1 |gp |select pspath

   gi . |select -exp property  # This returns line by line the names of the value entries.

    $p=pwd; cd 7-zip; gpv -name lang; cd $p; rv p;

   gi . |select -exp property |% {$v=gpv -name $_; write-host $_":", $v; rv v;}

   ls -rec -name -de 2 |% {$cd=pwd; $p=$_; cd $p -ea 4; gi . |select -exp property|`
   % {$name=$_; $v=gpv -name $name; write-host $p": ", $name" = "$v; rv name, v }; cd $cd; rv cd, p}

   $string = "aul"
   ls -rec -name -depth 2 |% {$cd=pwd; $p=$_; cd $p -ea 4; gi . |select -exp property|`
   % {$name=$_; $v=gpv -name $name; if ($v -match $string) {write-host $p": ", $name" = "$v;}; rv name, v }; cd $cd; rv cd, p}
   rv string

To contents