Hoje eu vou falar de duas coisas importantes em Go que são Escopo e Shadowing. Apesar de ser algo simples de entender, muitas vezes por descuido podemos introduzir bugs que podem afetar a aplicação em tempo de execução. Então vamos ao que interessa.
Escopo
O escopo de um nome é o trecho de código em que aquele nome exista e se refere a uma determinada variável, tipo ou função. Fora do escopo, o nome não existe. Então o compilador pode responder com undefined.
Go possui escopo léxico e por blocos. Onde léxico quer dizer que conseguimos identificar o escopo apenas fazendo a leitura do código, mesmo sem executar nada. E quando nos referimos aos blocos, é porque ele vem acompanhado de chaves {}. Na prática isso quer dizer que uma variável declarada dentro de um bloco vale do ponto de declaração até o fim daquele bloco.
Através do escopo conseguimos criar um isolamento, permitindo que uma variável que foi criada dentro de um if exista apenas naquele bloco, evitando que ela exista no restante da função, onde ela não terá utilidade.
Níveis de escopo
Basicamente temos 4 níveis de escopo, sendo eles:
| Nível | Onde o nome vale | O que vive nele |
|---|---|---|
| Universo | Todo o programa | Nomes pré-declarados: int, string, error, true, false, nil, len, append, make e etc |
| Pacote | Todos os arquivos de pacote | O que é declarado fora de qualquer função (const, type, var, func), em qualquer arquivo do pacote e em qualquer posição |
| Arquivo | Só no arquivo | Os nomes dos pacotes importados |
| Bloco | Dentro de {} | Variáveis locais e parâmetros |
Abaixo segue um exemplo para demonstrar o que foi dito:
package myapp // nível de pacote import "fmt" // nível de arquivo: fmt vale só aqui var Total int // nível de pacote: vale em todos os arquivos do pacote func Process() { x := 1 // nível de bloco da função if true { y := 2 // nível de bloco do if fmt.Println(x, y) } // y não existe mais } Os blocos implícitos de if, for e switch
Em Go podemos declarar uma variável no momento que estamos fazendo uma comparação, isso é bem útil quando queremos testar o conteúdo retornado e fazer algo. Essa variável criada fica dentro de um bloco implícito, ou seja, um bloco sem chaves que envolve o comando inteiro.
No if
O if tem dois níveis de bloco: as chaves que você vê (o corpo do if e do else) e o bloco implícito em volta de tudo. Abaixo temos um exemplo:
// ┌ bloco implícito: envolve o if inteiro if y := 2; y > 5 { // y é declarado aqui, no bloco implícito fmt.Println("maior", y) // bloco das chaves do if } else { fmt.Println("menor ou igual", y) // bloco das chaves do else } // └ fim do bloco implícito fmt.Println(y) // erro O exemplo acima nos mostra que y não pertence ao bloco do if e nem do else, mas sim ao bloco implícito que envolve os dois. Então a variável vale nos dois ramos. Por isso quando tentamos usar a variável y fora do bloco implícito ele emite um erro undefined: y.
E por fim temos mais um detalhe, se a variável y pertencesse apenas ao bloco do if, o bloco do else não teria acesso e emitiria um erro.
No for
A variável do cabeçalho do for existe durante o loop e some depois dele. Abaixo um exemplo:
for i := 0; i < 3; i++ { fmt.Println(i) } fmt.Println(i) // undefined: i No switch
O switch tem uma camada a mais, pois a variável do cabeçalho existe em todos os cases. Cada case é um bloco implícito próprio, mesmo sem as chaves. Abaixo um exemplo:
switch n := len("gopher"); n { case 6: msg := "seis letras" fmt.Println(n, msg) // 6 seis letras default: fmt.Println(n, msg) // undefined: msg } fmt.Println(n) // undefined: n A variável n vale nos dois case, mas a variável msg só existe no case 6, porque foi declarado no bloco desse case. Depois do switch, a variável n não existe mais.
Shadowing
O shadowing ocorre quando um bloco interno declara um nome igual ao de um bloco externo. Então essa nova variável passa a fazer "sombra" sobre a variável que foi declarada externamente. O código abaixo mostra isso:
x := 1 if true { x := 2 // cria um x NOVO, que esconde o de fora fmt.Println(x) // imprime o valor 2 } fmt.Println(x) // imprime o valor 1 Então precisamos prestar atenção se iremos usar := ou = na hora da atribuição da variável, pois o := declara uma variável. O exemplo abaixo mostra como o exemplo acima ficaria:
x := 1 if true { x = 2 // Altera o valor de x fmt.Println(x) // imprime o valor 2 } fmt.Println(x) // imprime o valor 2 O exemplo acima é bem simples, então vamos imaginar um exemplo que também é simples, mas um pouco mais elaborado. Imagine que queremos processar um texto recebido e alterar o valor dele para letras minúsculas. Ex.:
package main import ( "errors" "fmt" "strings" ) func main() { result, err := process("TEXTO PARA NORMALIZAR", true) if err != nil { fmt.Println(err.Error()) } fmt.Println("Resultado:", result) } func process(input string, shouldNormalize bool) (string, error) { result := input if shouldNormalize { result, err := normalize(result) if err != nil { return "", errors.New("não foi possível normalizar o texto") } fmt.Println("normalizado: ", result) } return result, nil } func normalize(input string) (string, error) { if input == "" { return "", errors.New("é necessário um texto para normalizar") } return strings.ToLower(input), nil } O código acima pode ser executado no playground, repare que o retorno será o seguinte:
normalizado: texto para normalizar Resultado: TEXTO PARA NORMALIZAR Note que apesar de ter impresso que o texto foi normalizado, ao imprimirmos o resultado ele sai de forma diferente. Então temos um resultado errado em tempo de execução, e isso ocorreu por conta do shadowing, onde utilizamos o mesmo nome da variável do bloco externo, dentro do bloco interno.
Então podemos nos perguntar, porque o Go deixou isso acontecer? Porque isso não necessariamente é um bug, depende muito da intenção do desenvolvedor. Se removermos a linha onde fazemos a impressão do texto normalizado, você vai reparar que o Go reclama que variável foi criada, mas não foi utilizada. Gerando o erro abaixo:
declared and not used: result Então como podemos saber se estamos fazendo shadowing? Isso será respondido na próxima seção.
Como verificamos o shadowing?
Para analisarmos o código e descobrir se fizemos shadowing, devemos instalar analyzer shadow que nos auxilia nessa tarefa:
go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow@latest go vet -vettool=$(which shadow) ./... Após executar o comando acima, o retorno será parecido com o debaixo, mas podendo variar a linha:
main.go:19:3: declaration of "result" shadows declaration at line 17 E como corrigimos nosso código?
O jeito mais simples é mudar o nome da variável e depois atribuir a variável criada a variável de resultado, conforme código abaixo:
if shouldNormalize { normalized, err := normalize(input) if err != nil { return "", errors.New("não foi possível normalizar o texto") } result = normalized // = altera o result de fora fmt.Println("normalizado:", result) } O código completo pode ser encontrado no playground. Lembrando que existem outras formas de corrigir esse problema.
Quando o shadowing é aceitável
Shadowing não é sempre um bug. O caso mais comum e idiomático é o err de vida curta no cabeçalho de um if:
if err := save(user); err != nil { return err } Esse err vive só dentro do if e não esconde nada que importe depois. Mesmo quando já existe um err mais acima na função, o shadow no modo padrão não reclama, desde que o err de fora não seja usado depois do if. Com a flag -strict, ele passa a apontar também esse caso.
Então podemos dizer que o shadowing vira bug quando você queria alterar a variável de fora e escreveu := no lugar de =.
Resumindo
- Escopo é onde um nome existe. Em Go ele é léxico e acompanha os blocos, inclusive os implícitos de
if,foreswitch. - Shadowing é um nome interno escondendo um externo. É legal, e o compilador não avisa.
- O bug clássico é um
:=dentro de um bloco quando a intenção era=. Às vezes odeclared and not useddenuncia; quando a variável de dentro é usada, só o analyzershadowacha.
