Udostępnij za pośrednictwem

about_Foreach

Krótki opis

Opisuje polecenie języka, którego można użyć do przechodzenia wszystkich elementów w kolekcji elementów.

Długi opis

Instrukcja foreach to konstrukcja języka do iterowania zestawu wartości w kolekcji.

Najprostszym i najbardziej typowym typem kolekcji do przechodzenia jest tablica. W ramach pętli foreach często uruchamia się co najmniej jedno polecenie względem każdego elementu w tablicy.

Składnia

Poniżej przedstawiono składnię foreach:

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

Część instrukcji foreach wewnątrz nawiasu reprezentuje zmienną i kolekcję do iteracji. Program PowerShell tworzy zmienną $<item> automatycznie po uruchomieniu pętli foreach. Na początku każdej iteracji foreach ustawia zmienną elementu na następną wartość w kolekcji. Blok {<statement list>} zawiera polecenia do wykonania dla każdej iteracji.

Przykłady

Na przykład pętla foreach w poniższym przykładzie wyświetla wartości w tablicy $letterArray.

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

W tym przykładzie $letterArray zawiera wartości ciągu a, b, ci d. Przy pierwszym uruchomieniu instrukcji foreach ustawia zmienną $letter równą pierwszemu elementowi w $letterArray (a). Następnie używa Write-Host do wyświetlania wartości. Przy następnym przejściu do pętli $letter ustawiono wartość b. Wzorzec powtarza się dla każdego elementu w tablicy.

Można również użyć instrukcji foreach z poleceniami cmdlet, które zwracają kolekcję elementów. W poniższym przykładzie instrukcja foreach przechodzi przez listę elementów zwracanych przez polecenie cmdlet Get-ChildItem.

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

Możesz uściślić przykład, używając instrukcji if, aby ograniczyć zwracane wyniki. W poniższym przykładzie instrukcja if ogranicza wyniki do plików, które są większe niż 100 kilobajtów (KB):

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

W tym przykładzie pętla foreach używa właściwości zmiennej $file do wykonania operacji porównania ($file.Length -gt 100KB). Zmienna $file ma wszystkie właściwości obiektu zwrócone przez Get-ChildItem.

W następnym przykładzie skrypt wyświetla długość i czas ostatniego dostępu na liście instrukcji:

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

Można również używać zmiennych spoza pętli foreach. Poniższy przykład zlicza pliki o rozmiarze ponad 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.'
}

W poprzednim przykładzie $i zaczyna się od wartości 0 poza pętlą. Następnie $i jest zwiększana wewnątrz pętli dla każdego pliku, który jest większy niż 100 KB. Gdy pętla kończy działanie, instrukcja if oblicza wartość $i, aby wyświetlić liczbę plików powyżej 100 KB.

W poprzednim przykładzie pokazano również, jak sformatować wyniki długości pliku:

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

Wartość jest podzielona przez 1024, aby pokazać wyniki w kilobajtach, a nie bajtach, a wynikowa wartość jest następnie formatowana przy użyciu specyfikatora formatu stałego punktu w celu usunięcia wszystkich wartości dziesiętnych z wyniku. 0 sprawia, że specyfikator formatu nie pokazuje miejsc dziesiętnych.

Poniższa funkcja analizuje skrypty programu PowerShell i moduły skryptów i zwraca lokalizację funkcji zawartych w programie . W przykładzie pokazano, jak używać MoveNext metody i Current właściwości $foreach zmiennej wewnątrz foreach bloku instrukcji.

Aby uzyskać więcej informacji, zobacz Using Enumerators.

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

Zobacz także

  • Last updated on