隆Te damos la bienvenida a este reto!

1

隆Bienvenido al mundo de JavaScript!

D铆a 1

2

Variables, funciones y sintaxis b谩sica

3

Tipos de datos

4

Playground - Retorna el tipo

5

Tipos de datos - pt 2

D铆a 2

6

Operadores

7

Hoisting y coerci贸n

8

Playground - Calcula la propina

9

Alcance de las variables

D铆a 3

10

Condicionales

11

Playground - Calcula a帽os bisiestos

12

Switch

13

Playground - Obten informaci贸n de mascotas seg煤n su tipo

14

Ciclos

15

Playground - Dibuja un triangulo

D铆a 4

16

Arrays

17

Playground - Encuentra al michi mas famoso

18

Objetos

19

Playground - Obten el promedio de los estudiantes

D铆a 5 - Checkpoint

20

Playground - encuentra el palindromo m谩s grande

D铆a 6

21

Reasignaci贸n y redeclaraci贸n

22

Modo estricto

D铆a 7

23

Debugging y manejo de errores

24

Programaci贸n funcional

Quiz: D铆a 7

D铆a 8

25

Closures

26

Playground - Crea una calculadora con closures

27

Higher order functions

28

Playground - Crea tu propio m茅todo map

D铆a 9

29

ECMAScript

30

TC39

Quiz: D铆a 9

D铆a 10 - Checkpoint

31

ES6

32

ES7

33

Playground - Task planner

D铆a 11

34

Asincronismo

35

Playground - Promesas

36

Manejando el asincronismo

37

Playground - Resuelve el callback hell usando promesas

38

Playground - Resuelve el callback hell usando async/await

D铆a 12

39

Arrays a profundidad

40

M茅todos de arrays: Every, Find y findIndex

41

Playground - V谩lida el formulario

D铆a 13

42

M茅todos de arrays: Includes, Join y concat

43

Playground - agrupa los productos

44

M茅todos de arrays: Flat y FlatMap

45

Playground - Encuentra la ubicaci贸n del valor buscado

D铆a 14

46

Mutable functions

47

Playground - Modifica una lista de compras

48

M茅todos de arrays: sort

49

Playground - Ordena los productos

D铆a 15 - Checkpoint

50

Playground - Sistema de reservaciones de un hotel

D铆a 16

51

Programaci贸n orientada a objetos en JavaScript

52

Objetos literales

53

Playground - Congela el objeto recursivamente

D铆a 17

54

Prototipos en JavaScript

55

Playground - Modifica el prototype de los arrays

56

Playground - Crea un auto usando clases

D铆a 18

57

Abstracci贸n en JavaScript

58

Playground - Sistema de carrito de compras

59

Encapsulamiento en JavaScript

60

Playground - Encapsula datos de los usuarios

D铆a 19

61

Herencia en JavaScript

62

Playground - Jerarqu铆a de animales

63

Polimorfismo en JavaScript

64

Playground - Sistema de pagos

D铆a 20 - Checkpoint

65

Playground - Agenda de vuelos

D铆a 21

66

Patrones de dise帽o

67

Sinlgeton y Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

D铆a 22

69

Adapter y Decorator pattern en JavaScript

70

Playground - Personaliza productos de una tienda

71

Builder y Protype pattern en JavaScript

72

Playground - Mejora el c贸digo usando builder pattern

D铆a 23

73

Facade y proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajer铆a

75

Chain of responsability y Observer pattern en JavaScript

76

Playground - Implementaci贸n de Observador en Newsletter

D铆a 24 - Checkpoint

77

Playground - Crea un task manager con patrones de dise帽o

D铆a 25

78

Estructuras de datos en JavaScript

79

Playground - Crea tu propia implementaci贸n de un array

80

Hash tables en JavaScript

81

Playground - Implementaci贸n de una HashTable para Contactos

D铆a 26

82

Set en JavaScript

83

Playground - Remueve duplicados de una lista

84

Maps en JavaScript

85

Playground - Crea un organizador de tareas

D铆a 27

86

Singly Linked List en JavaScript

87

Playground - Agrega m茅todos a la singly linked list

88

Playground - Implementaci贸n de una singly linked list

D铆a 28

89

Stacks en JavaScript

90

Playground - Crea un stack para una playlist

D铆a 29

91

Queues en JavaScript

92

Playground - Crea una cola de emails

D铆a 30

93

隆Lo lograste!

Live Class

94

30 d铆as de JS con Juan DC

95

30 d铆as de JS con Nicobytes

96

30 d铆as de JS con GNDX

97

30 d铆as de JS con LeoCode

98

30 d铆as de JS con Teffcode

99

Sesi贸n: Cierre de los 30 d铆as de JavaScript

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Prep谩rate para tu pr贸ximo empleo comprando hoy a precio especial

Antes: $249

Currency
$209
Suscr铆bete

Termina en:

7 D铆as
20 Hrs
30 Min
32 Seg

Playground - Modifica una lista de compras

47/99

Aportes 81

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Esta es mi respuesta, cuidado con los spoilers!!
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let total = 0;

  let newList = list.map(item => {
    if (item.name.includes("oferta")) {
      item.price = item.price * 0.8;
    }
    item.price = item.price * item.quantity;

    total += item.price;

    let { quantity, ...auxItem } = item;
    return auxItem;
  })

  Object.assign(list, newList);

  return total;
}

Soluci贸n鈥 馃槃
.
Para empezar, creamos una lista modificada donde al recorrer 鈥榣ist鈥 con map() verificamos si el elemento incluye la palabra 鈥渙ferta鈥.
.
Entonces al precio se le aplicar谩 el descuento del 20%, y retornamos los objetos con las propiedades 鈥榥ame鈥 y 鈥榩rice鈥; este 煤ltimo le asignamos el valor descontado previamente, ahora multiplicado por la cantidad.
.
En una variable total acumulamos el precio total. Finalmente pasamos los valores de la lista modificada a la lista original utilizando Object.assign(). Retornamos el total.
.

export function processShoppingList(list) {
  let modifiedList = list.map((element) => {
    if (element.name.includes("oferta")) {
      element.price *= 0.8;
    }

    return {
      name: element.name,
      price: element.price * element.quantity
    }
  });


  let total = modifiedList.reduce((acc, element) => acc + element.price, 0);

  Object.assign(list, modifiedList);

  return total;
}

Alerta de Spoilers

A mi parecer es una respuesta concisa y sencilla 馃槂

Acepto sugerencias
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let total = 0;
  list.forEach((element) => {
    console.log(element.name);
    if (element.name.includes("oferta")) {
      element.price *= 0.8
    }
    element.price = element.price * element.quantity
    total += element.price
    delete element.quantity
  });

  return total;
}

Mi respuesta 馃挌


.
.
.
.

export function processShoppingList(list) {
  let totalSum = 0;

  list.forEach((product) => {
    if (product.name.includes("oferta"))
      product.price -= product.price * 0.20

    product.price *= product.quantity
    delete product.quantity
    totalSum += product.price
    
  })

  return totalSum
}

SPOILER ALERT!

function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let sumaTotal = 0;

  for (let i = 0; i < list.length; i++) {
    if (list[i].name.includes('oferta')) {
      list[i].price = list[i].price * 0.8;
    }
    list[i].price = list[i].quantity * list[i].price;
    delete list[i].quantity;
    sumaTotal = sumaTotal + list[i].price;
  }

  return sumaTotal;
}
ESUCDO ANTI SPOILERS export function processShoppingList(list) { var total = 0; for (var i = 0; i < list.length; i++) { list\[i].price = list\[i].price \* list\[i].quantity; if (list\[i].name.split(" ").includes("oferta")) { list\[i].price = list\[i].price - (list\[i].price \* 20 / 100); } delete list\[i].quantity; total += list\[i].price } return total;} 馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍 ```js export function processShoppingList(list) { var total = 0; for (var i = 0; i < list.length; i++) { list[i].price = list[i].price * list[i].quantity; if (list[i].name.split(" ").includes("oferta")) { list[i].price = list[i].price - (list[i].price * 20 / 100); } delete list[i].quantity; total += list[i].price } return total; } ```

Usando funciones mutables


.

.
.
.
.
.
.

.
.
.
.
.

const shoppingList = [
  { name: "pan", price: 20, quantity: 2 },
  { name: "leche", price: 25, quantity: 1 },
  { name: "oferta manzanas", price: 10, quantity: 3 },
]
export function processShoppingList(list) {
  let listaPrecios = []
    for (let i = 0; i < list.length; i++){
      list[i].price *= list[i].quantity 
      delete list[i].quantity
      if (list[i].name.includes('oferta') === true){
        const restarValor = list[i].price * 0.20
        list[i].price -= restarValor
      }
      listaPrecios.push(list[i].price)
    }
  const cambio = listaPrecios.reduce((acc, elem) => {
    return acc += elem 
  },0)
   return cambio
}
processShoppingList(shoppingList)

Esta es mi solucion:

export function processShoppingList(list) {
  let total = 0

  for (let producto of list) {
    let precio = producto.price * producto.quantity

    if (producto.name.includes("oferta")) {
      precio = precio * .8
    }
    producto.price = precio
    delete producto.quantity
    total += producto.price
  }
  return total
}

Soluci贸n! 馃槃

Mi soluci贸n:

function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟

  list.map(function (item) {
    if (item.name.includes("oferta")) {
      item.price *= 0.8;
    }
    item.price *= item.quantity;
    delete item.quantity;
  });

  const total = list.reduce((total, item) => total += item.price, 0);
  return total;
}

export function processShoppingList(list) {
  list = list.map((e) => {
    if (e.name.includes("oferta")) {
      e.price = (e.price - e.price * 0.2) * e.quantity;
    } else {
      e.price = e.price * e.quantity;
    }
    delete e.quantity;
    return {
      name: e.name,
      price: e.price,
    };
  });
  return list.reduce((sum, item) => sum + item.price, 0);
}
export function processShoppingList(list){
  const DISCOUNT = ['oferta', 0.80];

  for (let product of list) {

    const nameDivision = 
      product.name.split(' ');

    let totalPrice = 
      product.price * product.quantity;

    let totalDiscountPrice = 
      totalPrice * DISCOUNT[1];

    let containsDiscount = 
      nameDivision.includes(DISCOUNT[0]);

    product.price = containsDiscount ? 
      totalDiscountPrice : totalPrice;

    delete product.quantity;
  }

  const prices = list.map(
    product => product.price
  );

  return prices.reduce(
    (total, value) => total += value
  );

}

Vamoooooooooooooooosss!!!
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let price = 0
  list.forEach(item => {
    item.price = item.price * item.quantity

    if (item.name.includes('oferta')) {
      item.price *= 0.75
    }
     price += item.price
  })
  return price
}

Mi soluci贸n:
|
|
|
|
|
|
|
|
|
|

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let modifiedList = list.map(product => {
    if (product.name.includes('oferta')) {
      product.price = product.price * 0.80;
    }
    return {
      name: product.name,
      price: product.price * product.quantity
    };
  });

  Object.assign(list, modifiedList);

  let totalPrices = modifiedList.reduce((sum, currentElement) => sum + currentElement.price, 0);

  return totalPrices;
}

export const processShoppingList = (list) => {
  let total = 0;
  for (let item of list) {
    item.price = item.name.includes('oferta') ? item.price - (item.price * 0.20) : item.price;
    item.price = item.price * item.quantity;
    delete item.quantity;
    total = total + item.price;
  }
  return total;
}

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
    let suma = 0
    for (let item in list) {
      console.log(list[item])

      if (list[item].name.includes('oferta')) {
        list[item].price *= 0.8
      }

      list[item].price *= list[item].quantity

     delete list[item].quantity

      suma += list[item].price
    }
    return suma
  }

Una soluci贸n en pocas lineas:

export function processShoppingList(list) {
  let precioTotal = 0
  list.forEach(item => {
    item.price = item.quantity * (item.name.includes("oferta") ? item.price * 0.8 : item.price)
    precioTotal += item.price
    delete item.quantity
  })
  return precioTotal
}


.
.
.
.
.
.

export function processShoppingList(list) {
    let finalPrice = 0;
    list.forEach(product => {
        if (product.name.includes("oferta")) {
            product.price = (product.price * (100 - 20)) / 100; 
        }
        product.price *= product.quantity;
        delete product.quantity;
        finalPrice += product.price;
    })
    return finalPrice;
}

Mi soluci贸n:

const OFFER_NAME_KEYWORD = 'oferta';
const DISCOUNT = 0.20;

export function processShoppingList(list) {
  return list.reduce((total, product, index) => {
    if (product.name.includes(OFFER_NAME_KEYWORD)) {
      product.price *= (1 - DISCOUNT);
    }

    product.price *= product.quantity;
    delete product.quantity;

    list[index] = product;

    return total + product.price
  }, 0);
}
export function processShoppingList(list) {
  let totalAllProducts = 0;
  list.forEach(product => {
    const total = (product.price * product.quantity)
    if (product.name.includes('oferta')) {
      const discount = total * 0.2;
      product.price = total - discount
    } else {
      product.price = total;
    }
    totalAllProducts += product.price;
    delete product.quantity;
  });
  return totalAllProducts;
}

ALERTA SPOILER
Mi soluci贸n:
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let total=0;
  list.forEach(function (item) {
    let indice = item.name.indexOf("oferta");
    if (indice != -1) { item.price *= 0.8; }
    item.price *= item.quantity;
    delete item.quantity;
    total += item.price;
  })
  return total;
}

Hola comunidad les comparto mi soluci贸n.



  list.forEach(element => {

    // suma += element.price * element.quantity;
    if (element.name.includes('oferta')) {
      console.log('El objeto tiene el valor oferta ');
      let descuento = (element.price * element.quantity) * 20 / 100;
      let priceTo = element.price * element.quantity;
      let preciofinal = priceTo - descuento;
      element.price = preciofinal
      total += preciofinal
      // console.log(preciofinal)
    } else {

      let priceTo = element.price * element.quantity;
      total += element.price * element.quantity;
      element.price = priceTo;
      //console.log('El objeto no tiene el valor oferta');
    }
    delete element.quantity


  });

  return total ```

dejo mi solucion por aqui
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let totalPrice = 0

  list.forEach(el => {
    if (el.name.includes('oferta')) {
      el.price -= el.price * 20 / 100
    }
    el.price = el.price * el.quantity
    totalPrice += el.price;
    delete el.quantity;
  });
  return totalPrice;
  
}
export function processShoppingList(list) {

  let totalProductos = 0;

  list.map(shopping => {
    if (shopping.name.includes("oferta")) {

      shopping.price = (shopping.price - ((20 * shopping.price) / 100)) * shopping.quantity;
      delete shopping.quantity;
      totalProductos += shopping.price;
    } else {
      shopping.price = shopping.price * shopping.quantity;
      delete shopping.quantity;
      totalProductos += shopping.price;
    }



  });

  return totalProductos;


}
export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let precio = 0
  list.forEach((item) => {

    if (item.name.includes('oferta') === false) {
      precio += item.price * item.quantity
      item.price = item.price * item.quantity
    }
    else {
      precio += item.price * item.quantity * 0.8
      item.price = item.price * item.quantity * 0.8
    }
    delete item.quantity;

  })
  return precio
}

Aun sigo resistiendo en usar funciones an贸nimas o flecha

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let total = 0
  for (const [key, item] of Object.entries(list)) {
    if (item.name.includes("oferta")) item.price *= 0.8
    item.price *= item.quantity
    total += item.price
    delete item.quantity
  }
  return total
}

Mi solucion:
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈
馃槈

export function processShoppingList(list) {
  let total = 0;
  for (let i = 0; i < list.length; i++) {
    if (list[i].name.includes("oferta")) {
      list[i].price *= 0.8;
    }
    list[i].price = list[i].price * list[i].quantity;
    total += list[i].price;
    delete list[i].quantity;
  }
  return total;
}

馃洝锔忦煕★笍Escudo anti-spoilers馃洝锔忦煕★笍

Mi soluci贸n al reto:

export function processShoppingList(list) {
    let modifiedList = list.map((item) => {
      if (item.name.includes('oferta'))
        item.price *= .80;
  
      return {
        name: item.name,
        price: item.price * item.quantity
      }
    }, 0)
    Object.assign(list, modifiedList);
    return list.reduce((sum, item) => sum += item.price, 0);
  }
 

Mi soluci贸n:
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list){
    const rePricedList=list.map(product=>{
        if(product.name.includes("oferta")){
            return{
                name: product.name,
                price: (product.price-product.price*0.2)*product.quantity
            }
        }else{
            return{
                name: product.name,
                price: product.price*product.quantity
            }
        }
    })
    Object.assign(list,rePricedList);
    const solution= list.reduce((acc,product)=>{
        return acc+product.price;
    },0)
    return solution;
};

Hola, Comparto la soluci贸n del reto:

馃挌
馃挌馃挌
馃挌馃挌馃挌
馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌馃挌
馃挌馃挌馃挌馃挌
馃挌馃挌馃挌
馃挌馃挌
馃挌

export function processShoppingList(list) {
  const OFERTA = "oferta";
  let total = 0;
  list.forEach((product) => {
    product.price *= product.quantity;
    delete product.quantity;

    const nameProduct = product.name.toLowerCase();
    if (nameProduct.search(OFERTA) > -1) {
      product.price *= 0.8;
    }
    total += product.price;
  });

  return total;
}

Mi aporte:
Antes sol铆a usar antes mucho el for of para casi todas las soluciones del reto. Ahora con el paso de actividades aprend铆 que el .map() puede sustituirlo.

SPOILER

.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let totalSum = 0;
  list.map((element, index, array) => {
    if (element.name.includes("oferta")) {
      array[index].price = element.price * 0.8 * element.quantity;
    } else {
      array[index].price = element.price * element.quantity;
    }
    delete array[index].quantity;
    totalSum += element.price;
  })
  return totalSum;
}

隆Aqu铆 va mi manera de hacerlo!

V
V
V
V
V
V
V
V
V
V
V
V
V


export function processShoppingList(list) {
  let totalAmount = 0;
  list.forEach((product) => {
    if (product.name.indexOf('oferta') !== -1) {
      let discounted = product.price - (product.price * 0.2);
      product.price = discounted * product.quantity;
    }
    else {
      product.price *=  product.quantity;
    }
    totalAmount += product.price
    delete product.quantity;
  })
  return totalAmount
}

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let total = 0;
  list.map(item => {
    if (item.name.includes('oferta')) {
      item.price *= 0.8;
    }
    item.price *= item.quantity;
    delete item.quantity;
    total += item.price; 
    return item
  })
  return total;
}

Solucion

function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  list.forEach(obj => {
    
    // Apply 20% discount if "offer" apears in name
    obj.name.includes("oferta") ? 
      obj.price = obj.price * 0.8 :
      ""
    
    // Multiply price * qty
    obj.price = obj.price * obj.quantity
    
    // Delete "quantity" attribute
    delete obj.quantity
  })

  // Return total
  const total = list
    .map(obj => obj.price)
    .reduce((acc, cur) => acc + cur)

  console.log(total)
  return total
}

SPOILERT ALERT!!!
Acepto sugerencias
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let discount = 0.8
  let totalPrice = 0
  list.map(product => {
    if (product.name.includes('oferta')) {
      product.price *= discount
    }
    product.price *= product.quantity
    totalPrice += product.price
    delete product.quantity
  })
  return totalPrice
}

Comparto mi solucion implementada

function processShoppingList(list) {
  
  for (const iterator of list) {
    if (iterator.name.includes('oferta')) {
      iterator.price -=  (iterator.price * (20/100))
    }
    iterator.price *= iterator.quantity
    delete iterator.quantity
  }
  return list.reduce((acc, current)=>(acc+current.price),0)
}

#My solution

a
.

export function processShoppingList(list) {
  let result = [...list]
    .map(prod => {
      return {
        name: prod.name,
        price: prod.price * prod.quantity
          * (prod.name.includes('oferta') ? 0.8 : 1)
      }
    })
  Object.assign(list, result);
  return result.reduce((sum, {price}) => sum += price ,0)
}

Use un forEach por velocidad y doble calculo al precio porque no afecta el resultado y castin a los n煤meros para no obtener float

export function processShoppingList(list) {
let total = 0
list.forEach(function (element, index, array) {
if (element?.name.indexOf(鈥榦ferta鈥) !== -1) {
array[index].price = parseInt(element.price * 0.8)
}
array[index].price = parseInt(element.price * element.quantity)
delete array[index].quantity
total += array[index].price
})
return total
}

Mi solucion, espero alguna devolucion gracias.

  let rta = 0;
  if (shoppingList.some(sol => sol.name.split(' ').find(x => x === 'oferta'))) {
    for (let index = 0; index < shoppingList.length; index++) {
      const element = shoppingList[index];
      if (element.name.split(' ').find(x => x === 'oferta')) {
        element.price = element.price * element.quantity * 0.8;
        delete element.quantity;
        rta += element.price;
      } else {
        element.price = element.price * element.quantity;
        delete element.quantity;
        rta += element.price;
      }
    }
  }
  console.log(shoppingList);
  return rta;
}

Cuidado Spoiler


*
*
*
*

Mi soluci贸n

export function processShoppingList(list) {
  for (let item of list) {
    if (item.name.includes("oferta")) {
      item.price *= 0.8
    }
    item.price *= item.quantity
    delete item.quantity
  }
  return list.reduce((total, item) => total += item.price, 0)
}

Esta es mi respuesta

function processShoppingList(list) 
{
    let total = 0;
    list.forEach(element => {
      let itemTotal = 0;
     if(element.name.includes('oferta'))
     {
      itemTotal = (element.price * 0.8) * element.quantity;
     }
     else
     {
      itemTotal = element.price * element.quantity;
     }

     element.price = itemTotal;
     delete element.quantity;
     
     total += itemTotal;

    });

    return total;
}

.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let item = {};
  for (let i = 0; i < list.length; i++) {
    item = list[i];
    if (item.name.includes("oferta")) {
      item.price = item.price * 0.8;
    }
    item.price = item.price * item.quantity;
    list[i] = {
      name: item.name,
      price: item.price,
    }
  }
  return list.reduce((total, item) => total + item.price,0);
}

馃洝锔廍scudo anti-spoilers馃洝锔

Aqui est谩 mi c贸digo

export function processShoppingList(list) {
  return  list.map(obj => {
    if (obj.name.includes("oferta")) {
      obj.price *= 0.80;
    }
    obj.price *= obj.quantity;
    delete obj.quantity;
    return obj.price;
  }).reduce((acc,cur)=>acc + cur,0);
 
}

Este es mi aporte
Este es mi aporte
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let total = 0;
  list = list.map(product => {
    if (product.name.includes('oferta')) {
      product.price -= (product.price * 20 / 100);
    }
    product.price *= product.quantity;
    total += product.price;
    delete product.quantity;
  });
  return total;
}

Mi aporte

export function processShoppingList(list) {
  let total = 0;
  list.forEach(el => {
    if (el.name.includes("oferta")) {
      let descount = el.price * 0.2;
      el.price = el.price - descount;

    }
    el.price = el.price * el.quantity;
    total += el.price;
    delete el["quantity"]
  })

  return total
}

Esta es mi soluci贸n
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  return list.reduce((acc, curr) => {
    let price;
    if (curr.name.includes('oferta')) {
      price = (curr.price * 0.8) * curr.quantity;
    }
    else {
      price = curr.price * curr.quantity;
    }
    curr.price = price;
    delete curr.quantity;
    return acc + price;
  }, 0);
}

Soluci贸n:

  • Inicializar una variable total en cero para ir acumulando el total de la lista procesada.
  • Recorrer cada objeto de la lista con un ciclo for o un m茅todo de array como map.
  • Multiplicar el precio del producto por su cantidad y asignar este valor a la propiedad price del objeto.
  • Verificar si el nombre del producto incluye la palabra 鈥渙ferta鈥 utilizando el m茅todo includes() de strings y aplicar un descuento del 20% al precio del producto en caso de ser necesario.
  • Eliminar la propiedad quantity del objeto utilizando el operador delete.
  • Acumular el valor del precio del objeto a la variable total.
  • Devolver el valor de la variable total.
export function processShoppingList(list) {
  let total = 0;
  list.map((product) => {
    const totalPrice = product.price * product.quantity;
    if (product.name.includes("oferta")) {
      product.price = totalPrice * 0.8; // aplicar descuento del 20%
    } else {
      product.price = totalPrice;
    }
    delete product.quantity;
    total += product.price;
    return product;
  });
  return total;
}

el primero que hago en menos de hora鈥 jajajaja

  let total = 0;
  for (let i = 0; i < list.length; i++) {
    if (list[i].name.includes("oferta") === true) {
        list[i].price = list[i].price - ((list[i].price * 20) / 100);
    }
    
    list[i].price = (list[i].price * list[i].quantity)
    total += list[i].price;
    delete list[i].quantity;
  };
  return total; 

Mi solucion

export function processShoppingList(list) {
  let total = 0;
  list.map(function (element) { 
    if (element.name.includes("oferta")){ 
      element.price = element.price * 0.8;
    }
    element.price=element.price*element.quantity
    total = total + element.price;
    delete element.quantity;
  })
  return total;
}

Que belleza, me gusta esto鈥 馃槂

 function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟   

  let findlist = list.find(prod => prod.name.includes("oferta"));
  if (findlist) {
    findlist.price -= findlist.price * 0.2;
    for (let prod of list) {
      prod.price *= prod.quantity;
      delete prod.quantity;
    }

    return list.reduce((acc, prod) => acc + prod.price, 0);
  }
}

ez solution bb

export function processShoppingList(list) {
  for (const item of list) {
    const isOnOffert = item.name.split(' ').some(value => value === 'oferta')
    item.price = item.price * item.quantity
    if (isOnOffert) item.price -= item.price * 0.20
    delete item.quantity
  }
  const total = list.reduce((a, b) => a += b.price, 0)
  return total
}

Mi soluci贸n
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  list.forEach(item => {
    if (item.name.includes("oferta")) item.price *= 0.8;

    item.price *= item.quantity;
    delete item.quantity;
  })

  const total = list.map(item => item.price).reduce((acumulador, numero) => acumulador + numero);

  return total;
}

Mi soluci贸n:

export function processShoppingList(list) {
  let total = 0
  for (let product of list) {
    product.price = product.name.includes("oferta") ? product.price * 0.8 : product.price
    product.price *= product.quantity
    delete product.quantity
    total += product.price
  }
  return total
}

MI SOLUCION 馃挭
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  list.forEach(product => {
    product.price *= product.quantity;
    if (product.name.includes("oferta")) {
      product.price -= product.price*.2;
    }
    delete product.quantity;
  });
  return list.reduce((total, product) => total + product.price, 0);
}

Mi humilde soluci贸n:

export function processShoppingList(list) {
  let total = 0;
  for (const prop in list) {
    if (list[prop].name.includes("oferta")) {
      list[prop].price -= (list[prop].price * .20);
    }
    list[prop].price *= list[prop].quantity;
    delete list[prop].quantity;
    total += list[prop].price;
  }
  return total;
}

Aqu铆 mi soluccion:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

function processShoppingList(list) {
  let total = 0;
  let newlist = list.map(function(elem) {
    if (elem.name.includes("oferta")){
      elem.price = elem.price * 0.8;      
    }
    elem.price = elem.price * elem.quantity;
    total += elem.price
    let { quantity, ... newElem } = elem;
    return newElem;
  });
  Object.assign(list, newlist);
  return total;
}

the sol mmm


export function processShoppingList(list) {
  let acumulator = 0;
  list.forEach(item => {
    if (item.name.includes('oferta')) {
      item.price = item.price - 0.2 * item.price;
    }
    item.total = item.price * item.quantity;
    delete item.quantity;
    acumulator += item.total   
  })
  return acumulator;
}

Mi solucion:

  • Utilic茅 los metodos 鈥榮plit鈥 e 鈥榠ncludes鈥 para descubrir productos en oferta
  • Us茅 鈥極bject.hasOwn鈥 para modificar el precio dependiendo de la propiedad quantity para luego eliminarla.
    .
    .
    .
function processShoppingList(list) {
  let totalPrice = 0
  list.map((product) => {
    const isThereProm = product.name.split(" ")

    if (isThereProm.includes("oferta")) {
      product.price *= 0.8
    }

    if (Object.hasOwn(product, "quantity")) {
      product.price *= product.quantity
      delete product.quantity
    }
    totalPrice += product.price
  })
  return totalPrice
}

Mi soluci贸n:
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  list.forEach((product, index) => {
    if (product.name.includes('oferta')) product.price *= 0.8;
    product.price *= product.quantity;
    const { quantity, ...productDetails } = product;
    list[index] = productDetails;
  });

  return list
    .reduce((total, product) => total += product.price, 0)
}

馃槑 Mi soluci贸n por ac谩:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  for (let item of list) {
    const discount = item.name.includes('oferta');
    item.price = discount
      ? item.price * (1 - 0.2) * item.quantity
      : item.price * item.quantity;
    delete item.quantity;
  }
  return list.reduce((acum, item) => acum + item.price, 0);
}

馃洝锔廍scudo anti-spoilers馃洝锔

Mi solucion:

export function processShoppingList(list) {
  for (let product of list) {
    //Almacena un multiplicador para el descuento
    const offer = product.name.includes("oferta") ? 0.8 : 1

    //Calcular precio
    product.price = product.price * product.quantity * offer

    //Eliminar la propiedad quantity
    delete product.quantity;
  }

  //Regresar la suma de los costos
  return list.reduce((acum, product) => acum + product.price, 0)
}

Soluci贸n 鈥
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let total = 0
  for (let item of list) {
    
    if (item.name.includes("oferta")) {
      let priceAux = item.price
      item.price = priceAux - priceAux * 0.2;
    }

    item.price = item.price * item.quantity
    delete item.quantity
    total += item.price
  }

  return total;
}


.
.
.
.
.

function processShoppingList(list) {
    // Tu c贸digo aqu铆 馃憟
    list.forEach(product => {
        if(product.name.includes("oferta")){
            product.price *= 0.8;
        }
        product.price *= product.quantity;
        delete product.quantity;
  })
  return list.map(product => product.price).reduce((acum, priceItem) => acum + priceItem, 0);
}

隆Hola, Desaf铆o cumplido 馃槂!
Objetivo

Mi soluci贸n,
Se detalla hasta abajo.猬









export function processShoppingList(list) {
  let indexFind = list.findIndex(item => item.name.includes("oferta"));
  if (indexFind >= 0)
    list[indexFind].price = list[indexFind].price - (list[indexFind].price * (20 / 100));

  let total = 0;

  list = list.map(item => {

    item.price *= item.quantity;
    delete item['quantity'];
    total += item.price;
  })

  return (total);
}

Mi respuesta
Recorriendo cada elemento de la lista, verifico si en el nombre tiene la palabra **oferta ** mediante la funci贸n includes(), si es as铆. multiplico directamente el objeto en su precio por el .80 y as铆 obtener el 20% de descuento.
Finalmente multiplico el precio por la cantidad y lo guardo en precio.
Borro el atributo de cantidad y hago la suma total de los precios para retornarlo afuera del forEach()

export function processShoppingList(list) {
  let total = 0;
  list.forEach(product => {
    if (product.name.includes('oferta')) {
      product.price *= .80;
    }
    product.price *= product.quantity;
    delete product.quantity;
    total += product.price;
  });
  return total;
}

.
.
.
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let total = 0;
  const DISCOUNT = 20;
  const KEY_WORD_DISCOUNT = "oferta"; 
  list = list.map(product => {
    if (product.name.includes(KEY_WORD_DISCOUNT)) {
      product.price = Math.trunc(product.price - (product.price * (DISCOUNT / 100))); 
    }
    product.price *= product.quantity;
    delete product['quantity'];
    total += product.price;
  })
  return total
}

Hola, dejo mi solucion
Caminito anti spoilers
馃洿鉁
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 馃搷

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let total = 0;
  list.forEach((element, index) => {
    const priceWithDiscount = element.name.includes('oferta') ? element.price * 0.8 : element.price;
    const priceQuantity = priceWithDiscount * element.quantity;
    list[index].price = priceQuantity;
    total += priceQuantity;
    delete element.quantity;
  });
  return total;
}

Mi soluci贸n :

function processShoppingList(list){
  const price = [];
  list.forEach((a) => {
    a.name.toLowerCase().includes("oferta")
      ? Object.assign(a, { price: a.price * a.quantity - a.price * a.quantity * 0.2, })
      : Object.assign(a, { price: a.price * a.quantity });
    delete a.quantity;
    price.push(a.price);
  });

  return price.reduce((a, b) => a + b);
}

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

let total = 0;
  list = list.map((elemt) => {
    (elemt.name.includes('oferta')) ? elemt.price = (elemt.price * 0.8) : "";
    elemt.price *= elemt.quantity;
    delete elemt.quantity;
    total += elemt.price
    return elemt;
  })
  return total;

.

.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.

export function processShoppingList(list) {
  const DESCUENTO = 0.8;
  let total = 0;
  list.forEach((element) => {
    element.price = element.name.split(' ').includes("oferta") ?
      ((element.price * DESCUENTO) * element.quantity) :
      (element.price * element.quantity)

    total += element.price
    delete element.quantity
  });

  return total;
}

Soluci贸n

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  let total = 0;
  list.forEach(product => {
    if (product.name.includes("oferta")) {
      product.price *= 0.8;
    }
    product.price *= product.quantity;
    total += product.price;
    delete product.quantity;
  })
  return total;
}

Mi soluci贸n:
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let totalPrice = 0;

  for (let i = 0; i < list.length; i++) {
    let product = list[i];
    product.price *= product.quantity;

    if (product.name.includes("oferta")) {
      product.price -= (product.price * 20) / 100;
    }

    let { quantity, ...newProduct } = product;
    list[i] = newProduct;

    totalPrice += product.price;
  }

  return totalPrice;
}

No se porque pero me siento orgulloso de mi soluci贸n xD

Soluci贸n:

.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  return list.reduce((sum, element) => {
    let totalPerProduct
    let total
    if (element.name.includes('oferta')) {
      totalPerProduct = (element.price * 0.8) * element.quantity
    }
    else {
      totalPerProduct = element.price * element.quantity
    }
    total = totalPerProduct + sum
    element.price = totalPerProduct
    delete element.quantity
    return total
  }, 0)
}

Mi soluci贸n:
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  let total = 0
  list.forEach(product => {
    product.price *= product.quantity
    if (product.name.includes('oferta'))
      product.price *= 0.8
    total += product.price
    delete product.quantity
  })
  return total
}

Spoiler:
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Tu c贸digo aqu铆 馃憟
  const discount = 20;
  let total = 0;
  for (let i = 0; i < list.length; i++) {
    const product = list[i];
    if (contains_oferta(product.name)) {
      product.price *= (100 - discount)/100;
    }
    product.price *= product.quantity;
    delete product.quantity;
    total += product.price;
  }
  return total;
}

export function contains_oferta(string) {
  const re = /oferta/g;
  const str = string;
  return re.test(str);
}

Hola. Comparto mi soluci贸n
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  /* acumulador de total */
  let sum = 0
  /* recorrido del arreglo */
  list.forEach(p => {
    /* evalua si tiene la cadena oferta y ajecuta el descuento */
    if (p.name.includes("oferta")) p.price = p.price * 0.8
    /* actualiza el valor de price */
    p.price = p.price * p.quantity
    /* acumula el total */
    sum += p.price
    /* elimina la propiedad quantity */
    delete p.quantity
  })
  return sum
}

  export function processShoppingList(list) {
    let response = 0;
    list.forEach(element => {
      if (element.name.includes("oferta")) {
        element.price = element.price * 0.8 * element.quantity;
        response += element.price;
      }
      else {
        element.price = element.price * element.quantity;
        response += element.price;
      }
      delete element.quantity;
    });
    return response;
  }

Les dejo mi soluci贸n
.
.
.
.
.
.
.
.
.
.

export function processShoppingList(list) {
  // Inicializo la variable que controla el total de la suma de los productos
  let total = 0

  // Creo la funci贸n que procesa producto por producto
  const procesarProducto = (producto) => {
    chequearYAplicarDescuento(producto)
    precioPorCantidad(producto)
    eliminarCantidad(producto)
  }

  //Chequeo si el nombre incluye la palabra oferta y le aplico el descuento
  const chequearYAplicarDescuento = (producto) => {
    if (producto['name'].includes('oferta')) {
      aplicarDescuento(producto)
    }
  }

  //Multiplico el precio por 0.8 para generar un descuento del 20%
  const aplicarDescuento = (producto) => {
    producto['price']*=0.8
  }

  //Multiplico el precio por la cantidad
  const precioPorCantidad = (producto) => {
    producto['price']*=producto['quantity']
  }

  //Elimino ['quantity']
  const eliminarCantidad = (producto) => {
    delete producto['quantity']
  }

  //Proceso producto por producto con un map, y al procesar el producto agrego el total del producto al total general
  list = list.map(producto => {
    procesarProducto(producto)
    total+=producto['price']
  })

  //Retorno la suma de todos los productos
  return total
}

Spoiler:
.
.
.
.
.
.
.
.
.
.

function processShoppingList(list) {
    list.map((ele) => {
        return ele.name.includes('oferta') ? 
        ele.price = (ele.price * ele.quantity) * .8  : 
        ele.price = ele.price * ele.quantity,
        delete ele.quantity  
    });

    return list.map((ele) => {return ele.price})
    .reduce((a,b) => a + b);
};

Aqu铆 mi soluci贸n, cualquier retroalimentaci贸n es bienvenida

export function processShoppingList(list) {
// Mutar el objeto list para colocar el precio seg煤n la cantidad de productos y aplicar descuento del 20% a los elementos que tengan oferta.
  list.filter(item => item.name.includes('oferta')).map((item) => {
    item.price = (item.price - item.price * 0.2);
    item.price = item.price * item.quantity;
    delete item.quantity;
    return item;
  });
  // Mutar el objeto list para colocar el precio a los productos sin oferta seg煤n la cantidad de productos.
  list.filter(item => !item.name.includes('oferta')).map((item) => {
    item.price = item.price * item.quantity;
    delete item.quantity;
    return item;
  });
  // Se crea nuevo objeto para concatenar los productos modificados.
  const prods = [];
  prods.push(...list);
  // Se suman los precios 
  const out = prods.map(prod => prod.price).reduce((sum, curr) => curr + sum);

  return out;
}
undefined