Erros no VBA Excel – Tudo que você precisa saber!

agosto 10, 2020 admin 0 comentários

Quer aprender a lidar corretamente com erros no VBA? Então você está no lugar certo!

Não importa o seu nível de experiência com códigos VBA no Excel, os erros sempre farão parte da sua jornada. A diferença entre um programador VBA iniciante e um especialista é que os programadores avançados sabem como lidar com cada tipo de erro.

Neste tutorial, mostraremos várias maneiras de lidar com erros de maneira eficaz no Excel VBA. Confira!

Use o índice abaixo para navegar pelo tópico desejado:

Tipos de Erros de VBA no Excel

Antes de entrarmos no tratamento de erros do VBA, vamos primeiro entender os diferentes tipos de erros que você provavelmente encontrará ao programar no Excel VBA. Basicamente existem quatro tipos de erros no Excel VBA:

Erros de sintaxe
Erros de compilação
Erros de tempo de execução
Erros lógicos

A seguir, descrevemos brevemente quais são esses erros e quando você provavelmente os encontrará.

Erro de sintaxe

Um erro de sintaxe, como o nome sugere, ocorre quando o VBA encontra algo errado com a sintaxe no código.

Por exemplo, se você esquecer uma parte da declaração / sintaxe necessária, verá o erro de compilação.

No código abaixo, assim que pressionamos Enter após a segunda linha, obtemos um erro de compilação. Isso ocorre porque a instrução IF precisa ter o comando ‘Then’, que está ausente no código abaixo.

Importante: Quando você insere um código no Excel VBA, ele verifica cada frase assim que você pressiona Enter. Caso o VBA encontre algo faltando na sintaxe, ele mostrará instantaneamente uma mensagem com algum texto que pode ajudá-lo a entender a parte que está faltando.

Outro detalhe é que para garantir que você veja o erro de sintaxe sempre que algo estiver faltando, verifique se a verificação de sintaxe automática está ativada. Para fazer isso, clique em ‘Ferramentas‘ e, em seguida, clique em ‘Opções‘. Na caixa de diálogo Opções, verifique se a opção ‘Autoverificar sintaxe‘ está ativada.

Se a opção ‘Autoverificar sintaxe’ estiver desativada, o VBA ainda irá destacar a linha com o erro de sintaxe em vermelho, mas não exibirá a caixa de diálogo de erro.

Erro de compilação

Erros de compilação ocorrem quando falta algo necessário para a execução do código. Por exemplo, no código abaixo, assim que tentarmos executar o código, ele mostrará o seguinte erro.Isso acontece porque usamos a instrução IF Then sem fechá-la com o obrigatório ‘End If’.

Dica: Um erro de sintaxe também é um tipo de erro de compilação. Um erro de sintaxe ocorre assim que você pressiona enter e o VBA identifica que algo está faltando. Um erro de compilação também pode ocorrer quando o VBA não encontra nada faltando ao digitar o código, mas ocorre quando o código é compilado ou executado.

Como dito anteriormente, em erros de sintaxe o VBA verifica cada linha enquanto você insere o código e destaca o erro de sintaxe assim que a linha estiver incorreta e você pressionar Enter. Por outro lado, os erros de compilação, são identificados apenas quando o código inteiro é analisado pelo VBA.

Abaixo estão alguns cenários em que você encontrará o erro de compilação:

Quando estiver usando uma instrução IF sem o End IF
Usando a instrução For com a Next
Usando a instrução Select sem usar a End Select
Não declarando a variável (isso funciona apenas quando a opção explícita está ativada)
Chamando uma Sub/Function que não existe (ou com parâmetros incorretos)

Observação sobre ‘Option Explicit’: Quando você adiciona ‘Option Explicit’, você será obrigado a declarar todas as variáveis antes de executar o código. Se houver alguma variável que não tenha sido declarada, o VBA mostrará um erro. Essa é uma boa prática, pois mostra um erro caso você tenha uma variável com erros ortográficos.

Erros de tempo de execução

Erros de tempo de execução são aqueles que ocorrem quando o código está em execução. Os erros em tempo de execução ocorrerão apenas quando todos os erros de sintaxe e compilação estiverem sendo resolvidos.

Por exemplo, se você executar o código que deveria abrir uma pasta de trabalho do Excel, mas essa pasta de trabalho não estiver disponível (excluída ou com outro nome), seu código causaria um erro de tempo de execução.

Quando ocorre um erro em tempo de execução, o VBA interrompe o código e mostra a caixa de diálogo de erro.

A mensagem na caixa de diálogo Erro em tempo de execução é um pouco mais útil. Ela tenta explicar o problema que pode ajudá-lo a corrigi-lo.

Se você clicar no botão Depurar, o VBA irá destacar a parte do código que está levando ao erro.

Caso você tenha corrigido o erro, então poderá clicar no botão Executar na barra de ferramentas (ou pressionar F5) para continuar executando o código de onde saiu. Se preferir, você também pode clicar no botão Fim para sair do código.

Detalhe Importante: Caso você clique no botão Fim na caixa de diálogo, o código será interrompido na linha em que é encontrado o erro. No entanto, todas as linhas anteriores terão sido executadas.

Erros lógicos

Os erros lógicos não interrompem seu código, mas podem levar a resultados incorretos. Esses erros também podem ser os tipos de erros mais difíceis de solucionar pois não são destacados pelo compilador e precisam ser corrigidos manualmente.

Um exemplo de erro lógico é executar um loop infinito.

Outro exemplo pode ser quando fornece um resultado errado. Por exemplo, você pode acabar usando uma variável errada no código ou adicionar duas variáveis em que uma está incorreta.

Existem algumas maneiras de lidar com os erros lógicos:

Insira a caixa de mensagem em algum lugar do código e realce valores / dados que podem ajudar a entender se tudo está indo conforme o esperado.
Em vez de executar o código de uma só vez, passe por cada linha, uma a uma. Para fazer isso, clique em qualquer lugar no código e pressione F8. Você notará que cada vez que você pressiona F8, uma linha é executada. Isso permite que você percorra o código linha a linha e identifique os erros lógicos.

Usando a depuração para encontrar erros de compilação / sintaxe

Depois de concluir o código, é uma boa prática compilá-lo antes de executar.

Para compilar um código, clique na opção Depurar na barra de ferramentas e clique em Compilar VBAProject.

Quando você compila um projeto VBA, ele passa pelo código e identifica erros (se houver). Caso encontre um erro, ele mostrará uma caixa de diálogo com o erro. Encontra erros um por um. Portanto, se ele encontrar um erro e você o corrigiu, será necessário executar a compilação novamente para encontrar outros erros (se houver).

Quando o código estiver livre de erros, a opção Compilar VBAProject ficará acinzentada (sem opção de clique)

Observe que a compilação encontrará apenas erros de ‘sintaxe’ e erros de ‘compilação’. NÃO encontrará os erros de tempo de execução.

Quando você cria um código VBA, obviamente você não deseja que os erros apareçam. E para evitar isso, existem diversos métodos de tratamento de erros que você pode usar. Nas próximas seções deste artigo, abordaremos os métodos que você pode usar para tratar erros no VBA Excel.

Definir configurações de erro (Manipulados x Erros não manipulados)

Antes de começar a trabalhar com seu código, é necessário verificar uma configuração no Excel VBA.

Na barra de ferramentas do VBA, clique em Ferramentas e, em seguida, clique em Opções.

Na caixa de diálogo Opções, clique na guia Geral e verifique se, no grupo ‘Interceptação de erros‘, a opção ‘Interromper em erros não tratados‘ está marcada.

Abaixo temos uma breve explicação das três opções:

Interromper em todos os erros: Essa opção interromperá seu código em todos os tipos de erros, mesmo quando você tiver usado as técnicas para lidar com esses erros.
Interromper em módulo de classe: Essa opção interromperá seu código em todos os erros não tratados e, ao mesmo tempo, se você estiver usando objetos como Userforms, ele também será quebrado nesses objetos e destacará a linha exata que está causando o erro.
Interromper em erros não tratados: Isso interromperá o seu código apenas para os erros que não são tratados. Essa é a configuração padrão, pois garante que quaisquer erros não tratados sejam informados. Se você estiver usando objetos como formas de usuário, isso não destacará a linha que está causando o erro no objeto, mas somente a linha referente a esse objeto.

Observação: Se você trabalha com objetos como Userforms, então pode alterar essa configuração para Interromper em módulo de classe. A diferença entre a segunda e a terceira opção é que, quando você usa o Interromper em módulo de classe, ele o leva para a linha específica no objeto que está causando o erro. Você também pode optar por continuar com isso em vez de ‘Interromper em erros não tratados:

Em resumo: se você está apenas começando com o Excel VBA, verifique se a opção ‘Interromper em erros não tratados‘ está marcada.

Tratando erros no VBA com instruções ‘On Error’

Quando seu código encontra um erro, há algumas coisas que você pode fazer:

Ignore o erro e deixe o código continuar
Tenha um código de tratamento de erros no lugar e execute-o quando ocorrer um erro

Ambos os métodos de tratamento de erros garantem que o usuário final não consiga ver um erro.

Existem algumas instruções ‘On Error’ que você pode usar para fazer isso.

On Error Resume Next

Quando você usa ‘On Error Resume Next‘ no seu código, qualquer erro encontrado será ignorado e o código continuará sendo executado.

Esse método de tratamento de erros é usado com bastante frequência, mas você precisa ser cauteloso ao usá-lo. Como ele ignora completamente qualquer erro que possa ocorrer, talvez você não consiga identificar os erros que precisam ser corrigidos.

Por exemplo, se o código abaixo for executado, ele retornará um erro.

Isso acontece porque você não pode dividir um número por zero.

Mas se eu usarmos a instrução ‘On Error Resume Next‘ neste código (como mostrado abaixo), ela ignorará o erro e não saberemos que há um problema que precisa ser corrigido.

A instrução ‘On Error Resume Next’ deve ser usada apenas quando você souber claramente o tipo de erro que seu código VBA deve mostrar e não há problema em ignorá-lo.

Por exemplo, o código abaixo adiciona a data e hora na célula A2 de uma planilha recém-inserida (esse código é adicionado na planilha e não em um módulo).

Private Sub Workbook_NewSheet(ByVal Sh As Object)
Sh.Range(“A2”) = Format(Now, “dd-mmm-yyyy hh:mm:ss”)
End Sub

Embora isso funcione muito bem na maioria dos casos, o VBA mostrará um erro se adicionarmos uma planilha de gráfico em vez de uma planilha comum. Como uma planilha de gráfico não possui células, o código geraria um erro.

Portanto, se eu usar a instrução ‘On Error Resume Next’ neste código, ela funcionará conforme o esperado com planilhas e não fará nada com planilhas de gráfico.

Private Sub Workbook_NewSheet(ByVal Sh As Object)
On Error Resume Next
Sh.Range(“A2”) = Format(Now, “dd-mmm-yyyy hh:mm:ss”)
End Sub

Note: A declaração ‘On Error Resume Next’ é melhor usada quando você sabe que tipo de erros provavelmente encontrará. E então, se você acha que é seguro ignorar esses erros, você pode usá-lo.

Você pode levar esse código para o próximo nível analisando se houve um erro e exibindo uma mensagem relevante para ele. O exemplo abaixo apresenta um código que mostra uma caixa de mensagem que informará ao usuário que uma planilha não foi inserida.

Private Sub Workbook_NewSheet(ByVal Sh As Object)
On Error Resume Next
Sh.Range(“A2”) = Format(Now, “dd-mmm-yyyy hh:mm:ss”)
If Err.Number <> 0 Then
MsgBox “Parece que você inseriu uma planilha de gráfico” & vbCrLf & “Error – ” & Err.Description
End If
End Sub

‘Err.Number’ é usado para obter o número do erro e ‘Err.Description’ é usado para obter a descrição do erro. (Abordaremos estes mais adiante neste tutorial).

No Error GoTo 0

A instrução ‘On Error GoTo 0‘ irá interromper o código na linha que causa o erro e mostrará uma caixa de mensagem que descreve o erro.

Em termos simples, ele habilita o comportamento de verificação de erro padrão e mostra a mensagem de erro padrão. Então, por que usá-lo?

Normalmente, você não precisa usar ‘On Error Goto 0’, mas pode ser útil quando você o usa em conjunto com ‘On Error Resume Next’

Para melhor compreensão, observe o código abaixo. Ele selecionará todas as células em branco em uma seleção.

Sub SelecionarCelEmBranco()
Selection.SpecialCells(xlCellTypeBlanks).Select
End Sub

No entanto, isso mostrará um erro quando não houver células em branco nas células selecionadas. Portanto, para evitar mostrar o erro, você pode usar a instrução ‘On Error Resume next ‘.

Agora, ele também mostrará qualquer erro ao executar o código abaixo:

Sub SelecionarCelEmBranco()
On Error Resume Next
Selection.SpecialCells(xlCellTypeBlanks).Select
End Sub

O problema surge quando há uma parte do código onde o erro pode ocorrer e, como você está usando ‘On Error Resume Next’, o código simplesmente o ignora e passa para a próxima linha.

Por exemplo, no código abaixo, não haveria prompt de erro:

Sub SelecionarCelEmBranco()
On Error Resume Next
Selection.SpecialCells(xlCellTypeBlanks).Select
‘.. mais código que pode conter o erro
End Sub

Observe que no código acima, há dois lugares onde um erro pode ocorrer. O primeiro lugar é onde estamos selecionando todas as células em branco (usando Selection.SpecialCells) e o segundo está no código restante.

Enquanto o primeiro erro é esperado, qualquer erro depois disso não é. E então é aqui que entra o ‘On Error Goto 0‘.

Ao usá-lo, você redefine a configuração de erro para o padrão, onde começará a mostrar erros quando o encontrar.

Por exemplo, no código abaixo, não haverá erro no caso de não haver células em branco, mas haverá uma mensagem de erro devido a ’30 / 0 ‘

Sub SelecionarCelEmBranco()
On Error Resume Next
Selection.SpecialCells(xlCellTypeBlanks).Select
On Error GoTo 0
y = 30 / 0
End Sub

On Error Goto [Label]

Conforme vimos, os dois métodos acima – ‘On Error Resume Next‘ e ‘On Error Goto 0‘ – não nos permitem realmente lidar com o erro. Enquanto um faz com que o código ignore o erro, o outro o retoma a verificação de erros.

Por outro lado, temos On Error Go [Label] que é uma maneira com a qual você pode especificar o que deseja fazer caso seu código tenha um erro.

Abaixo está a estrutura de código que usa esse manipulador de erros:

Sub Exemplo()
On Error GoTo Label:
X = 10 / 0 ‘esta linha causa um erro
‘…. seu código restante vai aqui
Exit Sub
Label: ‘para lidar com o erro
End Sub

Observe que antes do erro ao manipular ‘Label’, existe um Sub Exit. Isso garante que, caso não haja erros, o sub seja encerrado e o código ‘Label’ não seja executado. Caso você não use o Sub Exit, ele sempre executará o código ‘Label’.

No exemplo abaixo, quando ocorre um erro, o código salta e executa o código na seção do manipulador (e mostra uma caixa de mensagem).

Sub ManipularErro()

On Error GoTo ErroMsg
A = 12
B = 20 / 0
C = 30
Exit Sub
ErroMsg:
MsgBox “Parece haver um erro” & vbCrLf & Err.Description
End Sub

Observe que quando ocorre um erro, o código já foi executado e executado as linhas antes da linha que está causando o erro. No exemplo acima, o código define o valor de A como 12, mas como o erro ocorre na próxima linha, ele não define os valores para B e C.

Depois que o código saltar para o código do manipulador de erros (ErroMsg neste exemplo), ele continuará executando todas as linhas dentro e abaixo do código do manipulador de erros e sair do sub.

On Error Goto -1

On Error Goto -1 é uma instrução para manipulação de erros que pode ser improvável que você o use. Mas mesmo assim vale a pena compreendê-la. (Fique à vontade para ignorar e pular para a próxima seção, se você estiver procurando apenas o básico em tratamento de erros no Excel VBA).

Então, suponha que você tenha um código em que um erro seja encontrado. Até aí tudo bem, pois você possui um manipulador de erros no seu código. Mas o que acontece quando há outro erro no código do manipulador de erros?

Nesse caso, você não pode usar o segundo manipulador, pois o primeiro erro não foi limpo. Portanto, enquanto você lidou com o primeiro erro, na memória do VBA ele ainda existe. E a memória VBA tem apenas um lugar para um erro – não dois ou mais que isso.

Nesse cenário, você pode usar On Error Goto -1, pois ele limpa o erro e libera memória VBA para lidar com o próximo erro. Vamos conferir alguns exemplos para ver como isso funciona na prática:

Suponha que eu tenha o código abaixo. Isso gerará um erro, pois há divisão por zero.

Sub Exemplo()
A = 12
B = 10 / 0
C = 30
End Sub

Então, para lidar com isso, usamos o código de manipulador de erros (com o nome ErroMsg), como mostrado abaixo:

Sub Exemplo()

On Error GoTo ErroMsg
A = 12
B = 10 / 0
C = 30
ErroMsg:
MsgBox “Parece haver um erro” & vbCrLf & Err.Description
End Sub

Até aqui tudo bem! Assim que o erro ocorre, o manipulador de erros é usado e mostra uma caixa de mensagem como mostrado abaixo.

Agora, expanda o código para ter mais código no manipulador de erros ou depois dele.

Sub Exemplo()

On Error GoTo ErroMsg
A = 12
B = 10 / 0
C = 30
Exit Sub

ErroMsg:
MsgBox “Parece haver um erro” & vbCrLf & Err.Description
X = 20 / 2
Y = 40 / 0
End Sub

Como o primeiro erro foi tratado, mas o segundo não, novamente temos um erro como mostrado abaixo.

Como podemos ver, o código está se comportando da maneira que esperávamos. Portanto, para lidar com o segundo erro, podemos outro manipulador de erros (ErroMsg2).

Sub Exemplo()

On Error GoTo ErroMsg
A = 12
B = 10 / 0
C = 30
Exit Sub

ErroMsg:
MsgBox “Parece haver um erro” & vbCrLf & Err.Description
On Error GoTo ErroMsg2
X = 20 / 2
Y = 40 / 0
Exit Sub
ErroMsg2:
MsgBox “Parece haver um erro novamente” & vbCrLf & Err.Description
End Sub

E é aqui que não funciona como esperado.

Se você executar o código acima, ele ainda fornecerá um erro em tempo de execução, mesmo depois de ter o segundo manipulador de erros no lugar. Isso acontece porque não limpamos o primeiro erro da memória do VBA.

E quando o VBA encontra outro erro, ele ainda permanece com o primeiro erro e, portanto, o segundo manipulador de erros não é usado. O código para na linha que causou o erro e mostra o prompt de erro.

Para limpar a memória do VBA e limpar o erro anterior, você precisa usar o ‘On Error Goto -1‘.

Portanto, se você adicionar esta linha no código abaixo e executá-la, ela funcionará conforme o esperado.

Sub Exemplo()

On Error GoTo ErroMsg
A = 12
B = 10 / 0
C = 30
Exit Sub

ErroMsg:
MsgBox “Parece haver um erro” & vbCrLf & Err.Description
On Error GoTo -1
On Error GoTo ErroMsg2
X = 20 / 2
Y = 40 / 0
Exit Sub
ErroMsg2:
MsgBox “Parece haver um erro novamente” & vbCrLf & Err.Description
End Sub

Observação: O erro é limpo automaticamente quando uma sub-rotina termina. Portanto, ‘On Error Goto -1’ pode ser útil quando você está recebendo dois ou mais erros na mesma sub-rotina.

Objeto Err

Sempre que ocorre um erro com um código, é o objeto Err que é usado para obter detalhes sobre o erro (como o número do erro ou a descrição).

Propriedades do objeto Err

O objeto Err tem as seguintes propriedades:

Embora na maioria dos casos você não precise usar o objeto Err, às vezes ele pode ser útil ao lidar com erros no VBA Excel.

Por exemplo, suponha que você tenha um conjunto de dados como mostrado abaixo e para cada número, na seleção, você deseja calcular a raiz quadrada na célula adjacente.

O código abaixo pode fazer isso, mas como há uma sequência de texto na célula A5, ele mostra um erro assim que isso ocorre.

Sub CalculaRaiz()

Dim intervalo As Range
Set intervalo = Selection

For Each cell In intervalo
cell.Offset(0, 1).Value = Sqr(cell.Value)
Next cell
End Sub

O grande problema com esse tipo de mensagem de erro é que ela não informa nada sobre o que de fato deu errado e onde ocorreu o problema.

Deste modo, você pode usar o objeto Err para tornar essas mensagens de erro mais significativas.

Por exemplo, se usarmos o código VBA mostrado abaixo, ele irá interromper o código assim que ocorrer o erro e mostrará uma caixa de mensagem com o endereço da célula onde há um problema.

Sub CalculaRaiz()

Dim intervalo As Range
Set intervalo = Selection

For Each cell In intervalo
On Error GoTo ErrHandler
cell.Offset(0, 1).Value = Sqr(cell.Value)
Next cell

ErrHandler:
MsgBox “Erro número:” & Err.Number & vbCrLf & _
“Descrição do Erro: ” & Err.Description & vbCrLf & _
“Erro em: ” & cell.Address
End Sub

O código acima fornecerá muito mais informações do que uma simples mensagem de ‘Tipo Incompatível’, especialmente o endereço da célula para que você saiba onde ocorreu o erro.

Podemos melhorar ainda mais esse código para garantir a execução do código até o final (em vez de interromper a cada erro) e fornecer uma lista do endereço da célula onde o erro ocorre. Para isto, podemos usar o seguinte código:

Sub CalculaRaiz()

Dim ErroCelulas As String
Dim intervalo As Range

On Error Resume Next
Set intervalo = Selection

For Each cell In intervalo
cell.Offset(0, 1).Value = Sqr(cell.Value)

If Err.Number <> 0 Then
ErroCelulas = ErroCelulas & vbCrLf & cell.Address
On Error GoTo -1
End If
Next cell
MsgBox “Erro nas seguintes células” & ErroCelulas
Exit Sub
End Sub

Note que o código acima executa até o final e fornece a raiz quadrada de todas as células que possuem números (na coluna adjacente). Em seguida, mostra uma mensagem que lista todas as células em que houve um erro (como mostrado na imagem abaixo):

Métodos Objeto Err

Embora as propriedades Err sejam interessantes para exibir informações úteis sobre os erros, também existem dois métodos de Err que podem ajudá-lo no tratamento de erros. São eles:

Abaixo temos uma breve explicação de como eles funcionam e como usá-los para tratamento de Erros no VBA.

Método Err Clear

Suponha que você tenha um conjunto de dados como mostrado na imagem abaixo e deseje obter a raiz quadrada de todos esses números na coluna ao lado.

Ao usar o código abaixo você poderá obter as raízes quadradas de todos os números na coluna ao lado e terá uma mensagem de que ocorreu um erro nas células A5 e A9, pois elas possuem texto.

Sub CalculaRaiz()
Dim ErroCelulas As String
Dim intervalo As Range

On Error Resume Next

Set intervalo = Selection
For Each cell In intervalo
cell.Offset(0, 1).Value = Sqr(cell.Value)

If Err.Number <> 0 Then
ErroCelulas = ErroCelulas & vbCrLf & cell.Address
Err.Clear
End If
Next cell
MsgBox “Erro nas seguintes células” & ErroCelulas

End Sub

Note que usamos o método Err.Clear na instrução If Then.

Após ocorrer um erro, ele é interceptado pela condição If, o método Err.Clear redefine o número do erro para 0, garantindo que a condição If intercepte apenas os erros das células nas quais ele é gerado.

Se não tivéssemos utilizado o método Err.Clear, uma vez que o erro ocorresse, ele sempre seria verdadeiro na condição If e o número do erro não seria redefinido.

Outra maneira de fazer isso é usar o On Error Goto -1, que redefine o erro completamente

Importante: O método Err.Clear é diferente de On Error Goto -1. O método Err.Clear limpa apenas a descrição e o número do erro, ou seja, não o redefine completamente. Isso significa que, se houver outra instância de erro no mesmo código, não será possível lidar com isso antes de redefini-lo (o que pode ser feito com ‘On Error Goto -1’ e não com ‘Err.Clear’).

Método Err Raise

O método Err.Raise possibilita gerar um erro em tempo de execução.

A sintaxe de uso do método Err.Raise é:

Err.Raise [number], [source], [description], [helpfile], [helpcontext]

Todos esses argumentos são opcionais e você pode usá-los para tornar sua mensagem de erro mais significativa.

Esse método pode ser usado quando houver uma instância de erro (o que significa que há um erro de qualquer maneira) e, em seguida, usar esse método para informar ao usuário mais sobre o erro (em vez da mensagem de erro menos útil mostrada pelo VBA por padrão).

Por exemplo, suponha que você tenha um conjunto de dados como mostrado abaixo e que todas as células tenham apenas valores numéricos.

O código abaixo mostrará uma mensagem de erro com a descrição especificada e o arquivo de contexto.

Sub ExemploMetodoRaise()
Dim intervalo As Range
Set intervalo = Selection

On Error GoTo ErrHandler

For Each Cell In intervalo
If Not (IsNumeric(Cell.Value)) Then
Err.Raise vbObjectError + 513, Cell.Address, “Não é um número”, “Teste.docx”
End If
Next Cell

ErrHandler:
MsgBox Err.Description & vbCrLf & Err.HelpFile
End Sub

Se você quiser saber mais sobre o método Err.Raise confira aqui este artigo.

Boas práticas para manipulação de erros do VBA

Conforme dito no início desse artigo, não importa o seu nível de habilidade em desenvolver um código VBA, os erros sempre farão parte do seu trabalho. Isso significa que os melhores codificadores são aqueles que têm as habilidades necessárias para lidar com esses erros corretamente.

E para finalizarmos o assunto, abaixo listamos algumas boas práticas que você pode usar quando se trata de tratar erros no Excel VBA.

Use ‘On Error Go [Label]’ no início do código. Isso garantirá que qualquer erro que possa ocorrer a partir daí seja tratado.
Use ‘On Error Resume Next’ SOMENTE quando tiver certeza dos erros que podem ocorrer. Use-o apenas com o erro esperado. Caso você o utilize com erros inesperados, ele simplesmente o ignorará e seguirá em frente. Você pode usar ‘On Error Resume Next’ com ‘Err.Raise’ se desejar ignorar um certo tipo de erro e capturar o restante.
Ao usar manipuladores de erro, verifique se você está usando o Sub Exit antes dos manipuladores. Isso garantirá que o código do manipulador de erros seja executado apenas quando houver um erro (caso contrário, ele sempre será executado).
Use vários manipuladores de erro para interceptar diferentes tipos de erros. Ter vários manipuladores de erros garante que um erro seja tratado adequadamente. Por exemplo, você deseja lidar com um erro de ‘Tipo Incompatível’ diferente de um erro de tempo de execução ‘Divisão por 0’.

Confira também as seguintes dicas de Excel:

E então, o que achou do tutorial sobre tratamento de erros no VBA? Ficou com alguma dúvida? Deixe o seu comentário abaixo e continue acompanhando nossas dicas de Excel e VBA aqui no nosso site!