Desvendando os mistérios dos erros em Ruby: Um Guia para Iniciantes
Tags: ruby, programming, beginners, coding
Published: 2024-01-30 16:20:29

[EN-US version](https://dev.to/dedemenezes_/embracing-error-messages-in-ruby-a-guide-for-beginners-1996)


Celebrar mensagens de erro pode parecer estranho para muitos, mas no universo da programação, elas são como pistas para desvendar enigmas. Neste artigo, vamos explorar por que os programadores apreciam essas mensagens, como elas podem ser valiosas e, mais importante, como interpretá-las para aprimorar suas habilidades em Ruby.

<figure class="image">
  <img src="https://dev-to-uploads.s3.amazonaws.com/uploads/articles/of153dkyjgc09v2ycy0t.jpg" alt="Desenvolvedor comemora nova mensagem de erro" style="margin-bottom: 0;">
  <figcaption>Desenvolvedor comemora nova mensagem de erro</figcaption>
</figure>

Embora pareça piada, é assim, como na imagem, que muitos programadores se sentem por trás de cada mensagem de erro obtida, pois sabem que há uma oportunidade de aprendizado. Entender essas mensagens torna-se crucial antes de pensar em correções, e mesmo que no início olhar para o terminal possa parecer chato, a recompensa do entendimento faz valer a pena.

### Exemplo prático

Vamos olhar para esse simples script:

```ruby
# /home/***/***/dedemenezes/dedev-lab-blog/ruby_errors.rb

def cumprimentar(nome)
  puts "Olá, #{name}! Toca ai!\nzo/"
end

cumprimentar('Matsumoto')
```

Nele definimos um método `#cumprimentar` e chamamos esse método no final do arquivo. Ao executarmos o script acima, `ruby ruby_errors.rb`, recebemos a seguinte mensagem de erro ⤵️

```zsh
ruby_errors.rb:2:in `cumprimentar': undefined local variable or method `name' for main:Object (NameError)
Did you mean?  nome
        from ruby_errors.rb:5:in `<main>'
```


### Desmistificando as Mensagens de Erro

Mensagens de erro são verdadeiros guias no caminho da programação, e seu melhor amigo/a/x. Elas contêm informações cruciais como o nome do erro (tipo), uma descrição do problema e o local exato onde o erro ocorreu (nome do arquivo e linha). Aprender a lê-las vai te ensinar muito, ACREDITE! Vejamos abaixo um padrão no formato de como as mensagens são exibidas e entender cada parte:

```shell
[nome_do_arquivo.rb]:[LINHA]: in `[CONTEXTO]`: [DESCRIÇÃO] for [CONTEXTO]:[OBJETO] ([TIPO DO ERRO])
[RASTRAMENTO...]
```

- **[nome_do_arquivo.rb]:** Indica o nome do arquivo Ruby onde o erro foi detectado. Exemplo: `ruby_erros.rb`

- **[LINHA]:** Representa a linha específica no arquivo onde o erro ocorreu. Exemplo: `2`

- *in* **[CONTEXTO]:** Refere-se ao contexto do erro, geralmente indicando o método ou bloco de código onde o problema foi identificado. Exemplo: `in 'my_method'`

- **[DESCRIÇÃO]:** Fornece uma descrição do tipo de erro encontrado. Exemplo: `undefined local variable or method 'name'`

- *for* **[CONTEXTO]:[OBJETO]:** Indica o contexto e o objeto associado ao erro, ajudando a entender melhor o problema. Exemplo: `for main:Object`

- **[STACKTRACE]:** Refere-se ao stack trace (rastreamento de pilha), que mostra a sequência de chamadas de métodos até o ponto onde o erro ocorreu. Exemplo: `from ruby_errors.rb:5:in '<main>'`

O primeiro passo é ler, **calmamente**, a mensagem de erro. Observar o arquivo e a linha onde o erro ocorreu proporciona contexto. A descrição do erro é como um mapa indicando o problema. Após a leitura, podemos voltar diretamente para a linha do erro ou buscar entender o erro. Sempre vai ser **melhor entender o erro** do que *procurar alguma solução* no seu buscador favorito. Os erros vão te ensinar **MUITO**, acredita!

Nesse caso, observamos que o erro *explodiu* no arquivo `ruby_errors.rb`, na linha `2`, dentro (no contexto) do método `cumprimentar`, com a descrição de `undefined local variable or method...`. Abaixo da sugestão do Ruby *DidYouMean*, visualizamos o rastreamento de pilha, que mostra o caminho do programa até o erro, `from ruby_errors.rb:5:in '<main>'`.


### Entendendo o Stacktrace

O stacktrace, ou rastreamento de pilha, revela a sequência de execução do código, mostrando a hierarquia de chamadas de método. Entender isso pode ser crucial para identificar a origem de um erro em aplicações maiores. O stacktrace vai nos ajudar a compreender a trajetória do código. 

No nosso exemplo, dentro do arquivo `ruby_errors.rb`, definimos o método `#cumprimentar` (linhas 1 à 3). Na linha 5, chamamos o método `cumprimentar('Matsumoto')`. Seguindo a mensagem de erro podemos ver/aprender como Ruby executa um script. 

Ao encontrar uma definição de método Ruby guarda o mesmo em memória mas **não executa nada até o método ser chamado**, o que só acontece na linha 5. Por isso temos `from ruby_errors.rb:5` no rastreamento mas o erro **propriamente dito**, só foi encontrado **dentro** do método, na linha 2 `ruby_errors.rb:2:in [...]`

### Conclusão

Na próxima vez que se deparar com uma mensagem de erro em Ruby, lembre-se de comemorar. Ela é uma aliada valiosa na jornada da programação, oferecendo insights que podem transformar desafios em oportunidades de aprendizado. Lembre-se das boas práticas, analise as mensagens com cuidado e, antes que perceba, você estará desvendando os mistérios dos erros em Ruby com confiança.