⑧-购物车--小兔鲜电商项目实战

已于 2025-03-24 11:20:13 修改
阅读量662 收藏 12
点赞数 26
文章标签： javascript 开发语言 前端 vue.js
于 2025-03-22 09:36:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78301373/article/details/146431812
版权

本地购物车

第一步、在src\stores\cartStore.js，封装购物车模块（简单）

// 封装购物车模块
import { defineStore } from 'pinia'
import { ref } from 'vue'

export const useCartStore = defineStore('cart', () => {
  // 1. 定义state - cartList
  const cartList = ref([])
  // 2. 定义action - addCart
  const addCart = (goods) => {
    console.log('添加', goods)
    // 添加购物车操作
    // 已添加过 --- count + 1
    // 没有添加过 --- 直接push
    // 思路：通过匹配传递过来的商品对象中的skuId能不能在cartList中找到，
    // 找到了就是添加过
    const item = cartList.value.find((item) => goods.skuId === item.skuId)
    if (item) {
      // 找到了
      item.count++
    } else {
      // 没找到
      cartList.value.push(goods)
    }
  }
  return {
    cartList, // 购物车列表
    addCart // 添加商品的方法
  }
}, {
  persist: true
})

addCart 方法：

接收一个商品对象 goods。检查购物车中是否已经存在该商品（通过 skuId 匹配）。如果存在，商品数量 count +1。如果不存在，将商品添加到购物车。

第二步、在src\stores\cartStore.js，

<script setup>
import { ElMessage } from 'element-plus'
import { useCartStore } from '@/stores/cartStore'
const cartStore = useCartStore()

// sku规格被操作时
let skuObj = {}
const skuChange = (sku) => {
  console.log('skuChange-sku:', sku)
  // 验证:在商品详情页点击选择某个规格款式,控制台有输出
  skuObj = sku
}

const count = ref(1)
const countChange = (count) => {
  // 验证:商品详情页点击选择某个数量,会打印出当前数量
  console.log(count)
}

const addCart = () => {
  if (skuObj.skuId) {
    cartStore.addCart({
      id: goods.value.id,
      name: goods.value.name,
      picture: goods.value.mainPicture[0],
      price: goods.value.price,
      count: count.value,
      skuId: skuObj.skuId,
      attrsText: skuObj.specsText,
      selected: true
    })
  } else {
    ElMessage.warning('密码的,选商品不选规格,你买个集贸啊')
  }
}

</script>

<template>
              <!-- sku组件 -->
              <XtxSku :goods="goods" @change="skuChange" />
              <!-- 数据组件 -->
              <!-- 添加数据限制   :min="1" :max="10" -->
              <el-input-number v-model="count" :min="1" :max="10" @change="countChange" />
              <!-- 按钮组件 -->
</template>

addCart 方法：

检查用户是否选择了商品规格（skuObj.skuId 是否存在）。如果选择了规格，调用 cartStore.addCart 将商品加入购物车。如果没选择规格，弹出警告提示（ElMessage.warning）。

git提交--购物车--本地加入购物车

验证：判断有没有选规格，或者有没有选全规格

查看数据

1. 添加购物车

基础思想：如果已经添加过相同的商品，就在其数量count上加一，如果没有添加过，就直接push到购物车列表中

// 封装购物车模块

import { defineStore } from 'pinia'
import { ref } from 'vue'


export const useCartStore = defineStore('cart', () => {
  // 1. 定义state - cartList
  const cartList = ref([])
  // 2. 定义action - addCart
  const addCart = (goods) => {
    console.log('添加', goods)
    // 添加购物车操作
    // 已添加过 - count + 1
    // 没有添加过 - 直接push
    // 思路：通过匹配传递过来的商品对象中的skuId能不能在cartList中找到，找到了就是添加过
    const item = cartList.value.find((item) => goods.skuId === item.skuId)
    // item是回调函数的参数名,你可以随意命名,比如 product 或 goodsItem。
    // find 方法会遍历数组，将每个元素作为参数传给回调函数。
    if (item) {
      // 找到了
      item.count++
    } else {
      // 没找到
      cartList.value.push(goods)
    }
  }
  return {
    cartList,
    addCart
  }
}, {
  persist: true,
})

解释一下const item = cartList.value.find((item) => goods.skuId === item.skuId)： item 不是固定语法，而是回调函数的参数名，可以任意命名。find 方法会遍历数组，将每个元素传递给回调函数，item 只是参数名，代表当前遍历的元素。

2. 头部购物车

2.1 头部购物车组件模版

新建src\views\Layout\components\HeaderCart.vue

<script setup>

</script>

<template>
  <div class="cart">
    <a class="curr" href="javascript:;">
      <i class="iconfont icon-cart"></i><em>2</em>
    </a>
    <div class="layer">
      <div class="list">
        <!--
        <div class="item" v-for="i in cartList" :key="i">
          <RouterLink to="">
            <img :src="i.picture" alt="" />
            <div class="center">
              <p class="name ellipsis-2">
                {{ i.name }}
              </p>
              <p class="attr ellipsis">{{ i.attrsText }}</p>
            </div>
            <div class="right">
              <p class="price">&yen;{{ i.price }}</p>
              <p class="count">x{{ i.count }}</p>
            </div>
          </RouterLink>
          <i class="iconfont icon-close-new" @click="store.delCart(i.skuId)"></i>
        </div>
        -->
      </div>
      <div class="foot">
        <div class="total">
          <p>共 10 件商品</p>
          <p>&yen; 100.00 </p>
        </div>
        <el-button size="large" type="primary" >去购物车结算</el-button>
      </div>
    </div>
</div>
</template>

<style scoped lang="scss">
.cart {
  width: 50px;
  position: relative;
  z-index: 600;

  .curr {
    height: 32px;
    line-height: 32px;
    text-align: center;
    position: relative;
    display: block;

    .icon-cart {
      font-size: 22px;
    }

    em {
      font-style: normal;
      position: absolute;
      right: 0;
      top: 0;
      padding: 1px 6px;
      line-height: 1;
      background: $helpColor;
      color: #fff;
      font-size: 12px;
      border-radius: 10px;
      font-family: Arial;
    }
  }

  &:hover {
    .layer {
      opacity: 1;
      transform: none;
    }
  }

  .layer {
    opacity: 0;
    transition: all 0.4s 0.2s;
    transform: translateY(-200px) scale(1, 0);
    width: 400px;
    height: 400px;
    position: absolute;
    top: 50px;
    right: 0;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
    background: #fff;
    border-radius: 4px;
    padding-top: 10px;

    &::before {
      content: "";
      position: absolute;
      right: 14px;
      top: -10px;
      width: 20px;
      height: 20px;
      background: #fff;
      transform: scale(0.6, 1) rotate(45deg);
      box-shadow: -3px -3px 5px rgba(0, 0, 0, 0.1);
    }

    .foot {
      position: absolute;
      left: 0;
      bottom: 0;
      height: 70px;
      width: 100%;
      padding: 10px;
      display: flex;
      justify-content: space-between;
      background: #f8f8f8;
      align-items: center;

      .total {
        padding-left: 10px;
        color: #999;

        p {
          &:last-child {
            font-size: 18px;
            color: $priceColor;
          }
        }
      }
    }
  }

  .list {
    height: 310px;
    overflow: auto;
    padding: 0 10px;

    &::-webkit-scrollbar {
      width: 10px;
      height: 10px;
    }

    &::-webkit-scrollbar-track {
      background: #f8f8f8;
      border-radius: 2px;
    }

    &::-webkit-scrollbar-thumb {
      background: #eee;
      border-radius: 10px;
    }

    &::-webkit-scrollbar-thumb:hover {
      background: #ccc;
    }

    .item {
      border-bottom: 1px solid #f5f5f5;
      padding: 10px 0;
      position: relative;

      i {
        position: absolute;
        bottom: 38px;
        right: 0;
        opacity: 0;
        color: #666;
        transition: all 0.5s;
      }

      &:hover {
        i {
          opacity: 1;
          cursor: pointer;
        }
      }

      a {
        display: flex;
        align-items: center;

        img {
          height: 80px;
          width: 80px;
        }

        .center {
          padding: 0 10px;
          width: 200px;

          .name {
            font-size: 16px;
          }

          .attr {
            color: #999;
            padding-top: 5px;
          }
        }

        .right {
          width: 100px;
          padding-right: 20px;
          text-align: center;

          .price {
            font-size: 16px;
            color: $priceColor;
          }

          .count {
            color: #999;
            margin-top: 5px;
            font-size: 16px;
          }
        }
      }
    }
  }
}
</style>

进一步修改：在导航栏（Header导航和Fixed吸顶导航）导入购物车插件（渲染为一个购物车的小图标）（即src\views\Layout\components\LayoutFixed.vue和LayoutHeader.vue）

<script setup>
import HeaderCart from './HeaderCart.vue'
</script>

<template>
	略略略略略略略略略略略略
      <!-- 头部购物车 -->
      <HeaderCart />
    </div>
  </div>
</template>

<script setup>
import HeaderCart from './HeaderCart.vue'
</script>

<template>
	略略略略略略略略略略略略略略略
      <!-- 头部购物车 -->
      <HeaderCart />
    </div>
  </header>
</template>

再回到src\views\Layout\components\HeaderCart.vue，让购物车列表实现即时渲染，并且购物车小图标的右上角的红数字，也跟着响应式。

<script setup>
import { useCartStore } from '@/stores/cartStore'
const cartStore = useCartStore()
</script>

<template>
  <div class="cart">
    <a class="curr" href="javascript:;">
      <i class="iconfont icon-cart"></i><em>{{ cartStore.cartList.length }}</em>
    </a>
    <div class="layer">
      <div class="list">
        
        <div class="item" v-for="i in cartStore.cartList" :key="i">
          <RouterLink to="">
</template>

git提交--购物车-本地购物车-头部购物车列表渲染

验证：很好验证，随便点击一个商品详情页，选好规格，“加入购物车”，看看头部购物车那个小图标是否响应式变化即可。

2.2 添加删除功能：

第一步、在src\stores\cartStore.js，添加action删除方法

export const useCartStore = defineStore('cart', () => {
  // 3. 定义action - 删除购物车
  const delCart = (skuId) => {
    const idx = cartList.value.findIndex((item) => item.skuId === skuId)
    cartList.value.splice(idx, 1)
  }
  return {
    cartList, // 购物车列表
    addCart, // 添加商品的方法
    delCart // 删除商品的方法
  }
})

第二步、在src\views\Layout\components\HeaderCart.vue中调用

<template>
          </RouterLink>
          <i class="iconfont icon-close-new" @click="cartStore.delCart(i.skuId)"></i>
        </div>
</template>

git提交--本地购物车-头部购物车删除功能实现

验证：很好验证，去购物车里，把列表的商品删除，看看会不会即时响应即可

2.3 添加计算总价功能：

第一步、在src\stores\cartStore.js，添加计算属性，并导出

import { computed } from 'vue'

export const useCartStore = defineStore('cart', () => {
  // 4. 定义计算属性 - 购物车总数量和总价格
  const allCount = computed(() => cartList.value.reduce((a, c) => a + c.count, 0))
  // a: 累加器, 表示之前计算出的总价格. c: 当前遍历到的商品对象.包含skuId,price,count属性.
  const allPrice = computed(() => cartList.value.reduce((a, c) => a + c.price * c.count, 0))
  return {
    delCart, // 删除商品的方法
    allCount, // 购物车总数量
    allPrice // 购物车总价格
  }
})

第二步、在src\views\Layout\components\HeaderCart.vue，动态渲染总数量、总价响应式数据

<template>
        <div class="total">
          <p>共 {{ cartStore.allCount }} 件商品</p>
          <p>&yen; {{ cartStore.allPrice }} </p>
        </div>
</template>

git提交--本地购物车-头部购物车-添加计算总价功能

3. 列表购物车-基础内容渲染

3.1. 准备静态模版

新建文件夹和文件：src\views\CartList\index.vue

<script setup>
const cartList = []
</script>

<template>
  <div class="xtx-cart-page">
    <div class="container m-top-20">
      <div class="cart">
        <table>
          <thead>
            <tr>
              <th width="120">
                <el-checkbox/>
              </th>
              <th width="400">商品信息</th>
              <th width="220">单价</th>
              <th width="180">数量</th>
              <th width="180">小计</th>
              <th width="140">操作</th>
            </tr>
          </thead>
          <!-- 商品列表 -->
          <tbody>
            <tr v-for="i in cartList" :key="i.id">
              <td>
                <el-checkbox />
              </td>
              <td>
                <div class="goods">
                  <RouterLink to="/"><img :src="i.picture" alt="" /></RouterLink>
                  <div>
                    <p class="name ellipsis">
                      {{ i.name }}
                    </p>
                  </div>
                </div>
              </td>
              <td class="tc">
                <p>&yen;{{ i.price }}</p>
              </td>
              <td class="tc">
                <el-input-number v-model="i.count" />
              </td>
              <td class="tc">
                <p class="f16 red">&yen;{{ (i.price * i.count).toFixed(2) }}</p>
              </td>
              <td class="tc">
                <p>
                  <el-popconfirm title="确认删除吗?" confirm-button-text="确认" cancel-button-text="取消" @confirm="delCart(i)">
                    <template #reference>
                      <a href="javascript:;">删除</a>
                    </template>
                  </el-popconfirm>
                </p>
              </td>
            </tr>
            <tr v-if="cartList.length === 0">
              <td colspan="6">
                <div class="cart-none">
                  <el-empty description="购物车列表为空">
                    <el-button type="primary">随便逛逛</el-button>
                  </el-empty>
                </div>
              </td>
            </tr>
          </tbody>

        </table>
      </div>
      <!-- 操作栏 -->
      <div class="action">
        <div class="batch">
          共 10 件商品，已选择 2 件，商品合计：
          <span class="red">¥ 200.00 </span>
        </div>
        <div class="total">
          <el-button size="large" type="primary" >下单结算</el-button>
        </div>
      </div>
    </div>
  </div>
</template>

<style scoped lang="scss">
.xtx-cart-page {
  margin-top: 20px;

  .cart {
    background: #fff;
    color: #666;

    table {
      border-spacing: 0;
      border-collapse: collapse;
      line-height: 24px;

      th,
      td {
        padding: 10px;
        border-bottom: 1px solid #f5f5f5;

        &:first-child {
          text-align: left;
          padding-left: 30px;
          color: #999;
        }
      }

      th {
        font-size: 16px;
        font-weight: normal;
        line-height: 50px;
      }
    }
  }

  .cart-none {
    text-align: center;
    padding: 120px 0;
    background: #fff;

    p {
      color: #999;
      padding: 20px 0;
    }
  }

  .tc {
    text-align: center;

    a {
      color: $xtxColor;
    }

    .xtx-numbox {
      margin: 0 auto;
      width: 120px;
    }
  }

  .red {
    color: $priceColor;
  }

  .green {
    color: $xtxColor;
  }

  .f16 {
    font-size: 16px;
  }

  .goods {
    display: flex;
    align-items: center;

    img {
      width: 100px;
      height: 100px;
    }

    >div {
      width: 280px;
      font-size: 16px;
      padding-left: 10px;

      .attr {
        font-size: 14px;
        color: #999;
      }
    }
  }

  .action {
    display: flex;
    background: #fff;
    margin-top: 20px;
    height: 80px;
    align-items: center;
    font-size: 16px;
    justify-content: space-between;
    padding: 0 30px;

    .xtx-checkbox {
      color: #999;
    }

    .batch {
      a {
        margin-left: 20px;
      }
    }

    .red {
      font-size: 18px;
      margin-right: 20px;
      font-weight: bold;
    }
  }

  .tit {
    color: #666;
    font-size: 16px;
    font-weight: normal;
    line-height: 50px;
  }

}
</style>

3.2. 修改完善操作

第一步、绑定路由

在src\router\index.js中，为刚刚的cartList配置并绑定路由（是二级路由，在Layout的children里）

import CartList from '@/views/CartList/index.vue'

          path: 'detail/:id',
          component: Detail
        },
        {
          path: 'cartlist',
          component: CartList
        }

第二步、动态渲染响应式列表

回到src\views\CartList\index.vue，动态渲染响应式数据

<script setup>
import { useCartStore } from '@/stores/cartStore'
const cartStore = useCartStore()
</script>

<template>
          <tbody>
            <tr v-for="i in cartStore.cartList" :key="i.id">
            </tr>
            <tr v-if="cartStore.cartList.length === 0">
            </tr>
          </tbody>
</template>

git提交--本地购物车-列表购物车基础数据渲染

4. 列表购物车-单选功能实现

基本思想：通过skuId找到要进行单选操作的商品，把控制是否选中的selected字段修改为当前单选框的状态

核心思路：单选的核心思路就是始终把单选框的状态和Pinia中store对应的状态保持同步

注意事项：为什么不使用v-model呢？ v-model双向绑定指令不方便进行命令式的操作（因为后续还需要调用接口），所以把v-model回退到一般模式，也就是 :model-value 和 @change 的配合实现（没太懂）

第一步、在src\stores\cartStore.js 添加单选action并导出

export const useCartStore = defineStore('cart', () => {

  // 5. 单选功能
  const singleCheck = (skuId, selected) => {
    const item = cartList.value.find((item) => item.skuId === skuId)
    item.selected = selected
  }
  return {
    singleCheck // 单选功能
  }
})

singleCheck 方法：接收 skuId（商品的唯一标识） 和 selected（选中状态，true 或 false） 两个参数。通过 skuId 找到对应的商品，并更新其 selected 状态。

第二步、在src\views\CartList\index.vue，触发单选action方法

<script setup>
// 单选回调
const singleCheck = (i, selected) => {
  console.log(i, selected)
  // store cartList 数组 无法知道要修改谁的选中状态？
  // 除了selected补充一个用来筛选的参数 - skuId
  // 这一句最重要, 调用cartStore里面的singleCheck,不然不会触发响应式
  // 你去点击单选框,虽然会打印出i和selected,但是单选框的状态不会改变
  cartStore.singleCheck(i.skuId, selected)
}
</script>

  
<template>
  <td>
    <!-- 单选框 -->
    <!-- <el-checkbox/> -->
    <!-- 这个是使用v-model,不推荐 -->
    <!-- <el-checkbox v-model="i.selected" /> -->
    <!-- 使用箭头函数,传递俩参数,i和selected -->
    <el-checkbox :model-value="i.selected" @change="(selected) => singleCheck(i, selected)" />
  </td>
</template>

1、singleCheck 方法：

接收两个参数：①i：当前商品对象。②selected：单选框的选中状态（true 或 false）。

调用 cartStore.singleCheck(i.skuId, selected)，更新购物车中对应商品的选中状态。

2、cartStore.singleCheck(i.skuId, selected)：

调用 cartStore 中的 singleCheck 方法，更新商品的选中状态。如果不调用这个方法，单选框的状态不会改变，因为 Vue 的响应式系统无法感知到状态变化。

git提交（很难）--本地购物车--列表购物车单选功能实现

为什么不用v-model

<el-checkbox :model-value="i.selected" @change="(selected) => singleCheck(i, selected)" /> 和 <el-checkbox v-model="i.selected" />有什么区别？

先说结论：v-model 确实可以实现功能，但它 直接修改数据 的方式在大型项目中会带来维护上的问题。用 @change 的方式虽然代码稍微多一点，但更符合 单向数据流 的设计，也更易于维护和扩展。

如果你只关注功能，v-model 没问题；如果你在乎代码规范和长期维护，建议用 @change。简洁明了，就是这样！

1. 功能确实一样

回答来自--腾讯元宝

从功能上看，v-model 和 @change 都能实现单选框状态的同步，界面上看不出区别。

2. 为什么不用 v-model？

核心原因：v-model 会直接修改数据，而 Pinia 的最佳实践是通过 action 方法 来修改状态。以下是具体原因：

（1）直接修改数据 vs 通过 action 修改

• v-model 的方式：

<el-checkbox v-model="i.selected" />

这行代码会直接修改 i.selected，绕过了 Pinia 的 singleCheck 方法。虽然功能上没问题，但从设计上来说，直接修改 store 的状态是不推荐的，因为它会破坏状态管理的规范性。

• @change 的方式：

<el-checkbox :model-value="i.selected" @change="(selected) => singleCheck(i, selected)" />

这种方式会调用 Pinia 的 singleCheck 方法，通过 action 来更新状态。这是 Pinia 推荐的做法，因为它更规范、更易于维护。

（2）可维护性和扩展性

• 如果用 v-model，未来如果需要修改状态更新的逻辑（例如添加日志、校验等），你需要在多个地方修改代码。 • 如果用 @change 和 Pinia 的 action，所有状态更新的逻辑都集中在 store 中，更容易维护和扩展。

（3）调试和追踪

• 通过 action 修改状态，可以更方便地调试和追踪状态的变更。如果直接修改数据，调试起来会更困难。

3. 推荐使用 v-model 吗？

看情况： • 如果项目简单，且你确定不会遇到状态管理的复杂需求，用 v-model 完全没问题。它更简洁，适合快速开发。 • 如果项目复杂，或者你希望遵循 Pinia 的最佳实践，推荐用 @change 和 action 的方式，因为它更规范、更易于维护。

4. 用 v-model 的替代方案

如果你既想用 v-model 的简洁性，又想遵循 Pinia 的规范，可以这样做：

<el-checkbox :model-value="i.selected" @update:model-value="(selected) => singleCheck(i, selected)" />

这种方式结合了 v-model 的简洁性和 @change 的规范性，是一个折中的方案。

总结

• 功能上，v-model 和 @change 确实一样。 • 设计上，@change 更符合 Pinia 的最佳实践，适合复杂项目。 • 推荐： • 简单项目用 v-model，快速开发。 • 复杂项目用 @change，遵循规范。 • 如果想兼顾简洁和规范，可以用 @update:model-value。

5. 列表购物车-全选功能实现

基础思想：

  1. 全选状态决定单选框状态 - 遍历cartList把每一项的selected都设置为何全选框状态一致
  2. 单选框状态决定全选状态 - 只有所有单选框的selected都为true, 全选框才为true

第一步、在src\stores\cartStore.js中定义action和计算属性

export const useCartStore = defineStore('cart', () => {
  // 6. 全选功能
  // 判断是否全选
  const isAll = computed(() => cartList.value.every((item) => item.selected))
  const allCheck = (selected) => {
    // 把所有商品的selected状态设置为当前全选框的selected状态
    cartList.value.forEach(item => item.selected = selected)
  }
  return {
    isAll,
    allCheck
  }
})

第二步、在src\views\CartList\index.vue组件中触发aciton和使用计算属性

<script setup>
const allCheck = (selected) => {
  cartStore.allCheck(selected)
}
</script>

  
<template>
  <!-- 全选框 -->
  <el-checkbox :model-value="cartStore.isAll" @change="allCheck"/>
</template>

git提交（挺简单的）--本地购物车--列表购物车全选功能实现

6. 列表购物车-统计数据功能实现

第一步、在src\stores\cartStore.js中，定义计算属性，已选商品数量和总价

export const useCartStore = defineStore('cart', () => {
  const selectedCount = computed(() => cartList.value.filter((item) => item.selected).reduce((a, c) => a + c.count, 0))
  const selectedPrice = computed(() => cartList.value.filter((item) => item.selected).reduce((a, c) => a + c.count * c.price, 0))
  return {
    selectedCount,
    selectedPrice
  }
})

代码解释：

filter 用于筛选数组中符合条件的元素，返回一个新数组。这里返回一个只包含 selected 为 true 的商品的新数组。

reduce 用于将数组中的元素累积为一个值。(a, c) => a + c.count * c.price：回调函数。a：累积值（初始值为 0）。c：当前处理的商品对象。c.count：当前商品的数量。c.price：当前商品的单价。0：初始值，表示从 0 开始累积。

箭头函数有点多，有点复杂。替换成普通函数是

function() {
  return cartList.value.filter(...).reduce(...);
}

第二步、在src\views\CartList\index.vue中，

<template>
  <div class="batch">
    共 {{ cartStore.allCount }} 件商品，已选择 {{ cartStore.selectedCount }} 件，商品合计：
    <span class="red">¥ {{ cartStore.selectedPrice.toFixed(2) }} </span>
  </div>
</template>

git提交（较简单）--列表购物车-统计数据功能实现

接口购物车

1. 加入购物车

来自弹幕君："各位注意如果你一刷新就显示没有有效数据，或者你登录之后发现购物车多了写数据，是因为其他人和你登录了同一个账号，也说明你们同时在卷，共勉"

第一步、在src\apis\cart.js（新建）封装购物车相关的api接口

// 封装购物车相关的api接口
import request from '@/utils/http'

// 调用接口,发送POST请求,加入购物车
export const insertCartAPI = ({ skuId, count }) => {
  return request({
    url: '/member/cart',
    // 请求方式：POST，将数据通过 data 传递给服务器。
    method: 'POST',
    data: {
      skuId,
      count
    }
  })
}

// 调用接口,发送GET请求,获取最新购物车列表
export const findNewCartListAPI = () => {
  return request({
    url: '/member/cart'  
  })
}

第二步、在src\stores\cartStore.js中，action中适配登录和非登录，去实现接口购物车

import { useUserStore } from './userStore'
import { insertCartAPI, findNewCartListAPI } from '@/apis/cart'

export const useCartStore = defineStore('cart', () => {
  const userStore = useUserStore()
  const isLogin = computed(() => userStore.userInfo.token)

  // 2. 定义action - addCart
  const addCart = async (goods) => {
    const { skuId, count } = goods
    // 判断用户是否登录
    if (isLogin.value) {
     await insertCartAPI({ skuId, count }) // 调用加入购物车接口
       // 获取最新购物车列表,并用res接收
      const res = await findNewCartListAPI()
      cartList.value = res.result // 更新购物车列表
      // 未登录,则是本地购物车的逻辑了
    } else {
		// 把原来的本地购物车的代码,粘贴至此
    }
  }

问题： const isLogin = computed(() => userStore.userInfo.token)为什么要用computed？

如果直接获取 userStore.userInfo.token，比如 const isLogin = userStore.userInfo.token，那么 isLogin 的值只会被赋值一次，后续 userStore.userInfo.token 的变化不会自动更新 isLogin。computed 是响应式的，当 userStore.userInfo.token 发生变化时，isLogin 会自动重新计算并更新。这对于用户登录状态这种动态变化的场景非常重要。

git提交--接口购物车-封装接口-加入购物车

验证：

2. 删除购物车

第一步、在src\apis\cart.js中，封装接口，发送delete请求

// 3. 调用接口,发送DELETE请求,删除购物车中的商品
export const delCartAPI = (ids) => {
  return request({
    url: '/member/cart',
    method: 'DELETE',
    data: {
      ids
    }
  })
}

第二步、在src\stores\cartStore.js中，封装优化原有的delCart方法，action中适配登录和非登录

import { delCartAPI } from '@/apis/cart'

  // 3. 定义action - 删除购物车
  const delCart = async (skuId) => {
    if (isLogin.value) {
      // 发送DELETE请求(可在网络面板中查看请求)
      await delCartAPI([skuId])
      const res = await findNewCartListAPI()
      cartList.value = res.result
    } else {
      const idx = cartList.value.findIndex((item) => item.skuId === skuId)
      // 从idx位置开始，删除1个元素
      cartList.value.splice(idx, 1)
    }
  }

第三步、在src\views\CartList\index.vue中，调用delCart方法

第一种调用方法

<script setup>
const delCart = (i) => {
  cartStore.delCart(i.skuId)
}
</script>

  
<template>
    <el-popconfirm title="确认删除吗?" confirm-button-text="确认" cancel-button-text="取消" @confirm="delCart(i)">
</template>

第二种调用方法

<template>
    <el-popconfirm title="确认删除吗?" confirm-button-text="确认" cancel-button-text="取消" @confirm="cartStore.delCart(i.skuId)">
</template>

优化一、封装获取购物车最新列表方法。因为在src\stores\cartStore.js中，很多方法都有'获取购物车最新列表'的请求，不如封装成函数

  // 8. 定义action - 获取最新购物车列表
  const updateNewList = async () => {
    // 获取最新购物车列表,并用res接收
    const res = await findNewCartListAPI()
    cartList.value = res.result
  }

把原来的，替换成updateNewList方法

优化二、重命名

在stores文件夹里，命名规则都加上后缀Store

这边没做这一步

git提交--接口购物车-实现删除功能

验证：

很好验证，分两种情况，均可实现删除，一种是直接点击购物车小图标，直接删除，另一种是跳转到购物车页面，进行删除，会有确认取消判断操作。

直观验证，看商品有没有即使被删除掉即可，深度验证，去网络面板查看，是否有两次请求，一个是DELETE请求，用于删除，一个是get请求，用于获取购物车列表最新数据。

3. 退出登录-清空购物车列表

业务需求：在用户退出登录时，除了清除用户信息之外，也需要把购物车数据清空

第一步、在购物车store中补充清除购物车的action（src\stores\cartStore.js）

  // 8. 定义action - 清空购物车
  const clearCart = () => {
    cartList.value = []
  }
    return {
    clearCart
  }

第二步、userStore中找到退出登录action，执行清除业务（src\stores\user.js）

import { useCartStore } from './cartStore'
export const useUserStore = defineStore('user', () => {
  // 4. 获取购物车cartStore
  const cartStore = useCartStore()
  // 3. 退出时清除用户信息
  const clearUserInfo = () => {
    userInfo.value = {}
    // 执行清除购物车的action
    cartStore.clearCart()
  }
}

git提交--退出登录-清空购物车列表

验证：退出登录，此时购物车应为空。但是，当你再次登录的时候，没有记忆功能，也就是说再次登录，购物车从0开始，为空。（后面会解决）

4.合并本地购物车到服务器

问：用户在非登录时进行的所有购物车操作，我们的服务器能知道吗？ 答：不能！不能的话不是白操作了吗？还本地购物车的意义在哪？解决办法：在用户登录时，把本地的购物车数据和服务端购物车数据进行合并操作

第一步、封装合并购物车接口。（src\apis\cart.js）登录时调用合并购物车接口

// 调用接口,发送POST请求,合并购物车
export const mergeCartAPI = (data) => {
  return request({
    url: 'member/cart/merge',
    method: 'POST',
    // 此处data是由传参传过来的？？？
    data
  })
}

第二步、调用合并购物车接口，并获取最新的购物车列表（src\stores\user.js）

import { mergeCartAPI } from '@/apis/cart'

export const useUserStore = defineStore('user', () => {
  // 2. 定义获取接口数据的action函数
  const getUserInfo = async ({ account, password }) => {
    const res = await loginAPI({ account, password })
    userInfo.value = res.result
    // 2.2 合并本地购物车数据到服务器
    await mergeCartAPI(cartStore.cartList.map(item => {
      // map：用于遍历本地购物车数据，并提取需要的属性
      return {
        skuId: item.skuId,
        selected: item.selected,
        count: item.count
      }
    }))
    cartStore.updateNewList()
  }

  // 3. 退出时清除用户信息
  const clearUserInfo = () => {
    userInfo.value = {}
    // 执行清除购物车的action
    cartStore.clearCart()
  }
  // 以对象的格式把state和action return
  return {
    userInfo,
    getUserInfo,
    clearUserInfo,
    cartStore
  }
}, {
  persist: true
})

解释：map用法。

map 的详细过程

假设 cartStore.cartList 的数据如下：

[
  { skuId: '101', selected: true, count: 2, name: '商品A' },
  { skuId: '102', selected: false, count: 1, name: '商品B' }
]

经过 map 处理后，返回的新数组如下：

[
  { skuId: '101', selected: true, count: 2 },
  { skuId: '102', selected: false, count: 1 }
]

这个新数组会被传递给 mergeCartAPI，用于合并购物车数据。提取需要的data属性，去除不需要的属性，比如例子中的name属性。

git提交：合并本地购物车到服务器

验证，当你在本地（未登录状态）选好商品后，加入购物车，再登录后，本地购物车的数据，会合并到登录后的购物车。打开网络面板，会有俩请求，一个merge请求，一个cart请求

有个疑问，就是这里可以实现登录的记忆功能了。为什么呢？就仅仅那几行代码的作用，注释掉，又没有记忆功能了。

    await mergeCartAPI(cartStore.cartList.map(item => {
      // map：用于遍历本地购物车数据，并提取需要的属性
      return {
        skuId: item.skuId,
        selected: item.selected,
        count: item.count
      }
    }))
    cartStore.updateNewList()

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值