Médio Go

Usando any e type assertion

Enunciado

Escreva uma função descrever(v any) string que retorne uma descrição do valor:

  • Se for int, retorne "inteiro: N".
  • Se for string, retorne "texto: S".
  • Caso contrário, retorne "tipo desconhecido". Use type assertion com a forma v, ok := i.(T) para checar os tipos. No main, chame a função com 42, "Go" e true e imprima os resultados.

Requisitos

  • Definir descrever(v any) string.
  • Usar type assertion v, ok := i.(int) e v, ok := i.(string).
  • Retornar exatamente as strings pedidas.
  • Chamar a função com 42, "Go" e true e imprimir cada resultado.

Código inicial

package main

import "fmt"

func descrever(v any) string {
	// Use type assertion para int e string
	return ""
}

func main() {
	// Chame descrever e imprima
}

Saída esperada

inteiro: 42
texto: Go
tipo desconhecido
Ver dica

A forma v, ok := i.(T) retorna o valor convertido e um booleano. Use if para cada tipo.

Mostrar solução 
package main

import "fmt"

// descrever recebe any e usa type assertion para identificar o tipo
func descrever(v any) string {
	if n, ok := v.(int); ok {
		return fmt.Sprintf("inteiro: %d", n)
	}
	if s, ok := v.(string); ok {
		return "texto: " + s
	}
	return "tipo desconhecido"
}

func main() {
	fmt.Println(descrever(42))
	fmt.Println(descrever("Go"))
	fmt.Println(descrever(true))
}

Passo a passo

  1. A função descrever recebe v any, que aceita qualquer valor.
  2. n, ok := v.(int) tenta extrair um int. Se ok for true, n contém o valor inteiro.
  3. Retornamos "inteiro: N" usando fmt.Sprintf para formatar o número.
  4. Em seguida, testamos v.(string). Se for string, retornamos "texto: S".
  5. Se nenhum tipo corresponder, retornamos "tipo desconhecido".
  6. No main, chamamos a função com três valores de tipos diferentes e imprimimos.

Por que funciona

any é um alias para interface{} e pode armazenar qualquer valor. A type assertion v.(T) extrai o valor dinâmico se ele for do tipo T. Usando a forma com ok, evitamos panic quando o tipo não corresponde. Assim, a função trata tipos distintos de forma segura.

Erros comuns

  • Usar v.(int) sem ok quando o tipo pode não ser int: isso causa panic. Prefira n, ok := v.(int).
  • Esquecer de testar todos os tipos e cair no return final sem tratar: o return "tipo desconhecido" cobre isso.
  • Confundir any com tipo genérico: any é apenas interface{}.

Outra forma de resolver

Usar um type switch:

switch t := v.(type) {
case int:
	return fmt.Sprintf("inteiro: %d", t)
case string:
	return "texto: " + t
default:
	return "tipo desconhecido"
}

Type switch é mais limpo quando há muitos casos.

Saída esperada

inteiro: 42
texto: Go
tipo desconhecido