Convalida dell’esistenza del file PowerShell: Guida completa

Usi PowerShell per creare, leggere, aggiornare ed eliminare file? Se sì, probabilmente hai riscontrato errori quando i file di destinazione non esistono o esistono già. Per fortuna, ci sono modi in PowerShell per verificare se un file esiste prima di fare qualsiasi cosa ad esso.

Ad esempio, anziché permettere al tuo codice di creare il file subito, è meglio testare se il file esiste già. Come mostrato nella schermata qui sotto, puoi scrivere un codice migliore e ottenere un output chiaro.

In questo articolo, imparerai i diversi modi per utilizzare PowerShell per verificare se un file esiste. Imparerai anche come utilizzare ciascuno di questi modi per produrre un codice migliore e ottenere risultati chiari con la logica di gestione degli errori.

Prerequisiti

Riduci le chiamate al service desk e aggiorna le credenziali della cache per gli utenti remoti anche al di fuori della VPN con una soluzione di reset della password self-service. Ottieni una demo di Specops uReset!

Questo articolo è una guida pratica in cui imparerai da diversi esempi. E per seguire gli esempi, avrai bisogno dei seguenti:

• Editor di codice. Quelli consigliati sono Visual Studio Code e Atom, che funzionano su diverse piattaforme. Puoi anche usare Windows PowerShell ISE se stai lavorando su un computer Windows.
• Windows PowerShell 5.1 (Desktop) o PowerShell 7.1 (Core). I comandi e gli script in questo articolo si applicano a entrambe le edizioni di PowerShell. Che tu stia usando Windows, Linux o macOS, va bene finché hai PowerShell installato.

Correlato: Come scaricare e installare PowerShell 7 su Windows, Linux e macOS

Utilizzo di PowerShell per verificare se il file esiste

Questo articolo illustra tre metodi con cui utilizzare PowerShell per verificare se un file esiste. L’utilizzo di questi tre metodi differisce nell’uso, ma il concetto e l’obiettivo finale sono gli stessi. Questi tre modi sono:

• Test-Path Cmdlet.
• Get-Item e Get-ChildItem Cmdlet.
• System.IO.File Class.

Saranno forniti esempi e dimostrazioni di ciascuno di questi tre metodi, compreso come utilizzarli con la gestione degli errori.

Utilizzo di Test-Path

Il primo modo è il cmdlet Test-Path, specificamente progettato per determinare se un percorso o un file esiste. Quando si utilizza questo cmdlet per verificare se un file esiste, il risultato è true o false. Il risultato indica se il file esiste o meno.

Di seguito è riportata la sintassi di base per far funzionare il cmdlet Test-Path con il controllo di un file.

Test-Path -Path <PATH to FILE> -PathType Leaf

Ad esempio, se hai bisogno di verificare se un file con il nome C:\temp\important_file.txt esiste, utilizza il codice qui sotto. Nota che la parte -PathType Leaf indica al cmdlet di controllare esplicitamente un file e non una directory.

Test-Path -Path C:\temp\important_file.txt -PathType Leaf

Quando esegui il comando sopra in PowerShell, il risultato restituisce True se il file esiste. Altrimenti, il risultato sarebbe False, come puoi vedere dallo screenshot qui sotto.

Correlato: Come utilizzare il cmdlet Test-Path di PowerShell

Esempio: Creazione di un file se il file non esiste

Questo esempio è un caso d’uso tipico per creare file in una posizione specificata. Per evitare l’errore “il file esiste già”, lo script controlla se il file esiste già prima di crearlo. Se il file esiste, lo script mostra un messaggio e non tenta più di creare il file.

Copia il codice qui sotto e salvalo in un file chiamato Create-NewFile.ps1. Assicurati di modificare il valore della variabile $path se desideri modificare la posizione di output del file. Dopo aver salvato lo script, eseguilo in PowerShell per testarlo.

# Create-NewFile.ps1

# Percorso completo del file
$file = 'c:\temp\important_file.txt'

# Se il file non esiste, crealo.
if (-not(Test-Path -Path $file -PathType Leaf)) {
     try {
         $null = New-Item -ItemType File -Path $file -Force -ErrorAction Stop
         Write-Host "The file [$file] has been created."
     }
     catch {
         throw $_.Exception.Message
     }
 }
# Se il file esiste già, mostra il messaggio e non fare nulla.
 else {
     Write-Host "Cannot create [$file] because a file with that name already exists."
 }

La schermata sottostante mostra le due diverse uscite. La prima è quando viene eseguito lo script mentre il file non esiste. La seconda è dopo aver creato il file, e questo già esiste.

Correlato: Tornare alle basi: Come eseguire uno script di PowerShell

Utilizzando Get-Item e Get-ChildItem

Lo scopo del cmdlet “Get-Item” è quello di ottenere l’elemento in una posizione specificata. In confronto, il cmdlet “Get-ChildItem” serve per ottenere gli elementi e gli elementi figlio in una o più posizioni specificate. La funzionalità di questi due cmdlet non è esplicitamente quella di verificare l’esistenza dei file.

Cosa succede quando si utilizza “Get-Item” o “Get-ChildItem” per ottenere un elemento che non esiste? Si otterrà un errore per ogni file mancante. Prendi i comandi seguenti come esempio.

$file = 'c:\temp\important_file.txt'
Get-Item -Path $file
Get-ChildItem -Path $file

Supponiamo che il file c:\temp\important_file.txt non esista. Ciascuno dei comandi sopra restituisce un errore. Come puoi vedere dall’esempio qui sotto, il messaggio di errore per entrambi i comandi è lo stesso.

Esempio: Archiviazione del file esistente e creazione di un nuovo file

In questo esempio, lo script utilizza i cmdlet “Get-Item” e “Test-Path”. La logica di questo script è la seguente:

• Testa se la cartella dell’archivio esiste usando Test-Path.
  • Se la cartella dell’archivio non esiste, lo script crea una nuova cartella di archivio in questo formato – aaaa-MMM-gg_hh-mm-ss-tt.
  • Successivamente, lo script sposta il vecchio file nella cartella di archivio.
• Testa se il file esiste già usando Get-Item.
  • Se il file esiste, lo script lo sposta nella cartella di archivio prima. Poi lo script crea il nuovo file nella posizione originale.
  • Se il file non esiste, lo script crea il nuovo file.

Copia il codice qui sotto e salvalo come Create-NewFileAfterArchive.ps1. Dopo aver salvato lo script, eseguilo in PowerShell e verifica i risultati.

# Create-NewFileAfterArchive.ps1

# Percorso completo del file
$file = 'c:\temp\important_file.txt'

# Percorso completo della cartella di archiviazione
$archiveFolder = "c:\temp\archive_$(get-date -Format 'yyyy-MMM-dd_hh-mm-ss-tt')\"

# Se il file esiste, spostalo nella cartella di archiviazione e crea un nuovo file.
if (Get-Item -Path $file -ErrorAction Ignore) {
    try {
        ## Se la cartella di archiviazione non esiste, creala ora.
        if (-not(Test-Path -Path $archiveFolder -PathType Container)) {
            $null = New-Item -ItemType Directory -Path $archiveFolder -ErrorAction STOP
        }
        ## Sposta il file esistente nell'archivio.
        Move-Item -Path $file -Destination $archiveFolder -Force -ErrorAction STOP
        Write-Host "The old file [$file] has been archived to [$archiveFolder]"
     } catch {
        throw $_.Exception.Message
     }
 }
 Create the new file
 try {
     $null = New-Item -ItemType File -Path $file -Force -ErrorAction Stop
     Write-Host "The new file [$file] has been created."
 } catch {
    Write-Host $_.Exception.Message
 }

Suggerimento: Il parametro -ErrorAction Ignore sopprime l’errore (non verrà visualizzato nella console) e non registra l’errore nella variabile automatica $error.

Nella schermata sottostante, la prima esecuzione dello script ha creato il file c:\temp\important_file.txt. Le esecuzioni successive dello script hanno creato una nuova cartella di archivio ogni volta, spostato il file esistente nella cartella di archivio e quindi creato un nuovo file in c:\temp\important_file.txt.

Utilizzo del Metodo .NET [System.IO.File]::Exists()

Il último metodo da apprendere in questo articolo è il classe .NET System.IO.File, specificamente il metodo Exists(). Una delle forze di PowerShell è la sua capacità di importare e utilizzare classi e metodi .NET.

Per esempio, per utilizzare il metodo Exists() in PowerShell per verificare se un file esiste, utilizzare il codice seguente.

[System.IO.File]::Exists("PATH")

Il metodo sopra restituisce un risultato booleano – true o false. Se il risultato restituisce true, significa che il file di destinazione esiste. In caso contrario, il risultato restituito è false quando il file di destinazione non esiste.

Nel codice di esempio sottostante, il comando verifica l’esistenza del file c:\temp\important_file.txt.

$file = 'c:\temp\important_file.txt'
[System.IO.File]::Exists($file)

Come puoi vedere dal risultato qui sotto, il risultato restituisce true, confermando che il file esiste.

Con questo metodo .NET, puoi anche utilizzare operazioni ternary come nell’esempio qui sotto. Invece di mostrare i risultati predefiniti true o false, puoi personalizzare il messaggio di risultato con un’implementazione più breve. Tuttavia, l’operatore ternary in questo esempio si applica solo a PowerShell 7+.

$file = 'c:\temp\important_file.txt'
[System.IO.File]::Exists($file) ? "The file exists." : "The file does not exist."

Esempio: Aggiornamento dei Contenuti del File Se Il File Esiste

Questo script di esempio aggiorna il file di testo aggiungendo un nuovo valore GUID. Tuttavia, l’aggiornamento del contenuto avviene solo se il file esiste. In caso contrario, lo script mostra un messaggio e non fa nulla.

Copia lo script qui sotto e salvalo come Update-FileContents.ps1. Modifica il valore del percorso del file della variabile $file se necessario. Quindi esegui lo script in PowerShell per testarlo.

# Aggiorna-FileContents.ps1

# Percorso completo del file
$file = 'c:\temp\important_file.txt'

# Se il file esiste, aggiungi un nuovo valore GUID nel file.
if ([System.IO.File]::Exists($file)) {
    try {
        $newValue = ((New-Guid).Guid)
        Add-Content -Path $file -Value $newValue -ErrorAction STOP
        Write-Host "The file [$file] has been updated with [$newValue]"
     } catch {
        throw $_.Exception.Message
     }    
 }

# Se il file non esiste, mostra un messaggio e non fare nulla.
 else {
     Write-Host "The file [$file] could not be updated because it does not exist."
 }

Puoi vedere nella schermata sottostante che lo script ha aggiornato il file ad ogni esecuzione. L’aggiornamento è avvenuto perché il metodo [System.IO.File]::Exists() ha confermato che il file c:\temp\important_file.txt esiste.

Alla fine, utilizzando il comando gc c:\temp\important_file.txt per leggere il contenuto del file, è stato confermato che lo script ha aggiornato il file con i valori GUID.

Correlato: Utilizzo degli acceleratori dei tipi di dati di PowerShell per velocizzare la codifica

Conclusioni

Riduci le chiamate al service desk e aggiorna le credenziali della cache per gli utenti remoti anche al di fuori della VPN con una soluzione di reset della password self-service. Ottieni una demo di Specops uReset!

In questo articolo, hai appreso che esistono più modi per utilizzare PowerShell per verificare se un file esiste. È una buona pratica verificare la presenza di un file prima di apportare modifiche relative ai file.

Hai imparato ad utilizzare i cmdlet Get-Item, Get-ChildItem e Test-Path. Così come il metodo [System.IO.File]::Exists() .NET. Gli esempi ti hanno mostrato come utilizzare le tecniche e come combinarle con la logica di gestione degli errori.

Smetti di sopportare quei messaggi di errore. Superali aggiungendo del codice per verificare se un file esiste prima di qualsiasi operazione relativa ai file. Le tecniche apprese qui coprono solo le basi, e ora spetta a te migliorarle.