Vérifier le stock

Fait partie de la section Logique & Flux du Journey GO de Coddy — leçon 46 sur 68.

Défi

Facile

Implémentez une fonction de vérification des stocks pour votre système de gestion d'inventaire qui récupère en toute sécurité les quantités de produits et gère les cas où les produits n'existent pas. Ce défi s'appuie sur la base de l'inventaire de la leçon précédente et ajoute la gestion des erreurs pour les requêtes de stock.

Vous recevrez deux entrées :

Une chaîne contenant les données d'inventaire existantes au format "product1:price1:quantity1,product2:price2:quantity2,product3:price3:quantity3" (par exemple, "Laptop:999.99:5,Mouse:25.50:15,Keyboard:75.00:8")
Une chaîne contenant les demandes de vérification de stock au format "product1,product2,product3" (par exemple, "Mouse,Tablet,Keyboard")

Votre tâche consiste à :

Utiliser la même structure Product de la leçon précédente avec les champs Price (float64) et Quantity (int)
Analyser la première entrée en la divisant par les virgules pour obtenir les entrées de produits individuelles
Pour chaque entrée de produit, diviser par les deux-points pour obtenir le nom du produit, le prix et la quantité
Convertir la chaîne de prix en float64 et la chaîne de quantité en int
Créer et remplir la map inventory avec les données de produit analysées
Créer une fonction appelée checkStock qui prend la map d'inventaire et un nom de produit comme paramètres et retourne (int, error) :
- Si le produit existe dans l'inventaire, retourner sa quantité et nil
- Si le produit n'existe pas, retourner 0 et une erreur avec le message "product not found: [product_name]"
Analyser la deuxième entrée en la divisant par les virgules pour obtenir la liste des produits à vérifier
Afficher l'en-tête de vérification des stocks : "Stock Check Results:"
Pour chaque produit de la liste de vérification, appeler la fonction checkStock et afficher les résultats :
- Si aucune erreur : "[product_name]: [quantity] units in stock"
- Si erreur : "[product_name]: Error - [error_message]"
Compter et afficher les statistiques récapitulatives :
- "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]"
Afficher le stock total pour les produits trouvés :
- "Total stock for found products: [sum_of_quantities_for_existing_products] units"
Lister tous les produits manquants :
- S'il y a des produits manquants : "Missing products: [comma_separated_list_of_missing_products]"
- Si aucun produit n'est manquant : "All requested products are available"

Utilisez le package strings pour diviser les chaînes d'entrée, le package strconv pour convertir les chaînes en nombres, le package errors pour créer des messages d'erreur et le package fmt pour la sortie formatée. Ce défi démontre comment implémenter une récupération de données sécurisée avec une gestion appropriée des erreurs, un modèle fondamental dans les systèmes de gestion d'inventaire.

Essayez vous-même

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")
}

Toutes les leçons de Logique & Flux

2Structures et Méthodes

Définir des méthodes sur des structures Receveurs par valeur Receveurs par pointeur Choisir les receveurs Méthodes vs Fonctions Récapitulatif - Comportement des structures

5Les Maps en profondeur

Maps de Structs Pointeurs comme valeurs de Map Tester les Maps Nil Comparer des Maps Récapitulatif - Compteur de fréquence de mots

8Projet : Inventaire simple

Aperçu du projetVérifier le stock Leçon de projet

Ajouter un nouvel article

Mettre à jour la quantité en stock

Générer un rapport

Assemblage final

11Défis finaux

Liste de contacts basique Validateur de nombres simple Collecteur d'éléments uniques