Type Switch

Parte da seção Lógica & Fluxo do Journey de GO da Coddy. Lição 18 de 68.

Embora as asserções de tipo funcionem bem para verificar um único tipo, muitas vezes você precisa lidar com vários tipos possíveis para uma variável de interface. É aí que um type switch se torna extremamente útil — ele oferece uma maneira simples de executar ações diferentes com base no tipo concreto.

Uma chave de tipo usa esta sintaxe especial: switch v := i.(type). Observe a palavra-chave (type) em vez de um tipo específico. A variável v conterá o valor real com seu tipo concreto em cada caso:

func describe(data interface{}) {
    switch v := data.(type) {
    case int:
        fmt.Printf("Integer: %d\n", v)
    case string:
        fmt.Printf("String: %s\n", v)
    case bool:
        fmt.Printf("Boolean: %t\n", v)
    default:
        fmt.Printf("Unknown type: %T\n", v)
    }
}

Em cada caso, v tem automaticamente o tipo correto — não é necessária nenhuma asserção de tipo adicional. Isso torna as instruções switch de tipo muito mais simples do que encadear várias asserções de tipo com instruções if-else, especialmente quando você precisa lidar com vários tipos diferentes em um só lugar.

Desafio

Fácil

Neste desafio, você praticará o uso de alternâncias de tipos para lidar com vários tipos de dados em um sistema de notificações. Você criará uma função que processa diferentes tipos de notificações e as formata adequadamente com base em seu tipo concreto.

Você receberá duas entradas:

Uma string que representa o tipo de notificação (por exemplo, "email", "sms", "push" ou "alert")
Uma string que representa o conteúdo ou o valor da notificação

Sua tarefa é:

Criar uma função chamada processNotification que recebe um parâmetro interface{}
Com base na entrada que indica o tipo de notificação, converter o conteúdo para o tipo Go apropriado e armazená-lo em uma variável interface{}:
- Para "email": usar o conteúdo como uma string
- Para "sms": converter o conteúdo para um número inteiro (que representa a contagem de caracteres)
- Para "push": converter o conteúdo para um valor booleano (true para "enabled", false para qualquer outra coisa)
- Para "alert": converter o conteúdo para um float64 (que representa o nível de prioridade)
Chamar a função processNotification com o valor convertido
Dentro de processNotification, usar uma alternância de tipos para lidar com cada tipo e imprimir a mensagem apropriada:
- Para string: "Email notification: [value]"
- Para int: "SMS notification with [value] characters"
- Para bool: "Push notifications: [value]"
- Para float64: "Alert with priority: [value]"
- Para qualquer outro tipo: "Unknown notification type"

Use o pacote strconv para converter strings. Na conversão para booleano, somente "enabled" deve resultar em true. Este desafio demonstra como as alternâncias de tipos oferecem uma maneira simples de lidar com vários tipos em uma única estrutura de controle, fornecendo automaticamente o valor com o tipo correto em cada caso.

Imprima o float64 em sua forma mais curta, como fazem fmt.Println ou os verbos %v / %g: 3.5 é impresso como 3.5 e 1.0 como 1 (o verbo %f imprimiria 1.000000).

Experimente você mesmo

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// Leia a entrada
	var notificationType string
	var content string
	fmt.Scanln(&notificationType)
	fmt.Scanln(&content)
	
	// TODO: Escreva seu código abaixo
	// 1. Crie a função processNotification que recebe um parâmetro interface{}
	// 2. Converta content para o tipo apropriado com base em notificationType
	// 3. Chame processNotification com o valor convertido
	// 4. Use um type switch dentro de processNotification para tratar diferentes tipos
	
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Lógica & Fluxo

Pratique por conta própria: Compilador de Go online