Playground - Sistema de carrito de compras

Cursos Empresas Blog Live Conf Precios

Contenido del curso

¡Te damos la bienvenida a este reto!

1
¡Bienvenido al mundo de JavaScript!
01:33 min

Día 1

Día 2

Día 3

Día 4

Día 5 - Checkpoint

20
Playground - encuentra el palindromo más grande

Día 6

Día 7

Día 8

Día 9

Día 10 - Checkpoint

Día 11

Día 12

Día 13

Día 14

Día 15 - Checkpoint

50
Playground - Sistema de reservaciones de un hotel

Día 16

Día 17

Día 18

Día 19

Día 20 - Checkpoint

65
Playground - Agenda de vuelos

Día 21

Día 22

Día 23

Día 24 - Checkpoint

77
Playground - Crea un task manager con patrones de diseño

Día 25

Día 26

Día 27

Día 28

Día 29

Día 30

93
¡Lo lograste!
01:41 min

Live Class

Tomar examen

Playground - Sistema de carrito de compras

Comentarios

Israel Blas

student

Tengan en cuenta algo que no dice el ejercicio por lo cual me demoré yo tambien más de la cuenta.

En la clase Cart deben almacenar los productos en la propiedad products o no podrán pasar por todas las pruebas ya que hay dos que verifican la longitud de esta propiedad.

Literal me quede como 10 minutos viendo porque estaba mal mi código, bueno abajo les dejo mi solución.

Solución:

. . . . . . .

import { Product } from "./product";

export class Article extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }

  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {

    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  constructor(products = []) {
    this.products = products
  }

  addProduct(product) {
    product.addToCart()
    this.products.push(product)
  }

  deleteProduct(product) {
    let index = this.products.findIndex(item => item.name === product.name)
    this.products.splice(index, 1);
  }

  calculateTotal() {
    let total
    return this.products.reduce((total, item) => {
      total += item.price * item.quantity
      return total
    }, 0)
  }
}

JOHN FREDDY BUITRAGO QUEVEDO

student

Hola, ten presente que los constructores en las clases que heredan sólo son necesarios si se agregan atributos propios de la clase, de lo contrario sobran. En la clase Cart tampoco sería necesario el constructor a menos que se vaya a inicializar los productos, bastaría sólo con colocar la variable como: products = []; al inicio del cuerpo de la clase Cart.

Leonardo de los angeles Espinoza Hernandez

student

Me llevo este feedback para agregarlo a la guía 💪

David Higuera

student

import { Product } from "./product";


export class Article extends Product {
  // Tu código aquí 👈
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name
      }  al carrito`;
  }
}

export class Service extends Product {
  // Tu código aquí 👈
  addToCart() {
    return `Agregando servicio ${this.name} al carrito`;
  }
}

export class Cart {
  // Tu código aquí 👈
  products = [];

  addProduct(product) {
    this.products.push(product);
    return product.addToCart();
  }

  deleteProduct(product) {
    this.products = this.products.filter((p) => p.name !== product.name);
    product.addToCart();
  }

  calculateTotal() {
    return this.products.reduce(
      (sum, curr) => sum + curr.price * curr.quantity,
      0
    );
  }

  getProducts() {
    return this.products;
  }
}

Abril Darynka Tapia Sosa

student

Hola, les comparto mi solucion

Como nota, la variable para almacenar debe de ser products sino las pruebas no pasaran, creo que hace falta eso en la guia 😅

Caminito anti spoilers 🛴✨ . . . . . . . . . . . . . . . . . . . . Llegamos 📍

import { Product } from "./product";

export class Article extends Product {
  // Tu código aquí 👈
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito"`
  }
}

export class Service extends Product {
  // Tu código aquí 👈
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  // Tu código aquí 👈
  constructor() {
    this.products = [];
  }
  addProduct(product) {
    product.addToCart()
    this.products.push(product)
  }
  deleteProduct(product) {
    const index = this.products.findIndex((item) =>
      item.name === product.name &&
      item.price === product.price &&
      item.quantity === product.quantity

    )
    this.products.splice(index, 1)
  }
  calculateTotal() {
    return this.products.reduce((acumulador, numero) => (acumulador + (numero.price * numero.quantity)), 0);
  }
}

Rafael Livise Larico

student

My solution

58 58 58

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`    
  }
}

export class Cart {
  constructor() {
    this.products = []
  }

  addProduct(product) {
    this.products.push(product)
    return product.addToCart()
  }
  deleteProduct(product) {
    const idx = this.products.findIndex(({ name }) => product.name === name)
    if (idx > -1) {
      this.products.splice(idx,1)
    }
  } 
  calculateTotal() {
    return this.products.reduce((sum, prod) => sum + prod.quantity * prod.price, 0)
  }
  getProducts() {
    return this.products
  }
}

Andres Felipe Torres

student

Mi solución

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`;
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

export class Cart {
  constructor() {
    this.products = [];
  }

  addProduct(product) {    
    this.products.push(product);
    return product.addToCart();
  }

  deleteProduct(product) {
    let itemIdx = this.products.findIndex((item) => {
      return item.name === product.name;
    });
    if (itemIdx > -1) {
      return this.products.splice(itemIdx, 1);
    }
  }

  calculateTotal() {
    return this.products.reduce((acum, product) => acum + product.price * product.quantity, 0);
  }

  getProducts() {
    return this.products;
  }
}

Joan Alexander Valerio Rodríguez

student

He disfrutado mucho el curso, pero al mismo tiempo no niego que no deja de ser un dolor de cabeza cuando se llega a los retos. Siempre antes de llenar el ejercicio, ocupo en desarrollar mi código en mi editor de código, una vez estando seguro entonces vengo a llenar mi reto, con la gran sorpresa de que acá nunca me funciona a la primera. En este caso me di cuenta que no redactaron algo que era necesario para completar el reto.

Sugerencia: Por favor una mejor redacción nos ayudaría a todos a ahorrar algo de tiempo, de verdad.

Jaime Alberto Parra Acevedo

student

No me corrio en playground no se que tengo mal

export class Article extends Product {

  addToCart() {
    super.addToCart();
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`;
  }

}

export class Service extends Product {

  addToCart() {
    super.addToCart();
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

export class Cart {
  constructor() {
    this.products = [];
  }
  addProduct(product) {
    this.products.push(product);
    return product.addToCart();
  }
  deleteProduct(product) {
    const index = this.products.findIndex(element => element.name === product.name);
    this.products.splice(index, 1);
  }
  calculateTotal() {
    return this.products.reduce((a, c) => a + c.quantity * c.price, 0);

  }
  getProducts() {
    return this.products;
  }
}

Sergio Luis Arango Montes

student

Hola. Quita el return del metodo addProduct() y quita las llamadas a super en las clases Article y Service. Ya con esos cambios pasas la prueba. Espero te ayude.

Andrés Soret Chacin

student

Mi solución 👇

import { Product } from "./product";

class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`;
  }
}

class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

class Cart {
  products = [];

  addProduct(product) {
    this.products.push(product);
    return product.addToCart();
  }
  deleteProduct(product) {
    const index = this.products.findIndex((p) => p.name === product.name);
    this.products.splice(index, 1);
  }
  calculateTotal() {
    const total = this.products.reduce((acc, val) => {
      const price = val.price * val.quantity;
      return price + acc;
    }, 0);
    return total;
  }
  getProducts() {
    return this.products;
  }
}

Harrison Steve Pinzón Neira

student

Desafio superado!

Luifer Eduardo Ortega Perez

student

Hay que destacar que en el texto no se especifica que se debe crear un método de los productos en la clase cart. Aquí está mi solución:

export class Article extends Product{
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product{
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

export class Cart {
  constructor() {
    this.products = new Array;
  }

  addProduct(product) {
    this.products.push(product)
    product.addToCart();
  }

  deleteProduct(product) {
    this.products.splice(this.products.findIndex(products => products.name == product.name), 1)
  }
  calculateTotal() {
    return this.products.map(element => element.price*element.quantity).reduce((sum, element) => sum + element, 0)
  }
  getProducts() {
    return this.products
  }
}

David Ochoa

student

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Sistema de carrito de compras

!Spoiler Shield

export class Article extends Product {
  // Tu código aquí 👈
  constructor(name, price, quantity) {
    super(name, price, quantity);
  }

  addToCart() {
    return `Agregando ${this.quantity} unidades del articulo ${this.name} al carrito`;
  }
}

export class Service extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity);
  }

  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
  // Tu código aquí 👈
}

export class Cart {
  constructor() {
    this.products = [];
  }
  // Tu código aquí 👈
  addProduct(product) {
    product.addToCart();
    this.products.push(product);
  }

  deleteProduct(product) {
    this.products = this.products.filter(
      (cartItem) => cartItem.name != product.name
    );
  }

  calculateTotal() {
    let total = 0;
    for (let item of this.products) {
      total += item.price * item.quantity;
    }
    return total;
  }
}

Pablo Perez

student

export class Article extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}


export class Cart {
  constructor() {
    this.cartList = []
  }
  addProduct(product) {
    product.addToCart()
    this.cartList.push({
      name: product.name,
      price: product.price,
      quantity: product.quantity
    })
  }
  deleteProduct(product) {
    const index = this.cartList.findIndex(obj => JSON.stringify(obj) === JSON.stringify(product))
    this.cartList.splice(index, 1)
  }
  calculateTotal() {
    const total = this.cartList.reduce((sum, item) => sum + item.price * item.quantity, 0)
    return total
  }
  getProducts() {
    return this.cartList
  }
}

Manuel Alexander Montañez Gordillo

student

Vamoooss!!!! . . . . . . . . .. . . .

import { Product } from "./product";

export class Article extends Product{
  addToCart() {
    console.log(`Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`)
    return Article
 }
}

export class Service extends Product {
  constructor(name, price, quantity, serviceName){
  super(name, price, quantity);
this.serviceName = serviceName;}

  addToCart() {
    return `Agregando el servicio ${this.serviceName} al carrito`
  }
}

export class Cart extends Product{
  constructor() {
    this.products = []
  }
  addProduct(product) {
    this.products.push(product);
    product.addToCart()
  }
  deleteProduct(product) {
    const index = this.products.findIndex(p => p === product);
    if (index !== -1)
      this.products.splice(index, 1)
  }
    calculateTotal() {
      const total = this.products.reduce((accum, current) => accum + (current.price * current.quantity), 0)
      return total
    }

  getProducts() {
    return this.products
  }
}

Rubén Hernández Hernández

student

Mi solución 💚 . . .

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product{
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  products = []

  addProduct(product) {
    this.products.push(product)
    return product.addToCart()
  }

  deleteProduct(product) {
    this.products.splice(this.products.indexOf(product),1)
  }

  calculateTotal() {
    return this.products.reduce((total,product) => total + (product.price * product.quantity), 0)
  }

  getProducts() {
    return this.products
  }
}

Ramsés Alfonzo Salinas Mejías

student

Mi solución

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  constructor() {
    this.carrito = new Array();
  }

  addProduct(product) {
    this.carrito.push(product);
    return product.addToCart();
  }
  
  deleteProduct(product) {
    let inx;
    this.carrito.forEach(function (item, index) {
      if (item.name == product.name) {
        inx = index;
      }
    });
    if (inx != undefined) {
      this.carrito.splice(inx, 1);
    }
  }
  calculateTotal() {
    let suma = 0;
    this.carrito.forEach(function (item) {
      suma += item.price*item.quantity;
    });
    return suma;
  }
  getProducts() {
    return this.carrito;
  }
}

Pariksit Erikrsnan Ortiz Flores

student

import { Product } from "./product";

export class Article extends Product {
  // Tu código aquí 👈
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name}al carrito`;
  }
}

export class Service extends Product {
  // Tu código aquí 👈
  addToCart() {
    return `Agregando servicio ${this.name} al carrito`;
  }
}

export class Cart {
  // Tu código aquí 👈
  listProduct = [];

  addProduct(product) {
    this.listProduct.push(product);
   
  }
  deleteProduct(product) {
    this.listProduct = this.listProduct.filter(element => element.name !== product.name);
    
  }
  calculateTotal() {
    return this.listProduct.reduce((sum, currentElement) => sum + currentElement.price * currentElement.quantity, 0);
  }
  getProducts() {
    return this.listProduct;
  }

Angel Javier Sanchez Tenjo

student

Hola, Mi solución al reto

✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`;
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

export class Cart {
  constructor() {
    this.products = [];
  }

  addProduct(product) {
    product.addToCart();
    this.products.push(product);
  }

  deleteProduct(product) {
    const index = this.products.findIndex(
      (itemCart) => itemCart.name === product.name
    );
    if (index < 0) {
      throw new Error("El producto no existe en el carrito de compras");
    }
    this.products.splice(index, 1);
  }

  calculateTotal() {
    let initialValue = 0
    return this.products.reduce(function (totalCart, itemCart) {
      const subtotal = itemCart.quantity * itemCart.price;
      totalCart += subtotal;
      return totalCart;
    }, initialValue);
  }

  getProducts() {
    return this.products;
  }
}

Carina Payleman

student

. . . . . .

export class Article extends Product {
    addToCart() {
        return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
    }
}

export class Service extends Product {
    addToCart() {
        return `Agregando el servicio ${this.name} al carrito`
    }
}
  
export class Cart {
    constructor(productList = []) {
        this.productList = productList;
    }

    addProduct(product) {
        this.productList.push(product);
        product.addToCart(); 
    }

    deleteProduct(product) {
        const deletedProduct = this.productList.findIndex(i => i === product);
        this.productList.splice(deletedProduct, 1);
    }

    calculateTotal() {
        return this.productList.reduce((acum, product) => (acum + (product.price * product.quantity)), 0);
    }

    getProducts() {
        return this.productList;
    }
}

Alexis Corrales

student

import { Product } from "./product";

export class Article extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  products = [];
  addProduct(product) {
    this.products.push(product)
    product.addToCart()
  }
  deleteProduct(product) {
    let result = this.products.findIndex(pro => pro.name === product.name)
    this.products.splice(result, 1)
  }
  calculateTotal() {
    let total = 0;
    for (let key in this.products) {
      const pro = this.products[key];
      total += pro.price * pro.quantity;
    }
    return total;
  }
  getProducts() {
    return this.products;
  }
}

Alejandro Anaya

student

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

import { Product } from "./product.js";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  shoppingList = []
  addProduct(item) {
    this.shoppingList.push(item)
    return item.addToCart()
  }
  deleteProduct(product) {
    let indexToRemove = this.shoppingList.findIndex((item) => item.name = product.name)
    if (indexToRemove < 0) throw new Error('No se encuentra el producto', product.name)
    this.shoppingList.splice(indexToRemove, 1)

  }
  calculateTotal() {
    let total = 0;
    total = this.shoppingList.reduce((acc, item) => acc += item.price * item.quantity, 0)
    return total
  }
  getProducts() {
    return this.shoppingList
  }
}

import { Product } from "./product";

export class Article extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }

  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {

    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  constructor(products = []) {
    this.products = products
  }

  addProduct(product) {
    product.addToCart()
    this.products.push(product)
  }

  deleteProduct(product) {
    let index = this.products.findIndex(item => item.name === product.name)
    this.products.splice(index, 1);
  }

  calculateTotal() {
    let total
    return this.products.reduce((total, item) => {
      total += item.price * item.quantity
      return total
    }, 0)
  }
}

import { Product } from "./product";


export class Article extends Product {
  // Tu código aquí 👈
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name
      }  al carrito`;
  }
}

export class Service extends Product {
  // Tu código aquí 👈
  addToCart() {
    return `Agregando servicio ${this.name} al carrito`;
  }
}

export class Cart {
  // Tu código aquí 👈
  products = [];

  addProduct(product) {
    this.products.push(product);
    return product.addToCart();
  }

  deleteProduct(product) {
    this.products = this.products.filter((p) => p.name !== product.name);
    product.addToCart();
  }

  calculateTotal() {
    return this.products.reduce(
      (sum, curr) => sum + curr.price * curr.quantity,
      0
    );
  }

  getProducts() {
    return this.products;
  }
}

import { Product } from "./product";

export class Article extends Product {
  // Tu código aquí 👈
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito"`
  }
}

export class Service extends Product {
  // Tu código aquí 👈
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  // Tu código aquí 👈
  constructor() {
    this.products = [];
  }
  addProduct(product) {
    product.addToCart()
    this.products.push(product)
  }
  deleteProduct(product) {
    const index = this.products.findIndex((item) =>
      item.name === product.name &&
      item.price === product.price &&
      item.quantity === product.quantity

    )
    this.products.splice(index, 1)
  }
  calculateTotal() {
    return this.products.reduce((acumulador, numero) => (acumulador + (numero.price * numero.quantity)), 0);
  }
}

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`    
  }
}

export class Cart {
  constructor() {
    this.products = []
  }

  addProduct(product) {
    this.products.push(product)
    return product.addToCart()
  }
  deleteProduct(product) {
    const idx = this.products.findIndex(({ name }) => product.name === name)
    if (idx > -1) {
      this.products.splice(idx,1)
    }
  } 
  calculateTotal() {
    return this.products.reduce((sum, prod) => sum + prod.quantity * prod.price, 0)
  }
  getProducts() {
    return this.products
  }
}

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`;
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

export class Cart {
  constructor() {
    this.products = [];
  }

  addProduct(product) {    
    this.products.push(product);
    return product.addToCart();
  }

  deleteProduct(product) {
    let itemIdx = this.products.findIndex((item) => {
      return item.name === product.name;
    });
    if (itemIdx > -1) {
      return this.products.splice(itemIdx, 1);
    }
  }

  calculateTotal() {
    return this.products.reduce((acum, product) => acum + product.price * product.quantity, 0);
  }

  getProducts() {
    return this.products;
  }
}

export class Article extends Product {

  addToCart() {
    super.addToCart();
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`;
  }

}

export class Service extends Product {

  addToCart() {
    super.addToCart();
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

export class Cart {
  constructor() {
    this.products = [];
  }
  addProduct(product) {
    this.products.push(product);
    return product.addToCart();
  }
  deleteProduct(product) {
    const index = this.products.findIndex(element => element.name === product.name);
    this.products.splice(index, 1);
  }
  calculateTotal() {
    return this.products.reduce((a, c) => a + c.quantity * c.price, 0);

  }
  getProducts() {
    return this.products;
  }
}

import { Product } from "./product";

class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`;
  }
}

class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

class Cart {
  products = [];

  addProduct(product) {
    this.products.push(product);
    return product.addToCart();
  }
  deleteProduct(product) {
    const index = this.products.findIndex((p) => p.name === product.name);
    this.products.splice(index, 1);
  }
  calculateTotal() {
    const total = this.products.reduce((acc, val) => {
      const price = val.price * val.quantity;
      return price + acc;
    }, 0);
    return total;
  }
  getProducts() {
    return this.products;
  }
}

export class Article extends Product{
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product{
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

export class Cart {
  constructor() {
    this.products = new Array;
  }

  addProduct(product) {
    this.products.push(product)
    product.addToCart();
  }

  deleteProduct(product) {
    this.products.splice(this.products.findIndex(products => products.name == product.name), 1)
  }
  calculateTotal() {
    return this.products.map(element => element.price*element.quantity).reduce((sum, element) => sum + element, 0)
  }
  getProducts() {
    return this.products
  }
}

export class Article extends Product {
  // Tu código aquí 👈
  constructor(name, price, quantity) {
    super(name, price, quantity);
  }

  addToCart() {
    return `Agregando ${this.quantity} unidades del articulo ${this.name} al carrito`;
  }
}

export class Service extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity);
  }

  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
  // Tu código aquí 👈
}

export class Cart {
  constructor() {
    this.products = [];
  }
  // Tu código aquí 👈
  addProduct(product) {
    product.addToCart();
    this.products.push(product);
  }

  deleteProduct(product) {
    this.products = this.products.filter(
      (cartItem) => cartItem.name != product.name
    );
  }

  calculateTotal() {
    let total = 0;
    for (let item of this.products) {
      total += item.price * item.quantity;
    }
    return total;
  }
}

export class Article extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}


export class Cart {
  constructor() {
    this.cartList = []
  }
  addProduct(product) {
    product.addToCart()
    this.cartList.push({
      name: product.name,
      price: product.price,
      quantity: product.quantity
    })
  }
  deleteProduct(product) {
    const index = this.cartList.findIndex(obj => JSON.stringify(obj) === JSON.stringify(product))
    this.cartList.splice(index, 1)
  }
  calculateTotal() {
    const total = this.cartList.reduce((sum, item) => sum + item.price * item.quantity, 0)
    return total
  }
  getProducts() {
    return this.cartList
  }
}

import { Product } from "./product";

export class Article extends Product{
  addToCart() {
    console.log(`Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`)
    return Article
 }
}

export class Service extends Product {
  constructor(name, price, quantity, serviceName){
  super(name, price, quantity);
this.serviceName = serviceName;}

  addToCart() {
    return `Agregando el servicio ${this.serviceName} al carrito`
  }
}

export class Cart extends Product{
  constructor() {
    this.products = []
  }
  addProduct(product) {
    this.products.push(product);
    product.addToCart()
  }
  deleteProduct(product) {
    const index = this.products.findIndex(p => p === product);
    if (index !== -1)
      this.products.splice(index, 1)
  }
    calculateTotal() {
      const total = this.products.reduce((accum, current) => accum + (current.price * current.quantity), 0)
      return total
    }

  getProducts() {
    return this.products
  }
}

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product{
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  products = []

  addProduct(product) {
    this.products.push(product)
    return product.addToCart()
  }

  deleteProduct(product) {
    this.products.splice(this.products.indexOf(product),1)
  }

  calculateTotal() {
    return this.products.reduce((total,product) => total + (product.price * product.quantity), 0)
  }

  getProducts() {
    return this.products
  }
}

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  constructor() {
    this.carrito = new Array();
  }

  addProduct(product) {
    this.carrito.push(product);
    return product.addToCart();
  }
  
  deleteProduct(product) {
    let inx;
    this.carrito.forEach(function (item, index) {
      if (item.name == product.name) {
        inx = index;
      }
    });
    if (inx != undefined) {
      this.carrito.splice(inx, 1);
    }
  }
  calculateTotal() {
    let suma = 0;
    this.carrito.forEach(function (item) {
      suma += item.price*item.quantity;
    });
    return suma;
  }
  getProducts() {
    return this.carrito;
  }
}

import { Product } from "./product";

export class Article extends Product {
  // Tu código aquí 👈
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name}al carrito`;
  }
}

export class Service extends Product {
  // Tu código aquí 👈
  addToCart() {
    return `Agregando servicio ${this.name} al carrito`;
  }
}

export class Cart {
  // Tu código aquí 👈
  listProduct = [];

  addProduct(product) {
    this.listProduct.push(product);
   
  }
  deleteProduct(product) {
    this.listProduct = this.listProduct.filter(element => element.name !== product.name);
    
  }
  calculateTotal() {
    return this.listProduct.reduce((sum, currentElement) => sum + currentElement.price * currentElement.quantity, 0);
  }
  getProducts() {
    return this.listProduct;
  }

import { Product } from "./product";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`;
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`;
  }
}

export class Cart {
  constructor() {
    this.products = [];
  }

  addProduct(product) {
    product.addToCart();
    this.products.push(product);
  }

  deleteProduct(product) {
    const index = this.products.findIndex(
      (itemCart) => itemCart.name === product.name
    );
    if (index < 0) {
      throw new Error("El producto no existe en el carrito de compras");
    }
    this.products.splice(index, 1);
  }

  calculateTotal() {
    let initialValue = 0
    return this.products.reduce(function (totalCart, itemCart) {
      const subtotal = itemCart.quantity * itemCart.price;
      totalCart += subtotal;
      return totalCart;
    }, initialValue);
  }

  getProducts() {
    return this.products;
  }
}

export class Article extends Product {
    addToCart() {
        return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
    }
}

export class Service extends Product {
    addToCart() {
        return `Agregando el servicio ${this.name} al carrito`
    }
}
  
export class Cart {
    constructor(productList = []) {
        this.productList = productList;
    }

    addProduct(product) {
        this.productList.push(product);
        product.addToCart(); 
    }

    deleteProduct(product) {
        const deletedProduct = this.productList.findIndex(i => i === product);
        this.productList.splice(deletedProduct, 1);
    }

    calculateTotal() {
        return this.productList.reduce((acum, product) => (acum + (product.price * product.quantity)), 0);
    }

    getProducts() {
        return this.productList;
    }
}

import { Product } from "./product";

export class Article extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  constructor(name, price, quantity) {
    super(name, price, quantity)
  }
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  products = [];
  addProduct(product) {
    this.products.push(product)
    product.addToCart()
  }
  deleteProduct(product) {
    let result = this.products.findIndex(pro => pro.name === product.name)
    this.products.splice(result, 1)
  }
  calculateTotal() {
    let total = 0;
    for (let key in this.products) {
      const pro = this.products[key];
      total += pro.price * pro.quantity;
    }
    return total;
  }
  getProducts() {
    return this.products;
  }
}

import { Product } from "./product.js";

export class Article extends Product {
  addToCart() {
    return `Agregando ${this.quantity} unidades del artículo ${this.name} al carrito`
  }
}

export class Service extends Product {
  addToCart() {
    return `Agregando el servicio ${this.name} al carrito`
  }
}

export class Cart {
  shoppingList = []
  addProduct(item) {
    this.shoppingList.push(item)
    return item.addToCart()
  }
  deleteProduct(product) {
    let indexToRemove = this.shoppingList.findIndex((item) => item.name = product.name)
    if (indexToRemove < 0) throw new Error('No se encuentra el producto', product.name)
    this.shoppingList.splice(indexToRemove, 1)

  }
  calculateTotal() {
    let total = 0;
    total = this.shoppingList.reduce((acc, item) => acc += item.price * item.quantity, 0)
    return total
  }
  getProducts() {
    return this.shoppingList
  }
}

¡Te damos la bienvenida a este reto!

¡Bienvenido al mundo de JavaScript!

Día 1

Variables, funciones y sintaxis básica

Tipos de datos

Playground - Retorna el tipo

Tipos de datos - pt 2

Día 2

Operadores

Hoisting y coerción

Playground - Calcula la propina

Alcance de las variables

Día 3

Condicionales

Playground - Calcula años bisiestos

Switch

Playground - Obten información de mascotas según su tipo

Ciclos

Playground - Dibuja un triangulo

Día 4

Arrays

Playground - Encuentra al michi mas famoso

Objetos

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

Playground - encuentra el palindromo más grande

Día 6

Reasignación y redeclaración

Modo estricto

Día 7

Debugging y manejo de errores

Programación funcional

Día 8

Closures

Playground - Crea una calculadora con closures

Higher order functions

Playground - Crea tu propio método map

Día 9

ECMAScript

TC39

Día 10 - Checkpoint

ES6

ES7

Playground - Task planner

Día 11

Asincronismo

Playground - Promesas

Manejando el asincronismo

Playground - Resuelve el callback hell usando promesas

Playground - Resuelve el callback hell usando async/await

Día 12

Arrays a profundidad

Métodos de arrays: Every, Find y findIndex

Playground - Válida el formulario

Día 13

Métodos de arrays: Includes, Join y concat

Playground - agrupa los productos

Métodos de arrays: Flat y FlatMap

Playground - Encuentra la ubicación del valor buscado

Día 14

Mutable functions

Playground - Modifica una lista de compras

Métodos de arrays: sort

Playground - Ordena los productos

Día 15 - Checkpoint

Playground - Sistema de reservaciones de un hotel

Día 16

Programación orientada a objetos en JavaScript

Objetos literales

Playground - Congela el objeto recursivamente

Día 17

Prototipos en JavaScript

Playground - Modifica el prototype de los arrays

Playground - Crea un auto usando clases

Día 18

Abstracción en JavaScript

Playground - Sistema de carrito de compras

Encapsulamiento en JavaScript

Playground - Encapsula datos de los usuarios

Día 19