DEV Community

Cover image for Escopo e Shadowing em Go
Renato O da Silva
Renato O da Silva

Posted on

Escopo e Shadowing em Go

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
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
}
Enter fullscreen mode Exit fullscreen mode

O código acima pode ser executado no playground, repare que o retorno será o seguinte:

normalizado: texto para normalizar
Resultado: TEXTO PARA NORMALIZAR
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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) ./...
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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)
}
Enter fullscreen mode Exit fullscreen mode

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
}
Enter fullscreen mode Exit fullscreen mode

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, for e switch.
  • 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 o declared and not used denuncia; quando a variável de dentro é usada, só o analyzer shadow acha.

Referências

Top comments (0)