Utilisez la session pour stocker les paniers d'achat de visiteurs et les magasins de base de données connectés aux paniers d'achat utilisateur pour la persistance; 2. Créez des tables de panier pour stocker les données de panier d'achat utilisateur; 3. Créez une classe de service CartService pour encapsuler l'addition, la suppression, la modification et la logique de recherche; 4. Créer un contr?leur CartController pour gérer les opérations de panier d'achat; 5. Définir les routes dans web.php; 6. Créer un modèle de lame pour afficher le contenu du panier d'achat; 7. Faire fusionner les paniers d'achat de session dans la base de données lorsque l'utilisateur se connecte. Cette solution met en ?uvre un système de panier hybride qui prend en charge les visiteurs et les utilisateurs certifiés, et est durable, évolutif et répond aux besoins pratiques d'application.

La mise en ?uvre d'un panier à Laravel peut être effectuée de plusieurs manières en fonction de vos besoins - basée sur les utilisateurs invités, soutenu par la base de données pour les chariots persistants ou l'utilisation d'un package comme gloudemans/shoppingcart (maintenant archivé, mais toujours utilisé). Vous trouverez ci-dessous un guide pratique pour construire un système de panier simple mais efficace à partir de zéro.

1. Décider du stockage du chariot: Session vs base de données

Pour la plupart des applications Laravel, vous voudrez prendre en charge les invités et les utilisateurs connectés :

• Invités : Chariot de magasin dans la session.
• Utilisateurs connectés : stocker le panier dans la base de données, synchronisé avec la session pour la cohérence.

Cette approche hybride donne de la flexibilité et de la persistance.

2. Configuration de la base de données (pour les utilisateurs authentifiés)

Si vous voulez des chariots persistants, créez une table cart :

 PHP Artisan Make: Migration Create_Cart_Table

 Schéma :: Create ('CART', fonction (Table Blueprint $) {
    $ table-> id ();
    $ Table-> ForeignId ('user_id') -> contrainte () -> ondelete ('cascade');
    $ Table-> ForeignId ('product_id') -> contrainte ();
    $ table-> entier ('quantité') -> par défaut (1);
    $ Table-> TimeStamps ();
});

Exécuter la migration:

 PHP Artisan Migrate

3. Créez une classe de service de panier

Au lieu de mettre la logique dans les contr?leurs, créez un service réutilisable:

 PHP Artisan Make: Service CartService

Dans app/Services/CartService.php :

 Namespace App \ Services;

Utiliser illuminate \ support \ FACADES \ Auth;
Utiliser illuminate \ support \ FACADES \ Session;
Utilisez App \ Models \ CART;
Utilisez App \ Models \ Product;

classe de classe
{
    fonction publique get ()
    {
        if (auth :: check ()) {
            return Cart :: with ('product') -> où ('user_id', auth :: id ()) -> get ();
        }

        Session de retour :: get ('cart', []);
    }

    fonction publique ajouter ($ productId, $ quantité = 1)
    {
        $ Product = Product :: FindorFail ($ productId);

        if (auth :: check ()) {
            $ Cartitem = Cart :: Firstornw ([
                'user_id' => auth :: id (),
                'product_id' => $ product-> id,
            ]));

            $ cartitem-> quantité = $ quantité;
            $ Cartitem-> SAVE ();
        } autre {
            $ cart = session :: get ('cart', []);
            if (isset ($ cart [$ productid])) {
                $ Cart [$ productId] ['Quantité'] = $ Quantité;
            } autre {
                $ cart [$ productid] = [
                    'product_id' => $ product-> id,
                    'name' => $ product-> name,
                    'Price' => $ Product-> Prix,
                    'quantité' => $ quantité,
                ]]
            }
            Session :: put (?Cart?, $ cart);
        }
    }

    Mise à jour de la fonction publique ($ productId, $ Quantity)
    {
        if (auth :: check ()) {
            $ carcitem = Cart :: Where ('user_id', auth :: id ())
                           -> où ('product_id', $ productId)
                           -> First ();
            if ($ carditem) {
                if ($ quantité <= 0) {
                    $ cartitem-> delete ();
                } autre {
                    $ cartitem-> quantité = $ quantité;
                    $ Cartitem-> SAVE ();
                }
            }
        } autre {
            $ cart = session :: get (&#39;cart&#39;, []);
            if (isset ($ cart [$ productid])) {
                if ($ quantité <= 0) {
                    Unset ($ CART [$ productId]);
                } autre {
                    $ Cart [$ productId] [&#39;Quantité&#39;] = $ Quantité;
                }
                Session :: put (?Cart?, $ cart);
            }
        }
    }

    Fonction publique Supprimer ($ productId)
    {
        $ this-> mise à jour ($ productId, 0);
    }

    Fonction publique Clear ()
    {
        if (auth :: check ()) {
            Cart :: où (&#39;user_id&#39;, auth :: id ()) -> delete ();
        } autre {
            Session :: oublier (&#39;CART&#39;);
        }
    }

    fonction publique total ()
    {
        $ cart = $ this-> get ();
        if (auth :: check ()) {
            return $ cart-> sum (fn ($ item) => $ item-> product-> prix * $ item-> quantité);
        } autre {
            return Collect ($ cart) -> sum (fn ($ item) => $ item [&#39;prix&#39;] * $ item [&#39;Quantity&#39;]);
        }
    }
}

Assurez-vous que votre modèle Product est configuré et dispose d'un champ price .

4. Créer un contr?leur de chariot

 PHP Artisan Make: Contr?leur de contr?leur

 Namespace App \ Http \ Controllers;

Utiliser App \ Services \ CartService;
Utiliser illuminate \ http \ request;

Class CartController étend le contr?leur
{
    protégé $ cartservice;

    Fonction publique __construct (cartservice $ cartservice)
    {
        $ this-> cartService = $ cartService;
    }

    Index de fonction publique ()
    {
        $ carcitems = $ this-> cartService-> get ();
        $ total = $ this-> cartService-> total ();

        Return View ('Cart.Index', compact ('Cartitems', 'Total'));
    }

    fonction publique ajouter (demande $ demande)
    {
        $ this-> cartService-> add ($ request-> id, $ request-> quantité ?? 1);

        return redirect () -> back () -> avec ('succès', 'item ajouté à cart!');
    }

    Mise à jour de la fonction publique (demande $ demande, $ id)
    {
        $ this-> CartService-> Update ($ id, $ request-> quantité);

        return redirect () -> Route ('Cart.index');
    }

    Suppression de la fonction publique ($ id)
    {
        $ this-> CartService-> retirer ($ id);

        return redirect () -> Route ('Cart.index');
    }

    Fonction publique Clear ()
    {
        $ this-> cartService-> clear ();

        return redirect () -> Route ('Cart.index');
    }
}

5. Définir les routes

Dans routes/web.php :

 Utilisez App \ Http \ Controllers \ CartController;

Route :: Middleware (['Auth']) -> Groupe (fonction () {
    Route :: get ('/ cart', [cartController :: class, 'index']) -> name ('Cart.index');
    Route :: Post ('/ Cart / add / {id}', [CartController :: class, 'add']) -> name ('cart.add');
    Route :: put ('/ carta / update / {id}', [cartController :: class, 'update']) -> name ('Cart.update');
    Route :: Delete ('/ Cart / REPOP / {id}', [CartController :: class, 'repos']) -> name ('cart.remove');
    Route :: Delete ('/ Cart / Clear', [CartController :: Class, 'Clear']) -> name ('Cart.Clear');
});

Vous pouvez autoriser add sans auth si vous souhaitez que les invités ajoutent des articles.

6. Exemple de modèle de lame

resources/views/cart/index.blade.php :

 <h1> Votre panier </h1>

@if (session (?succès?))
    <div class = "alert-alert-sucess"> {{session (&#39;succès&#39;)}} </div>
@endif

<ul>
    @ForEach ($ Cartitems As $ article)
        <li>
            {{$ item [&#39;name&#39;] ?? $ item-> Product-> nom}}
            x {{$ item [&#39;quantité&#39;] ?? $ item-> quantité}}
            = $ {{($ item [&#39;Price&#39;] ?? $ item-> Product-> prix) * ($ item [&#39;Quantity&#39;] ?? $ item-> quantité)}}

            <form méthode = "post" Action = "{{Route (&#39;Cart.Update&#39;, $ item [&#39;product_id&#39;] ?? $ item-> product_id)}}" style = "affiche: inline;">
                @csrf
                @Method (&#39;put&#39;)
                <input type = "nombre" name = "quantité" value = "{{$ item [&#39;Quantity&#39;] ?? $ item-> quantité}}" min = "1" />
                <Button Type = "Soumider"> Mise à jour </frutch>
            </ form>

            <form méthode = "post" action = "{{Route (&#39;Cart.remove&#39;, $ item [&#39;product_id&#39;] ?? $ item-> product_id)}}" style = "affiche: inline;">
                @csrf
                @Method (&#39;Delete&#39;)
                <Button Type = "Soumider"> Supprimez </fontificateur>
            </ form>
        </li>
    @endforeach
</ul>

<p> <strong> total: $ {{numéro_format ($ total, 2)}} </strong> </p>
<a href = "{{Route (&#39;Checkout&#39;)}}"> Procéder à la caisse </a>

7. Sync Cart sur la connexion (facultatif mais recommandé)

Lorsqu'un utilisateur se connecte, fusionnez le panier de session dans la base de données.

Dans votre LoginController ou utilisez un écouteur d'événements:

 // dans une méthode authentifiée de connexion LoginController ou d'utilisation
fonction publique authentifiée (demande $ demande, $ utilisateur)
{
    // fusionner le panier de session dans la base de données
    $ sessioncart = session :: get ('cart', []);
    foreach ($ sessioncart comme $ item) {
        $ Cartitem = Cart :: Firstornw ([
            'user_id' => $ user-> id,
            'product_id' => $ item ['product_id'],
        ]));
        $ carcitem-> quantité = $ item ['quantité'];
        $ Cartitem-> SAVE ();
    }

    Session :: oublier ('CART'); // chariot de session claire
}

Notes finales

• Vous pouvez améliorer cela avec Ajax pour UX plus lisse.
• Pensez à utiliser Laravel Livewire pour les mises à jour de CART en temps réel.
• Pour les applications à grande échelle, envisagez d'utiliser Redis ou un microservice de panier dédié.

Fondamentalement, vous avez maintenant un système de panier flexible qui fonctionne à la fois pour les invités et les utilisateurs connectés, persiste les données et est facile à étendre. Pas trop complexe, mais couvre les besoins réels.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!