Que conceito é implementado com a construção defer na linguagem Go?

A construção defer implementa o conceito de execução diferida de funções. A função diferida é executada imediatamente antes de a função que a contém terminar.

Pontos-chave:

• Momento de execução: A função diferida é executada no final da função pai, mesmo que ocorra um pânico ou exceção.
• Pilha: As chamadas diferidas formam uma pilha. A última chamada diferida será executada primeiro (LIFO).
• Captura de variáveis: Os argumentos da função diferida são avaliados no momento da declaração de defer, não no momento da execução.

Exemplos de uso típico:

• Fechar arquivos, conexões de rede, mutexes.
• Restaurar o estado (por exemplo, após alterar variáveis globais ou flags).
• Medir o tempo de execução.

// Exemplo de uso de defer para fechar um arquivo
func readFile(filename string) error {
	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	defer f.Close() // O arquivo será fechado antes de sair da função

	// Leitura do arquivo...
	return nil
}

// Exemplo de pilha de chamadas defer
func process() {
	defer fmt.Println("Primeiro na pilha")
	defer fmt.Println("Segundo na pilha")
	defer fmt.Println("Terceiro na pilha") // Será executado por último

	fmt.Println("Processando...")
}

Chamadas diferidas com argumentos:

// Exemplo de captura do valor de uma variável no momento da declaração de defer
func demonstrateDeferArgEval() {
	i := 0
	defer fmt.Println("Valor de i em defer:", i) // i será 0

	i++
	fmt.Println("Valor de i após incremento:", i) // i será 1
}