Cómo exportar resultados de scripts de PowerShell a archivos de texto

Cuando trabajas con PowerShell tarde o temprano necesitas guardar la salida de tus comandos en un fichero. Exportar resultados a un archivo de texto es una forma sencilla de auditar, compartir o procesar información más tarde sin depender de la consola.

En esta guía vas a encontrar un repaso completo y práctico sobre cómo sacar a texto la salida de scripts y comandos, tanto con Out-File como con los operadores de redirección, incluyendo ejemplos reales, trucos de codificación, ancho de línea y situaciones típicas como leer desde CSV, gestionar salidas de comandos nativos o registrar logs. Todo explicado en español de España y con un tono claro y directo.

Qué implica “exportar” en PowerShell y cómo encaja la familia Out-*

PowerShell dispone de una serie de cmdlets cuyo verbo es Out y que están pensados para enviar la salida a destinos fuera del propio motor de PowerShell. Al escribir a fichero, impresora o host estos cmdlets transforman los objetos en texto, aplicando el sistema de formateo de la consola.

Esto tiene una consecuencia clave: los cmdlets Out-* deben ir al final de la canalización. Si colocas, por ejemplo, Out-Host en medio del pipeline, cortas el flujo y lo que venga después no recibirá nada. La prueba: Get-Process | Out-Host -Paging | Format-List no mostrará una lista, sino la vista tabular por defecto, porque la salida ya se envió al host antes del formateo.

La forma correcta es invertir el orden: Get-Process | Format-List | Out-Host -Paging. Primero eliges el formato, después envías la salida al destino correspondiente. Lo mismo aplica con Out-File, Out-Printer o Out-Null (este último descarta todo lo que recibe, útil para silenciar resultados que no necesitas).

Out-File de arriba abajo: sintaxis y comportamiento

El cmdlet Out-File escribe la salida en un archivo aplicando el formateo de la consola. Puedes usarlo de dos maneras principales: por ruta normal (ByPath) o por ruta literal (ByLiteralPath) cuando hay caracteres especiales que no quieres que PowerShell interprete.

Out-File  <string>  <Encoding>]        
Out-File  <Encoding>] -LiteralPath <string>        

Si prefieres redirección clásica, > y >> son funcionalmente equivalentes a canalizar a Out-File sin parámetros extra (salvo matices) y, desde PowerShell 7.4, cambió el comportamiento de la redirección de la salida estándar de comandos nativos. Conviene revisar about_Redirection si rediriges ejecutables externos para evitar sorpresas.

Ten presente que Out-File no devuelve objetos a la canalización; su misión es guardar texto. La representación que escribe es la misma que verías en la consola, de modo que puede no ser ideal para procesamientos posteriores si no conviertes antes a cadenas o eliges un formato controlado con Format-Table o Format-List.

Parámetros de Out-File explicados con detalle

Para sacar el máximo partido a la exportación conviene conocer bien sus parámetros. Estos son los más importantes y cómo te ayudan en el día a día.

• -FilePath indica la ruta del archivo de salida. Es obligatorio en el conjunto ByPath y tiene alias como Ruta. Si el fichero no existe, se crea; si existe, se sobrescribe salvo que indiques lo contrario.
• Cuando necesitas referenciar rutas tal cual están escritas, -LiteralPath es tu aliado. No admite comodines y respeta exactamente la cadena indicada. Úsalo con comillas simples si hay barras invertidas o caracteres escapables.
• Con -Append agregas contenido al final de un archivo ya existente sin perder lo anterior. Perfecto para logs o informes incrementales.
• Si no quieres que se sobrescriba un archivo por accidente, -NoClobber bloquea esa operación y devuelve un mensaje aclarando que el archivo ya existe, evitando sustos.
• Para forzar la escritura aun cuando el archivo es de solo lectura, -Force invalida ese atributo. Ojo, no salta restricciones de seguridad, solo el flag de solo lectura.
• Con -Width defines el ancho máximo por línea. La salida con formato de tabla suele ajustarse al ancho del host; si no te interesa el truncado, fija un ancho alto (por ejemplo, 2000) o controla globalmente el valor con $PSDefaultParameterValues = 2000.
• ¿No quieres salto de línea al final? -NoNewline concatena las cadenas resultantes sin añadir nuevas líneas, útil cuando realmente te interesa unir textos al vuelo.
• Con -InputObject puedes suministrar directamente los objetos o cadenas a escribir sin necesidad de canalizar. Ideal para variables o resultados compuestos previamente.
• Para controlar qué pasa antes de ejecutar, -WhatIf te muestra la acción sin realizarla (prueba en seco) y -Confirm te pide confirmación previa, lo cual aporta seguridad al automatizar.
• La codificación es crucial. -Encoding determina cómo se guarda el texto. Por defecto es utf8NoBOM. Admite valores como ascii, unicode (UTF-16 LE), utf8, utf8BOM, utf8NoBOM, utf32, bigendianunicode, bigendianutf32 y oem (pensado para MS-DOS o consolas antiguas). Desde PowerShell 7.4 puedes usar ansi para la página de códigos ANSI de tu cultura sin poner el identificador manualmente. Y a partir de 6.2 puedes pasar identificadores numéricos de página de códigos (por ejemplo, 1251) o nombres tipo «windows-1251».
• Además, Out-File soporta los CommonParameters como -Verbose, -ErrorAction, -Debug, etc., con lo que puedes ajustar el comportamiento de diagnóstico y errores de forma homogénea.

Ejemplos prácticos que te conviene dominar

Veamos escenarios reales que cubren las casuísticas más habituales, todos ellos reescritos para que los puedas copiar y adaptar a tu entorno.

Crear un archivo con la lista de procesos y leerlo. Si el fichero no existe, se crea. Es ideal para capturar un “snapshot” del estado del sistema.

Get-Process | Out-File -FilePath .\Process.txt
Get-Content -Path .\Process.txt

Evitar la sobrescritura con -NoClobber. Cuando el fichero ya existe, bloquea la operación y muestra un error informativo en lugar de reemplazarlo silenciosamente.

Get-Process | Out-File -FilePath .\Process.txt -NoClobber

Elegir codificación y ancho. Guarda en ASCII y limita cada línea a 50 caracteres (se trunca, no se ajusta). Útil para integraciones con herramientas que esperan un formato clásico.

$procs = Get-Process
Out-File -FilePath .\Process.txt -InputObject $procs -Encoding ascii -Width 50

Escribir desde un proveedor no FileSystem. Puedes listar alias desde la unidad Alias: y llevarlos a un archivo en C:\TestDir sin cambiarte de contexto.

Set-Location -Path Alias:
Get-ChildItem | Out-File -FilePath C:\TestDir\AliasNames.txt
Get-Content -Path C:\TestDir\AliasNames.txt

Fijar el ancho por defecto en todo el ámbito. Si generas informes constantemente, fijar un ancho alto evita truncados independientemente del tamaño de la ventana de la consola.

$PSDefaultParameterValues = 2000
$logFile = "$PWD\logfile.txt"
Get-ChildItem Env:\ | Out-File $logFile
Get-Service -ErrorAction Ignore | Format-Table -AutoSize | Out-File $logFile -Append
Get-Process | Format-Table Id,SI,Name,Path,MainWindowTitle >> $logFile
$PSDefaultParameterValues.Remove('Out-File:Width')

Redirección en CMD y en PowerShell: diferencias importantes

Si trabajas en el símbolo del sistema clásico, puedes enviar la salida a TXT con el operador de redirección. La forma general es:

Comando > C:\Ruta\archivo.txt

Por ejemplo, para guardar la salida de nslookup harías algo como nslookup > C:\CMD\CMD.txt y abrirías ese archivo para revisar el resultado. Es un patrón universal en CMD.

En PowerShell la recomendación suele ser canalizar a Out-File para tener control fino sobre codificación y ancho. Una forma básica es:

Get-Service | Out-File -FilePath C:\CMD\PowerShell.txt

Después puedes inspeccionarlo con Get-Content -Path C:\CMD\PowerShell.txt. Si observas que la salida se trunca (muy típico con tablas anchas), sube el ancho con -Width o usa el truco de los $PSDefaultParameterValues.

Cuando la salida debe caber en una sola línea ancha, una técnica es fijar el máximo entero soportado por Width (2147483647), aunque a efectos prácticos con 2000 suele bastar.

Leer desde CSV y exportar la salida de comandos nativos (net user /domain)

Un caso común es importar un CSV con usuarios o extraer datos con PowerShell, y, para cada uno, ejecutar net user … /domain y volcar la salida a un TXT. Si lo haces dentro de un ForEach y cada iteración escribe con -Append, debería funcionar, pero a veces aparecen errores o solo queda la salida del último elemento.

Una forma más robusta es acumular toda la salida y escribir una sola vez, reduciendo aperturas/cierres del archivo y evitando condiciones de carrera con procesos nativos:

Import-Csv 'C:\Desktop\domain.csv' |
  ForEach-Object { net user $_.Username /domain } |
  Out-File -FilePath 'C:\_test\user.txt' -Append

Si prefieres separar bloques por usuario para que el archivo quede más legible, puedes inyectar delimitadores manuales. Write-Output ayuda a añadir encabezados o líneas en blanco:

Import-Csv 'C:\Desktop\domain.csv' |
  ForEach-Object {
    Write-Output ("----- USUARIO: {0} -----" -f $_.Username)
    net user $_.Username /domain
    Write-Output ""
  } | Out-File -FilePath 'C:\_test\user.txt'

Si aun así tienes comportamientos raros, hay alternativas: Start-Process con -RedirectStandardOutput para cada usuario, o redirección tradicional >> desde cmd.exe. Lo importante es que el fichero no quede bloqueado y que todo el texto acabe en el mismo archivo sin truncado ni mezcolanza de streams.

Escribir en la carpeta desde la que se ejecuta el script

Otra duda frecuente es cómo guardar siempre en la carpeta del propio script o en la carpeta actual. Usa $PSScriptRoot para la ruta del script (cuando se ejecuta desde archivo .ps1) o $PWD para el directorio de trabajo actual en la sesión.

$destino = Join-Path $PSScriptRoot 'salida.txt'
Get-Process | Out-File -FilePath $destino

Si ejecutas pegando comandos en la consola y quieres la ruta actual, $PWD o el alias . te sirven. Para mayor claridad, compón la ruta con Join-Path y evitarás problemas de barras.

Contar páginas de PDF y registrar resultados en texto

Imagina que examinas un directorio y quieres totalizar las páginas de todos los PDF usando una herramienta externa como pdfinfo. La idea es recorrer los ficheros, extraer el dato «Pages», acumularlo y escribir un informe claro.

$carpeta = 'C:\PRUEBA'
$totalPaginas = 0
$contadorArchivos = 0

Get-ChildItem -Path $carpeta -Filter *.pdf | ForEach-Object {
  $info = & .\pdfinfo $_.FullName | Select-String -Pattern '(?<=Pages:\s*)\d+'
  $paginas = $info.Matches.Value
  $totalPaginas += $paginas
  $contadorArchivos++
  @{
    Pdf = $_.Name
    Paginas = $paginas
  }
} | Out-File -FilePath (Join-Path $PWD 'detalle_pdfs.txt')

("Total de páginas: {0} en {1} archivos" -f $totalPaginas, $contadorArchivos) |
  Out-File -FilePath (Join-Path $PWD 'detalle_pdfs.txt') -Append

Con esto obtienes un listado línea a línea de cada PDF y un pie con el total. Si prefirieras un formato procesable, podrías ir a CSV, pero si tu destino es un TXT legible, Out-File cumple de sobra.

Caso real: logueo, filtros con Select-String y edición del Registro

Otro escenario muy didáctico es el de un script que: identifica el usuario actual, lo cruza con listados externos, limpia ficheros, extrae valores, modifica una clave del Registro y registra todo lo ocurrido en un log. Aunque parezca largo, son piezas sencillas encadenadas.

El flujo típico sería: capturar el usuario con whoami, normalizarlo (por ejemplo, quitando el dominio), buscarlo en un listado de Active Directory con Select-String y volcar la coincidencia a un TXT con Set-Content. Después, limpiar líneas vacías con Where-Object {$_.Trim() -ne »}, y hacer reemplazos con -replace para quedarte solo con el patrón útil.

A continuación se carga el primer valor con Select-Object -First 1 (evitas ambigüedades si hay varias coincidencias). Se hace una segunda búsqueda en otro fichero de referencia, se limpia igual, y de nuevo te quedas con el primer resultado. Con esos datos ya puedes consultar o exportar la rama del Registro relevante.

Un patrón muy utilizado es extraer la clave antigua exportando la rama con reg export, localizar la línea que contiene «User ID» con Select-String -Pattern «User ID», limpiar comillas y el prefijo con -replace, y quedarte con el valor que te interesa como «valor original».

Para aplicar el cambio real empleas Set-ItemProperty con la ruta completa de HKEY_USERS basada en el SID del perfil, nombre de valor «User ID» y el nuevo dato que has resuelto antes. Y, muy importante, todo lo que ocurra se registra con Write-Output … | Out-File -Append en un log (incluyendo hora, usuario, SID, valor antiguo y nuevo, etc.).

$hora = Get-Date
"Hora: $hora ; Usuario: $usuario ; ClaveOriginal: $valorOld ; NuevaClave: $valor ; SID: $sid" |
  Out-File -FilePath "\\SERVIDOR\RUTA\usuarios.log" -Append

Para cerrar de forma limpia, elimina ficheros temporales con Remove-Item. Un detalle de seguridad: Out-File -Append mantiene un historial consistentemente legible, lo cual es oro para auditorías posteriores si algo falla.

Out-Host, Out-Null y Out-Printer: cuándo pintan y cuándo no

Ya lo hemos insinuado: Out-Host básicamente envía al host (la ventana de la consola). Su utilidad estrella es la paginación con -Paging en listados largos, siempre situado al final del pipeline para no cortar la cadena.

Out-Null es el sumidero. Todo lo que le entra se descarta de inmediato. Sirve para comandos con efectos secundarios cuando la salida no aporta valor. Ten en cuenta que no elimina errores: si la orden no existe o falla, verás el mensaje igualmente.

Si necesitas imprimir, en Windows tienes Out-Printer. Puedes enviar la salida a la impresora por defecto o indicar su nombre visible (como un driver de impresora a archivo) y PowerShell se encarga del resto.

Ajustes finos: formato, ANSI y ancho sin sorpresas

Como Out-File formatea usando el mismo sistema que la consola, a veces el resultado puede venir truncado. Controlar el ancho con -Width o el valor por defecto global evita estos problemas al guardar tablas anchas.

Desde PowerShell 7.2 puedes controlar cómo se manejan las secuencias de escape ANSI mediante $PSStyle.OutputRendering. Si tu salida incluye color u otras decoraciones y quieres conservar o desactivar ese comportamiento al exportar, ajusta esa preferencia antes de escribir a fichero.

En versiones como Windows PowerShell 5.1, el formato por defecto de Out-File era Unicode. Hoy, con PowerShell moderno, el predeterminado es utf8NoBOM, que suele ser lo más compatible. Si una herramienta antigua insiste en ASCII, indícalo con -Encoding ascii. Y si trabajas con herramientas de la cultura local, ansi (desde 7.4) es atajo cómodo.

Consejos rápidos de buenas prácticas

Siempre que puedas, elige Out-File sobre redirección si necesitas controlar codificación, ancho o comportamiento de archivo existente. La redirección es rápida, pero menos explícita y cambió su comportamiento con nativos en 7.4.

Cuando escribas repetidamente durante un bucle, prioriza acumular y escribir una sola vez o, si debes escribir por iteración, usa -Append y evita mezclar varios destinos en paralelo que puedan competir por el mismo archivo.

Si tu script debe guardar en su propia carpeta, usa $PSScriptRoot. Si es una sesión interactiva, $PWD. Con Join-Path te blindas ante errores de separadores y mejoras la portabilidad.

Cuando el objetivo sea procesar posteriormente, plantéate usar Export-Csv o ConvertTo-Json en lugar de texto formateado. Si la prioridad es legibilidad humana (informes, bitácoras), Out-File es perfecto.

Para rutas raras con caracteres especiales, -LiteralPath te evita dolores de cabeza. Y recuerda que Out-File no devuelve salida al pipeline: si necesitas tanto imprimir como guardar, usa Tee-Object para duplicar flujos.

Si estás generando informes tabulares, considera formatear tú mismo con Format-Table o Format-List antes de la escritura. Controlar el formato a priori produce resultados más estables y evita depender del ancho de la consola.

El ecosistema de cmdlets comunes (-Verbose, -ErrorAction, etc.) también aplica aquí. Activa -Verbose durante pruebas para ver qué ocurre y desactívalo en producción si no quieres ruido.

Este recorrido te deja con un mapa claro: Out-File y compañía sirven para materializar en ficheros, impresoras o la propia consola lo que antes eran objetos. Con la combinación adecuada de codificación, ancho y orden correcto del pipeline, tus informes y logs quedarán fiables, legibles y listos para compartir o archivar.