Automatizar Tareas en Excel con Macros y Fórmulas Avanzadas

Automatizar tareas en Excel con macros: guía completa de VBA paso a paso

Respuesta directa: para automatizar tareas en Excel con macros necesitas cuatro movimientos. Uno, activar la pestaña Programador desde Archivo → Opciones → Personalizar cinta de opciones. Dos, grabar la tarea con la grabadora de macros para que Excel escriba el VBA por ti. Tres, abrir el editor con Alt + F11 y limpiar ese código, porque la grabadora genera entre tres y diez veces más líneas de las necesarias. Y cuatro, guardar el archivo como .xlsm, ya que el formato .xlsx borra las macros al cerrar sin avisarte más que con un cuadro de diálogo que casi nadie lee. Un informe mensual que te lleva 40 minutos a mano se ejecuta en menos de 5 segundos cuando la macro está bien escrita.

Esta página va de la ruta con código. Si prefieres el camino sin programar (tablas, Power Query, formato condicional, funciones dinámicas), tienes la guía hermana en automatización de Excel para no programadores, y todas las plantillas Excel gratis del sitio ya vienen con parte del trabajo hecho.

Qué tareas merece la pena automatizar (y cuáles no)

La regla que uso desde hace años es la del factor 10: automatiza cuando el tiempo que vas a invertir en montar la macro sea menor que diez veces el tiempo que ahorras al año. Si formateas un informe cinco minutos al día, son unas 20 horas al año; dedicar dos tardes a escribir una macro sale rentabilísimo. Si es algo que haces una vez cada seis meses, hazlo a mano y sigue con tu vida.

Candidatas claras: consolidar hojas con la misma estructura, limpiar exportaciones de un ERP, aplicar el formato corporativo a un informe recurrente, generar un PDF por delegación, renombrar hojas por fecha, eliminar filas vacías de un volcado, refrescar tablas dinámicas y mandar el libro por correo. Malas candidatas: cualquier proceso donde tú tomas decisiones distintas cada vez, o donde el origen de datos cambia de formato cada mes. Ahí la macro se rompe y acabas depurando más de lo que ahorrabas.

Una macro no arregla un proceso mal diseñado, lo acelera. Si tu archivo tiene 14 hojas con nombres inconsistentes y celdas combinadas por todas partes, ordena primero la estructura y automatiza después. Automatizar el caos solo produce caos más rápido.

Activar la pestaña Programador en Excel

Excel esconde la pestaña Programador por defecto en todas las versiones desde 2007. Para sacarla en Excel 2016, 2019, 2021, 2024 y Microsoft 365 de escritorio: Archivo → Opciones → Personalizar cinta de opciones, y en la columna de la derecha marca la casilla Programador (Desarrollador en algunas traducciones). Aceptas y aparece entre Vista y Ayuda. En Excel para Mac la ruta es Excel → Preferencias → Cinta y barra de herramientas, mismo resultado.

Dentro verás cinco grupos. Los que vas a tocar son Código (Visual Basic, Macros, Grabar macro, Seguridad de macros) y Controles (Insertar, para poner botones en la hoja). Los grupos de complementos y XML puedes ignorarlos durante meses sin echarlos de menos.

La grabadora de macros y cómo leer el código que genera

La grabadora es el mejor profesor de VBA que existe, y no porque escriba buen código (escribe código pésimo), sino porque te enseña los nombres de los objetos y propiedades que necesitas. Cuando no sepas cómo se llama algo en VBA, grábalo y mira el resultado.

Pulsa Grabar macro, ponle un nombre sin espacios ni acentos (Excel no acepta ni una cosa ni la otra), asígnale un atajo si quieres y elige dónde guardarla. Haz la tarea despacio y pulsa Detener grabación. Ahora Alt + F11 y busca tu macro dentro de Módulos → Módulo1. Te vas a encontrar algo así:

Sub FormatearInforme()
'
' FormatearInforme Macro
'
    Range("A1:F1").Select
    Selection.Font.Bold = True
    With Selection.Interior
        .Pattern = xlSolid
        .PatternColorIndex = xlAutomatic
        .Color = 15773696
        .TintAndShade = 0
        .PatternTintAndShade = 0
    End With
    Columns("A:F").Select
    Selection.Columns.AutoFit
    Range("A1").Select
End Sub

Léelo así: Sub abre el procedimiento y End Sub lo cierra; todo lo de dentro se ejecuta de arriba abajo. Las líneas que empiezan por comilla simple son comentarios y Excel las ignora. Range("A1:F1") es un rango de celdas y .Select lo selecciona. Selection se refiere a lo que acabas de seleccionar. El bloque With ... End With agrupa varias propiedades del mismo objeto para no repetir su nombre cinco veces.

Y ahora la primera lección seria: ese código se puede reducir a la mitad. La grabadora selecciona antes de actuar porque tú seleccionas con el ratón, pero VBA no lo necesita. La versión limpia hace lo mismo, corre más rápido y no mueve el cursor del usuario:

Sub FormatearInforme()
    With Range("A1:F1")
        .Font.Bold = True
        .Interior.Color = RGB(255, 217, 102)
    End With
    Columns("A:F").AutoFit
End Sub

De 16 líneas a 6. Cada vez que veas .Select seguido de Selection., junta las dos líneas en una. Esa única costumbre te ahorra el 70% del ruido que genera la grabadora y multiplica la velocidad en libros grandes.

Referencias relativas frente a referencias absolutas

En el grupo Código hay un botón que casi nadie pulsa y que decide si tu macro sirve para algo: Usar referencias relativas. Por defecto está desactivado, o sea, la grabadora trabaja en modo absoluto y escribe Range("B4").Select. Esa macro escribirá siempre en B4, estés donde estés. Perfecto para una plantilla de estructura fija; inútil para "añade una fila al final de la lista".

Si activas referencias relativas antes de grabar, Excel escribe ActiveCell.Offset(1, 0).Range("A1").Select, es decir, "una fila más abajo de donde estés". La macro se vuelve portátil: la lanzas en la fila 7 y trabaja en la 8; la lanzas en la 4.000 y trabaja en la 4.001. Para tareas de registro (meter un movimiento nuevo, apuntar una incidencia) es lo que quieres. Puedes mezclar los dos modos dentro de la misma grabación pulsando el botón a mitad de camino, aunque el código resultante es difícil de seguir; mejor grabar los dos trozos por separado.

El editor de VBA por dentro: lo mínimo para escribir tus propias macros

Alt + F11 abre el Editor de Visual Basic, una ventana con aspecto de los años noventa que no ha cambiado desde Office 2000 y que sigue funcionando igual de bien. A la izquierda tienes el Explorador de proyectos con un árbol por cada libro abierto: las hojas, ThisWorkbook y la carpeta Módulos. Debajo, la ventana Propiedades. En el centro, el área de código.

Módulos, procedimientos y dónde va cada cosa

Un módulo estándar (menú Insertar → Módulo) es donde viven las macros que quieres ejecutar tú, las que aparecen en la lista de Alt + F8. Los módulos de hoja (haz doble clic en Hoja1) guardan los eventos de esa hoja concreta. ThisWorkbook guarda los eventos del libro entero. Y un UserForm es una ventana de diálogo propia. Meter una macro normal dentro del módulo de una hoja es el error de novato más común: deja de aparecer en la lista de macros y luego no entiendes por qué.

Dentro de un módulo, cada macro es un Sub. Si el procedimiento devuelve un valor se llama Function y lo puedes usar como fórmula en la hoja, igual que SUMA. Un Sub declarado como Private no aparece en la lista de macros, algo que se agradece cuando tienes veinte rutinas auxiliares.

Variables, tipos y por qué debes escribir Option Explicit

Pon Option Explicit en la primera línea de cada módulo. Obliga a declarar toda variable antes de usarla y te ahorra horas de depuración: sin esa línea, si escribes totalVentas en un sitio y totalVetnas en otro, VBA crea dos variables vacías y no protesta. Para que se ponga solo en cada módulo nuevo, marca Herramientas → Opciones → Requerir declaración de variables.

Option Explicit

Sub EjemploVariables()
    Dim ultimaFila As Long        ' números enteros grandes (más de 32.767)
    Dim nombreHoja As String      ' texto
    Dim importe As Double         ' decimales
    Dim esValido As Boolean       ' Verdadero / Falso
    Dim hoja As Worksheet         ' un objeto hoja
    Dim celda As Range            ' un objeto rango

    ultimaFila = Cells(Rows.Count, 1).End(xlUp).Row
    nombreHoja = ActiveSheet.Name
    MsgBox "La hoja " & nombreHoja & " tiene datos hasta la fila " & ultimaFila
End Sub

Usa Long y no Integer para filas: Integer se queda en 32.767 y una hoja de Excel tiene 1.048.576 filas, así que en cuanto pases de ese número te salta un desbordamiento. La línea Cells(Rows.Count, 1).End(xlUp).Row es la más útil de todo VBA: se planta en el final de la columna A y sube hasta encontrar el último dato. Equivale a pulsar Ctrl + Flecha arriba desde A1048576.

Range frente a Cells: cuándo usar cada uno

Range("B5") usa la notación que ves en la hoja y se lee de maravilla cuando la dirección es fija. Cells(5, 2) usa fila y columna numéricas, y es la que necesitas dentro de un bucle porque puedes sustituir los números por variables: Cells(i, 2). Se combinan sin problema: Range(Cells(1, 1), Cells(ultimaFila, 6)) define un rango dinámico desde A1 hasta la última fila de la columna F.

Un detalle que causa muchos errores: si escribes Range("A1") sin más, VBA lo aplica a la hoja activa, la que esté delante en ese momento. Si tu macro cambia de hoja a mitad de ejecución, empieza a escribir donde no debe. Cualifica siempre: Worksheets("Datos").Range("A1"). Es más largo de teclear y te evita el 90% de los sustos.

Bucles For, For Each y condicionales If

Los bucles son lo que separa una macro grabada de una macro de verdad. For ... Next repite un número conocido de veces; For Each ... Next recorre una colección (todas las hojas, todas las celdas de un rango) sin que te importe cuántos elementos hay.

Sub MarcarPendientes()
    Dim i As Long, ultimaFila As Long
    ultimaFila = Cells(Rows.Count, 1).End(xlUp).Row

    For i = 2 To ultimaFila                      ' empieza en 2 para saltar la cabecera
        If Cells(i, 4).Value > 1000 And Cells(i, 5).Value = "" Then
            Cells(i, 6).Value = "REVISAR"
            Cells(i, 6).Interior.Color = RGB(255, 199, 206)
        ElseIf Cells(i, 5).Value <> "" Then
            Cells(i, 6).Value = "OK"
        End If
    Next i
End Sub

Línea a línea: declaras el contador i y la última fila con datos; el bucle va de la fila 2 a la última; el If comprueba dos condiciones a la vez con And (importe mayor de 1.000 y columna E vacía) y marca la celda; ElseIf cubre el caso contrario; <> significa "distinto de"; Next i pasa a la siguiente fila. Cambia And por Or si basta con que se cumpla una condición.

La versión con For Each para recorrer hojas es aún más limpia y no necesita saber cuántas hay:

Sub RecorrerHojas()
    Dim hoja As Worksheet
    For Each hoja In ThisWorkbook.Worksheets
        If hoja.Name <> "Resumen" Then
            hoja.Range("A1").Value = "Actualizado " & Format(Date, "dd/mm/yyyy")
        End If
    Next hoja
End Sub

Siete macros listas para copiar y explicadas por dentro

Estas rutinas resuelven las peticiones que más me llegan. Pégalas en un módulo estándar (Alt + F11 → Insertar → Módulo) y ejecútalas con Alt + F8. Antes de lanzar cualquiera de ellas sobre datos que te importen, guarda una copia: VBA no pasa por la papelera y Ctrl + Z no deshace lo que hace una macro.

1. Limpiar todo el formato de la selección

Sub LimpiarFormato()
    If TypeName(Selection) <> "Range" Then Exit Sub
    With Selection
        .ClearFormats
        .Font.Name = "Calibri"
        .Font.Size = 11
        .HorizontalAlignment = xlGeneral
        .UnMerge
    End With
End Sub

La primera línea comprueba que lo seleccionado sea un rango y no un gráfico, en cuyo caso sale sin hacer nada. .ClearFormats borra colores, bordes, formatos numéricos y estilos, pero deja los valores intactos. Después reponemos la fuente base y descombinamos celdas, que es lo que suele estropear los archivos heredados. Ojo: también elimina el formato condicional del rango.

2. Eliminar filas vacías de un volcado

Sub EliminarFilasVacias()
    Dim i As Long, ultimaFila As Long
    ultimaFila = Cells(Rows.Count, 1).End(xlUp).Row

    Application.ScreenUpdating = False
    For i = ultimaFila To 2 Step -1
        If Application.WorksheetFunction.CountA(Rows(i)) = 0 Then
            Rows(i).Delete
        End If
    Next i
    Application.ScreenUpdating = True
    MsgBox "Filas vacías eliminadas.", vbInformation
End Sub

Fíjate en Step -1: el bucle va de abajo hacia arriba. Si lo haces al revés, al borrar la fila 10 la 11 pasa a ser la 10, el contador avanza a 11 y te saltas una fila. Es el fallo clásico de las macros de borrado. CountA(Rows(i)) cuenta celdas no vacías de la fila entera; si da cero, la fila se va. En una hoja de 20.000 filas esta macro tarda unos segundos; para volúmenes mayores usa un rango de unión con Union y borra todo de golpe.

3. Consolidar todas las hojas en un resumen

Sub ConsolidarHojas()
    Dim hoja As Worksheet, destino As Worksheet
    Dim ultimaOrigen As Long, ultimaDestino As Long

    Set destino = ThisWorkbook.Worksheets("Resumen")
    destino.Cells.ClearContents
    destino.Range("A1:F1").Value = Worksheets(2).Range("A1:F1").Value

    For Each hoja In ThisWorkbook.Worksheets
        If hoja.Name <> destino.Name Then
            ultimaOrigen = hoja.Cells(hoja.Rows.Count, 1).End(xlUp).Row
            ultimaDestino = destino.Cells(destino.Rows.Count, 1).End(xlUp).Row + 1
            If ultimaOrigen > 1 Then
                hoja.Range("A2:F" & ultimaOrigen).Copy _
                    destino.Cells(ultimaDestino, 1)
                destino.Cells(ultimaDestino, 7).Resize(ultimaOrigen - 1).Value = hoja.Name
            End If
        End If
    Next hoja
    Application.CutCopyMode = False
End Sub

Esta es la macro estrella de cualquier oficina con un archivo por delegación, mes o comercial. Set destino = ... guarda la hoja Resumen en una variable de objeto (fíjate en que los objetos necesitan Set y las variables normales no). Vaciamos el destino, copiamos la cabecera, y recorremos todas las hojas menos la propia Resumen. Para cada una calculamos su última fila con datos, calculamos la primera libre del destino y pegamos el bloque A2:F. La línea del Resize escribe el nombre de la hoja de origen en la columna G de cada fila pegada, para que después sepas de dónde salió cada dato. El guion bajo al final de una línea significa "esto continúa abajo".

4. Exportar cada hoja a un PDF independiente

Sub ExportarHojasAPdf()
    Dim hoja As Worksheet, ruta As String
    ruta = ThisWorkbook.Path & Application.PathSeparator

    For Each hoja In ThisWorkbook.Worksheets
        If hoja.Visible = xlSheetVisible Then
            hoja.ExportAsFixedFormat _
                Type:=xlTypePDF, _
                Filename:=ruta & hoja.Name & "_" & Format(Date, "yyyy-mm-dd") & ".pdf", _
                Quality:=xlQualityStandard, _
                OpenAfterPublish:=False
        End If
    Next hoja
    MsgBox "PDF generados en: " & ruta, vbInformation
End Sub

ThisWorkbook.Path devuelve la carpeta del libro, así que los PDF caen al lado del Excel. Application.PathSeparator pone la barra correcta en Windows o en Mac. Saltamos las hojas ocultas y añadimos la fecha al nombre del archivo con Format(Date, "yyyy-mm-dd"), que ordena alfabéticamente igual que cronológicamente. Si el libro nunca se ha guardado, Path viene vacío y la macro falla: guarda antes de ejecutarla.

5. Enviar el libro por correo con Outlook

Sub EnviarLibroPorCorreo()
    Dim outlookApp As Object, mail As Object

    ThisWorkbook.Save
    Set outlookApp = CreateObject("Outlook.Application")
    Set mail = outlookApp.CreateItem(0)

    With mail
        .To = "[email protected]"
        .Subject = "Informe " & Format(Date, "mmmm yyyy")
        .Body = "Buenos días:" & vbCrLf & vbCrLf & _
                "Adjunto el informe actualizado." & vbCrLf & "Un saludo."
        .Attachments.Add ThisWorkbook.FullName
        .Display          ' cambia .Display por .Send para enviarlo sin revisar
    End With

    Set mail = Nothing
    Set outlookApp = Nothing
End Sub

Usamos CreateObject (enlace tardío) en lugar de añadir la referencia a la librería de Outlook, así el archivo funciona en ordenadores con versiones distintas de Office. CreateItem(0) crea un mensaje nuevo. Deja .Display mientras pruebas: abre el correo y lo revisas antes de mandarlo. Cuando confíes en la macro, cambia a .Send. Necesita Outlook de escritorio instalado y configurado; con Outlook web o Gmail esto no funciona y tendrás que tirar de Power Automate.

6. Renombrar la hoja activa con la fecha

Sub RenombrarHojaPorFecha()
    Dim nuevoNombre As String
    nuevoNombre = Format(Date, "yyyy-mm-dd")

    On Error Resume Next
    ActiveSheet.Name = nuevoNombre
    If Err.Number <> 0 Then
        ActiveSheet.Name = nuevoNombre & "_" & Format(Time, "hhmm")
        Err.Clear
    End If
    On Error GoTo 0
End Sub

Excel no admite dos hojas con el mismo nombre, ni los caracteres / \ ? * [ ], ni más de 31 caracteres. Por eso el formato con guiones y no con barras. Si ya existe una hoja con esa fecha, el On Error Resume Next captura el fallo y le añade la hora para diferenciarlas. On Error GoTo 0 devuelve la gestión de errores a la normalidad, algo que hay que hacer siempre después de un Resume Next.

7. Dar formato completo a un informe recurrente

Sub FormatearInformeMensual()
    Dim ultimaFila As Long, ultimaCol As Long
    Dim rangoDatos As Range

    Application.ScreenUpdating = False
    Application.Calculation = xlCalculationManual

    ultimaFila = Cells(Rows.Count, 1).End(xlUp).Row
    ultimaCol = Cells(1, Columns.Count).End(xlToLeft).Column
    Set rangoDatos = Range(Cells(1, 1), Cells(ultimaFila, ultimaCol))

    With rangoDatos
        .Font.Name = "Calibri"
        .Font.Size = 11
        .Borders.LineStyle = xlContinuous
        .Borders.Color = RGB(200, 200, 200)
        .VerticalAlignment = xlCenter
    End With

    With Range(Cells(1, 1), Cells(1, ultimaCol))
        .Font.Bold = True
        .Font.Color = vbWhite
        .Interior.Color = RGB(31, 78, 121)
        .HorizontalAlignment = xlCenter
    End With

    Range(Cells(2, 4), Cells(ultimaFila, ultimaCol)).NumberFormat = "#,##0.00 €"
    rangoDatos.Columns.AutoFit
    ActiveWindow.FreezePanes = False
    Range("A2").Select
    ActiveWindow.FreezePanes = True

    Application.Calculation = xlCalculationAutomatic
    Application.ScreenUpdating = True
End Sub

Aquí está casi todo lo anterior junto: detectamos el rango real de datos por los dos extremos, aplicamos formato de cuerpo y de cabecera con dos bloques With, ponemos formato de euros a partir de la columna D, ajustamos anchos e inmovilizamos la fila de títulos. Las dos líneas de Application del principio y del final son las que convierten una macro lenta en una macro instantánea; te explico por qué en el apartado de rendimiento.

Cómo lanzar tus macros: botones, atajos y libro personal

Asignar una macro a un botón en la hoja

Ve a Programador → Insertar → Botón (control de formulario), dibújalo sobre la hoja y Excel te pregunta qué macro asignar. Elígela, acepta y cámbiale el rótulo con un clic derecho → Modificar texto. Este tipo de botón es el más resistente: sobrevive a copias del archivo y no depende de ActiveX, que da problemas en equipos con configuraciones de seguridad estrictas.

La alternativa elegante es asignar la macro a una forma: inserta un rectángulo redondeado, dale el color corporativo, clic derecho → Asignar macro. Queda mucho mejor que el botón gris de 1997 y funciona igual. Y si prefieres tenerla siempre a mano, añádela a la barra de acceso rápido: Archivo → Opciones → Barra de herramientas de acceso rápido → Comandos disponibles: Macros.

Atajos de teclado sin pisar los de Excel

En Alt + F8 → Opciones puedes asignar Ctrl + una letra. El problema es que Excel ya usa casi todas: Ctrl + C, Ctrl + V, Ctrl + B, Ctrl + G... Y tu macro tiene prioridad, así que si eliges Ctrl + G te quedas sin Buscar mientras el libro esté abierto. Truco: usa Ctrl + Mayús + letra (mantén Mayús al escribir la letra en el cuadro). Ese espacio está casi libre y evitas sorpresas.

PERSONAL.XLSB: tus macros en todos los libros

Si guardas una macro en "Este libro", solo existe en ese archivo. Para tener tus utilidades disponibles siempre, guárdala en el Libro de macros personal. Al elegir esa opción en la grabadora por primera vez, Excel crea PERSONAL.XLSB en la carpeta %AppData%\Microsoft\Excel\XLSTART y lo abre oculto en cada arranque. Ahí meto las rutinas de limpieza, el formateador de informes y el conversor de fechas de texto: son las que uso a diario con cualquier archivo.

Dos avisos. Ese archivo no viaja con tus libros, así que si mandas el Excel a un compañero las macros no van dentro. Y conviene copiarlo a tu backup de vez en cuando: si formateas el equipo y no lo has guardado, pierdes años de utilidades. Yo tengo una copia en la nube y la sustituyo cada trimestre.

Eventos: macros que se ejecutan solas

Los eventos son el salto de "pulso un botón" a "el libro reacciona". Van en el módulo de la hoja o en ThisWorkbook, nunca en un módulo estándar. Los tres que más se usan:

' En el módulo de la Hoja1: sella la fecha al escribir en la columna B
Private Sub Worksheet_Change(ByVal Target As Range)
    If Target.Count > 1 Then Exit Sub
    If Not Intersect(Target, Me.Range("B2:B1000")) Is Nothing Then
        Application.EnableEvents = False
        Me.Cells(Target.Row, 3).Value = Now
        Me.Cells(Target.Row, 3).NumberFormat = "dd/mm/yyyy hh:mm"
        Application.EnableEvents = True
    End If
End Sub

Target es la celda que ha cambiado. Salimos si se han modificado varias a la vez (un pegado masivo). Intersect comprueba si el cambio cae dentro del rango vigilado y Is Nothing significa "no hay intersección", de ahí el Not. La línea de EnableEvents = False es obligatoria: al escribir en C estamos provocando otro Worksheet_Change, y sin desactivar eventos entras en un bucle infinito que cuelga Excel. Me se refiere a la hoja donde vive el código.

' En ThisWorkbook: prepara el libro al abrirlo
Private Sub Workbook_Open()
    Worksheets("Panel").Activate
    Range("A1").Select
    Application.StatusBar = "Datos actualizados a " & Format(Now, "dd/mm hh:mm")
    ThisWorkbook.RefreshAll
End Sub

' Avisa si intentan guardar sin rellenar un campo obligatorio
Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)
    If Worksheets("Panel").Range("B2").Value = "" Then
        MsgBox "Rellena el responsable antes de guardar.", vbExclamation
        Cancel = True
    End If
End Sub

Poner Cancel = True aborta el guardado. Con la misma lógica, Workbook_BeforeClose te deja hacer limpieza al cerrar y Worksheet_SelectionChange reacciona al mover el cursor. Usa los eventos con cabeza: un libro lleno de eventos mal escritos se vuelve imprevisible y frustra a quien lo usa.

UserForm: una ventana de entrada de datos en diez minutos

Cuando varias personas rellenan la misma hoja, un formulario evita que escriban donde no toca. En el editor, Insertar → UserForm, y desde el Cuadro de herramientas arrastras dos TextBox, un ComboBox y un CommandButton. Renómbralos en la ventana Propiedades (txtCliente, txtImporte, cboTipo, btnGuardar) porque TextBox1 no te dirá nada dentro de tres meses.

Private Sub UserForm_Initialize()
    cboTipo.AddItem "Factura"
    cboTipo.AddItem "Abono"
    cboTipo.AddItem "Provisión"
End Sub

Private Sub btnGuardar_Click()
    Dim fila As Long
    If txtCliente.Value = "" Or Not IsNumeric(txtImporte.Value) Then
        MsgBox "Revisa el cliente y el importe.", vbExclamation
        Exit Sub
    End If

    With Worksheets("Movimientos")
        fila = .Cells(.Rows.Count, 1).End(xlUp).Row + 1
        .Cells(fila, 1).Value = Date
        .Cells(fila, 2).Value = txtCliente.Value
        .Cells(fila, 3).Value = CDbl(txtImporte.Value)
        .Cells(fila, 4).Value = cboTipo.Value
    End With

    txtCliente.Value = "": txtImporte.Value = ""
    txtCliente.SetFocus
End Sub

UserForm_Initialize se dispara al abrir la ventana y rellena el desplegable. El botón valida antes de escribir (IsNumeric comprueba que el importe sea un número), busca la primera fila libre, vuelca los cuatro campos, limpia las cajas y devuelve el foco a la primera. Para mostrarlo desde una macro normal: UserForm1.Show. Con esto y una hoja bloqueada tienes un mini formulario de captura que aguanta cualquier auditoría interna.

Errores, depuración y rendimiento: que la macro no te deje tirado

Gestión de errores con On Error

Una macro sin control de errores muestra al usuario un cuadro amarillo con "Error 1004 en tiempo de ejecución" y dos botones que no entiende. Peor aún: si el fallo ocurre después de haber desactivado la actualización de pantalla, Excel se queda congelado hasta que lo cierras a la fuerza. El patrón que uso en todo lo que entrego:

Sub ProcesoSeguro()
    On Error GoTo Fallo

    Application.ScreenUpdating = False
    ' ... aquí va el trabajo de verdad ...
    Worksheets("Datos").Range("A1").Value = 1 / 0   ' provoca el error 11

Salir:
    Application.ScreenUpdating = True
    Application.EnableEvents = True
    Application.Calculation = xlCalculationAutomatic
    Exit Sub

Fallo:
    MsgBox "Algo ha fallado en el paso: " & Err.Description & _
           vbCrLf & "Código " & Err.Number, vbCritical, "Proceso detenido"
    Resume Salir
End Sub

On Error GoTo Fallo desvía cualquier error a la etiqueta Fallo. Ahí avisas con un mensaje comprensible y Resume Salir salta a la etiqueta de limpieza, que devuelve Excel a su estado normal. El Exit Sub antes de Fallo impide que el flujo normal caiga dentro del bloque de error. Códigos que verás a menudo: 9 (subíndice fuera del intervalo: la hoja que buscas no existe o está mal escrita), 13 (no coinciden los tipos: metes texto donde esperabas número), 91 (variable de objeto no establecida: te falta un Set) y 1004 (el comodín de "Excel no puede hacer eso ahí").

Reserva On Error Resume Next para líneas sueltas donde el fallo es previsible y aceptable, como borrar una hoja que puede no existir. Ponerlo al principio de una macro larga equivale a taparte los ojos: los errores siguen ocurriendo, pero ya no te enteras.

Depurar con puntos de interrupción y ventana Inmediato

Haz clic en el margen gris izquierdo del editor, junto a una línea, y aparece un punto rojo: es un punto de interrupción (F9 hace lo mismo). Al ejecutar, la macro se detiene ahí. Desde ese momento, F8 avanza línea a línea, Mayús + F8 ejecuta un procedimiento entero sin entrar, F5 continúa a velocidad normal y pasar el ratón por encima de una variable te enseña su valor. Con esas cuatro teclas resuelves la mayoría de los fallos en minutos.

La ventana Inmediato (Ctrl + G) es tu bloc de notas de ejecución. Escribe ?ActiveSheet.Name y pulsa Intro para ver la hoja activa; escribe Range("A1").Value = 500 y se ejecuta al momento. Dentro del código, Debug.Print ultimaFila va dejando valores ahí sin molestar al usuario con MsgBox. Añade también la ventana Locales (menú Ver) para ver de un vistazo todas las variables y su contenido mientras avanzas con F8.

Cuando una macro falla en el ordenador de otra persona pero no en el tuyo, el 80% de las veces es una de estas tres cosas: una referencia a una librería que ese equipo no tiene, una ruta de red que no está montada, o una versión de Excel donde ese objeto no existe. Empieza por ahí antes de reescribir nada.

Rendimiento: de dos minutos a dos segundos

La mayoría de las macros lentas no lo son por el volumen de datos, sino porque Excel repinta la pantalla y recalcula fórmulas después de cada operación. Estas cuatro líneas al principio y su reverso al final suelen dividir el tiempo de ejecución entre diez o más:

Application.ScreenUpdating = False      ' deja de repintar la pantalla
Application.Calculation = xlCalculationManual  ' no recalcula tras cada cambio
Application.EnableEvents = False        ' no dispara eventos en cadena
Application.DisplayAlerts = False       ' no pregunta "¿seguro que quieres borrar?"

Devuélvelas todas a su valor original al terminar, también dentro del bloque de error. Dejar Calculation en manual y no restaurarlo es el motivo por el que un compañero te dirá que "Excel ya no calcula". El segundo gran acelerador es trabajar con matrices en memoria en vez de celda a celda: cargar un rango en un Variant, procesarlo y volcarlo de una sola vez. En una tabla de 100.000 filas la diferencia entre leer celda a celda y leer en bloque pasa de minutos a menos de un segundo.

Dim datos As Variant, i As Long
datos = Range("A2:D100000").Value      ' una sola lectura
For i = 1 To UBound(datos, 1)
    datos(i, 4) = datos(i, 2) * datos(i, 3)
Next i
Range("A2:D100000").Value = datos      ' una sola escritura

Y elimina los .Select y .Activate que dejó la grabadora. Cada uno de ellos obliga a Excel a mover el foco, redibujar y actualizar la barra de estado. En un bucle de 10.000 iteraciones eso son 10.000 repintados que no aportan nada.

Formatos, seguridad y firma digital de las macros

Por qué .xlsx no guarda macros y qué formato usar

Desde Office 2007 Microsoft separó los formatos con y sin código, precisamente para frenar los virus de macro que arrasaron oficinas enteras a finales de los noventa. Un .xlsx es un contenedor que, por diseño, no admite el proyecto VBA: si guardas ahí un libro con macros, Excel muestra un aviso y, si aceptas, el código desaparece para siempre. No hay recuperación posible salvo que tengas copia.

Configuración de seguridad y ubicaciones de confianza

En Archivo → Opciones → Centro de confianza → Configuración del Centro de confianza → Configuración de macros tienes cuatro niveles. El recomendado es "Deshabilitar macros VBA con notificación": el archivo se abre, las macros no corren y aparece una barra amarilla que tú decides si habilitas. Nunca actives "Habilitar todas las macros", por muy pesado que se te haga el aviso.

Desde 2022 Microsoft bloquea por defecto las macros de archivos descargados de internet o recibidos por correo, con una barra roja que ni siquiera ofrece el botón de habilitar. Ese bloqueo se debe a la marca de la web que Windows añade al archivo. Si el archivo es tuyo y sabes lo que contiene: clic derecho sobre el fichero → Propiedades → marca Desbloquear abajo del todo → Aceptar.

La solución limpia para el trabajo diario son las ubicaciones de confianza: en el mismo Centro de confianza, añade una carpeta concreta (por ejemplo D:\Automatizaciones) y todo lo que guardes ahí se abrirá con las macros activas sin preguntar. Regla de oro: que sea una carpeta local que controles tú, nunca la carpeta de Descargas ni una unidad de red compartida donde cualquiera puede dejar archivos.

Firmar digitalmente el proyecto VBA

Si repartes un archivo con macros a un equipo, la firma digital evita que cada persona tenga que habilitar nada y garantiza que el código no se ha tocado desde que lo firmaste. Para uso interno vale SelfCert.exe, la herramienta que viene con Office (búscala en la carpeta de instalación, normalmente C:\Program Files\Microsoft Office\root\OfficeXX). Creas un certificado con tu nombre y luego, en el editor VBA, Herramientas → Firma digital → Elegir → tu certificado.

El certificado autofirmado solo lo reconoce el ordenador donde se creó, salvo que lo instales en el almacén de Editores de confianza de los demás equipos, algo que suele hacer el departamento de sistemas. Para distribución externa hace falta un certificado de firma de código de una autoridad reconocida, que en 2026 ronda los 200-400 € al año, o bastante más si es de validación extendida. Para una pyme que reparte una plantilla entre veinte personas, casi siempre sale mejor la ubicación de confianza.

Macros descargadas de internet: cómo revisarlas antes de ejecutar

El riesgo es real, no teórico. VBA puede borrar archivos, escribir en el registro de Windows, descargar contenido de una URL y ejecutarlo. Las campañas de ransomware siguen usando documentos de Office como puerta de entrada, y el señuelo habitual es una imagen que dice "habilita el contenido para ver el documento". Si un archivo te pide activar macros para ver algo, ya sabes que es un fraude: las macros no muestran contenido, lo procesan.

Protocolo antes de ejecutar código que no has escrito tú:

1. Abre el archivo con las macros deshabilitadas y pulsa Alt + F11 para leer el código sin ejecutarlo. Mirar nunca ejecuta nada.
2. Revisa todos los módulos, las hojas y ThisWorkbook. Un Workbook_Open o un Auto_Open arranca solo en cuanto habilites; es donde se esconde lo malo.
3. Busca instrucciones de riesgo con Ctrl + F: Shell, CreateObject("WScript.Shell"), URLDownloadToFile, Kill, FileSystemObject, Environ, Base64, Chr( repetido decenas de veces y Application.OnTime. Ninguna es maliciosa por sí sola, pero juntas en una macro que dice formatear una tabla no pintan nada.
4. Desconfía del código ofuscado. Cadenas partidas en trocitos, nombres de variables aleatorios o líneas de 800 caracteres solo tienen un objetivo: que no entiendas qué hace.
5. Comprueba si hay módulos ocultos y si el proyecto está protegido con contraseña. Un proyecto VBA bloqueado en un archivo que te llega por correo es motivo suficiente para borrarlo.
6. Pruébalo aislado. Copia el código a un libro nuevo con datos falsos, sin conexión a las carpetas de trabajo y sin unidades de red montadas.

Si el archivo viene de un desconocido, no lo revises: bórralo. Ninguna macro de internet vale el riesgo de cifrar los datos de tu empresa. Y si tienes cualquier duda sobre un archivo que ya has abierto en el ordenador del trabajo, avisa a sistemas antes de seguir trabajando con él.

Límites de VBA y alternativas: Office Scripts, Power Query y Power Automate

VBA tiene tres límites que conviene conocer antes de montar toda tu operativa sobre él. El primero: no funciona en Excel para la web. Si abres un .xlsm desde el navegador, verás los datos y podrás editarlos, pero las macros no se ejecutan ni puedes abrir el editor. El segundo: necesita que alguien tenga el archivo abierto, no hay ejecución programada en la nube. El tercero: en Mac, las funciones que tocan el sistema operativo (Outlook, sistema de archivos, llamadas a la API de Windows) fallan o se comportan de otro modo.

Microsoft lleva desde 2020 empujando Office Scripts, basado en TypeScript, como sustituto para el Excel de navegador. Y no, VBA no está muerto: Microsoft mantiene el soporte en las versiones de escritorio de Excel 2024 y Microsoft 365, y no hay fecha de retirada anunciada. Lo sensato en 2026 es elegir la herramienta según dónde y cómo se ejecute el proceso.

La combinación que mejor me funciona en proyectos reales es esta: Power Query para traer y limpiar los datos, tablas y fórmulas dinámicas para los cálculos, y una macro VBA corta para lo que ninguna de las dos hace bien (formatear, exportar PDF, mandar correo, mostrar un formulario). Reservar VBA para el último tramo reduce el código a mantener a una décima parte. Si quieres montar la parte sin código, tienes el detalle en la guía de automatización de Excel sin programar y en nuestras plantillas de Excel, donde ya van resueltas las fórmulas.

Cómo pedirle código VBA a una IA sin llevarte disgustos

Los asistentes de IA generan VBA razonable si les das contexto suficiente. Un buen prompt incluye: la versión de Excel, los nombres exactos de las hojas, las columnas implicadas con su letra y su contenido, dónde empiezan los datos, qué pasa con la cabecera y qué debe ocurrir si algo falla. Un mal prompt ("hazme una macro para mi informe") produce código que asume una estructura que no tienes.

Revisa siempre lo que te devuelva antes de ejecutarlo, con el mismo protocolo que aplicas a una macro descargada. Los fallos que más veo en código generado: usar Integer para filas, no cualificar las hojas, olvidar restaurar ScreenUpdating y borrar filas de arriba abajo. Si el código contiene un Kill, un Shell o un borrado masivo que tú no has pedido, no lo ejecutes.

Preguntas frecuentes sobre macros y VBA en Excel

Empieza por una sola tarea, la que más veces repitas esta semana. Grábala, ábrela con Alt + F11, quítale los .Select y asígnala a un botón. Ese primer ciclo completo enseña más que cualquier curso, y a partir de ahí el resto de las macros de esta guía las vas a leer con otros ojos.