PSItem hakkında

Kısa açıklama

İşlem hattı nesnesindeki geçerli nesneyi içeren otomatik değişken.

Uzun açıklama

PowerShell, işlem hattındaki geçerli nesneye başvuran iki $_ ve '$PSItem' içerir.

$PSItem , değişken adına daha net bir anlam sağlamaya yönelik bir girişimde PowerShell'e eklendi. Ancak pratikte dolar işareti alt çizgi formu $_ en yaygın olarak kullanılır.

Bu makale örneklerde kullanılsa $PSItem da, $PSItem her örnekte ile $_ değiştirilebilir. $_ tercih edilen kullanımdır.

için $PSItembirkaç yaygın kullanım örneği vardır:

komutunun ForEach-Object parametresinin script bloğunda
cmdlet'in Where-Object parametresinin betik bloğunda
ForEach ve Where iç yöntemlerinde
delay-bind scriptblock parametreleriyle
Deyimin switch koşullu değerlerinde ve ilişkili deyimlerinde
İşlevin process deyim bloğunda
filter tanımında
ValidateScript özniteliğinin betik bloğunda
Bir deyiminin deyim bloğunda catch
-replace işlecinin değiştirme operandı betik bloğunda

Bu makalenin geri kalanında bu kullanım örnekleri için kullanım $PSItem örnekleri yer alır.

ForEach-Object İşlem parametresi

ForEach-Object cmdlet'i işlem hattındaki nesneler üzerinde çalışacak şekilde tasarlanmıştır ve işlem hattındaki her nesne için İşlem parametresinin betik bloğu bir kez yürütülür.

İşlem$PSItembetik bloğunda kullanabilirsiniz ancak Başlangıç veya Bitiş parametresi betik bloklarında kullanamazsınız. Başlangıç veya $PSItem parametresi betik bloklarında başvuruda bulunursanız, değerin $null nedeni bu betik bloklarının işlem hattındaki her nesne üzerinde çalışmamadır.

$parameters = @{
    Begin   = { Write-Host "PSItem in Begin is: $PSItem" }
    Process = {
        Write-Host "PSItem in Process is: $PSItem"
        $PSItem + 1
    }
    End     = { Write-Host "PSItem in End is: $PSItem" }
}

$result = 1, 2, 3 | ForEach-Object @parameters

Write-Host "Result is: $result"

PSItem in Begin is:
PSItem in Process is: 1
PSItem in Process is: 2
PSItem in Process is: 3
PSItem in End is:
Result is: 2 3 4

FilterScript'i Where-Object

Where-Object cmdlet'i, işlem hattındaki nesneleri filtrelemek için tasarlanmıştır.

İşlem hattındaki her giriş nesnesi için bir kez yürütülen FilterScript$PSItemkullanabilirsiniz.

1, 2, 3 | Where-Object -FilterScript { ($PSItem % 2) -eq 0 }

Bu örnekte, FilterScript geçerli nesnenin eşit olup olmadığını denetler, tek değerleri filtreler ve yalnızca 2 özgün listeden döndürür.

ForEach ve Where yöntemleri

Diziler için hem ForEach hem de Where iç yöntemleri giriş parametresi olarak bir betik bloğu alır. Geçerli nesneye erişmek için bu betik bloklarında öğesini $PSItem kullanabilirsiniz.

@('a', 'b', 'c').ForEach({ $PSItem.ToUpper() }).Where({ $PSItem -ceq 'B' })

Bu örnekte, ForEach yönteminin betik bloğu geçerli nesnenin büyük harflerini oluşturur. Ardından Where yönteminin betik bloğu yalnızca Bdöndürür.

Gecikmeli bağlama betiği engellemeleri

Gecikmeli bağlama betik blokları , işlem hattı cmdlet'ini yürütmeden önce parametreleri tanımlamak için kullanmanıza $PSItem olanak sağlar.

dir config.log | Rename-Item -NewName { "old_$($_.Name)" }

Switch deyimleri

Switch deyimlerinde hem eylem betik bloklarında hem de deyim koşulu betik bloklarında kullanabilirsiniz$PSItem.

$numbers = 1, 2, 3

switch ($numbers) {
    { ($PSItem % 2) -eq 0 } { "$PSItem is even" }
    default { "$PSItem is odd" }
}

1 is odd
2 is even
3 is odd

Bu örnekte koşul deyimi bloğu, geçerli nesnenin çift olup olmadığını denetler. Eşitse, ilişkili eylem deyimi bloğu geçerli nesnenin eşit olduğunu belirten bir ileti oluşturur.

Koşulun eylem deyimi bloğu, geçerli nesnenin default tek olduğunu belirten bir ileti oluşturur.

İşlev işlemi deyimi blokları

bir işlev tanımlarken, blok tanımında $PSItem kullanabilirsinizprocess, ancak veya begin blok tanımlarında end kullanamazsınız. veya bloklarında başvuruda $PSItem bulunursanızbegin, değerin end nedeni bu blokların işlem hattındaki her nesne üzerinde çalışmamadır.$null

deyimi blok tanımında $PSItem kullandığınızdaprocess, işlev işlem hattında çağrılırsa ve aksi takdirde $nulldeğeri geçerli nesne olur.

function Add-One {
    process { $PSItem + 1 }
}

1, 2, 3 | Add-One

2
3
4

İpucu

Gelişmiş işlevlerde $PSItemkullanabilirsiniz ancak bunu yapmak için çok az neden vardır. İşlem hattından giriş almayı planlıyorsanız, ValueFromPipeline özniteliğindeki veya ValueFromPipelineByPropertyName bağımsız değişkenlerini kullanarak parametreleri tanımlamak en iyisidir.

Gelişmiş işlevler için Parameter özniteliğini ve cmdlet bağlamasını kullanmak, gerekli değerleri almak için uygulamayı geçerli nesneyi işlemeye göre daha açık ve öngörülebilir hale getirir.

Gelişmiş işlevlerde iyi bir kullanım, işlevin $PSItem işlem hattından giriş alan birden çok parametresi olduğunda hata ayıklama veya günlüğe kaydetme için geçerli nesnenin kendisini incelemektir.

function Write-JsonLog {
    [CmdletBinding()]
    param(
        [Parameter(ValueFromPipelineByPropertyName)]
        [string]$Message
    )
    begin {
        $entries = @()
    }
    process {
        $entries += [pscustomobject]@{
            Message   = $Message
            TimeStamp = [datetime]::Now
        }

        if ($PSItem) {
            $props  = $PSItem | ConvertTo-Json
            $number = $entries.Length
            Write-Verbose "Input object $number is:`n$props"
        }
    }
    end {
        ConvertTo-Json -InputObject $entries
    }
}

Bu örnek işlev, bir ileti ve zaman damgası ile bir JSON nesneleri dizisi oluşturur. İşlem hattında çağrıldığında, her giriş için geçerli nesnenin Message özelliğini kullanır. Ayrıca geçerli nesnenin JSON gösterimini ayrıntılı akışa yazar, böylece çıkış günlükleriyle karşılaştırıldığında gerçek girişi görebilirsiniz.

$Items = @(
    [pscustomobject]@{
        Name    = 'First Item'
        Message = 'A simple note'
    }
    [pscustomobject]@{
        Name    = 'Item with extra properties'
        Message = 'Missing message, has info instead'
        Info    = 'Some metadata'
        Source  = 'Where this came from'
    }
    [pscustomobject]@{
        Name    = 'Last Item'
        Message = 'This also gets logged'
    }
)

$Items | Write-JsonLog -Verbose

VERBOSE: Input object 1 is:
{
    "Name":  "First Item",
    "Message":  "A simple note"
}
VERBOSE: Input object 2 is:
{
    "Name":  "Item with extra properties",
    "Message":  "Missing message, has info instead",
    "Info":  "Some metadata",
    "Source":  "Where this came from"
}
VERBOSE: Input object 3 is:
{
    "Name":  "Last Item",
    "Message":  "This also gets logged"
}
[
    {
        "Message":  "A simple note",
        "TimeStamp":  "\/Date(1670344068257)\/"
    },
    {
        "Message":  "Missing message, has info instead",
        "TimeStamp":  "\/Date(1670344068259)\/"
    },
    {
        "Message":  "This also gets logged",
        "TimeStamp":  "\/Date(1670344068261)\/"
    }
]

Filtre tanımları

Bir filtrenin$PSItemdeyim listesinde kullanabilirsiniz.

Bir tanımda kullandığınızda $PSItem , filtre işlem hattında veya başka bir filter şekilde $nullçağrılırsa değer geçerli nesnedir.

filter Test-IsEven { ($PSItem % 2) -eq 0 }

1, 2, 3 | Test-IsEven

False
True
False

Bu örnekte, Test-IsEven geçerli nesne çift sayıysa ve $true değilse filtre çıkışını $false verir.

ValidateScript özniteliği ScriptBlock

ValidateScript$PSItemkullanabilirsiniz. ValidateScript ile kullanıldığında, $PSItem doğrulanan geçerli nesnenin değeridir. Değişken veya parametre değeri bir dizi olduğunda, betik bloğu geçerli nesne olarak dizideki $PSItem her nesne için bir kez çağrılır.

function Add-EvenNumber {
    param(
        [ValidateScript({ 0 -eq ($PSItem % 2) })]
        [int[]]$Number
    )

    begin {
        [int]$total = 0
    }

    process {
        foreach ($n in $Number) {
            $total += $n
        }
    }

    end {
        $total
    }
}

Add-EvenNumber -Number 2, 4, 6

Add-EvenNumber -Number 1, 2

12

Add-EvenNumber:
Line |
  24 |  Add-EvenNumber -Number 1, 2
     |                         ~~~~
     | Cannot validate argument on parameter 'Number'. The
" 0 -eq ($PSItem % 2) " validation script for the argument
with value "1" did not return a result of True. Determine
why the validation script failed, and then try the command
again.

Bu örnekte ValidateScript özniteliğinin betik bloğu Number parametresine geçirilen her değer için bir kez çalıştırılır ve herhangi bir değer eşit değilse hata döndürür.

Add-EvenNumber işlevi geçerli giriş numaralarını ekler ve toplamı döndürür.

Deyim `catch` bloğu

Bir catch deyim bloğu içinde geçerli $PSItem hatayı içerir. Nesne ErrorRecord türündedir.

try { NonsenseString }
catch {
    Write-Host "An error occurred:"
    Write-Host $PSItem
}

Bu betiği çalıştırmak aşağıdaki sonucu döndürür:

An error occurred:
The term 'NonsenseString' is not recognized as the name of a cmdlet, function,
script file, or operable program. Check the spelling of the name, or if a path
was included, verify that the path is correct and try again.

Daha fazla örnek için about_Try_Catch_FinallyÖzel durum bilgilerine erişme bölümüne bakın.

İşlecin `-replace` değiştirme betiği bloğu

PowerShell 6'dan başlayarak, $PSItem işlecini çağırırken ve değiştirme betiği bloğu tanımlarken kullanabilirsiniz. Bunu yaptığınızda değeri geçerli $PSItem eşleşmenin değeridir.

$datePattern = '\d{4}-\d{2}-\d{2}'
'Today is 1999-12-31' -replace $datePattern, { [datetime]$PSItem.Value }

Today is 12/31/1999 00:00:00

Bu örnekte, değiştirme betiği bloğu, değeri datetime değerine dönüştürerek özgün tarih dizesini geçerli kültür için varsayılan biçimle değiştirir.

değerini değiştirme `$PSItem`

değerine yeni bir değer $PSItem atayarak değerini değiştirebilirsiniz. Ancak bunu yapmak, kullanan $PSItemherhangi bir kodun beklenen davranışını değiştirebilir. Aşağıdaki örneği göz önünde bulundurun. Normalde deyimi dizisindeki switch$namestüm değerleri işler. değeri $PSItem eylem deyimi bloğu içinde değiştirildiğinden switch , deyimi yalnızca ilk değeri işler.

$names = 'Alice', 'Charlie'
switch ($names) {
    Alice   { "$PSItem says 'Hello!'"; $PSItem = 'Bob' }
    Bob     { "$PSItem says 'Goodbye.'"; $PSItem = 'Charlie'; break }
    Charlie { "$PSItem says 'How are you?'" }
}

switch deyimi ilk değerini değerlendirdiğinde, Aliceilk koşulla eşleşir ve ilişkili eylem deyimi bloğunu yürütür. Bu bloğun içinde değeri $PSItem olarak değiştirilir Bobve bu durum deyiminin değerlendirilmesini switch de etkiler.

Alice says 'Hello!'
Bob says 'Goodbye.'

değerini $PSItemdeğiştirmekten kaçınmanız gerekir.

Ayrıca bakınız

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-01-14