Recapitulação - Construindo um Utilitário

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

Desafio

Fácil

Crie um pacote stringutil abrangente com funções de manipulação de strings e demonstre seu uso em um programa principal. Este desafio testará sua habilidade de criar um pacote utilitário personalizado, implementar funções exportadas e usar seu pacote a partir de outro programa.

Você receberá duas entradas:

Uma string contendo especificações de funções no formato "function1:description1,function2:description2" (ex: "Reverse:reverses a string,ToUpper:converts to uppercase,ToLower:converts to lowercase")
Uma string contendo strings de teste separadas por barras verticais no formato "string1|string2|string3" (ex: "hello|Go Programming|WORLD")

Sua tarefa é:

Criar um pacote stringutil declarando package stringutil
Analisar a primeira entrada dividindo-a por vírgulas para obter as especificações individuais das funções
Para cada especificação de função, dividir por dois-pontos para obter o nome da função e a descrição
Implementar as seguintes funções exportadas no seu pacote stringutil:
- Reverse(s string) string - retorna a string com os caracteres em ordem inversa
- ToUpper(s string) string - retorna a string convertida para maiúsculas
- ToLower(s string) string - retorna a string convertida para minúsculas
- Length(s string) int - retorna o comprimento da string
No seu programa principal, importar o pacote stringutil
Exibir o cabeçalho do pacote: "=== STRINGUTIL PACKAGE DEMONSTRATION ==="
Exibir as funções disponíveis:
- "Available functions in stringutil package:"
- Para cada função da primeira entrada: "- [function_name]: [description]"
Analisar a segunda entrada dividindo-a por barras verticais para obter as strings de teste individuais
Exibir o cabeçalho de teste: "Testing stringutil functions:"
Para cada string de teste, demonstrar todas as funções:
- "Testing with: \"[test_string]\""
- " stringutil.Reverse: \"[reversed_result]\""
- " stringutil.ToUpper: \"[uppercase_result]\""
- " stringutil.ToLower: \"[lowercase_result]\""
- " stringutil.Length: [length_result]"
Calcular e exibir estatísticas:
- "=== STATISTICS ==="
- "Total test strings processed: [number_of_test_strings]"
- "Functions available in package: [number_of_functions_from_first_input]"
- "Total function calls made: [total_function_calls]"
Exibir a string mais longa e a mais curta:
- "Longest string: \"[longest_string]\" (length: [length])"
- "Shortest string: \"[shortest_string]\" (length: [length])"
Exibir a mensagem de conclusão: "Package demonstration completed successfully"

Use o pacote strings para dividir as strings de entrada e manipular texto, e o pacote fmt para saída formatada. Para a função Reverse, você precisará converter a string em um slice de runes, inverter a ordem e converter de volta para uma string. Lembre-se de que todas as funções exportadas devem começar com letras maiúsculas para serem acessíveis de outros pacotes. Este desafio demonstra como criar pacotes utilitários reutilizáveis e organizar funcionalidades relacionadas.

Experimente você mesmo

package main

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

// TODO: Crie as funções do seu pacote stringutil aqui
// Como não podemos usar arquivos separados, defina as funções diretamente
// Elas normalmente estariam em um arquivo de pacote separado

// func Reverse(s string) string {
//     // Converter para runes, inverter, converter de volta para string
// }

// func ToUpper(s string) string {
//     // Usar strings.ToUpper
// }

// func ToLower(s string) string {
//     // Usar strings.ToLower
// }

// func Length(s string) int {
//     // Retornar len(s)
// }

func main() {
	// Ler a entrada usando bufio.Scanner para lidar com espaços corretamente
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	functionSpecs := scanner.Text()
	
	scanner.Scan()
	testStrings := scanner.Text()
	
	// Analisar especificações das funções
	funcList := strings.Split(functionSpecs, ",")
	
	// Analisar strings de teste
	testList := strings.Split(testStrings, "|")
	
	// TODO: Escreva seu código abaixo
	// 1. Exibir cabeçalho do pacote
	// 2. Exibir funções disponíveis de funcList (verificar comprimentos do array)
	// 3. Testar todas as funções com cada string de teste
	// 4. Calcular e exibir estatísticas
	// 5. Encontrar e exibir as strings mais longas/curtas (verificar se testList possui elementos)
	// 6. Exibir mensagem de conclusão
	
	// Lembre-se de usar as funções do seu pacote stringutil como:
	// Reverse(testString)
	// ToUpper(testString)
	// ToLower(testString)
	// Length(testString)
}

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

3Interfaces (O Básico)

O que é uma Interface?Definindo uma Interface Implementando uma Interface Usando Tipos de Interface Interface Vazia Asserções de Tipo Type Switch Recapitulação - Formas e Comportamentos

6Go Idiomático: Conjuntos

O Idioma de Conjuntos em Go Criando um Conjunto Adicionando a um Conjunto Verificando a Existência de Elementos Removendo de um Conjunto Iterando sobre um Conjunto Recapitulação - Nomes de Usuário Únicos

9Pacotes e Escopo

O que é um Pacote?Exportado vs Não Exportado Criando um Pacote Simples Aliasing de Pacotes O Identificador em Branco `_` A função `init`Recapitulação - Construindo um Utilitário