Proteggi foreach loop quando elenco vuoto

Utilizzando Powershell v2.0 voglio eliminare tutti i file più vecchi di X giorni:

$backups = Get-ChildItem -Path $Backuppath | 
                Where-Object {($_.lastwritetime -lt (Get-Date).addDays(-$DaysKeep)) -and (-not $_.PSIsContainer) -and ($_.Name -like "backup*")}

foreach ($file in $backups)
{
    Remove-Item $file.FullName;
}

Tuttavia, quando $ backup è vuoto ottengo: Remove-Item : Cannot bind argument to parameter 'Path' because it is null.

Ho provato:

1. Proteggere la foreach con if (!$backups)
2. Proteggere l'elemento Rimuovi con if (Test-Path $file -PathType Leaf)
3. Proteggere l'elemento Rimuovi con if ([IO.File]::Exists($file.FullName) -ne $true)

Nessuno di questi sembra funzionare, e se il modo raccomandato per impedire l'inserimento di un ciclo foreach se l'elenco fosse vuoto?

Con Powershell 3 l' foreachistruzione non viene ripetuta $nulle il problema descritto da OP non si verifica più.

Dal post del blog di Windows PowerShell Nuove funzionalità della lingua V3 :

Ogni istruzione ForEach non esegue l'iterazione su $ null

In PowerShell V2.0, le persone erano spesso sorprese da:

PS> foreach ($i in $null) { 'got here' }

got here

Questa situazione si presenta spesso quando un cmdlet non restituisce alcun oggetto. In PowerShell V3.0, non è necessario aggiungere un'istruzione if per evitare iterazioni su $ null. Ci prendiamo cura di questo per te.

Per PowerShell $PSVersionTable.PSVersion.Major -le 2vedere quanto segue per la risposta originale.

Hai due opzioni, io uso principalmente la seconda.

Controlla $backupsdi no $null. Un semplice Ifgiro del ciclo può controllare se no$null

if ( $backups -ne $null ) {

    foreach ($file in $backups) {
        Remove-Item $file.FullName;
    }

}

O

Inizializza $backupscome array null. Questo evita l'ambiguità del problema di "iterazione di array vuoti" di cui hai chiesto l'ultima domanda .

$backups = @()
# $backups is now a null value array

foreach ( $file in $backups ) {
    # this is not reached.
    Remove-Item $file.FullName
}

Siamo spiacenti, ho dimenticato di fornire un esempio di integrazione del codice. Si noti il Get-ChildItemcmdlet avvolto nella matrice. Ciò funzionerebbe anche con funzioni che potrebbero restituire a $null.

$backups = @(
    Get-ChildItem -Path $Backuppath |
        Where-Object { ($_.lastwritetime -lt (Get-Date).addDays(-$DaysKeep)) -and (-not $_.PSIsContainer) -and ($_.Name -like "backup*") }
)

foreach ($file in $backups) {
    Remove-Item $file.FullName
}

So che questo è un vecchio post, ma vorrei sottolineare che il cmdlet ForEach-Object non presenta lo stesso problema dell'uso della parola chiave ForEach. Quindi puoi reindirizzare i risultati di DIR a ForEach e fare semplicemente riferimento al file usando $ _, come:

$backups | ForEach{ Remove-Item $_ }

Puoi effettivamente inoltrare il comando Dir stesso attraverso la pipe ed evitare persino di assegnare la variabile come:

Get-ChildItem -Path $Backuppath | 
Where-Object {
             ($_.lastwritetime -lt (Get-Date).addDays(-$DaysKeep)) -and `
             (-not $_.PSIsContainer) -and ($_.Name -like "backup*")
             } |
ForEach{ Remove-Item $_ }

Ho aggiunto interruzioni di riga per la leggibilità.

Capisco alcune persone come ForEach / In per leggibilità. A volte ogni oggetto ForEach può diventare un po 'peloso, specialmente se stai annidando perché diventa difficile seguire il riferimento $ _. Ad ogni modo, per una piccola operazione come questa è perfetto. Molte persone affermano anche che è più veloce, tuttavia ho scoperto che è solo leggermente.

Ho sviluppato una soluzione eseguendo la query due volte, una volta per ottenere i file e una volta per contare i file eseguendo il cast di get-ChilItem per restituire un array (il cast di $ backup come array dopo che il fatto sembra non funzionare) .
Almeno funziona come previsto (le prestazioni non dovrebbero essere un problema poiché non ci saranno mai più di una dozzina di file), se qualcuno conosce una soluzione a query singola, si prega di pubblicarla.

$count = @(Get-ChildItem -Path $zipFilepath | 
                Where-Object {($_.lastwritetime -lt (Get-Date).addDays(-$DaysKeep)) -and (-not $_.PSIsContainer) -and ($_.Name -like $partial + "*")}).count;

if ($count -gt 0)
{
    $backups = Get-ChildItem -Path $zipFilepath | 
                Where-Object {($_.lastwritetime -lt (Get-Date).addDays(-$DaysKeep)) -and (-not $_.PSIsContainer) -and ($_.Name -like $partial + "*")};

    foreach ($file in $backups)
    {
        Remove-Item $file.FullName;
    }
}

Utilizzare quanto segue per valutare se l'array ha dei contenuti:

if($backups.count -gt 0) { echo "Array has contents" } else { echo "Array is empty" }

Se la variabile non esiste, Powershell la valuterà semplicemente come falsa, quindi non è necessario verificarne l'esistenza.