Dim en VBA: qué es y cómo declarar variables en Excel

Las macros de Excel se escriben en VBA, un lenguaje que vive dentro del propio libro. Antes de usarla, cada variable se "declara" con la instrucción Dim: una línea que le dice a Excel qué tipo de dato va a guardar (un número, un texto, una hoja, un rango) y cuánta memoria reservar. Al terminar este tutorial sabrás declarar variables en cualquier macro, activar Option Explicit para que el editor te avise de los errores y combinar Dim con Set para trabajar con hojas y rangos. Funciona en Excel 2007, 2010, 2013, 2016, 2019, 2021, 2024 y Microsoft 365, en Windows y en Mac; Excel para la web no ejecuta macros VBA, así que allí este tutorial no aplica.

Qué es Dim y por qué aparece en todas las macros de Excel

La palabra Dim viene de "Dimension" (dimensión) y es la forma que tiene VBA de avisarle del laboratorio: "voy a usar esto, resérvame sitio". Cada vez que una macro guarda un número para recorrer filas, un nombre de hoja para luego activarla o un rango para copiarlo, ese dato vive en una variable, y la variable se declara con Dim.

Imagina la macro más típica: la que recorre una hoja de ventas fila a fila y va calculando el importe de cada línea. La primera línea de esa macro, casi siempre, es Dim i As Long. Esa línea reserva cuatro bytes en memoria para un número entero largo llamado i. A partir de ahí, el bucle For i = 2 To 11 lo va cambiando de valor y Cells(i, 5).Value lo usa para escribir el resultado en la columna E.

Sin Dim, VBA también acepta variables (se llaman Variant y pueden guardar cualquier cosa), pero pierdes dos ventajas. Una, el editor no te ayuda con IntelliSense: al escribir i. no te sugiere nada. Y dos, un número guardado como Variant ocupa más memoria y se procesa más lento que guardado como Long. Por eso toda macro profesional empieza declarando.

La sintaxis de Dim, pieza por pieza

La forma general es:

Dim [WithEvents] nombre [(subíndices)] [As [New] tipo] [, …]

Cada parte tiene su cometido. Lo que va entre corchetes es opcional; lo demás, obligatorio. Vamos pieza por pieza.

nombre: cómo se llama la variable y dónde se ve

El nombre es lo que escribes para referirte a la variable después. VBA lo trata como un identificador, y como todos los lenguajes tiene las suyas:

• No puede tener espacios ni guiones; solo letras, números y el guion bajo.
• No puede empezar por un número: 2fila no vale, fila2 sí.
• No se usan tildes ni eñes: Importe mejor que Importeñor.
• No es una palabra reservada del lenguaje: no puedes llamar Dim a una variable.

Por convención, las macros profesionales usan prefijos para recordar el tipo de un vistazo: i o l para enteros largos (Integer, Long), s para textos (String), d para fechas (Date), rng para rangos (Range), ws para hojas, wb para libros. Así, rngOrigen se lee solo: un rango que sirve como punto de partida.

As tipo: el tipo de dato que Excel reservará

La parte As tipo es la más importante: le dice a VBA qué clase de valor va a guardar esa variable y cuánta memoria reservar. Esta tabla resume los tipos que verás en el 90 % de las macros:

WithEvents y New: dos modificadores opcionales

WithEvents solo se usa dentro de un módulo de clase y permite que la variable responda a eventos del objeto (por ejemplo, que una hoja ejecute código al cambiar). En una macro normal, en un módulo estándar, no lo verás nunca.

New crea el objeto la primera vez que se usa la variable, sin necesidad de una línea Set aparte. Por ejemplo, Dim coll As New Collection ya deja la colección lista para coll.Add .... New no es válido con WithEvents ni con tipos intrínsecos como Long o String.

Los paréntesis: declarar matrices estáticas o dinámicas

Los paréntesis en Dim declaran una matriz (array). Con números concretos defines el tamaño fijo: Dim arr(1 To 6) As Long crea seis posiciones numeradas del 1 al 6. Con paréntesis vacíos declaras una matriz dinámica: Dim arr() As Long, y luego ReDim arr(1 To n) cuando sepas cuántas posiciones hacen falta.

VBA admite hasta 60 dimensiones en una matriz, aunque más de tres es raro en macros normales. La instrucción Option Base 0 o Option Base 1, puesta al principio del módulo, cambia el límite inferior por defecto: con Option Base 1, Dim arr(5) crea seis posiciones (1 a 6) y no cinco (0 a 5).

Dónde se coloca Dim y cómo se activa Option Explicit

Dim se escribe al principio del bloque donde vive la variable: dentro de un Sub, dentro de un Function o, si la variable se ve desde varios Sub, en la cabecera del módulo. Cada Dim vale desde donde está hasta el final de su bloque.

La mejor red de seguridad es Option Explicit, una línea que se coloca arriba del todo de cada módulo y obliga a declarar todas las variables. Si no declaras una y la usas, el editor la marca en rojo y la macro no compila. Para que aparezca sola en cada módulo nuevo, hay que activar un ajuste.

Pasos para abrir el editor y configurar Option Explicit:

1. Pulsa Alt+F11 para abrir el editor de Visual Basic.
2. En la ventana que aparece, elige Insertar > Módulo para crear un módulo nuevo (verás una hoja en blanco a la derecha).
3. Vuelve al menú principal y entra en Herramientas > Opciones del editor (o Herramientas > Opciones > Editor según la versión).
4. Marca la casilla Requerir declaración de variables.
5. Pulsa Aceptar.

A partir de ahora, cada módulo nuevo empezará con Option Explicit arriba del todo.

Tu primera macro con Dim: recorrer una hoja y sumar importes

El libro que usaremos se llama Ventas y tiene una hoja llamada Enero con las ventas de una semana: fechas en A, producto en B, cantidad en D y precio unitario en E. La macro va a rellenar la columna F con la multiplicación de cantidad por precio, fila a fila.

Pasos para crear la macro que rellena la columna F:

1. En el editor (Alt+F11), en el módulo recién creado, escribe Option Explicit en la primera línea si no está.
2. Escribe este bloque:

Option Explicit

Sub RellenarImportes()
    Dim i As Long
    For i = 2 To 11
        Cells(i, 6).Formula = "=RC[-2]*RC[-1]"
    Next i
End Sub

1. Coloca el cursor dentro del Sub y pulsa F5 para ejecutar.

Declarar i como Long y otros como Integer

Long ocupa cuatro bytes y llega hasta ±2.147.483.647, más que suficiente para cualquier hoja de Excel (que tiene 1.048.576 filas). Integer, en cambio, llega solo hasta 32.767, y basta con que una macro recorra 33.000 filas para que el contador se desborde. Microsoft recomienda Long como tipo por defecto para enteros, y por eso las macros profesionales declaran i As Long casi siempre.

Escribir el resultado con .Formula o .Value

Hay dos formas de poner el importe en F, y se comportan distinto:

• Cells(i, 6).Formula = "=RC[-2]*RC[-1]" escribe una fórmula de verdad en la celda, en notación R1C1. Si cambia D o E, F se recalcula solo. La fórmula está en inglés con comas porque .Formula siempre va en inglés.
• Cells(i, 6).Value = Cells(i, 4).Value * Cells(i, 5).Value escribe solo el número ya calculado. No hay fórmula, y si cambia un precio, F se queda con el valor antiguo hasta que vuelvas a ejecutar la macro.

Trabajar con objetos: Dim más Set

Los objetos (libros, hojas, rangos) no se guardan en ella con un valor que se copia, sino con una referencia que apunta al objeto real. Por eso Dim solo no basta: hace falta una segunda línea con Set que diga "esta variable apunta ahí".

La macro siguiente abre un libro nuevo, copia el rango B2:B11 de la hoja Enero y lo pega en la hoja Comentarios del libro nuevo:

Option Explicit

Sub CopiarAOtroLibro()
    Dim wbNuevo As Workbook
    Dim wsOrigen As Worksheet
    Dim rngDatos As Range

    Set wbNuevo = Workbooks.Add
    Set wsOrigen = ThisWorkbook.Worksheets("Enero")
    Set rngDatos = wsOrigen.Range("B2:B11")

    rngDatos.Copy wbNuevo.Worksheets(1).Range("A1")

    MsgBox "Copiado en: " & wbNuevo.Name
End Sub

Pasos para probarla:

1. Pulsa Alt+F11 y abre el módulo.
2. Pega el código de arriba.
3. Coloca el cursor dentro del Sub y pulsa F5.
4. Aparece un libro nuevo con los productos en su primera columna, y un cuadro de mensaje con el nombre del libro creado.

Dim rng As Range con Set explícito

Sin Set, la línea rngDatos = wsOrigen.Range("B2:B11") da el error de compilación "Objeto requerido". Esto pasa porque un rango no es un valor que se copia, sino un puntero al objeto real de la hoja. Set es lo que ata la variable al objeto: sin él, VBA no sabe qué hacer con la dirección.

Si olvidas el Set y la macro se compila igual porque la variable es Variant, la variable contiene Nothing y el siguiente rngDatos.Copy fallará con "Variable de objeto o bloque With no establecido".

Dim coll As New Collection frente a Set coll = New Collection

Las dos formas son válidas y hacen lo mismo: crear una colección vacía lista para añadir elementos.

' Forma 1: con New en la declaración
Dim coll1 As New Collection
coll1.Add "Primero"

' Forma 2: con Set y New en líneas distintas
Dim coll2 As Collection
Set coll2 = New Collection
coll2.Add "Segundo"

La primera es más corta, pero tiene un matiz: VBA crea el objeto cada vez que la variable se usa después de un Set coll1 = Nothing. La segunda es más explícita y muchos programadores la prefieren porque deja claro cuándo nace el objeto.

Las tres formas de Dim que más se ven (y los errores que esconden)

Hay tres formas de declarar que se ven constantemente en código copiado de internet, y una de ellas esconde una trampa que pasa incluso a programadores con experiencia.

Declarar varias variables en una sola línea

Se pueden poner varias variables en la misma línea Dim, pero VBA repite el As tipo solo para la última:

' Bien: las tres son Long
Dim a As Long, b As Long, c As Long

' Mal: a y b son Variant, solo c es Long
Dim a, b, c As Long

Esto es un clásico de las preguntas en foros. La segunda línea parece prometer que las tres son Long, pero VBA solo aplica As Long a c. Si Option Explicit está activado, la macro compila; si está desactivado, también, y el error salta mucho después, en tiempo de ejecución, cuando una operación con Variant falla.

Asignar valor en la misma línea que Dim

Dim no deja asignar en la misma línea que VBA. Esto no funciona:

' No compila: 'Se esperaba: ='
Dim n As Long = 6

' Correcto: con dos puntos
Dim n As Long: n = 6

Los dos puntos (:) sirven para poner dos sentencias en la misma línea. Es la forma que se ve en código compacto.

Por qué tu macro falla: errores típicos con Dim

Estos son los cuatro errores que más se repiten cuando se empieza con Dim. Cada uno tiene una causa clara y un arreglo concreto.

El error 13: Type Mismatch

El error 13 (Type Mismatch, "No coinciden los tipos") significa que intentaste guardar en una variable un valor de otro tipo. El ejemplo más claro:

Option Explicit

Sub TestError13()
Dim edad As Integer
edad = "treinta"
End Sub

La variable edad es Integer (un número), pero le intentas meter un texto. VBA lanza el error 13 y la macro se para.

Para detectar estos errores sobre la marcha, abre la ventana Inmediato con Ctrl+G desde el editor y usa Debug.Print variable para ver su valor mientras la macro corre.

Option Explicit como red de seguridad

Option Explicit evita la mitad de los errores de Dim. Si activas Requerir declaración de variables (Herramientas > Opciones > Editor), cada módulo nuevo empieza con esa línea arriba, y cualquier variable mal escrita se marca en rojo antes de ejecutar.

Pasos para verlo en acción:

1. En el editor, abre Herramientas > Opciones > Editor y marca Requerir declaración de variables.
2. Inserta un módulo nuevo con Insertar > Módulo.
3. Escribe este código:

Option Explicit

Sub TestOptionExplicit()
Dim contador As Integer
contador = 5
MsgBox contar
End Sub

1. La línea MsgBox.contar aparece en rojo porque contar (sin la d) no está declarada.

Los otros dos errores típicos son bucles infinitos (suele ser porque el contador del For no es Long y se desborda, o porque Next i no avanza) y variables que quedan vacías (un Long declarado vale 0, pero un Variant declarado vale Empty, y hay que inicializarlo).

Lo que Dim no hace (y qué usar en su lugar)

Dim tiene un perímetro claro, y conocerlo evita sorpresas:

• No inicializa variables salvo los numéricos a 0 y los String a "" de longitud cero. Una variable Date declarada con Dim vale 00:00:00, y una variable Object vale Nothing. Si necesitas otro valor inicial, asigna con una segunda línea.
• No sirve para declarar constantes. Para eso existe Const: Const IVA As Double = 0.21.
• No declara funciones. Para eso se usa Function Nombre() As Tipo y luego End Function.
• No comparte variables entre macros por arte de magia. Sin Public o Private, una variable Dim vive solo dentro del Sub donde está; para que se vea desde otros módulos, declárala con Public en la cabecera de un módulo.
• No vale en Excel para la web. Allí las macros VBA no se ejecutan: se usa Office Scripts, que tiene otra sintaxis.

Lo que ya sabes hacer con Dim y el siguiente paso

Seis ideas para llevar encima cada vez que escribas Dim:

• Declara siempre todas las variables: el coste es una línea y el ahorro, errores evitados.
• Usa Long para enteros: aguanta hojas grandes y no se desborda.
• Prefija el nombre con la inicial del tipo: i, s, d, rng, ws, wb.
• Activa Option Explicit: una marca en Herramientas > Opciones > Editor y los errores saltan a la vista.
• Recuerda Set para objetos: sin Set, los objetos no apuntan a nada.
• Usa paréntesis solo para matrices: Dim arr() As Long luego se dimensiona con ReDim.

El siguiente paso natural es escribir tu primer Sub con parámetros: Sub MiMacro(nombre As String, cantidad As Long) te permite llamar a la macro desde un botón con valores distintos cada vez. Ahí es donde Dim empieza a ser rentable de verdad.

Datos comprobados en octubre de 2026.

Dudas al usar Dim en VBA