Parsing de Strings de Tempo

Parte da seção Lógica & Fluxo do Journey de GO da Coddy — lição 61 de 68.

Às vezes, você receberá informações de data e hora como strings que precisam ser convertidas em objetos time.Time para processamento. O Go fornece a função time.Parse para lidar com essa conversão.

A função time.Parse funciona como o inverso da formatação - ela recebe uma string de layout e uma string de tempo, então retorna um objeto time.Time:

dateString := "2023-10-26"
parsedTime, err := time.Parse("2006-01-02", dateString)
if err != nil {
    fmt.Println("Error parsing time:", err)
} else {
    fmt.Println(parsedTime)
}

Assim como na formatação, você usa os mesmos componentes de data de referência em sua string de layout. O layout "2006-01-02" diz ao Go para esperar a string de entrada no formato YYYY-MM-DD. O layout deve corresponder ao formato exato da sua string de entrada.

Lembre-se de que time.Parse retorna dois valores: o objeto time.Time analisado e um erro. Sempre verifique o erro para garantir que a análise foi bem-sucedida, pois strings de data inválidas ou layouts incompatíveis farão com que a análise falhe.

Teste seus conhecimentos

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

Teste seus conhecimentos

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

Teste seus conhecimentos

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

Desafio

Fácil

Crie um analisador de arquivos de log que converte strings de timestamp de vários formatos em objetos time.Time para análise. Este desafio testará sua habilidade de usar time.Parse com diferentes padrões de layout para lidar com múltiplos formatos de data e hora comumente encontrados em logs de sistema.

Nota Importante: Como as mensagens de log e os padrões de layout podem conter espaços, você precisará usar bufio.Scanner para ler linhas inteiras de entrada. A função fmt.Scanln para de ler no primeiro espaço, o que quebraria as entradas de log e layouts com espaços. Use bufio.NewScanner(os.Stdin) e chame scanner.Scan() seguido de scanner.Text() para ler linhas completas.

Você receberá duas entradas:

Uma string contendo entradas de log no formato "timestamp1:message1,timestamp2:message2,timestamp3:message3" (ex: "2023-10-26:System startup,2023/12/25:Holiday shutdown,Jan 15 2024:Maintenance window")
Uma string contendo padrões de layout separados por vírgulas no formato "layout1,layout2,layout3" (ex: "2006-01-02,2006/01/02,Jan 2 2006")

Sua tarefa é:

Usar bufio.Scanner para ler as linhas de entrada adequadamente para lidar com espaços em mensagens de log e padrões de layout
Analisar a primeira entrada dividindo-a por vírgulas para obter entradas de log individuais
Para cada entrada de log, dividir por dois-pontos para extrair a string do timestamp e a mensagem
Analisar a segunda entrada dividindo-a por vírgulas para obter os padrões de layout
Exibir o cabeçalho da aplicação: "=== LOG TIMESTAMP PARSER ==="
Exibir o status do processamento: "Processing log entries with multiple timestamp formats..."
Para cada entrada de log, tentar analisar o timestamp usando cada padrão de layout até que um tenha sucesso:
- Tente cada padrão de layout com time.Parse até que a análise seja bem-sucedida (sem erro)
- Quando for bem-sucedido, exiba: "Parsed: [timestamp_string] -> [parsed_time_object] (using layout: [successful_layout])"
- Também exiba: " Message: [log_message]"
- Se nenhum layout funcionar para um timestamp, exiba: "Failed to parse: [timestamp_string] - no matching layout found"
Após processar todas as entradas, exiba as estatísticas de análise:
- "=== PARSING RESULTS ==="
- "Total log entries processed: [number_of_entries]"
- "Successfully parsed timestamps: [number_of_successful_parses]"
- "Failed parsing attempts: [number_of_failed_parses]"
Exibir estatísticas de uso de layout:
- "Layout pattern usage:"
- Para cada padrão de layout: " [layout_pattern]: [number_of_times_used] times"
Se algum timestamp foi analisado com sucesso, exiba a análise cronológica:
- "=== CHRONOLOGICAL ANALYSIS ==="
- "Earliest timestamp: [earliest_parsed_time]"
- "Latest timestamp: [latest_parsed_time]"
- "Time span covered: [time_difference_description]"
Exibir a mensagem de conclusão: "Log parsing completed - timestamps converted to time objects"

Use o pacote time para operações de análise, o pacote strings para dividir as strings de entrada, os pacotes bufio e os para o tratamento adequado de entrada, e o pacote fmt para saída formatada. Lembre-se que time.Parse retorna tanto um objeto time.Time quanto um erro - você deve verificar o erro para determinar se a análise foi bem-sucedida. Quando a análise falhar com um layout, tente o próximo padrão de layout até encontrar um que funcione ou esgotar todas as opções. Este desafio demonstra como lidar com múltiplos formatos de timestamp em cenários reais de processamento de log.

Folha de consulta

Use time.Parse para converter strings de data/hora em objetos time.Time:

dateString := "2023-10-26"
parsedTime, err := time.Parse("2006-01-02", dateString)
if err != nil {
    fmt.Println("Error parsing time:", err)
} else {
    fmt.Println(parsedTime)
}

A string de layout deve corresponder ao formato exato da sua string de entrada usando os componentes de data de referência do Go. time.Parse retorna tanto um objeto time.Time quanto um erro - sempre verifique o erro para garantir que a análise foi bem-sucedida.

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"time"
)

func main() {
	// Cria um scanner para ler as linhas de entrada
	scanner := bufio.NewScanner(os.Stdin)
	
	// Lê as entradas de log
	scanner.Scan()
	logEntries := scanner.Text()
	
	// Lê os padrões de layout
	scanner.Scan()
	layoutPatterns := scanner.Text()
	
	// Analisa as entradas
	entries := strings.Split(logEntries, ",")
	layouts := strings.Split(layoutPatterns, ",")
	
	// Inicializa contadores para estatísticas
	totalEntries := len(entries)
	successfulParses := 0
	failedParses := 0
	layoutUsage := make(map[string]int)
	var parsedTimes []time.Time
	
	// TODO: Escreva seu código abaixo
	// 1. Exibir o cabeçalho da aplicação
	// 2. Exibir o status de processamento
	// 3. Processar cada entrada de log:
	//    - Dividir a entrada em ":" para obter o timestamp e a mensagem
	//    - Tentar cada padrão de layout até que um funcione
	//    - Exibir os resultados da análise
	//    - Atualizar as estatísticas
	// 4. Exibir estatísticas de análise
	// 5. Exibir estatísticas de uso de layout
	// 6. Se os timestamps foram analisados, exibir análise cronológica
	// 7. Exibir mensagem de conclusão
	
}

Teste seus conhecimentos

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