Delen via

about_Foreach

Korte beschrijving

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

Lange beschrijving

De instructie foreach 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 die moet worden herhaald. PowerShell maakt de variabele automatisch $<item> wanneer de foreach lus wordt uitgevoerd. Aan het begin van elke iteratie stelt foreach de itemvariabele in op de volgende waarde in de verzameling. Het {<statement list>} blok bevat de opdrachten die voor elke iteratie moeten worden uitgevoerd.

Voorbeelden

De foreach lus in het volgende voorbeeld geeft bijvoorbeeld de waarden in de $letterArray matrix weer.

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

In dit voorbeeld bevat de $letterArray de tekenreekswaarden a, b, cen d. De eerste keer dat de instructie foreach wordt uitgevoerd, wordt de variabele $letter ingesteld die gelijk is aan het eerste item in $letterArray (a). Vervolgens wordt Write-Host gebruikt om de waarde weer te geven. De volgende keer dat de lus wordt doorlopen, wordt $letter ingesteld op b. Het patroon wordt herhaald voor elk item in de matrix.

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

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

U kunt het voorbeeld verfijnen met behulp van een if instructie om de resultaten te beperken die worden geretourneerd. 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 variabele $file heeft alle eigenschappen van het object dat door de Get-ChildItemwordt 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 begint $i met een waarde van 0 buiten de lus. Vervolgens wordt $i in 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 om het aantal bestanden van meer dan 100 KB weer te geven.

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 zorgt ervoor dat de opmaak specificatie geen decimalen weergeeft.

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 instructieblok gebruikt.

Voor meer informatie, zie Enumerators gebruiken.

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

  • Last updated on