Curso de PowerShell desde cero, en español

PowerShell es la consola y el lenguaje de automatización de Microsoft. Viene en todas las computadoras con Windows y sirve para lo mismo que Bash en Linux: renombrar cien archivos de un jalón, ordenar la carpeta de Descargas, sacar totales de un CSV, revisar registros o hacer copias de seguridad sin dar un solo clic. Su gran diferencia es que no pasa texto de una orden a otra, sino objetos con propiedades, y eso hace que muchas tareas sean más cortas y menos frágiles. Este curso empieza desde cero, usa PowerShell 7.6, la versión con soporte largo, y en cada lección enseña el error típico y el mensaje real que lo delata.

La ruta: ocho lecciones

Están pensadas para leerse en orden. Las dos primeras están en esta misma página y las demás tienen la suya. Cada lección tiene un recuadro «El error que te ahorra», con un fallo típico y el mensaje real de PowerShell o de PSScriptAnalyzer que lo delata, al menos un esquema y retos al final con la solución escondida. Al terminar hay un test de 24 preguntas: adivinar qué escribe cada fragmento.

Lección 1. Primeros pasos

Qué es PowerShell

En 2002, Jeffrey Snover, ingeniero de Microsoft, escribió el Monad Manifesto: una propuesta para que Windows tuviera una consola tan capaz como las de Unix, pero pensada para un sistema donde casi todo se configura con objetos y no con archivos de texto. El proyecto se llamó Monad y salió en noviembre de 2006 como Windows PowerShell 1.0. Desde Windows 7 viene incluido en el sistema.

En 2016 Microsoft lo publicó como software libre, con licencia MIT, y lo llevó a Linux y macOS. Esa rama nueva se construye sobre .NET (el moderno, no el .NET Framework de Windows) y desde la versión 7, de 2020, se llama simplemente PowerShell. Por eso hoy conviven dos:

  • Windows PowerShell 5.1PowerShell 7
  • Viene con WindowsSí, en Windows 10 y 11No: se instala aparte
  • Programapowershell.exepwsh.exe
  • Se actualizaSolo recibe parches de seguridadSí: versiones nuevas cada año
  • SistemasSolo WindowsWindows, macOS y Linux
  • Texto que escribe en archivosUTF-16 o la página de códigos de Windows, según el cmdletUTF-8 sin BOM, siempre
  • Scripts permitidos de fábricaNinguno (política Restricted)Los tuyos sí (RemoteSigned)

Las dos se pueden tener instaladas a la vez: PowerShell 7 se instala en su propia carpeta y no reemplaza a la 5.1. En este curso usamos la 7, en concreto la 7.6, que salió en marzo de 2026 y es la versión de soporte largo (LTS): Microsoft le da parches hasta noviembre de 2028. El 10 de noviembre de 2026 salió la 7.7, de soporte corto; todo lo que enseñamos funciona igual en ella. Cuando algo cambie en la 5.1, lo avisamos.

Comparación: en Bash, lo que pasa de un programa a otro es texto, por ejemplo notas.txt 120, y hay que recortar las columnas a mano. En PowerShell pasan objetos con propiedades, como Name igual a notas.txt y Length igual a 120, y cada propiedad se pide por su nombreTexto frente a objetosEn Bashnotas.txt 120fotos.zip 8200hay que recortarcolumnas a manoEn PowerShellName: notas.txtLength: 120LastWriteTime: …pides lapropiedadpor su nombre
La idea central de PowerShell: entre una orden y la siguiente viajan objetos con propiedades, no líneas de texto. Esquema: decodigo.com.

Instalar PowerShell 7 en Windows

Abre la consola que ya tienes (en el menú Inicio, busca «Terminal» o «Windows PowerShell») y escribe la orden que recomienda Microsoft. Usa winget, el instalador de programas que viene en Windows 11:

winget install --id Microsoft.PowerShell --source winget

Cuando termine, cierra la ventana y abre PowerShell 7 desde el menú Inicio, o escribe pwsh en cualquier consola. Si usas Terminal de Windows, aparece en la flechita junto a las pestañas. En macOS se instala con brew install powershell y en Linux con el paquete de Microsoft para tu distribución; el programa siempre se llama pwsh.

Para saber qué versión tienes, escribe esto. Todo lo que va precedido de PS> en este curso se teclea en la consola, y debajo está lo que responde:

consolaPS> $PSVersionTable.PSVersion

Major  Minor  Patch  PreReleaseLabel BuildLabel
-----  -----  -----  --------------- ----------
7      6      10

PS> $PSEdition
Core

$PSVersionTable es una variable que PowerShell llena solo. Si dice 5 y Desktop, estás en la ventana vieja, Windows PowerShell 5.1; con 7 y Core, en la nueva. En tu consola, el indicador no será PS> sino la carpeta donde estás, como PS C:\Users\ana>.

Cmdlets: verbo y sustantivo

Las órdenes propias de PowerShell se llaman cmdlets (se pronuncia «command-lets») y todas se nombran igual: un verbo en inglés, un guion y un sustantivo en singular. Get-Date obtiene la fecha, Get-ChildItem lista lo que hay en una carpeta, Copy-Item copia, Remove-Item borra. Los verbos son una lista cerrada (Get, Set, New, Remove, Start, Stop…), así que muchas veces puedes adivinar el nombre. Y si no, se lo preguntas:

consolaPS> Get-Command -Noun Date | Select-Object Name

Name
----
Get-Date
Set-Date

PS> Get-Date -Year 2026 -Month 12 -Day 24 -Format "dddd d 'de' MMMM"
jueves 24 de diciembre

Los parámetros van con un guion delante: -Year 2026. No importa si los escribes en mayúsculas o minúsculas, y basta con poner el principio del nombre mientras no haya otro que empiece igual (-Form vale por -Format), aunque en los scripts conviene escribirlos completos. La barra vertical | es el pipeline: pasa lo que sale de una orden a la siguiente. Le dedicamos la lección 4.

Para ver cómo se usa un cmdlet, Get-Help Get-Date -Examples muestra ejemplos. La primera vez conviene descargar la ayuda completa con Update-Help (necesita internet y tarda un poco). Sin ella, Get-Help solo enseña la sintaxis.

Los alias: dir, cd y compañía

Para que no te sientas perdido, PowerShell trae alias, nombres cortos de cmdlets: cd es Set-Location y dir es Get-ChildItem. En Windows también existen ls, cat, cp o rm, que imitan a Linux; en Linux y macOS PowerShell no los define, para no tapar los programas del sistema que se llaman igual. Puedes comprobar qué hay detrás de un alias:

consolaPS> Get-Alias dir, cd, echo | Select-Object Name, Definition

Name Definition
---- ----------
dir  Get-ChildItem
cd   Set-Location
echo Write-Output

Los alias están bien para teclear rápido en la consola, pero en un script es mejor el nombre completo: se entiende mejor y funciona igual en cualquier sistema. PSScriptAnalyzer, la herramienta que revisa scripts y que usaremos en todo el curso, avisa si usas alias en un archivo .ps1.

Tu primer script

Un script es un archivo de texto con extensión .ps1 que contiene órdenes de PowerShell. Para escribirlos, lo más cómodo es Visual Studio Code con la extensión oficial de PowerShell, que colorea el código, avisa de errores y deja ejecutar paso a paso. El viejo PowerShell ISE solo funciona con la 5.1. Guarda esto como hola.ps1:

# Mi primer script de PowerShell
$nombre = "Ana"
$hoy = Get-Date -Date "2026-11-18"
$navidad = Get-Date -Date "2026-12-24"
"Hola, $nombre. Hoy es $($hoy.ToString('dddd d \d\e MMMM'))."
"Faltan $(($navidad - $hoy).Days) días para Navidad."

Y ejecútalo desde la consola, en la carpeta donde lo guardaste, con .\hola.ps1 (en Linux y macOS, ./hola.ps1). El .\ delante es obligatorio: PowerShell no ejecuta scripts de la carpeta actual solo con su nombre, para que nadie pueda dejarte un dir.ps1 trampa que se ejecute cuando escribes dir.

PS> .\hola.ps1Hola, Ana. Hoy es miércoles 18 de noviembre.
Faltan 36 días para Navidad.

Fíjate en que no hizo falta ningún echo ni print: en PowerShell, todo valor que no guardas en una variable ni mandas a otra orden se escribe en la pantalla. $( … ) dentro de unas comillas dobles evalúa lo que haya dentro y pone el resultado en el texto, y restar dos fechas da la diferencia, con sus días en .Days. La fecha sale en español porque la consola está configurada para México; con otro idioma verías «Wednesday».

Solo en Windows

Si al ejecutar un script en Windows PowerShell 5.1 te sale un error que dice que la ejecución de scripts está deshabilitada en este sistema, es la política de ejecución. En las computadoras con Windows 10 y 11 la 5.1 viene con la política Restricted, que no deja ejecutar ningún script. PowerShell 7 usa RemoteSigned: deja ejecutar los scripts que escribes tú y bloquea los descargados de internet que no estén firmados. Para que la 5.1 se comporte igual, solo para tu usuario y sin permisos de administrador:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

No uses Unrestricted ni Bypass «para que ya no moleste». Microsoft aclara que la política no es una barrera de seguridad sino una medida para evitar ejecutar algo sin querer, pero quitarla del todo te deja sin ese aviso. Si descargaste un script en el que confías, desbloquéalo solo a él con Unblock-File .\script.ps1. En Linux y macOS la política no existe: siempre es Unrestricted.

Lección 2. Variables, tipos y cadenas

Variables

Las variables empiezan con $, se crean al asignarles un valor y pueden guardar cualquier cosa: un número, un texto, una fecha, una lista o el resultado de un cmdlet. Los espacios alrededor del = dan igual, y los nombres no distinguen mayúsculas: $Total y $total son la misma variable.

$producto = "Audífonos"
$precio = 1299.99
$cantidad = 3
$total = $precio * $cantidad
"$cantidad x $producto = $total"
$precio.GetType().Name
$cantidad.GetType().Name
$producto.Length
$producto.ToUpper()
salida3 x Audífonos = 3899.97
Double
Int32
9
AUDÍFONOS

Cada valor es un objeto de .NET con su tipo: Double para los números con decimales, Int32 para los enteros, String para el texto. Por eso un texto tiene propiedades como .Length (cuántos caracteres) y métodos como .ToUpper(). No tienes que declarar el tipo, pero puedes forzarlo poniéndolo entre corchetes:

[int]$edad = "42"
$edad + 1
[int]"7" * 2
"7" * 2
7 / 2
[math]::Round(1299.99 * 0.16, 2)
[int]7.5
[int]8.5
salida43
14
77
3.5
208
8
8

Hay varias cosas que aprender de aquí:

  • [int]$edad = "42" convierte el texto en número, y la variable se queda con ese tipo para siempre: si después le asignas "hola", da error.
  • "7" * 2 no da 14 sino 77: con un texto a la izquierda, * repite el texto. PowerShell decide qué hacer según el tipo de lo que está a la izquierda del operador; lo vemos a fondo en las rarezas.
  • A diferencia de C, Java o Bash, 7 / 2 da 3.5: la división siempre da decimales si hace falta.
  • [int]7.5 da 8, pero [int]8.5 también da 8: al convertir, .NET redondea al par más cercano (el «redondeo del banquero»). Para cortar los decimales usa [math]::Truncate(), y para redondear como en la escuela, [math]::Round(8.5, [MidpointRounding]::AwayFromZero).

Comillas dobles y simples

Las comillas dobles sustituyen las variables y lo que haya dentro de $( ); las simples dejan el texto tal cual. Para escribir un $ dentro de comillas dobles se pone el acento grave delante: `$. El acento grave (`) es el carácter de escape de PowerShell, porque la barra invertida ya se usa en las rutas de Windows: `n es un salto de línea y `t un tabulador.

Comillas en PowerShell. Entre comillas dobles, Hola, $nombre se convierte en Hola, Ana porque se sustituye la variable. Entre comillas simples, el texto queda tal cual: Hola, $nombreComillas dobles y simples"Hola, $nombre"dobles: sustituye la variableHola, Ana'Hola, $nombre'simples: el texto queda tal cualHola, $nombre
Las comillas dobles sustituyen las variables; las simples no. Esquema: decodigo.com.
$nombre = "Ana"
"Hola, $nombre"
'Hola, $nombre'
"Precio: `$1,299.99 MXN"
"Dos líneas:`nsegunda"
"Hoy es $((Get-Date -Date '2026-11-18').DayOfWeek)"
"{0} compró {1} piezas de {2:N2} pesos" -f $nombre, 3, 1299.99
salidaHola, Ana
Hola, $nombre
Precio: $1,299.99 MXN
Dos líneas:
segunda
Hoy es Wednesday
Ana compró 3 piezas de 1,299.99 pesos

Ojo con DayOfWeek: es un valor de .NET y siempre sale en inglés («Wednesday»), aunque tu Windows esté en español. Para el nombre del día en tu idioma usa .ToString('dddd'), como en el primer script. La última línea usa el operador -f (formato): cada {0}, {1}… se sustituye por el valor que está en esa posición de la lista de la derecha, y {2:N2} lo escribe con separador de miles y dos decimales. Es la forma más limpia de armar textos con números.

Para un texto de varias líneas hay here-strings: se abren con @" al final de una línea y se cierran con "@ al principio de otra. Con comillas dobles sustituyen variables; con @' y '@, no.

$cliente = "Luis"
$mensaje = @"
Hola, $cliente.
Tu pedido ya salió.
Gracias por tu compra.
"@
$mensaje
salidaHola, Luis.
Tu pedido ya salió.
Gracias por tu compra.

Arreglos y hashtables

Un arreglo es una lista de valores. Se crea separándolos con comas, o con @( ), y se lee por posición empezando en 0; las posiciones negativas cuentan desde el final. Una hashtable es una tabla de pares clave y valor, y se crea con @{ }:

$frutas = "mango", "papaya", "guayaba"
$frutas[0]
$frutas[-1]
$frutas.Count
$frutas += "tuna"
$frutas -join ", "

$precios = @{ mango = 25; papaya = 38.5 }
$precios["mango"]
$precios.papaya
$precios.guayaba = 30
$precios.Count
salidamango
guayaba
3
mango, papaya, guayaba, tuna
25
38.5
3

+= añade un elemento al arreglo (en realidad crea uno nuevo, un poco más grande; con miles de elementos conviene otra forma, que vemos en la lección 3). -join une los elementos con el texto que le digas. En la hashtable, a cada valor se llega por su clave, con corchetes o con punto, y asignar a una clave que no existe la crea.

Leer lo que escribe el usuario

Read-Host muestra un mensaje, espera a que el usuario escriba algo y pulse Intro, y devuelve lo que escribió como texto:

$nombre = Read-Host "¿Cómo te llamas?"
$anio = [int](Read-Host "¿En qué año naciste?")
"Hola, $nombre. En 2026 cumples $(2026 - $anio) años."
salida (con «Ana» y «1990» como respuestas)¿Cómo te llamas?: Ana
¿En qué año naciste?: 1990
Hola, Ana. En 2026 cumples 36 años.

En la consola, lo que escribe el usuario aparece justo después de los dos puntos que añade Read-Host. Lo que devuelve siempre es texto, así que para hacer cuentas hay que convertirlo con [int]. Si alguien escribe letras, la conversión falla con un error claro en vez de calcular cualquier cosa; validar lo que llega y reaccionar a los errores es parte de la lección 7.

El error que te ahorra: la propiedad que no se sustituye dentro de las comillas

Dentro de comillas dobles, PowerShell solo sustituye el nombre de la variable, no lo que va después del punto. Este script parece correcto:

$archivo = [pscustomobject]@{ Nombre = "reporte.xlsx"; Tamano = 2048 }
"Archivo: $archivo.Nombre ($archivo.Tamano bytes)"
"Archivo: $($archivo.Nombre) ($($archivo.Tamano) bytes)"
salidaArchivo: @{Nombre=reporte.xlsx; Tamano=2048}.Nombre (@{Nombre=reporte.xlsx; Tamano=2048}.Tamano bytes)
Archivo: reporte.xlsx (2048 bytes)

En la primera línea, PowerShell convirtió todo el objeto en texto (@{Nombre=…; Tamano=…}) y le pegó .Nombre detrás. Para acceder a una propiedad dentro de un texto hay que envolverla en $( ), como en la segunda línea. Ninguna herramienta lo avisa, porque las dos formas son válidas: solo se nota al ver la salida.

Ojo con la seguridad: no guardes contraseñas en el script

Es tentador escribir $clave = "MiClave123" al principio de un script que se conecta a un servidor. Cualquiera que abra el archivo, o que lo encuentre en una copia de seguridad o en un repositorio, la verá. Para pedirla al momento, Read-Host -AsSecureString no la muestra en pantalla mientras se escribe, y Get-Credential pide usuario y contraseña juntos. Para guardarlas de forma segura existe el módulo oficial Microsoft.PowerShell.SecretManagement, que usa la bóveda de contraseñas del sistema.

Retos

Reto 1. Escribe un script que pida una cantidad en pesos y escriba cuánto es el IVA (16 %) y el total, con dos decimales y separador de miles.

Ver la solución
$monto = [double](Read-Host "Monto sin IVA")
$iva = $monto * 0.16
"IVA: {0:N2}  Total: {1:N2}" -f $iva, ($monto + $iva)
salida (con 12500)Monto sin IVA: 12500
IVA: 2,000.00  Total: 14,500.00

[double] admite decimales, a diferencia de [int]. Los paréntesis en ($monto + $iva) hacen falta: sin ellos, la coma del operador -f se tomaría primero.

Reto 2. Con una hashtable de tres productos y sus precios, escribe el precio del más caro. Pista: .Values da todos los valores y Measure-Object -Maximum busca el mayor.

Ver la solución
$precios = @{ teclado = 649; mouse = 289.5; monitor = 3899 }
$mayor = ($precios.Values | Measure-Object -Maximum).Maximum
"El más caro cuesta $mayor pesos"
salidaEl más caro cuesta 3899 pesos

Measure-Object recibe los valores por el pipeline y devuelve un objeto con el resultado; .Maximum toma esa propiedad. En la lección 4 verás cómo sacar también el nombre del producto.

Reto 3. ¿Qué escribe esto? Piénsalo antes de mirar: $a = "10", $b = 5 y después $a + $b y $b + $a.

Ver la solución
$a = "10"
$b = 5
$a + $b
$b + $a
salida105
15

Manda el tipo de la izquierda. En $a + $b la izquierda es texto, así que el 5 se convierte en texto y se pega: 105. En $b + $a la izquierda es un número, así que el texto "10" se convierte en número y se suma: 15.

Cómo está hecho este curso

Cada script se ejecutó con PowerShell 7.6.10 en un contenedor limpio de Linux (Ubuntu 24.04) sin acceso a la red, con la usuaria ana, la configuración regional de México y la hora de la Ciudad de México, y se revisó con PSScriptAnalyzer 1.25. Las salidas, los errores y los avisos están copiados de esa ejecución; los mensajes de error salen en inglés, como en PowerShell 7. Como el contenedor es Linux, las rutas se ven como /home/ana/proyecto en vez de C:\Users\ana, y lo que solo existe en Windows (servicios, registro, Programador de tareas) va en recuadros «Solo en Windows», explicado pero sin una salida que no pudimos comprobar.

¿Buscas una receta concreta en vez de una lección? En Ejemplos de PowerShell hay tareas resueltas: renombrar en lote, CSV, JSON, fechas, registros, copias de seguridad… Y si también trabajas en Linux, el curso de Bash sigue la misma ruta.