ForEach-Object

Sözdizimi

ForEach-Object
            [-InputObject <PSObject>]
            [-Begin <ScriptBlock>]
            [-Process] <ScriptBlock[]>
            [-End <ScriptBlock>]
            [-RemainingScripts <ScriptBlock[]>]
            [-WhatIf]
            [-Confirm]
            [<CommonParameters>]

ForEach-Object
            [-InputObject <PSObject>]
            [-MemberName] <String>
            [-ArgumentList <Object[]>]
            [-WhatIf]
            [-Confirm]
            [<CommonParameters>]

ForEach-Object
            -Parallel <scriptblock>
            [-InputObject <psobject>]
            [-ThrottleLimit <int>]
            [-TimeoutSeconds <int>]
            [-AsJob]
            [-UseNewRunspace]
            [-WhatIf]
            [-Confirm]
            [<CommonParameters>]

Description

cmdlet'i ForEach-Object giriş nesneleri koleksiyonundaki her öğe üzerinde bir işlem gerçekleştirir. Giriş nesneleri cmdlet'ine yöneltilebilir veya InputObject parametresi kullanılarak belirtilebilir.

Windows PowerShell 3.0'dan başlayarak, komut ForEach-Object oluşturmanın iki farklı yolu vardır.

• Betik bloğu. İşlemi belirtmek için bir betik bloğu kullanabilirsiniz. Betik bloğunun içinde, geçerli nesneyi temsil etmek için değişkenini kullanın $_ . Betik bloğu, İşlem parametresinin değeridir. Betik bloğu herhangi bir PowerShell betiği içerebilir.

  Örneğin, aşağıdaki komut bilgisayardaki her işlemin ProcessName özelliğinin değerini alır.

  Get-Process | ForEach-Object {$_.ProcessName}

  ForEach-Objectbegin, processve end bloklarını about_functions açıklandığı gibi destekler.

  Not

  Betik blokları çağıranın kapsamında çalışır. Bu nedenle, bloklar bu kapsamdaki değişkenlere erişebilir ve cmdlet tamamlandıktan sonra bu kapsamda kalıcı olan yeni değişkenler oluşturabilir.

• operation deyimi. Ayrıca doğal dile çok benzeyen bir işlem deyimi de yazabilirsiniz. Bir özellik değeri belirtmek veya bir yöntem çağırmak için işlem deyimini kullanabilirsiniz. İşlem deyimleri Windows PowerShell 3.0'da kullanıma sunulmuştur.

  Örneğin, aşağıdaki komut ayrıca bilgisayardaki her işlemin ProcessName özelliğinin değerini alır.

  Get-Process | ForEach-Object ProcessName

• Paralel çalışan betik bloğu. PowerShell 7.0 sürümünden başlayarak, her betik bloğunu paralel olarak çalıştıran üçüncü bir parametre kümesi kullanılabilir. ThrottleLimit parametresi, aynı anda çalışan paralel betik sayısını sınırlar. Daha önce olduğu gibi, betik bloğundaki geçerli giriş nesnesini göstermek için değişkenini kullanın $_ . $using: Değişken başvurularını çalışan betike geçirmek için anahtar sözcüğünü kullanın.

  PowerShell 7'de, maksimum yalıtım sağlamak için her döngü yinelemesi için yeni bir çalışma alanı oluşturulur. Yaptığınız iş yeni çalışma alanları oluşturmaya kıyasla küçükse veya önemli bir çalışma gerçekleştiren çok fazla yineleme varsa, bu büyük bir performans ve kaynak isabeti olabilir. PowerShell 7.1'den itibaren, bir runspace havuzundan gelen runspace'ler varsayılan olarak yeniden kullanılır. ThrottleLimit parametresi, runspace havuzu boyutunu ayarlar. Varsayılan çalışma alanı havuzu boyutu 5'tir. Yine de UseNewRunspace anahtarını kullanarak her yineleme için yeni bir çalışma alanı oluşturabilirsiniz.

  Varsayılan olarak, paralel betik blokları paralel görevleri başlatan çağıranın geçerli çalışma dizinini kullanır.

  Daha fazla bilgi için bu makalenin NOTLAR bölümüne bakın.

Örnekler

Örnek 1: Dizideki tamsayıları bölme

Bu örnek üç tamsayıdan oluşan bir dizi alır ve bunların her birini 1024'e böler.

30000, 56798, 12432 | ForEach-Object -Process {$_/1024}

29.296875
55.466796875
12.140625

Örnek 2: Dizindeki tüm dosyaların uzunluğunu alma

Bu örnek, PowerShell yükleme dizinindeki $PSHOMEdosyaları ve dizinleri işler.

Get-ChildItem $PSHOME |
  ForEach-Object -Process {if (!$_.PSIsContainer) {$_.Name; $_.Length / 1024; " " }}

Nesne bir dizin değilse, betik bloğu dosyanın adını alır, Length özelliğinin değerini 1024'e böler ve bir sonraki girdiden ayırmak için bir boşluk (" ") ekler. Cmdlet, bir nesnenin dizin olup olmadığını belirlemek için PSISContainer özelliğini kullanır.

Örnek 3: En son Sistem olayları üzerinde çalışma

Bu örnek, Sistem olay günlüğündeki en son 1000 olayı bir metin dosyasına yazar. Geçerli saat, olaylar işlenmeden önce ve işlendikten sonra görüntülenir.

Get-EventLog -LogName System -Newest 1000 |
    ForEach-Object -Begin {Get-Date} -Process {
        Out-File -FilePath Events.txt -Append -InputObject $_.Message
    } -End {Get-Date}

Get-EventLog Sistem olay günlüğünden en son 1000 olayı alır ve bunları cmdlet'ine ForEach-Object aktarır. Begin parametresi geçerli tarih ve saati görüntüler. Ardından İşlem parametresi cmdlet'ini Out-File kullanarak events.txt adlı bir metin dosyası oluşturur ve bu dosyadaki olayların her birinin ileti özelliğini depolar. Son olarak End parametresi, tüm işlemler tamamlandıktan sonra tarih ve saati görüntülemek için kullanılır.

Örnek 4: Kayıt defteri anahtarının değerini değiştirme

Bu örnek, anahtarın altındaki tüm alt anahtarlardaki RemotePath kayıt defteri girdisinin HKCU:\Network değerini büyük harfle değiştirir.

Get-ItemProperty -Path HKCU:\Network\* |
  ForEach-Object {
    Set-ItemProperty -Path $_.PSPath -Name RemotePath -Value $_.RemotePath.ToUpper()
  }

Kayıt defteri giriş değerinin biçimini veya içeriğini değiştirmek için bu biçimi kullanabilirsiniz.

Ağ anahtarındaki her alt anahtar, oturum açma sırasında yeniden bağlanan eşlenmiş bir ağ sürücüsünü temsil eder. RemotePath girdisi, bağlı sürücünün UNC yolunu içerir. Örneğin, sürücüyü ile eşlersenizE:, içinde RemotePath kayıt defteri değeri olarak ayarlanmış \\Server\Sharebir E alt anahtarı oluşturulur HKCU:\Network .\\Server\Share

Komutu, her anahtardaki Get-ItemProperty RemotePath kayıt defteri girdisinin değerini değiştirmek için Ağ anahtarının tüm alt anahtarlarını ve Set-ItemProperty cmdlet'ini almak için cmdlet'ini kullanır. komutunda Set-ItemProperty yol, kayıt defteri anahtarının PSPath özelliğinin değeridir. Bu, kayıt defteri girdisini değil, kayıt defteri anahtarını temsil eden Microsoft .NET Framework nesnesinin bir özelliğidir. Komut, REG_SZ dize olan RemotePath değerinin ToUpper() yöntemini kullanır.

Set-ItemProperty Her anahtarın özelliğini değiştirdiğinden, ForEach-Object özelliğe erişmek için cmdlet gereklidir.

Örnek 5: $null otomatik değişkenini kullanma

Bu örnek, otomatik değişkeni cmdlet'e $null bağlamanın ForEach-Object etkisini gösterir.

1, 2, $null, 4 | ForEach-Object {"Hello"}

Hello
Hello
Hello
Hello

PowerShell açık bir yer tutucu olarak davrandığından $null , ForEach-Object cmdlet'i, kanala alınan diğer nesneler için olduğu gibi için bir değer $null oluşturur.

Örnek 6: Özellik değerlerini alma

Bu örnek, cmdlet'in MemberName parametresini kullanarak tüm yüklü PowerShell modüllerinin Path özelliğinin ForEach-Object değerini alır.

Get-Module -ListAvailable | ForEach-Object -MemberName Path
Get-Module -ListAvailable | Foreach Path

İkinci komut, birinci komutla eşdeğerdir. Cmdlet'in ForEach-Object diğer adını kullanır Foreach ve isteğe bağlı olan MemberName parametresinin adını atlar.

ForEach-Object cmdlet'i özellik değerlerini almak için kullanışlıdır, çünkü özellik değeri türünü değiştiren Biçim cmdlet'lerinden veya Select-Object cmdlet'inden farklı olarak türü değiştirmeden değeri alır.

Örnek 7: Modül adlarını bileşen adlarına bölme

Bu örnekte, iki noktayla ayrılmış modül adını bileşen adlarına bölmenin üç yolu gösterilmektedir. Komutlar dizelerin Split yöntemini çağırır. Üç komut farklı söz dizimi kullanır, ancak eşdeğer ve değiştirilebilir. Çıkış, üç durumda da aynıdır.

"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" |
    ForEach-Object {$_.Split(".")}
"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" |
    ForEach-Object -MemberName Split -ArgumentList "."
"Microsoft.PowerShell.Core", "Microsoft.PowerShell.Host" |
    Foreach Split "."

Microsoft
PowerShell
Core
Microsoft
PowerShell
Host

İlk komut, bir betik bloğu ve geçerli nesne işlecini içeren geleneksel söz dizimini $_kullanır. Sınırlayıcı bağımsız değişkenini kapsayan yöntemi ve parantezleri belirtmek için nokta söz dizimini kullanır.

İkinci komut, Split yöntemini belirtmek için MemberName parametresini ve bölme sınırlayıcısı olarak noktayı (.) tanımlamak için ArgumentList parametresini kullanır.

Üçüncü komut, cmdlet'in Foreach diğer adını kullanır ve isteğe bağlı olan MemberName ve ArgumentList parametrelerinin adlarını atlar.ForEach-Object

Örnek 8: ForEach-Object'i iki betik bloğuyla kullanma

Bu örnekte, konumsal olarak iki betik bloğu geçiririz. Tüm betik blokları process parametresine bağlanır. Ancak, bunlar Begin ve Process parametrelerine geçirilmiş gibi kabul edilir.

1..2 | ForEach-Object { 'begin' } { 'process' }

begin
process
process

Örnek 9: ForEach-Object'i ikiden fazla betik bloğuyla kullanma

Bu örnekte, konumsal olarak dört betik bloğu geçiririz. Tüm betik blokları process parametresine bağlanır. Ancak bunlar Begin, Process ve End parametrelerine geçirilmiş gibi kabul edilir.

1..2 | ForEach-Object { 'begin' } { 'process A' }  { 'process B' } { 'end' }

begin
process A
process B
process A
process B
end

Örnek 10: Her işlem hattı öğesi için birden çok betik bloğu çalıştırma

Önceki örnekte gösterildiği gibi, İşlem parametresi kullanılarak geçirilen birden çok betik bloğu Başlangıç ve Bitiş parametrelerine eşlenir. Bu eşlemeyi önlemek için Başlangıç ve Bitiş parametreleri için açık değerler sağlamanız gerekir.

1..2 | ForEach-Object -Begin $null -Process { 'one' }, { 'two' }, { 'three' } -End $null

one
two
three
one
two
three

Örnek 11: Yavaş betiği paralel toplu işlerde çalıştırma

Bu örnek, bir dizeyi değerlendiren ve bir saniye boyunca uyuyan bir betik bloğu çalıştırır.

$Message = "Output:"

1..8 | ForEach-Object -Parallel {
    "$using:Message $_"
    Start-Sleep 1
} -ThrottleLimit 4

Output: 1
Output: 2
Output: 3
Output: 4
Output: 5
Output: 6
Output: 7
Output: 8

Girişin dört toplu olarak işlenmesi için ThrottleLimit parametre değeri 4 olarak ayarlanır. $using: anahtar sözcüğü, değişkeni her paralel betik bloğuna $Message geçirmek için kullanılır.

Örnek 12: Günlük girdilerini paralel olarak alma

Bu örnek, yerel bir Windows makinesindeki 5 sistem günlüğünden 50.000 günlük girdisi alır.

$logNames = 'Security', 'Application', 'System', 'Windows PowerShell',
    'Microsoft-Windows-Store/Operational'

$logEntries = $logNames | ForEach-Object -Parallel {
    Get-WinEvent -LogName $_ -MaxEvents 10000
} -ThrottleLimit 5

$logEntries.Count

50000

Parallel parametresi, her giriş günlüğü adı için paralel olarak çalıştırılacak betik bloğunu belirtir. ThrottleLimit parametresi, beş betik bloğunun da aynı anda çalışmasını sağlar.

Örnek 13: paralel olarak iş olarak çalıştırma

Bu örnek, bir betik bloğunu aynı anda iki kez paralel olarak çalıştıran bir iş oluşturur.

PS> $job = 1..10 | ForEach-Object -Parallel {
    "Output: $_"
    Start-Sleep 1
} -ThrottleLimit 2 -AsJob

PS> $job

Id     Name            PSJobTypeName   State         HasMoreData     Location      Command
--     ----            -------------   -----         -----------     --------      -------
23     Job23           PSTaskJob       Running       True            PowerShell    …

PS> $job.ChildJobs

Id     Name            PSJobTypeName   State         HasMoreData     Location      Command
--     ----            -------------   -----         -----------     --------      -------
24     Job24           PSTaskChildJob  Completed     True            PowerShell    …
25     Job25           PSTaskChildJob  Completed     True            PowerShell    …
26     Job26           PSTaskChildJob  Running       True            PowerShell    …
27     Job27           PSTaskChildJob  Running       True            PowerShell    …
28     Job28           PSTaskChildJob  NotStarted    False           PowerShell    …
29     Job29           PSTaskChildJob  NotStarted    False           PowerShell    …
30     Job30           PSTaskChildJob  NotStarted    False           PowerShell    …
31     Job31           PSTaskChildJob  NotStarted    False           PowerShell    …
32     Job32           PSTaskChildJob  NotStarted    False           PowerShell    …
33     Job33           PSTaskChildJob  NotStarted    False           PowerShell    …

ThrottleLimit parametresi, aynı anda çalışan paralel betik bloklarının sayısını sınırlar. AsJob parametresi, cmdlet'in ForEach-Object konsola akış çıkışı yerine bir iş nesnesi döndürmesine neden olur. değişkeni, $job çıkış verilerini toplayan ve çalışma durumunu izleyen iş nesnesini alır. özelliği, $job.ChildJobs paralel betik bloklarını çalıştıran alt işleri içerir.

Örnek 14: İş parçacığı güvenli değişken başvurularını kullanma

Bu örnek, benzersiz olarak adlandırılmış process nesnelerini toplamak için betik bloklarını paralel olarak çağırır.

$threadSafeDictionary = [System.Collections.Concurrent.ConcurrentDictionary[string,object]]::new()
Get-Process | ForEach-Object -Parallel {
    $dict = $using:threadSafeDictionary
    $dict.TryAdd($_.ProcessName, $_)
}

$threadSafeDictionary["pwsh"]

NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
     82    82.87     130.85      15.55    2808   2 pwsh

Nesneleri toplamak için her betik bloğuna tek bir ConcurrentDictionary nesnesi örneği geçirilir. ConcurrentDictionary iş parçacığı güvenli olduğundan, her paralel betik tarafından değiştirilmesi güvenlidir. System.Collections.Generic.Dictionary gibi iş parçacığı güvenli olmayan bir nesnenin burada kullanılması güvenli olmaz.

Örnek 15: Paralel yürütme ile hata yazma

Bu örnek, yazılı hataların sırasının rastgele olduğu hata akışına paralel olarak yazar.

1..3 | ForEach-Object -Parallel {
    Write-Error "Error: $_"
}

Write-Error: Error: 1
Write-Error: Error: 3
Write-Error: Error: 2

Örnek 16: Paralel yürütmede hataları sonlandırma

Bu örnekte paralel çalışan bir betik bloğunda sonlandırma hatası gösterilmektedir.

1..5 | ForEach-Object -Parallel {
    if ($_ -eq 3)
    {
        throw "Terminating Error: $_"
    }

    Write-Output "Output: $_"
}

Exception: Terminating Error: 3
Output: 1
Output: 4
Output: 2
Output: 5

Output: 3 hiçbir zaman yazılmamıştır çünkü bu yineleme için paralel betik bloğu sonlandırılmıştır.

Örnek 17: ScriptBlockSet iç içe paralel betikte değişkenleri geçirme

Kapsamlı bir betik bloğunun dışında bir Foreach-Object -Parallel değişken oluşturabilir ve bunu anahtar sözcüğüyle $using scriptblock içinde kullanabilirsiniz.

$test1 = 'TestA'
1..2 | Foreach-Object -Parallel {
    $using:test1
}

TestA
TestA

# You CANNOT create a variable inside a scoped scriptblock
# to be used in a nested foreach parallel scriptblock.
$test1 = 'TestA'
1..2 | Foreach-Object -Parallel {
    $using:test1
    $test2 = 'TestB'
    1..2 | Foreach-Object -Parallel {
        $using:test2
    }
}

Line |
   2 |  1..2 | Foreach-Object -Parallel {
     |         ~~~~~~~~~~~~~~~~~~~~~~~~~~
     | The value of the using variable '$using:test2' can't be retrieved because it has
     | not been set in the local session.

İç içe betik bloğu değişkene $test2 erişemiyor ve bir hata oluşuyor.

Örnek 18: Betikleri paralel olarak çalıştıran birden çok iş oluşturma

ThrottleLimit parametresi, her örneği ForEach-Object -Parallelsırasında çalıştırılan paralel betik sayısını sınırlar. AsJob parametresi kullanılırken oluşturulabilecek iş sayısını sınırlamaz. İşler aynı anda çalıştığından, her biri eşzamanlı betik bloklarının azaltma sınırına kadar çalışan birden çok paralel iş oluşturmak mümkündür.

$jobs = for ($i=0; $i -lt 10; $i++) {
    1..10 | ForEach-Object -Parallel {
        ./RunMyScript.ps1
    } -AsJob -ThrottleLimit 5
}

$jobs | Receive-Job -Wait

Bu örnek 10 çalışan iş oluşturur. Her iş aynı anda 5 betik çalıştırmaz. Eşzamanlı olarak çalışan örneklerin toplam sayısı 50 ile sınırlıdır (10 iş, ThrottleLimit sayısının 5 katıdır).

Parametreler

-ArgumentList

-AsJob

-Begin

-Confirm

-End

-InputObject

-MemberName

-Parallel

-Process

-RemainingScripts

-ThrottleLimit

-TimeoutSeconds

-UseNewRunspace

-WhatIf

Girişler

PSObject

Herhangi bir nesneyi bu cmdlet'e yöneltebilirsiniz.

Çıkışlar

PSObject

Bu cmdlet, giriş tarafından belirlenen nesneleri döndürür.

Notlar

PowerShell için aşağıdaki diğer adları ForEach-Objectiçerir:

• Tüm Platformlar:
  • %
  • foreach

Cmdlet, ForEach-Object Foreach deyimine çok benzer şekilde çalışır, ancak foreach deyimine giriş kanalı oluşturamazsınız. Foreach deyimi hakkında daha fazla bilgi için bkz. about_Foreach.

PowerShell 4.0'dan Where ForEach başlayarak koleksiyonlarla kullanılmak üzere yöntemler eklendi. Bu yeni yöntemler hakkında daha fazla bilgiyi burada about_arrays

kullanarak ForEach-Object -Parallel:

• ForEach-Object -Parallel her betik bloğunu yeni bir çalışma alanında çalıştırır. Yeni çalışma alanları, sıralı işleme ile çalışmaktan ForEach-Object önemli ölçüde daha fazla ek yük oluşturur. Paralel çalıştırma ek yükünün betik bloğunun gerçekleştirdiği çalışmaya kıyasla küçük olduğu Paralel'i kullanmak önemlidir. Örneğin:

  • Çok çekirdekli makinelerde işlem yoğunluklu betikler
  • Sonuçları beklemek veya dosya işlemleri yapmak için zaman harcayan betikler

  Parallel parametresinin kullanılması betiklerin normalden çok daha yavaş çalışmasına neden olabilir. Özellikle paralel betikler önemsizse. Yararlı olabilecek yerleri keşfetmek için Paralel ile denemeler yapın.

• Paralel çalışırken, ScriptProperties veya ScriptMethods ile dekore edilmiş nesnelerin, betiklerin özgün olarak eklendiğinden farklı bir çalışma alanında çalıştırıldıklarında düzgün çalışması garanti edilemez.

  Scriptblock çağrısı, çağrıldığı yerden bağımsız olarak her zaman kendi giriş çalışma alanında çalıştırmayı dener. Ancak, ForEach-Object -Parallel kullanımdan sonra silinen geçici çalışma alanları oluşturur, bu nedenle betiklerin artık içinde yürütülecek bir çalışma alanı yoktur.

  Bu davranış, giriş çalışma alanı hala mevcut olduğu sürece çalışabilir. Ancak betik, giriş çalışma alanında değil yalnızca çağıranın çalışma alanında bulunan dış değişkenlere bağımlıysa istenen sonucu alamayabilirsiniz.

• Sonlandırılmayan hatalar, paralel çalışan betik bloklarında oluştukları için cmdlet hata akışına yazılır. Paralel betik engelleme yürütme sırası belirleyici olmadığından, hata akışında hataların görünme sırası rastgeledir. Benzer şekilde, uyarı, ayrıntılı veya bilgi gibi diğer veri akışlarına yazılan iletiler de bu veri akışlarına belirsiz bir sırada yazılır.

  Özel durumlar gibi sonlandırma hataları, oluştukları betik bloklarının tek tek paralel örneğini sonlandırır. Bir betik bloğunda sonlandırma hatası cmdlet'in sonlandırılmasına Foreach-Object neden olmayabilir. Paralel çalışan diğer betik blokları, sonlandırıcı bir hatayla karşılaşmadıkları sürece çalışmaya devam eder. Sonlandırıcı hata, hata veri akışına errorRecord ve fullyQualifiedErrorId olarak PSTaskExceptionyazılır. Sonlandırma hataları, PowerShell try/catch veya trap bloklar kullanılarak sonlandırılmayan hatalara dönüştürülebilir.

• PipelineVariable ortak parametre değişkenleri, anahtar sözcükle $using: bile paralel senaryolarda desteklenmez.

  Önemli

  Parametre kümesi, ForEach-Object -Parallel betik bloklarını ayrı işlem iş parçacıklarında paralel olarak çalıştırır. $using: anahtar sözcüğü, cmdlet çağırma iş parçacığından çalışan her betik bloğu iş parçacığına değişken başvuruları geçirilmesine olanak tanır. Betik blokları farklı iş parçacıklarında çalıştırıldığından, başvuru tarafından geçirilen nesne değişkenleri güvenli bir şekilde kullanılmalıdır. Genellikle, değişmeyen başvurulmuş nesnelerden okumak güvenlidir. Nesne durumunu değiştirmeniz gerekiyorsa.NET System.Collection.Concurrent türleri gibi iş parçacığı güvenli nesneleri kullanmanız gerekir (Bkz. Örnek 14).

İlişkili Bağlantılar

• Compare-Object
• Where-Object
• Group-Object
• Measure-Object
• New-Object
• Select-Object
• Sort-Object
• Tee-Object