Criando um Pacote Simples

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

Agora é hora de criar seu próprio pacote personalizado! Criar pacotes permite organizar seu código em módulos reutilizáveis que podem ser importados e usados em diferentes programas.

Para criar um pacote, você começa declarando-o no início do arquivo com a palavra-chave package seguida pelo nome do pacote. Para o nosso pacote de calculadora, usaremos:

package calculator

Dentro deste pacote, você pode definir funções, variáveis e tipos. Lembre-se de que apenas identificadores exportados (aqueles que começam com uma letra maiúscula) estarão acessíveis a partir de outros pacotes. Veja como você pode definir uma função Add exportada:

package calculator

func Add(a, b int) int {
    return a + b
}

Para usar seu pacote personalizado a partir de outro arquivo, importe-o assim como qualquer outro pacote. A partir do seu pacote main, você pode então chamar as funções exportadas:

package main

import "calculator"

func main() {
    result := calculator.Add(5, 3)
}

Essa abordagem modular torna seu código mais organizado e permite reutilizar funcionalidades em vários programas sem duplicar código.

Desafio

Fácil

Crie um pacote personalizado mathutils com operações matemáticas básicas e use-o em seguida no seu programa principal. Este desafio testará sua capacidade de criar um pacote, definir funções exportadas e importar seu pacote personalizado para uso em outro programa.

Você receberá duas entradas:

Uma string contendo definições de funções no formato "function1:param1,param2:operation|function2:param1,param2:operation" (por exemplo, "Add:5,3:addition|Multiply:4,7:multiplication|Subtract:10,4:subtraction")
Uma string contendo solicitações de cálculo no formato "operation1:value1,value2|operation2:value1,value2|operation3:value1,value2" (por exemplo, "Add:15,25|Multiply:6,8|Subtract:50,20")

Sua tarefa é:

Crie um pacote mathutils declarando package mathutils no início
Analise a primeira entrada dividindo-a nas barras verticais (|) para obter definições de funções individuais
Para cada definição de função, divida-a nos dois-pontos para obter o nome da função, os parâmetros e o tipo de operação
Crie as seguintes funções exportadas no seu pacote mathutils:
- Add(a, b int) int - retorna a soma de a e b
- Subtract(a, b int) int - retorna a menos b
- Multiply(a, b int) int - retorna o produto de a e b
- Divide(a, b int) int - retorna a divisão de a por b (divisão inteira)
No seu programa principal, importe o pacote mathutils
Exiba o cabeçalho de informações do pacote: "=== MATHUTILS PACKAGE DEMO ==="
Analise a primeira entrada e exiba as funções disponíveis:
- "Available functions in mathutils package:"
- Para cada função: "- [function_name]: Performs [operation_type] on two integers"
Analise a segunda entrada dividindo-a nas barras verticais para obter solicitações de cálculo individuais
Para cada solicitação de cálculo, divida-a nos dois-pontos para obter o nome da função e os parâmetros
Divida os parâmetros nas vírgulas para obter os dois valores inteiros
Converta as strings dos parâmetros em inteiros usando strconv.Atoi
Exiba o cabeçalho do processo de cálculo: "Performing calculations:"
Para cada solicitação de cálculo:
- Chame a função apropriada do pacote mathutils
- Exiba: "mathutils.[function_name]([param1], [param2]) = [result]"
Calcule e exiba as estatísticas de resumo:
- "Calculation Summary:"
- "Total calculations performed: [number_of_calculations]"
- "Functions used: [comma_separated_list_of_unique_function_names_used]"
- "Sum of all results: [sum_of_all_calculation_results]"
Exiba a confirmação de uso do pacote:
- "Package demonstration completed successfully"
- "All functions from mathutils package executed correctly"

Use o pacote strings para dividir as strings de entrada, o pacote strconv para converter strings em inteiros e o pacote fmt para a saída formatada. Lembre-se de que somente funções que começam com letras maiúsculas serão exportadas e acessíveis a partir de outros pacotes.

Importante: Ambas as linhas de entrada usam barras verticais (|) como delimitador entre as entradas. Cada entrada da primeira linha tem o formato FunctionName:param1,param2:operationtype: divida primeiro em | e, em seguida, divida cada entrada em : para extrair o nome da função (índice 0) e o tipo de operação (índice 2).

Este desafio demonstra como criar código reutilizável por meio de pacotes personalizados e como organizar funcionalidades em módulos lógicos.

Experimente você mesmo

package main

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

// TODO: Create your mathutils package functions here
// Como não podemos usar arquivos separados, defina as funções diretamente
// Estas normalmente estariam em um arquivo de pacote separado

func main() {
	// Lê a entrada usando bufio.Scanner para lidar com espaços corretamente
	scanner := bufio.NewScanner(os.Stdin)

	scanner.Scan()
	functionDefs := scanner.Text()

	scanner.Scan()
	calcRequests := scanner.Text()

	// TODO: Escreva seu código abaixo
	// 1. Define Add, Subtract, Multiply, Divide functions (simulating mathutils package)
	// 2. Analise functionDefs: divida por '|' para obter cada definição, depois divida cada uma por ':'
	//    Formato: FuncName:param1,param2:operation  (ex.: "Add:5,3:addition")
	// 3. Display package information and available functions
	// 4. Parse calcRequests (split by '|'), perform calculations
	// 5. Exiba os resultados e as estatísticas resumidas

	// Suprima avisos de variáveis não utilizadas
	_ = functionDefs
	_ = calcRequests
	_ = fmt.Sprintf
	_ = strconv.Atoi
	_ = strings.Split

	// Lembre-se de gerar a saída no formato exigido conforme especificado no desafio
}

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