Mettre à jour la quantité en stock

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

Défi

Facile

Améliorez votre système de gestion des stocks en implémentant des mises à jour de quantités de stock avec une validation complète et une gestion des erreurs. Ce défi s'appuie sur les fonctionnalités précédentes et ajoute la possibilité de modifier les quantités de produits existants tout en empêchant les opérations invalides qui pourraient entraîner des niveaux de stock négatifs.

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 mise à jour de stock au format "product1:change1,product2:change2,product3:change3" où les changements peuvent être des entiers positifs ou négatifs (par exemple, "Mouse:10,Tablet:-5,Keyboard:-3")

Votre tâche consiste à :

Utiliser la même structure Product des leçons précédentes 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 existants individuels
Pour chaque entrée de produit existant, 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 produits existants
Créer une fonction nommée updateStock qui prend la map d'inventaire, le nom du produit et le changement de quantité comme paramètres et retourne une erreur :
- Si le produit n'existe pas dans l'inventaire, retourner une erreur avec le message "product not found: [product_name]"
- Si le changement de quantité entraînait un stock négatif (quantité actuelle + changement < 0), retourner une erreur avec le message "insufficient stock: cannot reduce [product_name] by [absolute_change_value], only [current_quantity] available"
- Si la mise à jour est valide, modifier la quantité du produit dans l'inventaire et retourner nil
Analyser la seconde entrée en la divisant par les virgules pour obtenir la liste des demandes de mise à jour de stock
Pour chaque demande de mise à jour, diviser par les deux-points pour obtenir le nom du produit et le changement de quantité
Convertir la chaîne de changement de quantité en int
Afficher l'en-tête du processus de mise à jour : "Processing Stock Updates:"
Pour chaque demande de mise à jour, appeler la fonction updateStock et afficher les résultats :
- Si aucune erreur et que le changement est positif : "[product_name]: Added [change] units - New stock: [new_quantity]"
- Si aucune erreur et que le changement est négatif : "[product_name]: Removed [absolute_change_value] units - New stock: [new_quantity]"
- Si aucune erreur et que le changement est nul : "[product_name]: No change - Current stock: [current_quantity]"
- En cas d'erreur : "[product_name]: Update failed - [error_message]"
Compter et afficher les statistiques de mise à jour :
- "Update Summary:"
- "Updates processed: [total_number_of_updates_processed]"
- "Updates successful: [number_of_successful_updates]"
- "Updates failed: [number_of_failed_updates]"
Afficher l'inventaire mis à jour par ordre alphabétique des noms de produits :
- "Updated Inventory:"
- Pour chaque produit : "- [product_name]: $[price] (Stock: [quantity])"
Calculer et afficher les statistiques finales de l'inventaire :
- "Final Inventory Statistics:"
- "Total Products: [total_number_of_products_in_inventory]"
- "Total Items in Stock: [sum_of_all_quantities]"
- "Total Inventory Value: $[sum_of_price_times_quantity_for_all_products]"
Lister toutes les mises à jour ayant échoué :
- S'il y a des mises à jour échouées : "Failed updates: [comma_separated_list_of_failed_product_names]"
- Si aucune mise à jour n'a échoué : "All stock updates were processed successfully"

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, le package fmt pour la sortie formatée, et le package sort pour trier les noms de produits par ordre alphabétique. Formatez tous les prix à 2 décimales et la valeur totale de l'inventaire à 2 décimales. Ce défi démontre comment modifier en toute sécurité des données existantes tout en empêchant les opérations invalides grâce à une validation complète et une gestion des erreurs.

Essayez vous-même

package main

import (
	"errors"
	"fmt"
	"sort"
	"strconv"
	"strings"
)

type Product struct {
	Price    float64
	Quantity int
}

func addNewItem(inventory map[string]Product, productName string, price float64, quantity int) error {
	if _, exists := inventory[productName]; exists {
		return errors.New("product already exists: " + productName)
	}
	inventory[productName] = Product{Price: price, Quantity: quantity}
	return nil
}

func main() {
	var existingInventory string
	var newProducts string
	fmt.Scanln(&existingInventory)
	fmt.Scanln(&newProducts)

	inventory := make(map[string]Product)

	// Parse existing inventory
	existingItems := strings.Split(existingInventory, ",")
	for _, item := range existingItems {
		parts := strings.Split(item, ":")
		name := parts[0]
		price, _ := strconv.ParseFloat(parts[1], 64)
		quantity, _ := strconv.Atoi(parts[2])
		inventory[name] = Product{Price: price, Quantity: quantity}
	}

	// Parse new products to add
	newItems := strings.Split(newProducts, ",")
	
	fmt.Println("Adding New Items:")
	
	itemsProcessed := 0
	itemsAdded := 0
	itemsRejected := 0
	var rejectedProducts []string

	for _, item := range newItems {
		parts := strings.Split(item, ":")
		name := parts[0]
		price, _ := strconv.ParseFloat(parts[1], 64)
		quantity, _ := strconv.Atoi(parts[2])
		
		itemsProcessed++
		
		err := addNewItem(inventory, name, price, quantity)
		if err != nil {
			fmt.Printf("%s: Failed to add - %s\n", name, err.Error())
			itemsRejected++
			rejectedProducts = append(rejectedProducts, name)
		} else {
			fmt.Printf("%s: Successfully added - $%.2f (Stock: %d)\n", name, price, quantity)
			itemsAdded++
		}
	}

	// Addition summary
	fmt.Println("Addition Summary:")
	fmt.Printf("Items processed: %d\n", itemsProcessed)
	fmt.Printf("Items added: %d\n", itemsAdded)
	fmt.Printf("Items rejected: %d\n", itemsRejected)

	// Display updated inventory in alphabetical order
	fmt.Println("Updated Inventory:")
	var productNames []string
	for name := range inventory {
		productNames = append(productNames, name)
	}
	sort.Strings(productNames)

	totalProducts := 0
	totalItems := 0
	totalValue := 0.0

	for _, name := range productNames {
		product := inventory[name]
		fmt.Printf("- %s: $%.2f (Stock: %d)\n", name, product.Price, product.Quantity)
		totalProducts++
		totalItems += product.Quantity
		totalValue += product.Price * float64(product.Quantity)
	}

	// Final inventory statistics
	fmt.Println("Final 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)

	// List rejected products
	if len(rejectedProducts) > 0 {
		fmt.Printf("Rejected products: %s\n", strings.Join(rejectedProducts, ","))
	} else {
		fmt.Println("All new products were added 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 projet Vérifier le stock

Ajouter un nouvel article

Mettre à jour la quantité en stock Leçon de projet

Générer un rapport

Assemblage final

11Défis finaux

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