Dela via

about_Foreach

Kort beskrivning

Beskriver ett språkkommando som du kan använda för att bläddra igenom alla objekt i en samling objekt.

Lång beskrivning

-instruktionen foreach är en språkkonstruktion för iterering över en uppsättning värden i en samling.

Den enklaste och mest typiska typen av samling att korsa är en matris. I en foreach loop är det vanligt att köra ett eller flera kommandon mot varje objekt i en matris.

Syntax

Följande visar syntaxen foreach :

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

Delen av -instruktionen foreach inom parentes representerar en variabel och en samling att iterera. PowerShell skapar variabeln $<item> automatiskt när loopen foreach körs. I början av varje iteration foreach anger du objektvariabeln till nästa värde i samlingen. Blocket {<statement list>} innehåller de kommandon som ska köras för varje iteration.

Exempel

Loopen foreach i följande exempel visar till exempel värdena i matrisen $letterArray .

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

I det här exemplet $letterArray innehåller strängvärdena a, , bcoch d. Första gången -instruktionen foreach körs anger den variabeln $letter lika med det första objektet i $letterArray (a). Sedan används Write-Host det för att visa värdet. Nästa gång genom loopen $letter är inställd på b. Mönstret upprepas för varje objekt i matrisen.

Du kan också använda foreach instruktioner med cmdletar som returnerar en samling objekt. I följande exempel stegar instruktionen foreach igenom listan över objekt som returneras av cmdleten Get-ChildItem .

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

Du kan förfina exemplet med hjälp av en if -instruktion för att begränsa de resultat som returneras. I följande exempel begränsar instruktionen if resultatet till filer som är större än 100 kilobyte (KB):

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

I det här exemplet använder loopen foreach en egenskap för variabeln $file för att utföra en jämförelseåtgärd ($file.Length -gt 100KB). Variabeln $file har alla egenskaper för objektet som returneras av Get-ChildItem.

I nästa exempel visar skriptet längden och den senaste åtkomsttiden i instruktionslistan:

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

Du kan också använda variabler utanför en foreach loop. I följande exempel räknas filer över 100 KB i storlek:

$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.'
}

I föregående exempel $i börjar med värdet 0 utanför loopen. $i Sedan ökas i loopen för varje fil som är större än 100 KB. När loopen avslutas utvärderar en if instruktion värdet $i för för att visa ett antal filer över 100 KB.

I föregående exempel visas också hur du formaterar fillängdsresultatet:

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

Värdet divideras med 1 024 för att visa resultatet i kilobyte i stället för byte, och det resulterande värdet formateras sedan med hjälp av fastpunktsformatsspecificeraren för att ta bort eventuella decimalvärden från resultatet. Gör 0 att formatspecificeraren inte visar några decimaler.

Följande funktion parsar PowerShell-skript och skriptmoduler och returnerar platsen för funktioner som finns i. Exemplet visar hur du använder MoveNext metoden och Current egenskapen för variabeln $foreach i ett foreach skriptblock.

Mer information finns i Använda uppräknare.

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
    }
  }
}

Se även