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 voorkomende type verzameling dat moet worden gekruist, is een matrix. Binnen een foreach lus is het gebruikelijk om een of meer opdrachten uit te voeren voor elk item in een matrix.

Syntax

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

Voorbeelden

Met 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 de tekenreekswaarden a, b, cen d. De eerste keer dat de foreach instructie wordt uitgevoerd, wordt de $letter variabele gelijk aan het eerste item in $letterArray (a) ingesteld. Vervolgens wordt gebruikt Write-Host om de waarde weer te geven. De volgende keer dat de lus wordt doorlopen, $letter wordt 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 instructie de if resultaten tot bestanden die groter zijn dan 100 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 () uit te voeren.$file.length -gt 100KB De $file variabele heeft alle eigenschappen van het object dat wordt geretourneerd door de Get-ChildItem.

In het volgende voorbeeld geeft het script de lengte en de laatste toegangstijd weer in de instructielijst:

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 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 om een aantal bestanden van meer dan 100 kB weer te geven.

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

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

De waarde wordt gedeeld door 1.024 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 notatieaanduiding geen decimalen weergeeft.

Met de volgende functie parseert u PowerShell-scripts en scriptmodules en retourneert u de locatie van de functies in deze functie. 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