Al igual que las Colecciones, los diccionarios son un tipo de arreglo que nos permite almacenar todo tipo de variables como números, textos, objetos y combinación de ellas. En este tutorial verás por qué consideramos esta estructura muy útil.

Su forma de trabajo hace que el Dictionary sea muy similar al Collection; sin embargo tienen algunas diferencias en sus estructuras. Aquí te mostramos un resumen con las características de los Diccionarios, Colecciones y Arreglos:

En este tutorial te explicaremos las formas más generales de trabajar con los diccionarios para la cantidad de variables que tú decidas. Existen unos pasos que podríamos omitir cuando tu diccionario almacene sólo una variable, pero nuestra intención es enseñarte todo!.

1. Declaración de diccionarios

Microsoft nos provee dos modalidades para la declaración: Early Binding y Late Binding.

La modalidad Early Binding necesita que actives la referencia “Microsoft Scripting Runtime”, lo cual podría no ser del agrado para algunos usuarios finales de nuestras herramientas, debido a que muchos no estarán familiarizados con VBA.

El Late Binding resulta ventajoso en el sentido de que la declaración la harás directamente en el código, sin labores extras para el usuario final, por ello trabajaremos bajo esta modalidad. La única desventaja de esta opción es que perderás la ayuda de escritura que el código muestra en los procedimientos disponibles, sin embargo con la explicación que te daremos, esa ayuda no sería necesaria 🙂

En este tutorial iremos desarrollando un ejemplo de creación de un diccionario que almacene la información de la nómina de una empresa.

1.2. Declaración del diccionario

La declaración de nuestro diccionario se hace bajo la siguiente estructura:

Set NombreDeDiccionario = CreateObject("Scripting.Dictionary")

Ejemplo de declaración de un diccionario en VBA:

Set Nomina = CreateObject("Scripting.Dictionary")

2. Añadir elementos al Diccionario

En muchas ocasiones necesitaremos añadir elementos al diccionario a partir de la información de una hoja Excel. Al tomar los datos de la hoja de cálculo, debemos definir cuál columna representará nuestro identificador único o Key y cuáles serán las variables agregadas o Ítems que pertenecerán a dicho Key.

Debemos recordar que el Key es un identificador único, así que en este ejemplo el nombre de la persona no sería un buen identificador, ya que en algún momento podría repetirse (en nuestra tabla existen dos personas distintas llamadas Ana). Te sugerimos usar el número de identificación (Columna A en este caso) como Key.

Debemos entonces hacer un recorrido por todas las filas llenas, para lo cual recurrimos a un Loop.

Para evitar errores en nuestra rutina, es conveniente revisar si el Key ha sido previamente utilizado en el diccionario, es decir, debemos verificar si la persona fue previamente registrada. Esto lo podremos hacer siguiendo la estructura:

Dim DeclaraciónVariables As Nombre de módulo de clase
Abrir Loop que barre la columna
Asigna Key  
If (Revisa si el Key ya esté utilizado) Then
  Acción si el Key fue utilizado
Else  (Acción si el Key está libre)  
  Set ObjetoDeClase = New NombreDeModuloDeClase           NombreDeDiccionario.Add Key, ObjetoDeClase(Ítems) o arreglo de items  
End If
ObjetoDeClase.NombreDeItem = CeldaQueContieneEseItem.Value (subItem) 
Cerrar el Loop

2.1. Ejemplo para añadir elementos al Diccionario sin usar módulo de clases

En lugar de un módulo de clases, esta modalidad hace uso de un Array auxiliar para almacenar la información de los ítems. Bajo este concepto, cuando queramos acceder a los elementos del Dictionary debemos hacerlo a través de la posición que cada ítem ocupa en el mismo. En este ejemplo, la primera posición la ocupa el ítem “Person”, la segunda el ítem “Age” y la tercera el elemento “Gen”.

'Declaración de diccionario
Dim key As Variant, listItem() As Variant
Set WorkerList = CreateObject("Scripting.Dictionary")
'-----------------------------------------------------------------------------
'--- Añadir elementos al Diccionario -
i = 2
Do While IsEmpty(ws.Cells(i, 1)) = False '--->Loop through "A" Column
 IDPerson = ws.Cells(i, 1).Value        '--->Key
 '---> Revisa si el key fue añadido al diccionario
 If WorkerList.Exists(IDPerson) = True Then
  MsgBox ("Key " & IDPerson & "is already used")
 Else
 '---> Asigna Items
    ReDim listItem(i - 1, 3)
    listItem(i - 1, 1) = ws.Cells(i, 2).Value '-->Person
    listItem(i - 1, 2) = ws.Cells(i, 3).Value '---> Age
    listItem(i - 1, 3) = ws.Cells(i, 4).Value '---> Gen
    WorkerList.Add IDPerson, listItem
 End If
 i = i + 1
Loop

2.2. Ejemplo para añadir elementos al diccionario con módulo de clases

2.2.1. Creación de módulo de clases

Aunque este paso no es obligatorio, es altamente recomendado para poder tener un mejor tratamiento y manejo de la información en el diccionario. Te recomendamos crear un módulo de clases donde almacenaremos todas las variables que estarán en el diccionario. Para ello haz clic sobre el menú “Insertar” de VBE y selecciona la opción “Módulo de clase”.

Si decides no usar el módulo de clases, tendrás que tener ciertas consideraciones (que aprenderás más adelante) a la hora de acceder al diccionario.

Es buena práctica renombrar el módulo de clases para relacionarlo con el diccionario que crearemos. Para ello debes dirigirte al nombre de la clase y escribir el nombre que desees.  Dado que haremos un diccionario de nómina, le colocaremos “clsNom” (las tres primeras letras para diferenciar nemotécnicamente que es un módulo de clases).

Dentro del módulo de clases declararemos los ítems o variables (según su tipo) con las que trabajaremos en nuestro diccionario, bajo la siguiente estructura:

Option Explicit
Public NombreDeVariable As TipodeVariable

Ejemplo de creación de módulo de clase para un diccionario VBA:

Option Explicit
Public Name As String   'Worker’s name
Public Age As Long      'Worker’s age
Public Gen As String    'Worker’s genre

2.2.2. Añadir elementos al diccionario VBA

Para implementar esta opción, deberás haber creado previamente el módulo de clases. La ventaja de este método es que posteriormente podrás acceder a cada elemento del diccionario solo con conocer su nombre, sin necesidad de conocer su posición.

La información que continua en el tutorial es basada en la estructura del módulo de clases, sin embargo, si tienes dudas con la otra modalidad, no dejes de contactarnos.

Dim key As Variant
Dim oNom As clsNom
'-----------------------------------------------------------------------------
'Declaración de diccionario
Set WorkerList = CreateObject("Scripting.Dictionary")
'-----------------------------------------------------------------------------
'--- Añadir elementos al Diccionario -
i = 2
Do While IsEmpty(ws.Cells(i, 1)) = False '--->Loop through "A" Column
 IDPerson = ws.Cells(i, 1).Value        '--->Key
'---> Revisa si el key fue añadido al diccionario
 If WorkerList.Exists(IDPerson) = True Then
  MsgBox ("Key " & IDPerson & "is already used")
 Else '---> Crea el objeto de clase (ClsNom)
  Set oNom = New clsNom
  WorkerList.Add IDPerson, oNom
 End If
 '---> Asigna Items
 oNom.Name = ws.Cells(i, 2).Value
 oNom.Age = ws.Cells(i, 3).Value
 oNom.Gen = ws.Cells(i, 4).Value
 i = i + 1
Loop

3. Acceder a elementos del diccionario

Al igual que las Colecciones, los diccionarios tienen un excelente desempeño para manejar grandes cantidades de datos que se relacionan con el identificador único (Key). Así, cuando necesitamos acceder a alguna información para luego actualizarla, eliminarla o sencillamente visualizarla, las instrucciones de VBA hacen una búsqueda en el diccionario por Key  o palabra clave.

Para acceder a los elementos del diccionario debemos seguir la siguiente estructura:

Abrir Loop que busca por cada key del diccionario  
With
NombreDeDiccionario(key)   
Acciones  
End With
Cerrar el Loop

Ejemplo para acceder a elementos de un diccionario VBA:

'--- Acceder al diccionario ---
For Each key In WorkerList.Keys '---> Busca en cada elemento del diccionario
With Nomina(key)            '---> Con el Key de objeto de clase: Acciones
  Debug.Print key, .Name, .Age, .Gen'---> Acción: Imprimir Key e ítems
 End With
Next key

4. Modificar el Diccionario

Sabiendo ya como acceder a los elementos del diccionario, para la modificación sólo restaría encontrar la entrada que deseamos modificar y hacer las respectivas acciones. Veamos ejemplos con las dos modificaciones más comunes: Actualización y Eliminación de entradas.

4.1. Actualizar entradas del diccionario

Identificar el key que deseamos modificar
Abrir Loop que busca por cada key del diccionario
Revisar si el key de loop es el que deseamos modificar  
With NombreDeDiccionario(key)   
Acciones sobre el ítem que seleccionamos en el loop  
End With
Cerrar el Loop

Ejemplo para actualizar datos en un diccionario VBA:

Dim ws As Worksheet
Dim i As Long
Dim oNom As clsNom
Dim key As Variant
 
Set ws = DictionaryWS
'-----------------------------------------------------------------------------
'Declaración de diccionario
Set WorkerList = CreateObject("Scripting.Dictionary")
'-----------------------------------------------------------------------------
'--- Añadir elementos al Diccionario -
i = 2
Do While IsEmpty(ws.Cells(i, 1)) = False '--->Recorrido por toda la columna A
 IDPerson = ws.Cells(i, 1).Value        '--->Key
'---> Revisa si el key fue añadido al diccionario
 If WorkerList.Exists(IDPerson) = True Then
  MsgBox ("Key " & IDPerson & "is already used")
 Else                                    '---> Crea Objeto de clase (ClsNom)
  Set oNom = New clsNom
  WorkerList.Add IDPerson, oNom
 End If
' ---> Asigna valores a los Items
 oNom.Name = ws.Cells(i, 2).Value
 oNom.Age = ws.Cells(i, 3).Value
 oNom.Gen = ws.Cells(i, 4).Value
 i = i + 1
Loop
'-----------------------------------------------------------------------------
'--- Actualización de diccionario ---
Query = "ID 09"              '---> Key a modificar
For Each key In WorkerList.Keys
    If key = Query Then     '---> Modifica si ek key es Query
      '---> Modificación de la entrada <---
      With WorkerList(key)
       .Age = .Age + 1 '---> Actualiza la Edad
      End With
    End If
Next key

Si deseamos limpiar o borrar la información de un ítem, debemos asignarle la el valor “Clear” a la entrada. Aquí te mostramos el ejemplo con el elemento “Age” (edad):

.Age = Clear    '---> Actualiza la Edad

4.2. Borrar Entradas del diccionario

Cuando necesitemos eliminar la información de una entrada del diccionario (por ejemplo, cuando la persona deje de prestar servicio en la empresa),  sería una acción similar a borrar una fila de la hoja de Excel:

La estructura es:

Identificar el key que deseamos eliminar 
NombreDeDiccionario.Remove key 

Ejemplo para eliminar entradas de un diccionario VBA:

'--- Borrar key & Items seleccionado ---
Query = "ID 09"              '---> Key a eliminar
For Each key In WorkerList.Keys
    If key = Query Then     '---> Elimina si el key es Query
       WorkerList.Remove key
    End If
Next key

Ahora bien, si lo que deseas es limpiar toda la información del diccionario, puedes utilizar la siguiente instrucción:

NombreDeDiccionario.RemoveAll

Ejemplo para limpiar información de un diccionario VBA:

'--- Borrar todo el diccionario --- 
WorkerList.RemoveAll

Quieres saber mas? Contáctanos...

Cuando desarrollamos códigos en VBA, en muchas ocasiones necesitamos referenciar distintas hojas (worksheets) de un mismo libro (workbook) o de un libro distinto al que contiene las macros para realizar operaciones entre ellas. A continuación te mostramos distintos métodos que podemos usar para hacer dichas referencias. Cada uno de estos métodos puede ser más o menos útil dependiendo de la naturaleza del desarrollo.

Referenciar hojas por su nombre visible

La referencia de las hojas por su nombre visible es muy usada, ya que a todos los que estamos acostumbrados al ambiente Excel nos resulta muy familiar. La debilidad de este método es que el nombre visible de la hoja debe permanecer inalterable para que no se genere un error en tu macro o código VBA.

Suponiendo que queremos referenciar una hoja para su activación, la secuencia de comandos para hacerlo es:

Ejemplo:

Sheets(“Hoja 1”).Activate

Referenciar hojas por su índice o lugar en el libro

Este método aplica cuando se busca referenciar la hoja según el orden de la pestaña que ocupe en el libro de Excel. Así, la primera pestaña tendrá un índice de 1, la segunda un índice de 2 y así sucesivamente. Con este método podrás cambiar el nombre visible de la hoja sin ningún problema, pero el orden o índice de las pestaña u hoja referenciada debe ser siempre el mismo para que el código VBA haga lo que necesitamos.

Siguiendo el mismo ejemplo de activar una determinada hoja, la secuencia de comandos para hacerlo utilizando índices es:

Ejemplo:

Sheets(3).Select

Nótese que en este caso utilizamos la opción .Select, en lugar de .Activate para activar la hoja, pero ambas opciones generan el efecto deseado.

Referenciar hojas por su nombre interno o nombre de código

El nombre visible de las pestañas en Excel no es necesariamente el mismo nombre interno o de código con el que Excel se refiere a las hojas  de trabajo. Para ver y modificar este nombre de código es necesario hacerlo desde el editor de VBA. Como ya te puedes imaginar, es más difícil que usuarios sin conocimientos de VBA tengan acceso a este nombre para modificaarlo, por lo que referencias las hojas de trabajo bajo este método ofrece mayor seguridad y estabilidad del código de nuestra macro, independientemente de si se modifica el nombre visible de la pestaña o su orden en el libro. Por esta razón es nuestra SmartCode Recomendation.

La secuencia de comandos para activar una hoja usando su nombre de código es:

Ejemplo:

Hoja1.Activate

Quieres saber más? Contáctanos...

La selección de Rangos o Select Range  es una actividad muy usada en la programación en VBA. Existen varios métodos muy similares entre sí para la selección de rangos de celdas, te presentaremos los más comunes.

Selección de rangos por referencias

En Excel estamos acostumbrados a referirnos a una celda según aparece por defecto en una hoja de cálculo, es decir, según la letra de la columna y el número de la fila. Si deseamos utilizar esta forma, debemos referirnos al rango con su identificación de columnas y filas tal y como aparecen en la hoja de cálculo separando con dos puntos “:” las celdas de inicio y fin del rango. Aunque no es obligatorio, es buena práctica hacer la referencia a la hoja donde se encuentra el rango que se desea seleccionar. La secuencia de comandos para hacerlo es:

Sheets(“Hoja 2”).Range(“A2:B3”).Select

Selección de rangos en forma matricial

Aunque es similar a la selección de celdas, esta forma es más versátil porque te permitirá moverte entre filas o columnas fácilmente a través de Loops, por ello es nuestra SmartCode Recomendation. Te podrás referir a ella bajo la siguiente estructura:

Donde la referencia a las celdas se debe hacer en forma matricial: Sheets(índice de hoja).Cells(Fila,Columna)

Ejemplo:

Sheets(2).Range(Sheets(3).Cells(2,1),Sheets(3).Cells(3,2)).Select

Quieres saber más? Contáctanos...

Una de las tareas más comunes al trabajar con hojas de cálculo en Excel y VBA es determinar la última celda ocupada en una fila o columna. Esto es útil cuando necesitas escribir datos de manera eficiente, ya que al identificar la última celda con datos, puedes desplazarte fácilmente a la primera celda vacía para ingresar nuevos valores. Este tutorial te ayudará a encontrar la última celda ocupada en Excel utilizando VBA, optimizando tu flujo de trabajo.

Cómo Encontrar la Última Celda Ocupada con un Loop en VBA

Una opción para encontrar la última celda ocupada es utilizando un loop en VBA. Aunque no es la más eficiente en términos de rendimiento, este método te permite recorrer todas las celdas de un rango (ya sea una columna o fila) y verificar si están vacías. A continuación te mostramos un ejemplo de cómo escribir en la primera celda vacía tras identificar la última fila ocupada:

Sub getLastRow()
i = 1
 Do
     If IsEmpty(Cells(i, 1)) = True Then Exit Do
     i = i + 1
 Loop
lastRow = i - 1
Cells(lastRow + 1, 1) = "Primera celda disponible" 
End Sub

Este código recorre la columna A y encuentra la última fila ocupada. Luego, se escribe en la primera celda disponible justo después de la última fila con datos.

También puedes adaptar este método para encontrar la última columna ocupada en una fila específica. A continuación te mostramos cómo hacerlo:

Sub getLastColumn()
 j = 1
 Do
     If IsEmpty(Cells(1, j)) = True Then Exit Do
     j = j + 1
Loop 
lastColumn=j - 1
Cells(1, lastColumn + 1) = "Primera celda disponible" 
End Sub

Método Rápido: Encontrar la Última Celda Ocupada sin Loop

Si prefieres un enfoque más rápido y eficiente en términos de rendimiento, te recomendamos usar el método descrito a continuación. Este método es ideal para encontrar la última celda ocupada en una columna específica o en una fila específica sin necesidad de recorrer todas las celdas con un loop. Aquí te mostramos cómo:

Para encontrar la última fila ocupada en una columna, puedes usar el siguiente código:

Variable = celda(Rows.Count, “Referencia de Columna”).End(xlUp).Row

Este código buscará la última fila ocupada en la columna indicada. A continuación, un ejemplo de cómo implementarlo:

Sub getLastRow()
lastRow = Cells(Rows.Count, "A").End(xlUp).Row
Cells(lastRow + 1, 1) = "Primera celda disponible"
End Sub

De manera similar, si necesitas encontrar la última columna ocupada en una fila específica, puedes usar el siguiente código:

Variable = Cells(Índice de fila, Columns.Count).End(xlToLeft).Column

Este comando devuelve el índice de la última columna ocupada en la fila indicada. Aquí tienes un ejemplo:

Sub getLastColumn()
lastColumn = Cells(1, Columns.Count).End(xlToLeft).Column
Cells(1, lastColumn + 1) = "Primera celda disponible"
End Sub

Este método es ideal para optimizar tu código VBA en Excel y mejorar el rendimiento, especialmente cuando trabajas con hojas de cálculo grandes.

Otros Métodos para Encontrar la Última Celda Ocupada

Existen varios métodos para encontrar la última celda ocupada en Excel utilizando VBA. Además de los métodos mencionados anteriormente, aquí te presentamos dos enfoques adicionales que pueden ser útiles según el contexto:

Uso de UsedRange

El objeto UsedRange te permite obtener el rango de celdas en uso, lo cual es útil cuando necesitas determinar rápidamente el área que contiene datos sin tener que recorrer todas las celdas. Aquí te mostramos cómo encontrar la última fila y columna ocupada:

Sub getLastRowUsedRange()
    Dim lastRow As Long
    lastRow = ActiveSheet.UsedRange.Rows.Count
    MsgBox "La última fila ocupada es: " & lastRow
End Sub

Sub getLastColumnUsedRange()
    Dim lastColumn As Long
    lastColumn = ActiveSheet.UsedRange.Columns.Count
    MsgBox "La última columna ocupada es: " & lastColumn
End Sub

Uso de Find

El método Find es una opción muy rápida para encontrar la última celda ocupada en una fila o columna. Utiliza esta técnica si prefieres una búsqueda precisa y eficiente. A continuación te mostramos un ejemplo para encontrar la última fila ocupada:

Sub getLastRowFind()
    Dim lastRow As Long
    On Error Resume Next
    lastRow = Cells.Find(What:="*", After:=[A1], SearchOrder:=xlByRows, SearchDirection:=xlPrevious).Row
    On Error GoTo 0
    MsgBox "La última fila ocupada es: " & lastRow
End Sub

De manera similar, puedes usar Find para encontrar la última columna ocupada:

Sub getLastColumnFind()
    Dim lastColumn As Long
    On Error Resume Next
    lastColumn = Cells.Find(What:="*", After:=[A1], SearchOrder:=xlByColumns, SearchDirection:=xlPrevious).Column
    On Error GoTo 0
    MsgBox "La última columna ocupada es: " & lastColumn
End Sub

¿Quieres saber más sobre cómo mejorar tu productividad en Excel con VBA? ¡Contáctanos!