Verificar el stock

Parte de la sección Lógica y Flujo del Journey de GO de Coddy — lección 46 de 68.

Desafío

Fácil

Implementa una función de verificación de stock para tu sistema de gestión de inventario que recupere de forma segura las cantidades de productos y maneje los casos en los que los productos no existen. Este desafío se basa en la base del inventario de la lección anterior y añade el manejo de errores para las consultas de stock.

Recibirás dos entradas:

Una cadena que contiene los datos del inventario existente en el formato "product1:price1:quantity1,product2:price2:quantity2,product3:price3:quantity3" (por ejemplo, "Laptop:999.99:5,Mouse:25.50:15,Keyboard:75.00:8")
Una cadena que contiene las solicitudes de verificación de stock en el formato "product1,product2,product3" (por ejemplo, "Mouse,Tablet,Keyboard")

Tu tarea es:

Usar el mismo struct Product de la lección anterior con los campos Price (float64) y Quantity (int)
Analizar la primera entrada dividiéndola por comas para obtener las entradas de productos individuales
Para cada entrada de producto, dividir por dos puntos para obtener el nombre del producto, el precio y la cantidad
Convertir la cadena de precio a float64 y la cadena de cantidad a int
Crear y poblar el mapa inventory con los datos de productos analizados
Crear una función llamada checkStock que tome el mapa de inventario y un nombre de producto como parámetros y devuelva (int, error):
- Si el producto existe en el inventario, devolver su cantidad y nil
- Si el producto no existe, devolver 0 y un error con el mensaje "product not found: [product_name]"
Analizar la segunda entrada dividiéndola por comas para obtener la lista de productos a verificar
Mostrar el encabezado de verificación de stock: "Stock Check Results:"
Para cada producto en la lista de verificación, llamar a la función checkStock y mostrar los resultados:
- Si no hay error: "[product_name]: [quantity] units in stock"
- Si hay error: "[product_name]: Error - [error_message]"
Contar y mostrar estadísticas de resumen:
- "Check Summary:"
- "Products checked: [total_number_of_products_checked]"
- "Products found: [number_of_products_that_exist]"
- "Products not found: [number_of_products_that_dont_exist]"
Mostrar el stock total de los productos encontrados:
- "Total stock for found products: [sum_of_quantities_for_existing_products] units"
Listar cualquier producto faltante:
- Si hay productos faltantes: "Missing products: [comma_separated_list_of_missing_products]"
- Si no hay productos faltantes: "All requested products are available"

Usa el paquete strings para dividir las cadenas de entrada, el paquete strconv para convertir cadenas a números, el paquete errors para crear mensajes de error y el paquete fmt para la salida formateada. Este desafío demuestra cómo implementar la recuperación segura de datos con un manejo de errores adecuado, un patrón fundamental en los sistemas de gestión de inventarios.

Pruébalo tú mismo

package main

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

// Define the Product struct
type Product struct {
	Price    float64
	Quantity int
}

func main() {
	// Read input using bufio.Scanner to handle spaces properly
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	storeInfo := scanner.Text()
	
	scanner.Scan()
	productData := scanner.Text()
	
	// 1. Parse store information (split by comma)
	storeInfoParts := strings.Split(storeInfo, ",")
	storeName := ""
	location := ""
	if len(storeInfoParts) >= 2 {
		storeName = storeInfoParts[0]
		location = storeInfoParts[1]
	}
	
	// 2. Parse product data (split by comma, then by colon for each product)
	productEntries := strings.Split(productData, ",")
	
	// 3. Create inventory map
	inventory := make(map[string]Product)
	
	// 4. Convert strings to appropriate types and populate inventory
	for _, entry := range productEntries {
		parts := strings.Split(entry, ":")
		if len(parts) >= 3 {
			productName := parts[0]
			price, _ := strconv.ParseFloat(parts[1], 64)
			quantity, _ := strconv.Atoi(parts[2])
			
			inventory[productName] = Product{
				Price:    price,
				Quantity: quantity,
			}
		}
	}
	
	// 5. Display store information
	fmt.Printf("=== %s Inventory System ===\n", storeName)
	fmt.Printf("Location: %s\n", location)
	fmt.Printf("Inventory initialized with %d products\n", len(inventory))
	
	// 6. Display current inventory (sorted alphabetically)
	fmt.Println("Current Inventory:")
	var productNames []string
	for name := range inventory {
		productNames = append(productNames, name)
	}
	sort.Strings(productNames)
	
	for _, name := range productNames {
		product := inventory[name]
		fmt.Printf("- %s: $%.2f (Stock: %d)\n", name, product.Price, product.Quantity)
	}
	
	// 7. Calculate and display inventory statistics
	totalProducts := len(inventory)
	totalItems := 0
	totalValue := 0.0
	
	for _, product := range inventory {
		totalItems += product.Quantity
		totalValue += product.Price * float64(product.Quantity)
	}
	
	fmt.Println("Inventory Statistics:")
	fmt.Printf("Total Products: %d\n", totalProducts)
	fmt.Printf("Total Items in Stock: %d\n", totalItems)
	fmt.Printf("Total Inventory Value: $%.2f\n", totalValue)
	
	// 8. Display system status
	fmt.Println("System Status: Ready")
	fmt.Println("Inventory management system initialized successfully")
}

Todas las lecciones de Lógica y Flujo

2Estructuras y Métodos

Definición de métodos en estructuras Receptores de valor Receptores de puntero Elegir receptores Métodos vs Funciones Resumen - Comportamiento de estructuras

5Mapas en profundidad

Mapas de Structs Punteros como valores de Map Verificación de Maps Nil Comparación de Maps Resumen - Contador de frecuencia de palabras

8Proyecto: Inventario simple

Descripción general del proyectoVerificar el stock Lección de proyecto

Añadir un nuevo artículo

Actualizar la cantidad de stock

Generar un informe

Poniéndolo todo junto

11Desafíos finales

Lista de contactos básica Validador de números simple Colector de elementos únicos