Validación de la Existencia de Archivos en PowerShell: Guía Completa

¿Usas PowerShell para crear, leer, actualizar y eliminar archivos? Si es así, probablemente hayas experimentado errores cuando los archivos de destino no existen o ya existen. Afortunadamente, hay maneras en PowerShell de verificar si un archivo existe antes de hacer cualquier cosa con él.

Por ejemplo, en lugar de permitir que tu código cree el archivo de inmediato, es mejor probar si el archivo ya existe. Como se muestra en la captura de pantalla a continuación, puedes escribir un código mejor y obtener resultados más claros.

En este artículo, aprenderás las diferentes formas de utilizar PowerShell para verificar si un archivo existe. También aprenderás cómo utilizar cada una de estas formas para producir un código y resultados mejores con lógica de manejo de errores.

Prerrequisitos

Reducir las llamadas al servicio de asistencia y actualizar las credenciales de la caché para usuarios remotos incluso fuera de VPN con una solución de restablecimiento de contraseña de autoservicio. ¡Obtén una demostración de Specops uReset!

Este artículo es una guía práctica en la que aprenderás de diferentes ejemplos. Y para seguir los ejemplos, necesitarás lo siguiente:

• Editor de código. Se recomiendan Visual Studio Code y Atom, que funcionan en todas las plataformas. También puedes usar Windows PowerShell ISE si estás trabajando en una computadora con Windows.
• Windows PowerShell 5.1 (Escritorio) o PowerShell 7.1 (Núcleo). Los comandos y scripts en este artículo se aplican a ambas ediciones de PowerShell. Ya sea que estés utilizando Windows, Linux o macOS, estarás bien siempre y cuando tengas PowerShell instalado.

Relacionado: Cómo Descargar e Instalar PowerShell 7 en Windows, Linux y macOS

Usando PowerShell para Verificar si un Archivo Existe

Este artículo cubre tres métodos con los cuales usar PowerShell para verificar si un archivo existe. El uso de estos tres métodos difiere en el uso, pero el concepto y el objetivo final son los mismos. Estas tres formas son:

• Test-Path Cmdlet.
• Get-Item y Get-ChildItem Cmdlet.
• System.IO.File Clase.

Habrá ejemplos y demos de cada uno de estos tres métodos, incluyendo cómo usarlos con manejo de errores.

Usando Test-Path

La primera forma es el cmdlet Test-Path, específicamente diseñado para determinar si una ruta o archivo existe. Cuando se utiliza este cmdlet para probar si un archivo existe, el resultado es true o false. El resultado indica si el archivo existe o no.

A continuación se muestra la sintaxis básica para hacer que el cmdlet Test-Path funcione con la verificación de un archivo.

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

Por ejemplo, si necesitas verificar si un archivo con el nombre C:\temp\important_file.txt existe, utiliza el código a continuación. Ten en cuenta que la parte -PathType Leaf le indica al cmdlet que verifique explícitamente si se trata de un archivo y no de un directorio.

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

Cuando ejecutas el comando anterior en PowerShell, el resultado devuelve True si el archivo existe. De lo contrario, el resultado sería False, como se puede ver en la captura de pantalla a continuación.

Relacionado: Cómo usar el cmdlet Test-Path de PowerShell

Ejemplo: Crear un archivo si el archivo no existe

Este ejemplo es un caso de uso típico para crear archivos en una ubicación específica. Para evitar el error “el archivo ya existe”, el script verifica si el archivo ya existe antes de crearlo. Si el archivo existe, el script muestra un mensaje y no intenta crear el archivo nuevamente.

Copia el código a continuación y guárdalo en un archivo llamado Create-NewFile.ps1. Asegúrate de cambiar el valor de la variable $path si deseas cambiar la ubicación de salida del archivo. Después de guardar el script, ejecútalo en PowerShell para probarlo.

# Create-NewFile.ps1

# Ruta completa del archivo
$file = 'c:\temp\important_file.txt'

# Si el archivo no existe, créalo.
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
     }
 }
# Si el archivo ya existe, muestra el mensaje y no hagas nada.
 else {
     Write-Host "Cannot create [$file] because a file with that name already exists."
 }

La captura de pantalla a continuación muestra las dos salidas diferentes. La primera es cuando se ejecuta el script mientras el archivo no existe. La segunda es después de crear el archivo, y ya existe.

Relacionado: Volver a lo básico: Cómo ejecutar un script de PowerShell

Usando Get-Item y Get-ChildItem

El propósito del cmdlet Get-Item es obtener el elemento en una ubicación especificada. En comparación, el cmdlet Get-ChildItem es para obtener los elementos y subelementos en una o más ubicaciones especificadas. La funcionalidad de estos dos cmdlets no es explícitamente comprobar si los archivos existen.

¿Qué sucede cuando usas Get-Item o Get-ChildItem para obtener un elemento que no existe? Obtendrás un error por cada archivo que falte. Toma los comandos a continuación como ejemplo.

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

Supongamos que el archivo c:\temp\important_file.txt no existe. Cada uno de los comandos anteriores devuelve un error. Como puedes ver en el ejemplo siguiente, el mensaje de error para ambos comandos es el mismo.

Ejemplo: Archivar el archivo existente y crear un nuevo archivo

En este ejemplo, el script utiliza los cmdlets Get-Item y Test-Path. La lógica de este script es la siguiente:

• Prueba si la carpeta de archivo existe usando Test-Path.
  • Si la carpeta de archivo no existe, el script crea una nueva carpeta de archivo en este formato: aaaa-MMM-dd_hh-mm-ss-tt.
  • Luego, el script mueve el archivo antiguo a la carpeta de archivo.
• Prueba si el archivo ya existe usando Get-Item.
  • Si el archivo existe, el script lo mueve primero a la carpeta de archivo. Luego, el script crea el nuevo archivo en la ubicación original.
  • Si el archivo no existe, el script crea el nuevo archivo.

Copia el código a continuación y guárdalo como Create-NewFileAfterArchive.ps1. Después de guardar el script, ejecútalo en PowerShell y verifica los resultados.

# Crear-NuevoArchivoDespuésDeArchivar.ps1

# Ruta completa del archivo
$file = 'c:\temp\important_file.txt'

# Ruta completa de la carpeta de archivado
$archiveFolder = "c:\temp\archive_$(get-date -Format 'yyyy-MMM-dd_hh-mm-ss-tt')\"

# Si el archivo existe, muévalo a la carpeta de archivado y luego cree un nuevo archivo.
if (Get-Item -Path $file -ErrorAction Ignore) {
    try {
        ## Si la carpeta de Archivo no existe, créela ahora.
        if (-not(Test-Path -Path $archiveFolder -PathType Container)) {
            $null = New-Item -ItemType Directory -Path $archiveFolder -ErrorAction STOP
        }
        ## Mueva el archivo existente al archivo.
        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
 }

Consejo: El parámetro -ErrorAction Ignore suprime el error (no se mostrará en la consola) y tampoco registra el error en la variable automática $error.

En la captura de pantalla a continuación, la primera ejecución del script creó el archivo c:\temp\important_file.txt. Las ejecuciones de script sucesivas crearon una nueva carpeta de archivo cada vez, mueven el archivo existente a la carpeta de archivo y luego crean un nuevo archivo en c:\temp\important_file.txt.

Usando el Método .NET [System.IO.File]::Exists()

El último método para aprender en este artículo es la clase .NET System.IO.File, específicamente el método Exists(). Una de las fortalezas de PowerShell es su capacidad para importar y usar clases y métodos .NET.

Por ejemplo, para usar el método Exists() en PowerShell para verificar si un archivo existe, utilice el siguiente código.

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

El método anterior produce un resultado booleano: verdadero o falso. Si el resultado devuelve verdadero, significa que el archivo de destino existe. De lo contrario, el resultado devuelto es falso cuando el archivo de destino no existe.

En el código de ejemplo a continuación, el comando verifica la existencia del archivo c:\temp\important_file.txt.

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

Como puedes ver en el resultado a continuación, el resultado devuelve verdadero, confirmando que el archivo existe.

Con este método de .NET, también puedes usar operaciones ternarias como el ejemplo a continuación. En lugar de mostrar los resultados predeterminados verdadero o falso, puedes personalizar el mensaje de resultado con una implementación más corta. Sin embargo, el operador ternario en este ejemplo solo se aplica a PowerShell 7 o superior.

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

Ejemplo: Actualización del Contenido del Archivo Si el Archivo Existe

Este script de ejemplo actualiza el archivo de texto agregando un nuevo valor GUID. Sin embargo, la actualización del contenido solo ocurre si el archivo existe. De lo contrario, el script muestra un mensaje y no hace nada más.

Copia el script a continuación y guárdalo como Update-FileContents.ps1. Cambia el valor de la ruta del archivo de la variable $file si es necesario. Luego ejecuta el script en PowerShell para probarlo.

# Update-FileContents.ps1

#Ruta completa del archivo
$file = 'c:\temp\important_file.txt'

# Si el archivo existe, agregar un nuevo valor GUID en el archivo.
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
     }    
 }

# Si el archivo no existe, mostrar un mensaje y no hacer nada.
 else {
     Write-Host "The file [$file] could not be updated because it does not exist."
 }

Puedes ver en la captura de pantalla a continuación, que el script actualizó el archivo durante cada ejecución. La actualización ocurrió porque el método [System.IO.File]::Exists() confirmó que el archivo c:\temp\important_file.txt existe.

Al final, usando el comando gc c:\temp\important_file.txt para leer el contenido del archivo, se confirmó que el script actualizó el archivo con los valores GUID.

Relacionado: Usando los Aceleradores de Tipos de Datos de PowerShell para Acelerar la Codificación

Conclusión

Reducir las llamadas al servicio de mesa de ayuda y actualizar las credenciales de caché para usuarios remotos incluso fuera de la VPN con una solución de restablecimiento de contraseña de autoservicio. ¡Obtén una Demo de Specops uReset!

En este artículo, has aprendido que hay más de una manera de usar PowerShell para verificar si un archivo existe. Es una buena práctica verificar la presencia de un archivo antes de realizar cualquier modificación relacionada con archivos.

Has aprendido sobre el uso de los cmdlets Get-Item, Get-ChildItem y Test-Path. Así como el método [System.IO.File]::Exists() .NET. Los ejemplos te mostraron cómo utilizar técnicas y cómo combinarlas con lógica de manejo de errores.

Deja de soportar esos mensajes de error. Supéralos añadiendo código para verificar si un archivo existe antes de cualquier operación relacionada con archivos. Las técnicas que has aprendido aquí solo cubren lo básico, y ahora depende de ti mejorarlas.