Lagerbestand aktualisieren

Teil des Abschnitts Logik & Ablauf der GO-Journey von Coddy — Lektion 48 von 68.

Aufgabe

Einfach

Verbessern Sie Ihr Bestandsverwaltungssystem, indem Sie Aktualisierungen der Lagerbestände mit umfassender Validierung und Fehlerbehandlung implementieren. Diese Herausforderung baut auf der vorherigen Funktionalität auf und fügt die Möglichkeit hinzu, vorhandene Produktmengen zu ändern, während ungültige Operationen, die zu negativen Lagerbeständen führen könnten, verhindert werden.

Sie erhalten zwei Eingaben:

Einen String, der die vorhandenen Inventardaten im Format "product1:price1:quantity1,product2:price2:quantity2,product3:price3:quantity3" enthält (z. B. "Laptop:999.99:5,Mouse:25.50:15,Keyboard:75.00:8")
Einen String, der die Aktualisierungsanfragen für den Lagerbestand im Format "product1:change1,product2:change2,product3:change3" enthält, wobei Änderungen positive oder negative Ganzzahlen sein können (z. B. "Mouse:10,Tablet:-5,Keyboard:-3")

Ihre Aufgabe ist es:

Verwenden Sie dieselbe Product-Struktur aus den vorherigen Lektionen mit den Feldern Price (float64) und Quantity (int)
Analysieren Sie die erste Eingabe, indem Sie sie an den Kommas trennen, um die einzelnen vorhandenen Produkteinträge zu erhalten
Trennen Sie für jeden vorhandenen Produkteintrag an den Doppelpunkten, um Produktname, Preis und Menge zu erhalten
Konvertieren Sie den Preis-String in float64 und den Mengen-String in int
Erstellen und befüllen Sie die inventory-Map mit den vorhandenen Produktdaten
Erstellen Sie eine Funktion namens updateStock, die die inventory-Map, den Produktnamen und die Mengenänderung als Parameter entgegennimmt und einen Fehler zurückgibt:
- Wenn das Produkt nicht im Inventar vorhanden ist, geben Sie einen Fehler mit der Meldung "product not found: [product_name]" zurück
- Wenn die Mengenänderung zu einem negativen Lagerbestand führen würde (aktuelle Menge + Änderung < 0), geben Sie einen Fehler mit der Meldung "insufficient stock: cannot reduce [product_name] by [absolute_change_value], only [current_quantity] available" zurück
- Wenn die Aktualisierung gültig ist, ändern Sie die Menge des Produkts im Inventar und geben Sie nil zurück
Analysieren Sie die zweite Eingabe, indem Sie sie an den Kommas trennen, um die Liste der Aktualisierungsanfragen für den Lagerbestand zu erhalten
Trennen Sie für jede Aktualisierungsanfrage an den Doppelpunkten, um Produktname und Mengenänderung zu erhalten
Konvertieren Sie den String der Mengenänderung in int
Zeigen Sie die Kopfzeile für den Aktualisierungsprozess an: "Processing Stock Updates:"
Rufen Sie für jede Aktualisierungsanfrage die Funktion updateStock auf und zeigen Sie die Ergebnisse an:
- Wenn kein Fehler auftritt und die Änderung positiv ist: "[product_name]: Added [change] units - New stock: [new_quantity]"
- Wenn kein Fehler auftritt und die Änderung negativ ist: "[product_name]: Removed [absolute_change_value] units - New stock: [new_quantity]"
- Wenn kein Fehler auftritt und die Änderung null ist: "[product_name]: No change - Current stock: [current_quantity]"
- Bei Fehler: "[product_name]: Update failed - [error_message]"
Zählen und zeigen Sie die Aktualisierungsstatistiken an:
- "Update Summary:"
- "Updates processed: [total_number_of_updates_processed]"
- "Updates successful: [number_of_successful_updates]"
- "Updates failed: [number_of_failed_updates]"
Zeigen Sie das aktualisierte Inventar in alphabetischer Reihenfolge nach Produktname an:
- "Updated Inventory:"
- Für jedes Produkt: "- [product_name]: $[price] (Stock: [quantity])"
Berechnen und zeigen Sie die endgültigen Inventarstatistiken an:
- "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]"
Listen Sie alle fehlgeschlagenen Aktualisierungen auf:
- Wenn fehlgeschlagene Aktualisierungen vorhanden sind: "Failed updates: [comma_separated_list_of_failed_product_names]"
- Wenn keine fehlgeschlagenen Aktualisierungen vorhanden sind: "All stock updates were processed successfully"

Verwenden Sie das strings-Paket, um die Eingabestrings zu trennen, das strconv-Paket, um Strings in Zahlen umzuwandeln, das errors-Paket, um Fehlermeldungen zu erstellen, das fmt-Paket für die formatierte Ausgabe und das sort-Paket, um Produktnamen alphabetisch zu sortieren. Formatieren Sie alle Preise auf 2 Dezimalstellen und den Gesamtwert des Inventars auf 2 Dezimalstellen. Diese Herausforderung zeigt, wie man vorhandene Daten sicher modifiziert und gleichzeitig ungültige Operationen durch umfassende Validierung und Fehlerbehandlung verhindert.

Probier es selbst

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

Alle Lektionen in Logik & Ablauf

2Structs und Methoden

Methoden für Structs definieren Value Receiver Pointer Receiver Receiver auswählen Methoden vs. Funktionen Zusammenfassung – Struct-Verhalten

5Maps im Detail

Maps von Structs Pointer als Map-Werte Prüfen auf Nil-Maps Maps vergleichen Zusammenfassung – Wortfrequenz-Zähler

8Projekt: Einfache Bestandsverwaltung

Projektübersicht Lagerbestand prüfen

Einen neuen Artikel hinzufügen

Lagerbestand aktualisieren Projekt-Lektion

Einen Bericht erstellen

Alles zusammenfügen

11Abschlussherausforderungen

Einfache Kontaktliste Einfacher Zahlen-Validator Sammler für eindeutige Elemente