about_Calculated_Properties

  • Artikel

Kort beskrivning

PowerShell ger möjlighet att dynamiskt lägga till nya egenskaper och ändra formateringen av objektutdata till pipelinen.

Lång beskrivning

Flera PowerShell-cmdletar transformerar, grupperar eller bearbetar indataobjekt till utdataobjekt med hjälp av parametrar som tillåter tillägg av nya egenskaper till dessa utdataobjekt. Du kan använda dessa parametrar för att generera nya beräknade egenskaper för utdataobjekt baserat på värdena för indataobjekt. Den beräknade egenskapen definieras av en hashtabell som innehåller nyckel/värde-par som anger namnet på den nya egenskapen, ett uttryck för att beräkna värdet och valfri formateringsinformation.

Cmdletar som stöds

Följande cmdletar stöder beräknade egenskapsvärden för egenskapsparametern. Cmdletarna Format-* stöder också beräknade värden för parametern GroupBy .

I följande lista specificeras de cmdletar som stöder beräknade egenskaper och nyckel/värde-par som varje cmdlet stöder.

  • Compare-Object

    • expression

  • ConvertTo-Html

    • name/label – valfritt (läggs till i PowerShell 6.x)
    • expression
    • width -Valfri
    • alignment -Valfri

  • Format-Custom

    • expression
    • depth -Valfri

  • Format-List

    • name/label -Valfri
    • expression
    • formatstring -Valfri

    Samma uppsättning nyckel/värde-par gäller även för beräknade egenskapsvärden som skickas till GroupBy-parametern för alla Format-* cmdletar.

  • Format-Table

    • name/label -Valfri
    • expression
    • formatstring -Valfri
    • width -Valfri
    • alignment -Valfri

  • Format-Wide

    • expression
    • formatstring -Valfri

  • Group-Object

    • expression

  • Measure-Object

    • Stöder endast ett skriptblock för uttrycket, inte en hashtable.
    • Stöds inte i PowerShell 5.1 och äldre.

  • Select-Object

    • name/label -Valfri
    • expression

  • Sort-Object

    • expression
    • ascending/descending -Valfri

Kommentar

Värdet för expression kan vara ett skriptblock i stället för en hashtable. Mer information finns i avsnittet Anteckningar .

Hashtable-nyckeldefinitioner

  • name/label – Anger namnet på den egenskap som skapas. Du kan använda name eller dess alias, label, utbytbart.
  • expression – Ett sträng- eller skriptblock som används för att beräkna värdet för den nya egenskapen. expression Om är en sträng tolkas värdet som ett egenskapsnamn på indataobjektet. Det här är ett kortare alternativ än expression = { $_.<PropertyName> }.
  • alignment – Används av cmdletar som producerar tabellutdata för att definiera hur värdena visas i en kolumn. Värdet måste vara 'left', 'center'eller 'right'.
  • formatstring – Anger en formatsträng som definierar hur värdet formateras för utdata. Mer information om formatsträngar finns i Formattyper i .NET.
  • width – Anger den maximala breddkolumnen i en tabell när värdet visas. Värdet måste vara större än 0.
  • depth– Parametern Format-Custom Djup för anger expansionsdjupet för alla egenskaper. Med depth nyckeln kan du ange djupet för expansionen per egenskap.
  • ascending / descending – Gör att du kan ange sorteringsordningen för en eller flera egenskaper. Det här är booleska värden.

Du behöver inte stava hashtabellnycklarna så länge det angivna namnprefixet är tvetydigt. Du kan till exempel använda n i stället för Name och e i stället för Expression.

Exempel

Compare-Object

Med beräknade egenskaper kan du styra hur egenskaperna för indataobjekten jämförs. I det här exemplet jämförs värdena i stället för att jämföra värdena direkt med resultatet av den aritmetiska åtgärden (modulus av 2).

Compare-Object @{p=1} @{p=2} -property @{ Expression = { $_.p % 2 } }

 $_.p % 2  SideIndicator
---------- -------------
         0 =>
         1 <=

ConvertTo-Html

ConvertTo-Html kan konvertera en samling objekt till en HTML-tabell. Med beräknade egenskaper kan du styra hur tabellen visas.

Get-Alias |
  ConvertTo-Html Name,
                 Definition,
                 @{
                    name='ParameterCount'
                    expr={$_.Parameters.Keys.Count}
                    align='center'
                 } |
    Out-File .\aliases.htm -Force

Det här exemplet skapar en HTML-tabell som innehåller en lista över PowerShell-alias och talparametrarna för varje aliaskommando. Värdena för kolumnen ParameterCount är centrerade.

Format-Custom

Format-Custom tillhandahåller en anpassad vy av ett objekt i ett format som liknar en klassdefinition. Mer komplexa objekt kan innehålla medlemmar som är djupt kapslade med komplexa typer. Parametern Format-Custom Djup för anger expansionsdjupet för alla egenskaper. Med depth nyckeln kan du ange djupet för expansionen per egenskap.

I det här exemplet depth förenklar nyckeln anpassade utdata för cmdleten Get-Date . Get-Date returnerar ett DateTime-objekt . Egenskapen Date för det här objektet är också ett DateTime-objekt , så objektet är kapslat.

Get-Date | Format-Custom @{expr={$_.Date};depth=1},TimeOfDay

class DateTime
{
  $_.Date =
    class DateTime
    {
      Date = 8/7/2020 12:00:00 AM
      Day = 7
      DayOfWeek = Friday
      DayOfYear = 220
      Hour = 0
      Kind = Local
      Millisecond = 0
      Minute = 0
      Month = 8
      Second = 0
      Ticks = 637323552000000000
      TimeOfDay = 00:00:00
      Year = 2020
      DateTime = Friday, August 07, 2020 12:00:00 AM
    }
  TimeOfDay =
    class TimeSpan
    {
      Ticks = 435031592302
      Days = 0
      Hours = 12
      Milliseconds = 159
      Minutes = 5
      Seconds = 3
      TotalDays = 0.503508787386574
      TotalHours = 12.0842108972778
      TotalMilliseconds = 43503159.2302
      TotalMinutes = 725.052653836667
      TotalSeconds = 43503.1592302
    }
}

Format-List

I det här exemplet använder vi beräknade egenskaper för att ändra namn och format för utdata från Get-ChildItem.

Get-ChildItem *.json -File |
  Format-List Fullname,
              @{
                 name='Modified'
                 expression={$_.LastWriteTime}
                 formatstring='O'
              },
              @{
                 name='Size'
                 expression={$_.Length/1KB}
                 formatstring='N2'
              }

FullName : C:\Git\PS-Docs\PowerShell-Docs\.markdownlint.json
Modified : 2020-07-23T10:26:28.4092457-07:00
Size     : 2.40

FullName : C:\Git\PS-Docs\PowerShell-Docs\.openpublishing.publish.config.json
Modified : 2020-07-23T10:26:28.4092457-07:00
Size     : 2.25

FullName : C:\Git\PS-Docs\PowerShell-Docs\.openpublishing.redirection.json
Modified : 2020-07-27T13:05:24.3887629-07:00
Size     : 324.60

Format-Table

I det här exemplet lägger den beräknade egenskapen till en typegenskap som används för att klassificera filerna efter innehållstyp.

Get-ChildItem -File |
  Sort-Object extension |
    Format-Table Name, Length -GroupBy @{
      name='Type'
      expression={
        switch ($_.extension) {
          '.md'   {'Content'}
          ''      {'Metacontent'}
          '.ps1'  {'Automation'}
          '.yml'  {'Automation'}
          default {'Configuration'}
        }
      }
    }

   Type: Metacontent

Name              Length
----              ------
ThirdPartyNotices   1229
LICENSE-CODE        1106
LICENSE            19047

   Type: Configuration

Name                                Length
----                                ------
.editorconfig                          183
.gitattributes                         419
.gitignore                             228
.markdownlint.json                    2456
.openpublishing.publish.config.json   2306
.openpublishing.redirection.json    332394
.localization-config                   232

   Type: Content

Name            Length
----            ------
README.md         3355
CONTRIBUTING.md    247

   Type: Automation

Name                      Length
----                      ------
.openpublishing.build.ps1    796
build.ps1                   7495
ci.yml                       645
ci-steps.yml                2035
daily.yml                   1271

Format-Wide

Med Format-Wide cmdleten kan du visa värdet för en egenskap för objekt i en samling som en lista med flera kolumner.

I det här exemplet vill vi se filnamnet och storleken (i kilobyte) som en bred lista. Eftersom Format-Wide inte visar fler än en egenskap använder vi en beräknad egenskap för att kombinera värdet för två egenskaper till ett enda värde.

Get-ChildItem -File |
  Format-Wide -Property @{e={'{0} ({1:N2}kb)' -f $_.name,($_.length/1kb)}}

.editorconfig (0.18kb)                          .gitattributes (0.41kb)
.gitignore (0.22kb)                             .localization-config (0.23kb)
.markdownlint.json (2.40kb)                     .openpublishing.build.ps1 (0.78kb)
.openpublishing.publish.config.json (2.25kb)    .openpublishing.redirection.json (324.60kb)
build.ps1 (7.32kb)                              ci.yml (0.63kb)
ci-steps.yml (1.99kb)                           CONTRIBUTING.md (0.24kb)
daily.yml (1.24kb)                              LICENSE (18.60kb)
LICENSE-CODE (1.08kb)                           README.md (3.28kb)
ThirdPartyNotices (1.20kb)

Group-Object

Cmdleten Group-Object visar objekt i grupper baserat på värdet för en angiven egenskap. I det här exemplet räknar den beräknade egenskapen antalet filer för varje innehållstyp.

Get-ChildItem -File |
  Sort-Object extension |
    Group-Object -NoElement -Property @{
      expression={
        switch ($_.extension) {
          '.md'   {'Content'}
          ''      {'Metacontent'}
          '.ps1'  {'Automation'}
          '.yml'  {'Automation'}
          default {'Configuration'}
        }
      }
    }

Count Name
----- ----
    5 Automation
    7 Configuration
    2 Content
    3 Metacontent

Measure-Object

Cmdleten Measure-Object beräknar de numeriska egenskaperna för objekt. I det här exemplet använder vi en beräknad egenskap för att hämta antalet (summa) av talen, mellan 1 och 10, som är jämnt delbara med 3.

1..10 | Measure-Object -Property {($_ % 3) -eq 0} -Sum

Count             : 10
Average           :
Sum               : 3
Maximum           :
Minimum           :
StandardDeviation :
Property          : ($_ % 3) -eq 0

Kommentar

Till skillnad från de andra cmdletarna Measure-Object accepterar inte en hashtable för beräknade egenskaper. Du måste använda ett skriptblock.

Select-Object

Du kan använda beräknade egenskaper för att lägga till ytterligare medlemmar i objektutdata med cmdleten Select-Object . I det här exemplet visar vi de PowerShell-alias som börjar med bokstaven C. Med hjälp av Select-Objectmatar vi ut aliaset, den cmdlet som det mappas till och ett antal för antalet parametrar som definierats för cmdleten. Med hjälp av en beräknad egenskap kan vi skapa egenskapen ParameterCount .

$aliases = Get-Alias c* |
  Select-Object Name,
                Definition,
                @{
                    name='ParameterCount'
                    expr={$_.Parameters.Keys.Count}
                }
$aliases | Get-Member
$aliases

   TypeName: Selected.System.Management.Automation.AliasInfo

Name           MemberType   Definition
----           ----------   ----------
Equals         Method       bool Equals(System.Object obj)
GetHashCode    Method       int GetHashCode()
GetType        Method       type GetType()
ToString       Method       string ToString()
Definition     NoteProperty string Definition=Get-Content
Name           NoteProperty string Name=cat
ParameterCount NoteProperty System.Int32 ParameterCount=21

Name    Definition         ParameterCount
----    ----------         --------------
cat     Get-Content                    21
cd      Set-Location                   15
cdd     Push-MyLocation                 1
chdir   Set-Location                   15
clc     Clear-Content                  20
clear   Clear-Host                      0
clhy    Clear-History                  17
cli     Clear-Item                     20
clp     Clear-ItemProperty             22
cls     Clear-Host                      0
clv     Clear-Variable                 19
cnsn    Connect-PSSession              29
compare Compare-Object                 20
copy    Copy-Item                      24
cp      Copy-Item                      24
cpi     Copy-Item                      24
cpp     Copy-ItemProperty              23
cvpa    Convert-Path                   13

Sort-Object

Med hjälp av de beräknade egenskaperna kan du sortera data i olika ordrar per egenskap. Det här exemplet sorterar data från en CSV-fil i stigande ordning efter Datum. Men inom varje datum sorteras raderna i fallande ordning efter UnitsSold.

Import-Csv C:\temp\sales-data.csv |
  Sort-Object Date, @{expr={$_.UnitsSold}; desc=$true}, Salesperson  |
    Select-Object Date, Salesperson, UnitsSold

Date       Salesperson UnitsSold
----       ----------- ---------
2020-08-01 Sally       3
2020-08-01 Anne        2
2020-08-01 Fred        1
2020-08-02 Anne        6
2020-08-02 Fred        2
2020-08-02 Sally       0
2020-08-03 Anne        5
2020-08-03 Sally       3
2020-08-03 Fred        1
2020-08-04 Anne        2
2020-08-04 Fred        2
2020-08-04 Sally       2

Kommentar

  • Du kan ange skriptblocket för uttrycket direkt, som ett argument, i stället för att ange det som Expression posten i en hashtable. Till exempel:

    '1', '10', '2' | Sort-Object { [int] $_ }

    Det här exemplet är praktiskt för cmdletar som inte kräver (eller stöder) namngivning av en egenskap via Name nyckeln, till exempel Sort-Object, Group-Objectoch Measure-Object.

    För cmdletar som stöder namngivning av egenskapen konverteras skriptblocket till en sträng och används som namnet på egenskapen i utdata.

  • Expression skriptblock körs i underordnade omfång, vilket innebär att anroparens variabler inte kan ändras direkt.

  • Pipelinelogik tillämpas på utdata från Expression skriptblock. Det innebär att utdata från en matris med ett enda element gör att matrisen packas upp.

  • För de flesta cmdletar ignoreras fel i uttrycksskriptblock i tysthet. För Sort-Objectär instruktionsslutande och skriptslutfel utdata , men de avslutar inte -instruktionen.

Se även