Delen via

about_Foreach

  • Artikel

Korte beschrijving

Beschrijft een taalopdracht die u kunt gebruiken om alle items in een verzameling items te doorlopen.

Lange beschrijving

De foreach instructie is een taalconstructie voor het herhalen van een set waarden in een verzameling.

Het eenvoudigste en meest typische type verzameling dat moet worden doorkruist, is een matrix. Binnen een foreach lus is het gebruikelijk om een of meer opdrachten uit te voeren voor elk item in een matrix.

Syntaxis

Hieronder ziet u de foreach syntaxis:

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

Het deel van de foreach instructie tussen haakjes vertegenwoordigt een variabele en een verzameling om te herhalen. PowerShell maakt de variabele $<item> automatisch wanneer de foreach lus wordt uitgevoerd. Aan het begin van elke iteratie foreach stelt u de itemvariabele in op de volgende waarde in de verzameling. Het {<statement list>} blok bevat de opdrachten die moeten worden uitgevoerd voor elke iteratie.

Voorbeelden

In de foreach lus in het volgende voorbeeld worden bijvoorbeeld de waarden in de $letterArray matrix weergegeven.

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

In dit voorbeeld bevat de $letterArray tekenreekswaardena, b, en cd. De eerste keer dat de foreach instructie wordt uitgevoerd, wordt de $letter variabele ingesteld die gelijk is aan het eerste item in $letterArray (a). Vervolgens wordt Write-Host de waarde weergegeven. De volgende keer dat de lus wordt doorlopen, $letter is ingesteld op b. Het patroon wordt herhaald voor elk item in de matrix.

U kunt ook instructies gebruiken foreach met cmdlets die een verzameling items retourneren. In het volgende voorbeeld doorloopt de foreach instructie de lijst met items die door de Get-ChildItem cmdlet worden geretourneerd.

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

U kunt het voorbeeld verfijnen met behulp van een if instructie om de geretourneerde resultaten te beperken. In het volgende voorbeeld beperkt de if instructie de resultaten tot bestanden die groter zijn dan 100 kilobytes (KB):

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

In dit voorbeeld gebruikt de foreach lus een eigenschap van de $file variabele om een vergelijkingsbewerking ($file.length -gt 100KB) uit te voeren. De $file variabele heeft alle eigenschappen van het object dat door de Get-ChildItemvariabele wordt geretourneerd.

In het volgende voorbeeld wordt in het script de lengte en de laatste toegangstijd in de lijst met instructies weergegeven:

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

U kunt ook variabelen van buiten een foreach lus gebruiken. In het volgende voorbeeld worden bestanden geteld die groter zijn dan 100 kB:

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

In het voorgaande voorbeeld $i begint u met een waarde van 0 buiten de lus. $i Vervolgens wordt de lus verhoogd voor elk bestand dat groter is dan 100 kB. Wanneer de lus wordt afgesloten, evalueert een if instructie de waarde van $i het weergeven van een aantal bestanden van meer dan 100 KB.

In het vorige voorbeeld ziet u ook hoe u de resultaten van de bestandsgrootte opmaken:

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

De waarde wordt gedeeld door 1024 om de resultaten weer te geven in kilobytes in plaats van bytes. De resulterende waarde wordt vervolgens opgemaakt met behulp van de notatieaanduiding met vaste punten om decimale waarden uit het resultaat te verwijderen. De 0 notatieaanduiding geeft geen decimalen weer.

De volgende functie parseert PowerShell-scripts en scriptmodules en retourneert de locatie van functies die zijn opgenomen in. In het voorbeeld ziet u hoe u de MoveNext methode en de Current eigenschap van de $foreach variabele in een foreach scriptblok gebruikt.

Zie Enumerators gebruiken voor meer informatie.

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

Zie ook