Formatando o Tempo

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

Depois que você tiver um objeto time.Time, frequentemente precisará convertê-lo para um formato de string legível. Go usa uma abordagem única para a formatação de horários, diferente da de outras linguagens de programação.

Em vez de usar códigos de formatação como %Y-%m-%d, Go usa uma data de referência como modelo. Essa data de referência é Mon Jan 2 15:04:05 MST 2006, que representa o momento exato: 2 de janeiro de 2006, às 15:04:05, no Horário Padrão das Montanhas.

now := time.Now()
formatted := now.Format("2006-01-02")
fmt.Println(formatted) // Saída: 2023-10-26

A ideia principal é que você organiza os componentes da data de referência no padrão que deseja. Para um formato YYYY-MM-DD, você usa "2006-01-02" porque é assim que a data de referência aparece nesse padrão. Para um formato diferente como Jan 2, 2006, você usaria "Jan 2, 2006".

Essa abordagem baseada em layout torna a formatação de tempo do Go memorável e flexível. Depois de se lembrar da data de referência, você pode criar qualquer formato simplesmente organizando seus componentes no padrão desejado.

Desafio

Fácil

Crie um sistema de exibição de data e hora em vários formatos que formate objetos time.Time usando o sistema exclusivo de layout de data de referência do Go. Este desafio testará sua capacidade de usar o método Format com diferentes padrões de layout para criar várias representações de data e hora.

Você receberá duas entradas:

Uma string contendo informações de data no formato "year:month:day:hour:minute" (por exemplo, "2023:12:25:14:30")
Uma string contendo solicitações de formato separadas por vírgulas no formato "format1,format2,format3" (por exemplo, "iso,american,european,time12,time24")

Sua tarefa é:

Analisar a primeira entrada, dividindo-a nos dois-pontos para extrair os valores de ano, mês, dia, hora e minuto
Converter esses valores de string em inteiros usando o pacote strconv
Criar um objeto time.Time usando time.Date com os valores analisados (use time.UTC para a localização, 0 para segundos e nanossegundos)
Exibir o cabeçalho da aplicação: "=== DATE/TIME FORMATTER ==="
Exibir a hora de origem: "Source time: [complete_time_object]"
Analisar a segunda entrada, dividindo-a nas vírgulas para obter as solicitações de formato
Exibir o cabeçalho de formatação: "Formatted outputs:"
Para cada solicitação de formato, usar a string de layout apropriada com o método Format:
- Para "iso": use o layout "2006-01-02" e exiba "ISO format: [formatted_result]"
- Para "american": use o layout "01/02/2006" e exiba "American format: [formatted_result]"
- Para "european": use o layout "02/01/2006" e exiba "European format: [formatted_result]"
- Para "long": use o layout "January 2, 2006" e exiba "Long format: [formatted_result]"
- Para "time12": use o layout "3:04 PM" e exiba "12-hour time: [formatted_result]"
- Para "time24": use o layout "15:04" e exiba "24-hour time: [formatted_result]"
- Para "full": use o layout "Monday, January 2, 2006 at 3:04 PM" e exiba "Full format: [formatted_result]"
- Para "compact": use o layout "20060102" e exiba "Compact format: [formatted_result]"
Calcular e exibir as estatísticas:
- "=== FORMATTING SUMMARY ==="
- "Total formats applied: [number_of_format_requests]"
- "Date components: [year]-[month]-[day]"
- "Time components: [hour]:[minute]"
Exibir as informações de referência:
- "=== REFERENCE DATE INFO ==="
- "Go uses reference date: Mon Jan 2 15:04:05 MST 2006"
- "This represents: January 2nd, 2006 at 3:04:05 PM"
- "Layout patterns arrange these components as needed"
Exibir a mensagem de conclusão: "Date formatting completed using Go's layout system"

Use o pacote time para operações com tempo, o pacote strings para dividir strings de entrada, o pacote strconv para converter strings em inteiros e o pacote fmt para saída formatada. Lembre-se de que a formatação de tempo do Go usa a data de referência Mon Jan 2 15:04:05 MST 2006 como modelo, e você organiza esses componentes no padrão desejado. Este desafio demonstra como funciona o sistema exclusivo de formatação baseado em layouts do Go, fazendo com que você aplique vários padrões de formato diferentes ao mesmo objeto de tempo.

Experimente você mesmo

package main

import (
	"fmt"
	"strconv"
	"strings"
	"time"
)

func main() {
	// Ler entrada
	var dateInput string
	var formatInput string
	fmt.Scanln(&dateInput)
	fmt.Scanln(&formatInput)
	
	// Analisar componentes da data dividindo por dois-pontos
	dateComponents := strings.Split(dateInput, ":")
	
	// Converter componentes de string para inteiros
	year, _ := strconv.Atoi(dateComponents[0])
	month, _ := strconv.Atoi(dateComponents[1])
	day, _ := strconv.Atoi(dateComponents[2])
	hour, _ := strconv.Atoi(dateComponents[3])
	minute, _ := strconv.Atoi(dateComponents[4])
	
	// Criar objeto time.Time
	sourceTime := time.Date(year, time.Month(month), day, hour, minute, 0, 0, time.UTC)
	
	// Analisar solicitações de formato
	formatRequests := strings.Split(formatInput, ",")
	
	// TODO: Escreva seu código abaixo
	// Exibir o cabeçalho da aplicação
	// Exibir o horário de origem
	// Processar cada solicitação de formato e exibir as saídas formatadas
	// Calcular e exibir estatísticas
	// Exibir informações de referência
	// Exibir mensagem de conclusão
	
}