AND en VBA para Excel: cómo usarla en una macro

Imagina una hoja de ventas con 800 filas a la que cada lunes tienes que poner el mismo formato, copiarla a un correo y mandarle un resumen al jefe. Eso, a mano, son dos horas. Con una macro de VBA lo haces en un clic, y además te llevas el código para la semana que viene. VBA es el lenguaje que lleva dentro Excel desde hace décadas: te deja decirle a la hoja qué hacer con instrucciones en tu idioma.

Al terminar este tutorial sabrás abrir el editor, escribir tu primera macro, dar formato a una hoja, recorrer filas para resumir datos, escribir fórmulas desde código y evitar los cuatro errores que dejan la macro atascada. Funciona en Excel para Microsoft 365, 2024, 2021, 2019 y 2016, en Excel 2010 y 2007, y en Excel para Mac. Excel para la web y los móviles no admiten macros: allí se usa otro sistema distinto.

Qué es VBA y por qué sigue mereciendo la pena en Excel

VBA son las iniciales de Visual Basic for Applications. Es un dialecto de Visual Basic que vive dentro de Excel y de los demás programas de Office. No es nuevo: lleva con nosotros desde los años noventa, y ahí sigue porque resuelve un problema muy concreto: el trabajo repetitivo dentro de una hoja.

Volvamos a la hoja de ventas. Cada lunes tienes que poner la fecha en formato día/mes/año, el importe con dos decimales, la cabecera en negrita, ajustar el ancho de columna, sumar el total, contar cuántos registros hay y dejar el resultado en una celda aparte para copiarlo al correo. Son seis pasos mecánicos que no cambian nunca. VBA te permite grabar esos seis pasos una vez y, a partir de ahí, repetirlos en cualquier hoja pulsando una sola tecla.

La idea importante: VBA no sustituye a las fórmulas ni a las tablas dinámicas, las complementa. Donde Excel se queda corto (automatizar clics, combinar pasos en un orden fijo, generar informes a partir de un libro terminado), VBA entra. Donde Excel ya brilla (calcular, buscar, resumir con BUSCARV o SUMAR.SI.CONJUNTO), te quedas en la hoja.

Dónde se esconde VBA y qué vas a encontrar al abrirlo

VBA no está a la vista: vive en una pestaña oculta llamada Programador. Cuando la actives, verás los botones para abrir el editor, grabar una macro y lanzar las macros guardadas. El editor es un programa aparte, con su propia ventana, menús y paneles. Se abre con Alt+F11 y se cierra con la misma combinación.

Dentro del editor hay tres paneles que vas a usar siempre. El Explorador de proyectos, a la izquierda, lista los libros abiertos y, dentro de cada uno, sus objetos (hojas) y sus módulos (donde escribes el código). La ventana de Código, en el centro, es el bloc de notas donde escribes las instrucciones. Y la ventana Inmediato, abajo, es una consola donde puedes probar una línea suelta y ver el resultado sin crear una macro. Para abrirla: Ver > Ventana Inmediato (Ctrl+G).

Activar la pestaña Programador y los atajos que usaremos

1. Abre Excel y ve a Archivo > Opciones > Personalizar cinta de opciones.
2. En la columna de la derecha (Pestañas principales), marca la casilla Programador.
3. Pulsa Aceptar. La pestaña Programador aparece a la derecha de Vista.

Los atajos que usaremos en todo el tutorial:

• Alt+F11: abre y cierra el editor de VBA.
• Alt+F8: abre el cuadro de macros para ejecutar una guardada.
• F5: ejecuta la macro donde está el cursor.
• F8: ejecuta paso a paso, línea por línea (tu mejor amigo para encontrar errores).
• F4: abre Propiedades del elemento seleccionado.
• Ctrl+G: abre la ventana Inmediato dentro del editor.

El editor de VBA: módulos, procedimientos y la grabadora

Un módulo es un bloc de notas dentro del libro donde escribes tus instrucciones. Cada instrucción autónoma se llama procedimiento y empieza por Sub Nombre() y termina por End Sub. Lo que hay entre medias es lo que Excel hace cuando lanzas la macro.

Para crear tu primer módulo: en el editor, Insertar > Módulo. Verás una hoja en blanco con las palabras Option Explicit arriba (si la tienes) o directamente Sub y End Sub esperándote.

Antes de escribir nada a mano, prueba la grabadora: Programador > Código > Grabar macro. Dale un nombre, acepta, y haz unos clics en la hoja: pon negrita, cambia un color, ajusta un ancho. Para la grabación y mira el módulo que se ha creado: ese código es exactamente lo que escribirías tú, y es la mejor forma de aprender cómo se llama cada objeto en VBA.

Los cuatro objetos que vas a usar siempre en VBA

VBA ve Excel como una colección de objetos dentro de otros. Para llegar a una celda tienes que pasar por el árbol: Application (Excel entero) > Workbooks (los libros abiertos) > Worksheets (las hojas de un libro) > Range o Cells (la celda o el rango de celdas).

La diferencia entre Range y Cells importa. Range usa letras y números como en la hoja: Range("A1") o Range("B2:D5"). Cells usa números: Cells(2, 1) es la fila 2, columna 1 (la A2). En VBA, los argumentos de Cells van con coma aunque Excel esté en español: Cells(2, 1) siempre, no Cells(2;1). La coma es del idioma de VBA, no del idioma de Excel.

Cells es la base del bucle For, porque te permite cambiar la fila con una variable. Range es más legible cuando el rango es fijo.

Leer y escribir en una celda: .Value, .Formula y sus variantes

Para leer o escribir el valor de una celda usas .Value. Para leer o escribir la fórmula que tiene dentro, tienes cuatro propiedades según el idioma y el estilo de referencia que quieras:

• .Formula: la fórmula en inglés y con comas. Range("C2").Formula = "=SUM(A2:B2)".
• .FormulaLocal: la fórmula en el idioma del usuario y con su separador. Range("C2").FormulaLocal = "=SUMA(A2:B2)".
• .FormulaR1C1: la fórmula en inglés, con referencias R1C1 y comas. Range("C2").FormulaR1C1 = "=SUM(RC[-2]:RC[-1])".
• .FormulaR1C1Local: la misma idea, pero en el idioma del usuario y con su separador.

=Range("C2").FormulaLocal = "=SUMA(A2:B2)"

¿Por qué cuatro? Porque VBA siempre piensa en inglés, y la fórmula de una celda escrita en un Excel en español lleva coma en VBA. Si no recuerdas la regla, casi siempre aciertas con FormulaLocal: escribes la fórmula tal como la ves en la barra de fórmulas, con punto y coma y en español.

.Value se queda fuera de esta discusión: es el valor, no la fórmula. Si la celda tiene =2+2, .Value devuelve 4; .Formula devuelve =2+2.

Tu primera macro: poner «Hola» en una celda y un aviso en pantalla

Vamos a hacerlo. Abre un libro nuevo, activa la pestaña Programador, abre el editor con Alt+F11, inserta un módulo y escribe este código:

Sub Saludo()
    Range("A1").Value = "Hola"
    MsgBox "Listo"
End Sub

Coloca el cursor dentro del Sub y pulsa F5. Vuelve a la hoja (Alt+F11 para salir del editor) y verás:

El código, línea por línea, y por qué hace lo que hace

Sub Saludo() abre el procedimiento y le da un nombre. VBA necesita saber dónde empieza y dónde termina cada bloque; por eso cada Sub lleva su End Sub. El nombre Saludo es el que verás después en la lista de macros (Alt+F8).

Range("A1").Value = "Hola" le dice a Excel: "vete a la hoja activa, busca la celda A1 y escribe en ella el texto Hola". Range es el objeto que apunta a una celda o un grupo de celdas; .Value es la propiedad que guarda lo que hay dentro. El signo igual asigna: lo de la derecha va a la izquierda.

MsgBox "Listo" abre un cuadro de diálogo con un botón Aceptar y el mensaje que pongas entre comillas. Es la forma más rápida de confirmar que la macro ha llegado al final sin atascarse.

End Sub cierra el bloque. Lo que escribas después queda fuera y no se ejecuta.

Dar formato a una hoja con una sola macro

Imagina la hoja Ventas de una tienda. La tienes así, en bruto:

Cada lunes la quieres dejar presentable: la cabecera en negrita, la columna A como fecha día/mes/año, la columna D con dos decimales y el ancho de columna ajustado. Una macro lo hace en un abrir y cerrar de ojos.

Abre el editor (Alt+F11), ve al módulo que creaste antes (o crea uno nuevo) y añade:

Sub Formatear()
    With Worksheets("Ventas")
        .Range("A1:D1").Font.Bold = True
        .Range("A2:A100").NumberFormat = "dd/mm/yyyy"
        .Range("D2:D100").NumberFormat = "#,##0.00"
        .Columns("A:D").AutoFit
    End With
End Sub

Cambiar formato con .NumberFormat y .ColumnWidth

La línea clave es .NumberFormat = "dd/mm/yyyy". NumberFormat recibe el código de formato como texto entre comillas, y ese código está siempre en inglés, sea cual sea el idioma de tu Excel. Los códigos que vas a usar:

• "dd/mm/yyyy" para fecha día/mes/año.
• "#,##0.00" para números con dos decimales y separador de miles.
• "0.00%" para porcentajes con dos decimales.
• "@" para forzar que la celda se vea como texto.

.Range("D2:D100").NumberFormat = "#,##0.00"

.ColumnWidth ajusta el ancho por su valor numérico (el número de caracteres que caben). .Columns("A:D").AutoFit hace lo mismo de forma automática: mide el contenido más ancho de cada columna y la deja exacta. AutoFit es más cómodo cuando los datos cambian.

Recorrer filas para calcular y avisar al final

Sigues con la misma hoja de ventas. Ahora quieres un resumen al final: la suma de la columna Importe y cuántos productos se han vendido. Con un bucle For lo haces y, al terminar, un MsgBox te lo muestra en pantalla.

Sub Resumen()
    Dim UltimaFila As Long
    Dim TotalImporte As Long
    Dim Cantidad As Long
    Dim i As Long

    UltimaFila = Worksheets("Ventas").Cells(Rows.Count, 1).End(xlUp).Row

    Application.ScreenUpdating = False

    For i = 2 To UltimaFila
        TotalImporte = TotalImporte + Worksheets("Ventas").Cells(i, 4).Value
        Cantidad = Cantidad + Worksheets("Ventas").Cells(i, 3).Value
    Next i

    Application.ScreenUpdating = True

    MsgBox "Total vendido: " & TotalImporte & " unidades." & vbCrLf & _
           "Importe total: " & Format(TotalImporte, "#,##0.00") & " EUR."
End Sub

Total vendido: 45 unidades.
Importe total: 62,00 EUR.

Bucle For i = 2 To UltimaFila, la pareja de Cells

Dim i As Long declara la variable i como un número entero largo. En VBA, las variables se declaran con Dim al principio del procedimiento: si no, VBA las crea al vuelo y puedes acabar con un nombre mal escrito que no da error.

La línea UltimaFila = Cells(Rows.Count, 1).End(xlUp).Row es el truco clásico para saber cuántas filas tienes. Cells(Rows.Count, 1) salta a la última fila posible de la columna A (la 1.048.576); .End(xlUp).Row sube hasta la primera que tiene algo y devuelve su número. Funciona aunque la hoja tenga huecos.

=Cells(Rows.Count, 1).End(xlUp).Row

El bucle For i = 2 To UltimaFila recorre desde la fila 2 (la primera con datos) hasta la última. En cada vuelta, Cells(i, 4) lee el D y a la fila i; Cells(i, 3) lee el C y a la misma fila. Acumulas en TotalImporte y Cantidad. Next i sube i en uno y vuelve al principio del bucle.

Application.ScreenUpdating = False apaga el repintado de pantalla mientras la macro trabaja. Hace la macro mucho más rápida porque Excel no tiene que dibujar cada cambio. Se vuelve a encender con True al final, antes del MsgBox.

Escribir fórmulas desde VBA: la trampa del idioma

Si en lugar de calcular con el bucle quisieras dejar una fórmula SUMA en la hoja, tienes dos formas:

Sub EscribirFormula()
    Worksheets("Ventas").Range("F2").Formula = "=SUM(D2:D10)"
    Worksheets("Ventas").Range("F3").FormulaLocal = "=SUMA(D2:D10)"
End Sub

La primera línea escribe la fórmula en inglés con comas: VBA entiende SUM. La segunda la escribe en español con punto y coma: VBA entiende SUMA. Si en un Excel en español escribes Formula = "=SUMA(D2:D10)", VBA no traduce y la celda queda con el texto =SUMA(D2:D10) que no calcula.

Por qué tu macro se atasca o se equivoca

Cuatro tropiezos que pasan a todo el mundo la primera vez, todos con la misma hoja de antes. Si tu macro falla, mira si estás aquí.

Error 1004 al asignar la fórmula

Suele pasar cuando escribes Range("F2").Formula = "=SUMA(D2:D10)" en un Excel en español. VBA no reconoce SUMA (solo SUM) y aborta con el error "Se ha producido el error '1004' en tiempo de ejecución". El arreglo es usar .FormulaLocal y dejar la fórmula en español, o pasar a .Formula y traducir los nombres de función al inglés.

.Range("F2").Formula = "=SUM(D2:D10)"
.Range("F2").FormulaLocal = "=SUMA(D2:D10)"

«Subíndice fuera del intervalo» al nombrar una hoja

Worksheets("Enero") falla cuando la hoja se llama "Enero 2026" o "ENERO" (con alguna diferencia). VBA distingue mayúsculas y acentos, y el nombre tiene que ser exacto. El arreglo es mirar el nombre real de la pestaña y escribirlo igual, o usar Worksheets(1) para referirte a la primera hoja por su posición.

La macro no hace nada al pulsar F5

Dos causas frecuentes. Una: el cursor está en otro módulo o en medio de un comentario; VBA siempre conviene mirar en qué módulo estás y colocar el cursor dentro del Sub que quieres ejecutar. Dos: el procedimiento está declarado como Private Sub en lugar de Sub. Private esconde la macro del cuadro Alt+F8. Cámbialo a Public Sub (o solo Sub, que en VBA es público por defecto) y vuelve a pulsar F5. Si quieres ver por dónde pasa, pulsa F8 en lugar de F5 y avanza línea por línea.

El archivo pierde las macros al guardar

Guardaste el libro como .xlsx y Excel te preguntó si querías borrar las macros. Las macros se fueron. Vuelve a Archivo > Guardar como, elige Libro de Excel habilitado para macros (*.xlsm) y vuelve a abrir. La próxima vez que tengas macros, guarda siempre primero como .xlsm.

Lo que VBA no puede (o no debe) hacer en Excel

VBA vive dentro de Excel de escritorio. Tres límites que conviene conocer antes de empezar un proyecto:

• VBA no existe en Excel para la web ni en los móviles. Allí se automatiza con TypeScript y la API de Office Scripts, que tiene otra sintaxis. Una macro que has escrito en tu .xlsm no se ejecuta cuando un compañero abre ese mismo archivo en Excel para la web.
• Las macros de archivos recibidos por correo o descargados de internet están deshabilitadas hasta que el usuario las habilita.
• VBA no sustituye a las herramientas modernas cuando el trabajo sale del libro: si necesitas un flujo entre Excel, Outlook y Teams, Power Automate encaja mejor; si el trabajo es analizar datos con pandas, Python en Excel (en Microsoft 365 con la licencia adecuada) es mejor opción; si el trabajo es importar y limpiar archivos, Power Query (integrado desde Excel 2016) hace lo mismo sin una línea de código.

Cuándo tiene sentido salir de VBA

VBA brilla cuando el trabajo está dentro de un libro .xlsx o .xlsm y no necesita internet: dar formato, recorrer hojas, generar informes, copiar datos entre libros abiertos. Cuando el trabajo sale de ahí, VBA se queda corto.

Lo que ya sabes hacer con VBA y tu próximo paso

• Abrir el editor con Alt+F11 y crear un módulo con Insertar > Módulo.
• Escribir una macro que pone texto en una celda y muestra un MsgBox.
• Dar formato a una hoja con .NumberFormat, .Font.Bold y AutoFit.
• Recorrer filas con For…Next y Cells(i, columna).
• Escribir fórmulas con .Formula y .FormulaLocal y saber cuándo usar cada uno.
• Detectar los cuatro errores que más se repiten (1004, subíndice, macro muda, .xlsx).

El siguiente paso natural: convertir el Sub del resumen en una función personalizada (Function en lugar de Sub) para reutilizarla desde cualquier celda de la hoja con =MiResumen(). Así llevas VBA a la cuadrícula, donde viven las fórmulas. La sintaxis es la misma, solo cambia la primera línea: Function MiResumen() As Long en lugar de Sub MiResumen().

Datos comprobados en octubre de 2026.

Dudas al empezar con VBA en Excel