Suma total de productos en el carrito

Otra alternativa es usar reduce, así:

return products.reduce((sum, product) => sum + product.price)

yo cree un custom hook que se encarga de manejar todo lo relacionado con el carrito de compra

import { useState } from 'react'

export const useShoppingCart = () => {
  const [cart, setCart] = useState([])
  const [totalQuantity, setTotalQuantity] = useState(0)
  const [totalPrince, setTotalPrince] = useState(0)
  const [isCheckoutSideMenuOpen, setIsCheckoutSideMenuOpen] = useState(false)
    
  //Funciones que se encargan de abrir y cerrar el menu laterial de las ordenes
  const openCheckoutSideMenu = () => setIsCheckoutSideMenuOpen(true)
  const closeCheckoutSideMenu = () => setIsCheckoutSideMenuOpen(false)

  //Agrega un producto al carrito, y si ya existe aumenta la cantidad y suma los productos
  const addProduct = payload => {
    const productIndex = cart.findIndex(product => product.id === payload.id)
    let newCart = []
    if (productIndex >= 0) {
      newCart = [...cart]
      newCart[productIndex].quantity++
      newCart[productIndex].price = payload.price + newCart[productIndex].price
    } else {
      newCart = [...cart, { ...payload, quantity: 1 }]
    }
    setCart(newCart)
    getTotalInfo(newCart)
    openCheckoutSideMenu()
  }

  const deleteProduct = (id) => {
    console.log(id)
    const newCart = cart.filter(product => product.id !== id)
    setCart(newCart)
  }

  const showCartList = () => {
    return cart
  }

  const getTotalQuantity = (data) => {
    const quantity = data.reduce((total, product) => total + product.quantity, 0)
    setTotalQuantity(quantity)
  }

  const getTotalPrice = (data) => {
    const price = data.reduce((total, product) => total + product.price, 0)
    setTotalPrince(price)
  }
  const getTotalInfo = (data) => {
    getTotalQuantity(data)
    getTotalPrice(data)
  }

  return {
    cart,
    addProduct,
    deleteProduct,
    showCartList,
    totalQuantity,
    totalPrince,
    isCheckoutSideMenuOpen,
    openCheckoutSideMenu,
    closeCheckoutSideMenu
  }
}

Hola a todos! les comparto como integré la funcionalidad de añadir más cantidades de productos al carrito, además de calcular el total de cada producto dependiendo de su cantidad. También se encuentran ordenados alfabéticamente para evitar que al darle click se muevan de su puesto:

Bienvenidos a ver el código en el repositorio 😄:
GitHub Repository - andrescaro16 - React-Vite-Ecommerce

 
Cualquier oportunidad de mejora se agradece! 🤠

Esta fue mi solucion:

const totalPrice = (array) => {
    let total = 0
    let prices = array.map(product => product.price)
    prices.forEach(price => total += price)
    return total
}

Con base a los comentarios de los pares: Sandro y Humberto, le pregunté a la IA y me sugirió este código para utiles/index.js:

export const totalPrice = products => products.reduce((sum, {price}) => sum + price, 0);

Hola comunidad! Preparé un Order Card pero con otras funcionalidades como pueden ver en la imagen. Se puede aumentar y disminuir la cantidad de un producto, hice cambios en el contexto y trate de dejar un diseño bonito para el componente (me tomó horas, soy principiante en Tailwind y CSS). Les dejo mis apuntes, el código y el paso a paso hecho en Notion. Espero les sea de utilidad.
Link aquí:
https://bg99astro.notion.site/Order-Card-641bb8875a3e47fca133b2dceae40b84

Mi solucion:

const accumulate = (acc, value ) => acc + value.price

export const totalPrice = (products) => {
 return products.reduce(accumulate, 0)
}

por si quieren aprender mas de reduce les dejo este link
https://youtu.be/tP8JiVUiyDo?t=1070

Antes de ver el resto de la clase:

export const calculateTotalPrice = (products) => {
  return products.reduce((total, product) => {
    return total + product.price
  }, 0)
}

Yo lo hice con el método de array “reduce” :

export const totalPrice = (products) =>{
    return products.reduce((acc, product) => acc + product.price, 0);
}

Mi versión…

/**
 * @function totalPrice - Function to calculate the total price of the products in the cart
 * @param {Array} cartProducts - Array of objects with the products added to the cart
 * @returns {Number} - The total price of the products in the cart
 */

export const totalPrice = (cartProducts) => {
  return cartProducts.reduce((acc, product) => acc + product.price, 0)
}

Mi solucion fue agregar una propiedad totalQuantityPrice que se inicia con el precio del producto. Al agregar un producto que ya está en el carrito se multiplica el precio del producto por quantity la cantidad del producto en el carrito y luego para obtener el precio total de los productos en el carrito agregue un constante en el contexto que utiliza la funcion reduce(se utiliza para reducir un array a un solo valor) para sumar el precio de todo el carrito

const addToCart = (product) => {
    // Encuentra la posición del producto actual en el carrito según su 'id'.
    const productInCart = cart.findIndex(item => item.id === product.id);

    // Si el producto ya está en el carrito.
    if (productInCart >= 0) {
        // Crea una copia profunda del carrito actual.
        const newCart = structuredClone(cart);

        // Incrementa la cantidad del producto en el nuevo carrito.
        newCart[productInCart].quantity += 1;

        // Actualiza el precio total multiplicando el precio por la nueva cantidad.
        newCart[productInCart].totalQuantityPrice = newCart[productInCart].price * newCart[productInCart].quantity;

        // Actualiza el estado del carrito con el nuevo carrito.
        setCart(newCart);
    } else {
        // Si el producto no está en el carrito, lo agrega como un nuevo elemento.
        setCart(prevState => ([
            ...prevState,
            {
                ...product,
                quantity: 1,
                totalQuantityPrice: product.price
            }
        ]));
    }
}

// Elimina una unidad de un producto dado del carrito.
const removeOneFromCart = (product) => {
    const productInCart = cart.findIndex(item => item.id === product.id);
    if (productInCart >= 0) {
        const newCart = structuredClone(cart);

        // Si la cantidad del producto no es 1, reduce la cantidad en el nuevo carrito.
        if (newCart[productInCart].quantity !== 1) {
            newCart[productInCart].quantity -= 1;

            // Actualiza el precio total multiplicando el precio por la nueva cantidad.
            newCart[productInCart].totalQuantityPrice = newCart[productInCart].price * newCart[productInCart].quantity;

            setCart(newCart);
        }
    }
}

En clases anteriores me dio por hacer esta funcion, tengan en cuenta de que no me esperaba esta clase:

  const getTotal = () => {
    if (cartProducts.length != 0) {
      return (
        <p className="font-medium text-xl">
          {
            cartProducts
            .map(product => product.price)
            .reduce((total, price) => total + price)
          }
        </p>
      )
    } 
  }

Use un reduce, creo que el metodo cumple perfecto para esta tarea.

export const sumPriceAllItems = (items, initialValue = 0) => {
  return items.reduce((acc, item) => acc + item.price, initialValue )
}

Asi vamos…

Mi funcion totalprice 😼

/*
 * This function calculates total price of a new order
 * @params {Array} products cartProducts: Array of Objects 
 * @return {number} Total price
 */


export const totalPrice = (productList) => {
    const listPrices = productList.map( product => product.price)
    return sumArray(listPrices)
}

function sumArray(arr){
    return arr.reduce( (total, currentValue) => total + currentValue, 0)
}

import { IProduct } from '@/interfaces';

/**
 * Calculate the total price of a list of products and return the result
 * in currency format.
 *
 * @param {IProduct[]} products - The list of products to sum.
 * @param {string} [currency='USD'] - The currency in which the result will be displayed. Default is 'USD'.
 * @returns {string} - The total in currency format.
 */
export const totalPrice = (
  products: IProduct[],
  currency: string = 'USD'
): string => {
  const total = products.reduce(
    (total: number, element: IProduct) => total + Number(element.price),
    0
  );

  const formatter = new Intl.NumberFormat(undefined, {
    style: 'currency',
    currency: currency,
  });

  return formatter.format(total);
};

Mi alternativa

const calcTotal = (items) => {
let total = 0;
items.map((item) => (
total = total + (item.price * item.quantity)
))
context.setTotalAmmount(total);
}

Mi solución:

export const totalPrice = shoppingCart => {
	const initialValue = 0
	return shoppingCart.reduce(
		(accumulator, product) => accumulator + product.price * product.count,
		initialValue,
	)
}

Bueno, en mi caso decidí hacer la fucnion para obtener el valor total en el context, agrupado cerca de donde definí el estado de cartItems
.
Decidí hacerlo así porque me pareció apropiado ya que es en el mismo contexto donde tengo la información de los productos.
.
No estoy muy seguro de que tipo de cosas meter en utils. He visto ese archivo en otras partes pero no lo he usado personalmente
.
Si no estuviera usando la estrategia de hooks sin usar context, el estado y las funciones para agregar y quitar productos del carrito y esto de sumar el total irían dentro de el hook useShoppingCart

La forma mas larga de hacerlo con un for.

let sum = 0
   for(let i = 0; i < products.length; i++){
        const product = products[i]
        const suma = sum += product.price
    }

Buenas si usan reduce, es necesario setear un valor inicial, ya que al cargar por 1 vez la pagina el carrito no tendra elementos y nos tira un error.

/**
 * This function allows to calculate the price of a new order
 * @param {Array} products
 * @returns Total Price
 */
export const GetTotalPrice = (products) =>
  products.reduce((sum, product) => {
    return sum + product.price;
  }, 0);

genial 😊