Freigeben über

about_Foreach

Kurzbeschreibung

Beschreibt einen Sprachbefehl, den Sie verwenden können, um alle Elemente in einer Auflistung von Elementen zu durchlaufen.

Lange Beschreibung

Die foreach-Anweisung ist ein Sprachkonstrukt zum Durchlaufen einer Reihe von Werten in einer Sammlung.

Der einfachste und typischste zu durchlaufende Sammlungstyp ist ein Array. In einer foreach-Schleife werden häufig Befehle für jedes Element in einem Array ausgeführt.

Syntax

Im Anschluss sehen Sie die foreach-Syntax:

foreach ($<item> in $<collection>){<statement list>}

Der Teil der foreach-Anweisung in den Klammern stellt eine Variable und eine Sammlung dar, die durchlaufen werden soll. PowerShell erstellt die Variable $<item> automatisch, wenn die foreach-Schleife ausgeführt wird. Am Anfang jeder Iteration legt foreach die Elementvariable auf den nächsten Wert in der Sammlung fest. Der {<statement list>}-Block enthält die Befehle, die für jede Iteration ausgeführt werden sollen.

Beispiele

Beispielsweise zeigt die foreach-Schleife im folgenden Beispiel die Werte im $letterArray-Array an.

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

In diesem Beispiel enthält $letterArray die Zeichenfolgenwerte a, b, c und d. Wenn die foreach-Anweisung zum ersten Mal ausgeführt wird, wird die $letter-Variable auf das erste Element in $letterArray (a) festgelegt. Anschließend wird Write-Host zum Anzeigen des Werts verwendet. Beim nächsten Durchlaufen der Schleife wird $letter auf b festgelegt. Das Muster wird für jedes Element im Array wiederholt.

Sie können auch foreach-Anweisungen mit Cmdlet verwenden, die eine Sammlung von Elementen zurückgeben. Im folgenden Beispiel durchläuft die Anweisung foreach die vom Cmdlet Get-ChildItem zurückgegebene Liste der Elemente.

foreach ($file in Get-ChildItem)
{
  Write-Host $file
}

Sie können das Beispiel mithilfe einer if-Anweisung verfeinern, um die zurückgegebenen Ergebnisse einzuschränken. Im folgenden Beispiel beschränkt die if-Anweisung die Ergebnisse auf Dateien, die größer als 100 KB sind:

foreach ($file in Get-ChildItem)
{
  if ($file.Length -gt 100KB)
  {
    Write-Host $file
  }
}

In diesem Beispiel verwendet die Schleife foreach eine Eigenschaft der Variablen $file, um einen Vergleichsvorgang auszuführen ($file.Length -gt 100KB). Die variable $file verfügt über alle Eigenschaften des Objekts, das vom Get-ChildItemzurückgegeben wird.

Im nächsten Beispiel zeigt das Skript die Länge und die Uhrzeit des letzten Zugriffs innerhalb der Anweisungsliste an:

foreach ($file in Get-ChildItem)
{
  if ($file.Length -gt 100KB)
  {
    Write-Host $file
    Write-Host $file.Length
    Write-Host $file.LastAccessTime
  }
}

Sie können auch Variablen außerhalb einer foreach-Schleife verwenden. Im folgenden Beispiel werden Dateien mit einer Größe von mehr als 100 KB gezählt:

$i = 0
foreach ($file in Get-ChildItem) {
  if ($file.Length -gt 100KB) {
    Write-Host $file 'file size:' ($file.Length / 1024).ToString('F0') KB
    $i = $i + 1
  }
}

if ($i -ne 0) {
  Write-Host
  Write-Host $i ' file(s) over 100KB in the current directory.'
}
else {
  Write-Host 'No files greater than 100KB in the current directory.'
}

Im vorherigen Beispiel beginnt $i mit dem Wert 0 außerhalb der Schleife. Dann wird $i in der Schleife für jede Datei erhöht, die größer als 100 KB ist. Wenn die Schleife beendet wird, wertet eine if-Anweisung den Wert $i aus, um die Anzahl von Dateien über 100 KB anzuzeigen.

Das vorherige Beispiel zeigt auch, wie die Ergebnisse der Dateilänge formatiert werden.

($file.Length / 1024).ToString('F0')

Der Wert wird durch 1.024 dividiert, um die Ergebnisse in Kilobyte anstelle von Bytes anzuzeigen, und der resultierende Wert wird dann mit dem Festkommaformatbezeichner formatiert, um alle Dezimalwerte aus dem Ergebnis zu entfernen. Mit 0 zeigt der Formatbezeichner keine Dezimalstellen an.

Die folgende Funktion analysiert PowerShell-Skripts und Skriptmodule und gibt den Speicherort der darin enthaltenen Funktionen zurück. Das Beispiel veranschaulicht die Verwendung der MoveNext Methode und der Current Eigenschaft der $foreach Variablen innerhalb eines foreach Anweisungsblocks.

Weitere Informationen finden Sie unter Verwenden von Enumeratoren.

function Get-FunctionPosition {
  [CmdletBinding()]
  [OutputType('FunctionPosition')]
  param(
    [Parameter(Position = 0, Mandatory,
      ValueFromPipeline, ValueFromPipelineByPropertyName)]
    [ValidateNotNullOrEmpty()]
    [Alias('PSPath')]
    [System.String[]]
    $Path
  )

  process {
    try {
      $filesToProcess = if ($_ -is [System.IO.FileSystemInfo]) {
        $_
      } else {
        Get-Item -Path $Path
      }
      $parser = [System.Management.Automation.Language.Parser]
      foreach ($item in $filesToProcess) {
        if ($item.PSIsContainer -or
            $item.Extension -notin @('.ps1', '.psm1')) {
          continue
        }
        $tokens = $errors = $null
        $ast = $parser::ParseFile($item.FullName, ([ref]$tokens),
          ([ref]$errors))
        if ($errors) {
          $msg = "File '{0}' has {1} parser errors." -f $item.FullName,
            $errors.Count
          Write-Warning $msg
        }
        :tokenLoop foreach ($token in $tokens) {
          if ($token.Kind -ne 'Function') {
            continue
          }
          $position = $token.Extent.StartLineNumber
          do {
            if (-not $foreach.MoveNext()) {
              break tokenLoop
            }
            $token = $foreach.Current
          } until ($token.Kind -in @('Generic', 'Identifier'))
          $functionPosition = [pscustomobject]@{
            Name       = $token.Text
            LineNumber = $position
            Path       = $item.FullName
          }
          $addMemberSplat = @{
              InputObject = $functionPosition
              TypeName = 'FunctionPosition'
              PassThru = $true
          }
          Add-Member @addMemberSplat
        }
      }
    }
    catch {
      throw
    }
  }
}

Siehe auch

  • Last updated on