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 switch de tipo se torna incrivelmente útil — ele fornece uma maneira clara de executar ações diferentes com base no tipo concreto.

Um switch 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 automaticamente tem o tipo correto — nenhuma asserção de tipo adicional é necessária. Isso torna os switches de tipos muito mais claros 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 switches de tipo 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 valor da notificação

Sua tarefa é:

Criar uma função chamada processNotification que recebe um parâmetro interface{}
Com base na entrada do 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 inteiro (representando a quantidade de caracteres)
- Para "push": converter o conteúdo para um booleano (true para "enabled", false para qualquer outra coisa)
- Para "alert": converter o conteúdo para um float64 (representando o nível de prioridade)
Chamar a função processNotification com o valor convertido
Dentro de processNotification, usar um switch de tipo 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 conversões de string. Para a conversão booleana, somente "enabled" deve resultar em true. Este desafio demonstra como os switches de tipo oferecem uma maneira limpa 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, da maneira como os verbos fmt.Println ou %v / %g fazem: 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() {
	// Ler entrada
	var notificationType string
	var content string
	fmt.Scanln(&notificationType)
	fmt.Scanln(&content)
	
	// TODO: Escreva seu código abaixo
	// 1. Create processNotification function that takes interface{} parameter
	// 2. Convert content to appropriate type based on notificationType
	// 3. Call processNotification with the converted value
	// 4. Use type switch inside processNotification to handle different types
	
}

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