Archivos, texto, CSV y JSON con PowerShell

Lección 6 de 8: archivos, texto, CSV y JSON con PowerShell. Es para lo que más se usa PowerShell en el día a día: crear y leer archivos, copiarlos y moverlos, buscar en registros, cambiar texto en lote y convertir datos entre CSV, que es lo que entiende Excel, y JSON, que es lo que hablan las APIs. Al final, el detalle que más problemas da en Windows: la codificación de los archivos.

Rutas

Antes de tocar archivos, conviene saber armar rutas sin pegar textos a mano. Join-Path une partes con la barra correcta para el sistema (en Windows, \; en Linux y macOS, /), Split-Path las separa y Test-Path dice si existen. Dentro de un script, $PSScriptRoot es la carpeta donde está el propio script, muy útil para encontrar archivos que viajan con él.

$carpeta = Join-Path -Path "reportes" -ChildPath "2026"
$archivo = Join-Path $carpeta "noviembre.csv"
$archivo
Split-Path $archivo -Leaf
Split-Path $archivo -LeafBase
Split-Path $archivo -Extension
Test-Path $archivo
(Split-Path $PSCommandPath -Leaf)
salidareportes/2026/noviembre.csv
noviembre.csv
noviembre
.csv
False
rutas.ps1

Como el curso se ejecutó en Linux, las barras salen como /; en Windows, la misma línea da reportes\2026\noviembre.csv. Esa es la ventaja de Join-Path: el script funciona igual en los dos.

Las partes de la ruta C:\Users\ana\informe.xlsx según Split-Path: con -Parent da la carpeta C:\Users\ana; con -Leaf, el nombre informe.xlsx; con -LeafBase, el nombre sin extensión, informe; y con -Extension, la extensión .xlsxLas partes de una rutaC:\Users\ana\informe.xlsxSplit-Path -ParentC:\Users\anaSplit-Path -Leafinforme.xlsxSplit-Path -LeafBaseinformeSplit-Path -Extension.xlsx
Split-Path saca cada parte de una ruta sin recortar textos a mano. Esquema: decodigo.com.

Crear, escribir y leer

New-Item -Path "notas" -ItemType Directory | Out-Null
Set-Content -Path "notas/pendientes.txt" -Value "Pagar la luz", "Llamar al dentista"
Add-Content -Path "notas/pendientes.txt" -Value "Renovar la licencia"
Get-Content -Path "notas/pendientes.txt"
"---"
(Get-Content -Path "notas/pendientes.txt").Count
Get-Content -Path "notas/pendientes.txt" -TotalCount 1
Get-Content -Path "notas/pendientes.txt" -Tail 1
$todo = Get-Content -Path "notas/pendientes.txt" -Raw
$todo.GetType().Name
salidaPagar la luz
Llamar al dentista
Renovar la licencia
---
3
Pagar la luz
Renovar la licencia
String
  • Set-Content crea el archivo o lo reemplaza; Add-Content añade al final.
  • Get-Content devuelve una lista con una línea por elemento; con -TotalCount lee las primeras y con -Tail, las últimas, sin cargar todo el archivo.
  • Con -Raw devuelve el archivo entero como un solo texto, que es lo que necesitas para buscar y reemplazar en todo el contenido o para leer un JSON.
  • Out-Null descarta lo que devuelve New-Item, que si no, escribiría la carpeta creada en la pantalla.

Listar y copiar

Get-ChildItem lista el contenido de una carpeta. Con -File solo archivos, con -Recurse también las subcarpetas, y -Filter filtra por nombre de forma muy rápida. Cada archivo es un objeto con Name, Length (tamaño en bytes), Extension, LastWriteTime y FullName (la ruta completa):

New-Item -ItemType Directory -Path "fotos/viaje" -Force | Out-Null
Set-Content "fotos/playa.jpg" -Value ("x" * 2047)
Set-Content "fotos/viaje/cena.jpg" -Value ("x" * 4095)
Set-Content "fotos/viaje/lista.txt" -Value "maleta"

Get-ChildItem -Path fotos -Recurse -File -Filter *.jpg | Select-Object Name, Length

Get-ChildItem -Path fotos -Recurse -File |
    Group-Object Extension |
    ForEach-Object { "{0}: {1} archivo(s), {2:N0} bytes" -f $_.Name, $_.Count, ($_.Group | Measure-Object Length -Sum).Sum }

Copy-Item -Path "fotos/viaje" -Destination "respaldo" -Recurse
Move-Item -Path "respaldo/lista.txt" -Destination "respaldo/equipaje.txt"
Get-ChildItem -Path respaldo -Name
salidaName      Length
----      ------
playa.jpg   2048
cena.jpg    4096
.jpg: 2 archivo(s), 6,144 bytes
.txt: 1 archivo(s), 7 bytes
cena.jpg
equipaje.txt

Los tamaños son 2,048 y 4,096 bytes porque Set-Content añade un salto de línea al final (en Linux, un solo carácter; en Windows serían dos, retorno y salto). Get-ChildItem -Name devuelve solo los nombres, como texto.

"uno", "dos" | ForEach-Object { Set-Content "$_.tmp" -Value $_ }
Remove-Item -Path *.tmp -WhatIf
Remove-Item -Path *.tmp
Test-Path "uno.tmp"
salidaWhat if: Performing the operation "Remove File" on target "/home/ana/proyecto/dos.tmp".
What if: Performing the operation "Remove File" on target "/home/ana/proyecto/uno.tmp".
False

Remove-Item no manda nada a la Papelera de reciclaje: lo borra directamente. Por eso -WhatIf primero, siempre que uses comodines.

Buscar y reemplazar en texto

Select-String es el grep de PowerShell: busca un patrón (una expresión regular) en archivos o en texto, y devuelve objetos con el archivo, el número de línea y la línea encontrada. Lo probamos con este registro, servidor.log:

2026-11-18 08:00:01 INFO Servidor iniciado en el puerto 8080
2026-11-18 08:02:17 WARN Disco al 85 %
2026-11-18 08:05:44 ERROR No se pudo conectar a la base de datos
2026-11-18 08:05:45 INFO Reintentando conexión
2026-11-18 08:06:02 ERROR Tiempo de espera agotado
2026-11-18 08:10:30 INFO Conexión restablecida
Select-String -Path servidor.log -Pattern "ERROR"
"---"
Select-String -Path servidor.log -Pattern "ERROR" | ForEach-Object { "Línea {0}: {1}" -f $_.LineNumber, $_.Line.Substring(20) }
"---"
(Select-String -Path servidor.log -Pattern "WARN|ERROR").Count
salidaservidor.log:3:2026-11-18 08:05:44 ERROR No se pudo conectar a la base de datos
servidor.log:5:2026-11-18 08:06:02 ERROR Tiempo de espera agotado
---
Línea 3: ERROR No se pudo conectar a la base de datos
Línea 5: ERROR Tiempo de espera agotado
---
3

Para cambiar texto se usa el operador -replace, que también trabaja con expresiones regulares y permite reutilizar lo encontrado con $1, $2… (entre comillas simples, para que PowerShell no los tome por variables):

"2026-11-18 08:05:44" -replace '(\d{4})-(\d{2})-(\d{2})', '$3/$2/$1'
"El IVA es 15 %" -replace "15", "16"
"precio: 1.299,50" -replace '\.', '' -replace ',', '.'

(Get-Content servidor.log -Raw) -replace 'ERROR', 'FALLA' | Set-Content servidor-revisado.log
Select-String -Path servidor-revisado.log -Pattern "FALLA" -SimpleMatch | Measure-Object | Select-Object -ExpandProperty Count
salida18/11/2026 08:05:44
El IVA es 16 %
precio: 1299.50
2

Ojo con el patrón: -replace '\.', '' lleva la barra porque un punto solo, en una expresión regular, significa «cualquier carácter» y habría borrado todo. -SimpleMatch le dice a Select-String que busque el texto tal cual, sin expresión regular.

CSV

Import-Csv convierte cada renglón en un objeto, como vimos en la lección 4, y Export-Csv hace lo contrario. Con eso, un reporte que en Excel lleva varios pasos se resuelve en unas líneas:

$ventas = Import-Csv ventas.csv
$resumen = $ventas | Group-Object Vendedor | ForEach-Object {
    [pscustomobject]@{
        Vendedor = $_.Name
        Ventas   = $_.Count
        Total    = ($_.Group | Measure-Object { [double]$_.Importe } -Sum).Sum
    }
} | Sort-Object Total -Descending

$resumen | Export-Csv -Path resumen.csv -NoTypeInformation -Encoding utf8BOM
Get-Content resumen.csv
salida"Vendedor","Ventas","Total"
"Marta","1","18499"
"Luis","2","6058"
"Ana","3","4947.5"

Dos detalles que ahorran problemas:

  • -Encoding utf8BOM: Excel en Windows reconoce que el archivo está en UTF-8, con sus acentos y eñes, cuando lleva al principio una marca invisible llamada BOM. PowerShell 7 escribe sin ella si no se lo pides.
  • -NoTypeInformation: en Windows PowerShell 5.1, sin esta opción, la primera línea del CSV es un comentario #TYPE … que estorba en Excel. En PowerShell 7 ya no se escribe, pero ponerla hace que el script dé lo mismo en las dos versiones.

Si tu Excel separa las columnas con punto y coma (pasa cuando Windows está configurado con coma decimal, como en España), usa Export-Csv -UseCulture, que toma el separador de la configuración regional. En México el separador es la coma.

JSON

JSON es el formato de casi todas las APIs y de muchos archivos de configuración. ConvertFrom-Json lo convierte en objetos y ConvertTo-Json hace lo contrario:

$texto = @'
{ "app": "inventario", "version": "2.1", "puertos": [8080, 8443],
  "base": { "servidor": "db.example.com", "usuario": "lectura" } }
'@
$config = $texto | ConvertFrom-Json
$config.app
$config.puertos[1]
$config.base.servidor

$config.version = "2.2"
$config | ConvertTo-Json -Compress
salidainventario
8443
db.example.com
{"app":"inventario","version":"2.2","puertos":[8080,8443],"base":{"servidor":"db.example.com","usuario":"lectura"}}

El error que te ahorra: el JSON que se corta en silencio

ConvertTo-Json solo baja dos niveles de profundidad por omisión. Con datos más anidados, lo que pasa de ahí se convierte en texto:

$pedido = [ordered]@{
    cliente = "Ana"
    envio   = [ordered]@{ direccion = [ordered]@{ calle = "Reforma 222"; ubicacion = [ordered]@{ lat = 19.43; lon = -99.16 } } }
}
$pedido | ConvertTo-Json
salidaWARNING: Resulting JSON is truncated as serialization has exceeded the set depth of 2.
{
  "cliente": "Ana",
  "envio": {
    "direccion": {
      "calle": "Reforma 222",
      "ubicacion": "System.Collections.Specialized.OrderedDictionary"
    }
  }
}

([ordered] hace que las claves salgan en el orden en que las escribiste; en una hashtable normal el orden no está garantizado.) PowerShell 7 avisa con un WARNING, pero el script sigue y el archivo queda mal: ubicacion, el tercer nivel, se guardó como el texto System.Collections.Specialized.OrderedDictionary en lugar de sus coordenadas. El aviso existe desde PowerShell 7.1; en Windows PowerShell 5.1 el JSON se corta sin decir nada. La solución es indicar la profundidad: ConvertTo-Json -Depth 10.

La codificación: el detalle que más confunde en Windows

Un archivo de texto es una serie de bytes, y la codificación dice cómo convertir esos bytes en letras. Para la «á» o la «ñ» hay varias formas, y si quien escribe y quien lee no usan la misma, aparecen cosas como «Información». Aquí es donde las dos versiones de PowerShell más se diferencian:

  • Windows PowerShell 5.1PowerShell 7
  • > y Out-FileUTF-16 (con BOM)UTF-8 sin BOM
  • Set-Content en un archivo nuevola página de códigos de Windows (ANSI)UTF-8 sin BOM
  • Get-Content de un archivo sin BOMlo lee como ANSIlo lee como UTF-8
  • Un script .ps1 sin BOMlo lee como ANSIlo lee como UTF-8

La última fila importa para tus propios scripts. Si un .ps1 lleva acentos y lo vas a ejecutar en la 5.1, guárdalo como UTF-8 con BOM; si no, los acentos de sus textos saldrán mal. PSScriptAnalyzer lo avisa:

"Información del día"
PSScriptAnalyzerlínea  · PSUseBOMForUnicodeEncodedFile · Missing BOM encoding for non-ASCII encoded file 'sin_bom.ps1'

Todos los scripts de este curso están guardados con BOM por esa razón. En Visual Studio Code, la codificación se ve y se cambia en la barra de abajo («UTF-8» o «UTF-8 with BOM»). Y para no depender de la versión al escribir archivos, indica siempre -Encoding: utf8BOM si lo va a abrir Excel o la 5.1, utf8NoBOM si lo va a leer un programa de Linux, la web o una API.

Ojo con la seguridad: cuidado con las rutas que vienen de fuera

Si un script arma una ruta con un nombre que escribe el usuario o que viene de un CSV, un nombre como ..\..\Windows\win.ini puede sacar la ruta de la carpeta que esperabas. Antes de leer, escribir o borrar, resuelve la ruta completa y comprueba que siga dentro de tu carpeta:

$base = (New-Item -ItemType Directory -Path "datos" -Force).FullName
foreach ($nombre in "reporte.txt", "../../etc/passwd") {
    $ruta = [System.IO.Path]::GetFullPath((Join-Path $base $nombre))
    if ($ruta.StartsWith($base + [System.IO.Path]::DirectorySeparatorChar)) {
        "Permitido: $nombre"
    } else {
        "Rechazado: $nombre sale de la carpeta"
    }
}
salidaPermitido: reporte.txt
Rechazado: ../../etc/passwd sale de la carpeta

Y para rutas con caracteres raros, como corchetes, usa -LiteralPath en vez de -Path: -Path interpreta [ y ] como comodines.

Retos

Reto 1. Cuenta cuántas líneas de servidor.log hay de cada nivel (INFO, WARN, ERROR).

Ver la solución
Get-Content servidor.log |
    ForEach-Object { ($_ -split ' ')[2] } |
    Group-Object |
    Sort-Object Count -Descending |
    Select-Object Count, Name
salidaCount Name
----- ----
    3 INFO
    2 ERROR
    1 WARN

-split ' ' parte cada línea por los espacios; la tercera parte (posición 2) es el nivel. Group-Object sin propiedad agrupa por el valor mismo.

Reto 2. Lee ventas.csv y guarda en ventas.json solo las ventas de más de 1,000 pesos, con el importe como número. Luego léelo y escribe cuántas son.

Ver la solución
Import-Csv ventas.csv |
    Where-Object { [double]$_.Importe -gt 1000 } |
    Select-Object Fecha, Vendedor, Producto, @{ Name = "Importe"; Expression = { [double]$_.Importe } } |
    ConvertTo-Json |
    Set-Content ventas.json -Encoding utf8NoBOM
$grandes = Get-Content ventas.json -Raw | ConvertFrom-Json
"Ventas de más de 1,000: $($grandes.Count)"
$grandes[0] | ConvertTo-Json -Compress
salidaVentas de más de 1,000: 4
{"Fecha":"2026-11-02","Vendedor":"Ana","Producto":"Teclado","Importe":1299.0}

Al convertir el importe a [double] antes de ConvertTo-Json, en el JSON queda como número (1299.0) y no como texto ("1299").

Reto 3. ¿Qué escribe esto? Piénsalo antes de mirar: "a.b.c" -replace ".", "-".

Ver la solución
"a.b.c" -replace ".", "-"
salida-----

Cinco guiones. -replace usa expresiones regulares, y el punto significa «cualquier carácter», así que se reemplazaron los cinco. Para cambiar solo los puntos: "a.b.c" -replace '\.', '-', o el método .Replace('.', '-'), que no usa expresiones regulares.

Todos los scripts de esta lección se ejecutaron con PowerShell 7.6.10 (la versión LTS) en un contenedor limpio sin acceso a la red, y se revisaron con PSScriptAnalyzer 1.25 antes de publicarla; las salidas están copiadas de esa ejecución. El contenedor es Linux, así que las rutas salen como /home/ana/proyecto; en tu Windows verás algo como C:\Users\ana. Mira tu versión con $PSVersionTable.PSVersion.