PowerShell Notes

1.  概要

     - PowerShell 是cmdlet（command-let）的指令集合，相似unix的bash。

     - IDE: Windows PowerShell ISE，不區分大小寫，能夠用命令行get-help獲取幫助

     - 以.NET爲基礎，向前兼容WSH，能夠使用現有的COM技術，也能夠直接訪問.NET類庫(如：[io.path]::GetDirectoryName($MyInvocation.InvocationName))，能夠與windows系的相關軟件互動（如：Excel， Exchange Server等）。

     - wiki上的範例      

 1 #1 - 獲取全部命令[4]：
 2 PS> Get-Command
 3 #2 - 查看Get-Command命令的用法[5]：
 4 PS> Get-Help Get-Command
 5 #3 - 中止全部目前執行中的以"p"字元開頭命名的程式：
 6 PS> get-process p* | stop-process
 7 #4 - 中止全部目前執行中的全部使用大於1000MB記憶體的程式：
 8 PS> get-process | where { $_.WS -gt 1000MB } | stop-process
 9 #5 - 計算一個目錄下檔案內的位元組大小：
10 PS> get-childitem | measure-object -property length -sum
11 #6 - 等待一個叫作"notepad"的程式執行結束：
12 PS> $processToWatch = get-process notepad
13 PS> $processToWatch.WaitForExit()
14 #7 - 將"hello, world!"字串轉為英文大寫字元，成為"HELLO, WORLD!"：
15 PS> "hello, world!".ToUpper()
16 #8 - 在字串"string"的第1個字元後插入字串"ABC"，成為"sABCtring"：
17 PS> "string".Insert(1, "ABC")
18 #9 - 訂閱一個指定的RSS Feed並顯示它最近8個主題：
19 PS> $rssUrl = "http://blogs.msdn.com/powershell/rss.aspx"
20 PS> $blog = [xml](new-object System.Net.WebClient).DownloadString($rssUrl)
21 PS> $blog.rss.channel.item | select title -first 8
22 #10 - 把"$UserProfile"設定成數值"UserProfile"的環境變數：
23 PS> $UserProfile = $env:UserProfile

View Code

2.  一段PS腳本的解析   

1 $status = @{1 = "L"; 2 = "R"; 4 = "W"; 8 = "M"}
2 $value = 14
3 $statutext = ($status.Keys | where { $_ -band $value } | foreach { $status.Get_Item($_) } | sort) -join ""
4 $expecting = ($expecting.GetEnumerator() | sort) -join ""

   - $_ 表明循環體內的值，$status中的key哪些包含在$value中，以上代碼段中當$value=14時，$status.Keys | where { $_ -band $value }的結果爲 {2，4，8}

   - 操做符-band 表示bit and； -join 做用是把數組鏈接成字符串，能夠經過get-help about_join得到具體使用方法

   - 操做符 | 爲pipe line，如： command1 | command2 | command3，執行順序爲 command1 -〉 command2 -〉 command3

#參考文檔 1

3.  about_Splatting

TOPIC
    about_Splatting

SHORT DESCRIPTION
    Describes how to use splatting to pass parameters to commands
    in Windows PowerShell.

LONG DESCRIPTION
    [This topic was contributed by Rohn Edwards of Gulfport, 
     Mississippi, a system administrator and the winner
     of the Advanced Division of the 2012 Scripting Games.
     Revised for Windows PowerShell 3.0.]

    Splatting is a method of passing a collection of parameter
    values to a command as unit. Windows PowerShell associates 
    each value in the collection with a command parameter. 
    Splatted parameter values are stored in named splatting 
    variables, which look like standard variables, but begin with
    an At symbol (@) instead of a dollar sign ($). The At symbol
    tells Windows PowerShell that you are passing a collection of
    values, instead of a single value.

    Splatting makes your commands shorter and easier to read. You 
    can re-use the splatting values in different command calls and
    use splatting to pass parameter values from the $PSBoundParameters
    automatic variable to other scripts and functions.

    Beginning in Windows PowerShell 3.0, you can also use splatting
    to represent all parameters of a command.


SYNTAX

    <CommandName> <optional parameters> @<HashTable> <optional parameters>

    <CommandName> <optional parameters> @<Array> <optional parameters>


    To provide parameter values for positional parameters, in which 
    parameter names are not required, use the array syntax. To provide 
    parameter name and value pairs, use the hash table syntax. The 
    splatted value can appear anywhere in the parameter list.

    When splatting, you do not need to use a hash table or an array to 
    pass all parameters. You may pass some parameters by using splatting 
    and pass others by position or by parameter name. Also, you can splat 
    multiple objects in a single command just so you pass no more than one
    value for each parameter.


 SPLATTING WITH HASH TABLES
    Use a hash table to splat parameter name and value pairs. You can use
    this format for all parameter types, including positional and named 
    parameters and switch parameters.

    The following examples compare two Copy-Item commands that copy the 
    Test.txt file to the Test2.txt file in the same directory. 

    The first example uses the traditional format in which parameter names
    are included.

        Copy-Item -Path "test.txt" -Destination "test2.txt" -WhatIf

    The second example uses hash table splatting. The first command creates 
    a hash table of parameter-name and parameter-value pairs and stores it 
    in the $HashArguments variable. The second command uses the $HashArguments 
    variable in a command with splatting. The At symbol (@HashArguments) 
    replaces the dollar sign ($HashArguments) in the command.

    To provide a value for the WhatIf switch parameter, use $True or $False. 

       PS C:\>$HashArguments = @{ Path = "test.txt"; Destination = "test2.txt"; WhatIf = $true }
       PS C:\>Copy-Item @HashArguments

    Note: In the first command, the At symbol (@) indicates a hash table, not
          a splatted value. The syntax for hash tables in Windows PowerShell is:
          @{ <name>=<value>; <name>=<value>; …} 


 SPLATTING WITH ARRAYS
    Use an array to splat values for positional parameters, which do not require 
    parameter names. The values must be in position-number order in the array.

    The following examples compare two Copy-Item commands that copy the Test.txt 
    file to the Test2.txt file in the same directory. 

    The first example uses the traditional format in which parameter names are 
    omitted. The parameter values appear in position order in the command.

        Copy-Item "test.txt" "test2.txt" -WhatIf

    The second example uses array splatting. The first command creates an array 
    of the parameter values and stores it in the $ArrayArguments variable. The 
    values are in position order in the array. The second command uses the 
    $ArrayArguments variable in a command in splatting. The At symbol 
    (@ArrayArguments) replaces the dollar sign ($ArrayArguments) in the command.

        PS C:\>$ArrayArguments = "test.txt", "test2.txt"
        PS C:\>Copy-Item @ArrayArguments -WhatIf

 EXAMPLES

    This example shows how to re-use splatted values in different commands. 
    The commands in this example use the Write-Host cmdlet to write messages 
    to the host program console. It uses splatting to specify the foreground 
    and background colors.

    To change the colors of all commands, just change the value of the $Colors
    variable.

    The first command creates a hash table of parameter names and values and 
    stores the hash table in the $Colors variable.

               $Colors = @{ForegroundColor = "black"
                           BackgroundColor = "white"}

    The second and third commands use the $Colors variable for splatting in a
    Write-Host command. To use the $Colors variable, replace the dollar sign 
    ($Colors) with an At symbol (@Colors).
             
               # Write a message with the colors in $Colors
               Write-Host "This is a test." @Colors

               # Write second message with same colors. 
               # The position of splatted hash table does not matter.
               Write-Host @Colors "This is another test."
       
    This example shows how to forward their parameters to other commands by
    using splatting and the $PSBoundParameters automatic variable. 

    The $PSBoundParameters automatic variable is a dictionary 
    (System.Collections.Generic.Dictionary) that contains all of the 
    parameter names and values that are used when a script or function
    is run. 

    In the following example, we use the $PSBoundParameters variable to 
    forward the parameters values passed to a script or function from Test2 
    function to the Test1 function. Both calls to the Test1 function from 
    Test2 use splatting.
           
              function Test1
              {
                   param($a, $b, $c)

                   $a
                   $b
                   $c
               }              

              function Test2
              {
                   param($a, $b, $c)

                   # Call the Test1 function with $a, $b, and $c.
                   Test1 @PsBoundParameters

                   # Call the Test1 function with $b and $c, but not with $a
                   $LimitedParameters = $PSBoundParameters
                   $LimitedParameters.Remove("a") | Out-Null
                   Test1 @LimitedParameters
               }

               PS C:\> Test2 -a 1 -b 2 -c 3
               1
               2
               3
               2
               3


 SPLATTING COMMAND PARAMETERS
    You can use splatting to represent the parameters of 
    a command. This technique is useful when you are creating
    a proxy function, that is, a function that calls another
    command. This feature is introduced in Windows PowerShell 3.0.
    
    To splat the parameters of a command, use @Args to represent
    the command parameters. This technique is easier than 
    enumerating command parameters and it works without revision
    even if the parameters of the called command change.

    The feature uses the $Args automatic variable, which contains 
    all unassigned parameter values.

    For example, the following function calls the Get-Process
    cmdlet. In this function, @Args represents all of the parameters 
    of the Get-Process cmdlet.
       
        function Get-MyProcess { Get-Process @Args }

    When you use the Get-MyProcess function, all unassigned
    parameters and parameter values are passed to @Args, as
    shown in the following commands.

        PS C:\> Get-MyProcess -Name PowerShell  

        Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
        -------  ------    -----      ----- -----   ------     -- -----------
            463      46   225484     237196   719    15.86   3228 powershell


        PS C:\> Get-MyProcess -Name PowerShell_Ise -FileVersionInfo 

        ProductVersion   FileVersion      FileName
        --------------   -----------      --------
        6.2.9200.16384   6.2.9200.1638... C:\Windows\system32\WindowsPowerShell\v1.0\PowerShell_ISE.exe


    You can use @Args in a function that has explicitly
    declared parameters. You can use it more than once in
    a function, but all parameters that you enter are passed
    to all instances of @Args, as shown in the following
    example.

        function Get-MyCommand 
        { 
            Param ([switch]$P, [switch]$C)
            if ($P) { Get-Process @Args }
            if ($C) { Get-Command @Args }
        }        

        PS C:\> Get-MyCommand -P -C -Name PowerShell

        Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
        -------  ------    -----      ----- -----   ------     -- -----------
            408      28    75568      83176   620     1.33   1692 powershell

        Path               : C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
        Extension          : .exe
        Definition         : C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
        Visibility         : Public
        OutputType         : {System.String}
        Name               : powershell.exe
        CommandType        : Application
        ModuleName         :
        Module             :
        RemotingCapability : PowerShell
        Parameters         :
        ParameterSets      :
        HelpUri            :
        FileVersionInfo    : File:             C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe





SEE ALSO
    about_Arrays
    about_Automatic_Variables
    about_Hash_Tables
    about_Parameters

View Code

$props = @{ From = $FROM_EMAIL_ADDRESS To= $to Subject = $subject Body = $message SmtpServer = $EMAIL_SERVER } If($cc){$props.Add("CC",$cc)} Send-MailMessage @props

Hashtable操做

4. launch VBA script from powershell

==============Powershell script=======================
$xl = new-object -comobject Excel.Application
$source_wb = $xl.workbooks.open("myExcel.xls")
$xl.visible=$false
$param = "myMethod myParams1 myParams2"
$type=$xl.GetType()

$ret=$type.InvokeMember("Run",[Reflection.BindingFlags]::InvokeMethod,$null,$xl,$param)
$xl.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($xl)
Remove-Variable xl

==============VBA script=======================
Sub myMethod(ByVal p1 As String, ByVal p2 As String) 
  'TODO sth.
End Sub

View Code

5. 獲取當前腳本運行的路徑

把如下腳本放到function裏面，不然Path爲null

Split-Path $script:MyInvocation.MyCommand.Path

#to make this snippet work, it should be named as a powershell file
# e.g. save it as D:\Scripts\get-location1.ps1

function Get-ScriptDirectory
{
    #Split-Path $script:MyInvocation.MyCommand.Path
    return $script:MyInvocation.MyCommand.Path
}

"immediate func call"
$xxx = Get-ScriptDirectory
echo $xxx

 

6. here-string

1 $x = @"
2 "
3 Curiouser 
4 and 
5 curiouser
6 !
7 "
8 "@

View Code

 

7.