¡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 - Mejora el código usando builder pattern

71

Builder y Protype pattern en JavaScript

72

Playground - Personaliza productos de una tienda

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

Live Class

77

30 días de JS con Juan DC

78

30 días de JS con Nicobytes

79

30 días de JS con GNDX

80

30 días de JS con LeoCode

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Playground - Ordena los productos

49/80

Aportes 49

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

Mi solución

export function sortByAvailabilityAndPrice(products) {
  return [...products].sort((producta, productb) => (productb.inStock - producta.inStock ||  producta.price - productb.price));
}

Mi respuestas:
.
.
.
.
.
.
.
.
.
.

let sorted = [...products]

sorted.sort(function(a,b){
    if(b.inStock > a.inStock) return 1;
    if(b.inStock < a.inStock) return -1;
    if(a.price > b.price) return 1; 
    if(a.price < b.price) return -1;
})

Hola, dejo mi solucion
Caminito anti spoilers
🛴✨
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

const list = [...products];

  list.sort((a, b) => a.price - b.price);
  list.sort((a, b) => b.inStock - a.inStock);
  return list

🛡️Escudo anti-spoilers🛡️

Mi solucion:

export function sortByAvailabilityAndPrice(products) {
  return [...products].sort((a, b) => {
     
    if (b.inStock != a.inStock)
      return a.inStock ? -1 : 1

    return (a.price - b.price)
  })
}

Spoiler Alert

Resuelto en 4 lineas

Acepto sugerencias 😃

Gatito anti-spoilers

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  const productsSorted = [...products];
  productsSorted.sort((a, b) => a.price - b.price)
  productsSorted.sort((a, b) => b.inStock - a.inStock)
  return productsSorted;
}

Mi aporte:
-----------------------SPOILE--------------------------
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  let clon = [...products];
  clon.sort((a) => {
    if (a.inStock) {
      return -1
    }
    else {
      return 1
    }
  })
  clon.sort((a, b) => {
    if (a.inStock && b.inStock) {
      return a.price - b.price;
    }
    if (!a.inStock && !b.inStock) {
      return a.price - b.price;
    }
  })
  return clon;
}

  const newArray = [...products].sort((a, b) => b.inStock - a.inStock || a.price - b.price);
  return newArray

Aquí mi versión:

V
V
V
V
V
V
V
V
V
V


export function sortByAvailabilityAndPrice(products) {
  const newList = [...products]
  newList.sort((a, b) => a.price - b.price)
  newList.sort((a, b) => b.inStock - a.inStock)
  return newList
}

Solucion

function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈

  const sortedProducts = [...products]
    .sort((a, b) => a.price - b.price)
    .sort((a, b) => b.inStock - a.inStock)

  console.log(sortedProducts)
  return sortedProducts
}

My Solution

.

.

export function sortByAvailabilityAndPrice(products) {
  return [...products]
    .sort((a, b) =>{
      const res = a.inStock !== b.inStock
        ? a.inStock === true ? -1 : 1
        : a.price - b.price
        return res
    }
    )
}

comparto mi solucion:

Les comparto mi solución. 😄

.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  const OUT_OF_STOCK = products.filter((product) => !product.inStock);
  const IN_STOCK = products.filter((product) => product.inStock);

  OUT_OF_STOCK.sort((a, b) => a.price - b.price);
  IN_STOCK.sort((a, b) => a.price - b.price);

  const PRODUCTS = IN_STOCK.concat(OUT_OF_STOCK);

  return PRODUCTS;
} 

Este es mi solución

<function sortByAvailabilityAndPrice(products) 
{
    const inStockProducts = products.filter(element => element.inStock).sort((a,b) => a.price - b.price);
    const outStockProducts = products.filter(element => !element.inStock).sort((a,b) => a.price - b.price);
    
    return [...inStockProducts, ...outStockProducts];

}
> 

para quienes se sienten estancados con este reto, les comparto esta referencia que me sirvió para encontrar la solución

Que tal esta solución? :
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  // Creamos una copia del array original para no modificarlo
  const copy = products.slice();

  // Definimos una función de comparación que primero ordena por disponibilidad
  // en inventario (los productos en stock primero), y luego por precio ascendente
  copy.sort((a, b) => {
    if (a.inStock === b.inStock) {
      return a.price - b.price;
    } else {
      return a.inStock ? -1 : 1;
    }
  });

  return copy;
}

.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  let zeroQ = products.filter((item) => !item.inStock);
  let nonZeroQ = products.filter((item) => item.inStock);

  zeroQ.sort((a, b) => a.price - b.price);
  nonZeroQ.sort((a, b) => a.price - b.price);

  return nonZeroQ.concat(zeroQ);
}

En mi solución utilice doble sort():

export function sortByAvailabilityAndPrice(products) {
  const sorted_products = [...products];
  return sorted_products.sort((a,b)=>a.price-b.price).sort((a, b) => {
    if (a.inStock===b.inStock)
      return 0;
    if (a.inStock)
      return -1;
    else
      return 1;
  })
}

Mi solución, primero ordenar por precio y luego ordenar para que los que esten en stock esten de principio.

export function sortByAvailabilityAndPrice(products) {
  let copiarray = new Array(...products);
  copiarray.sort((a, b) => a.price - b.price);
  copiarray.sort((a, b) => b.inStock - a.inStock);
  return copiarray;
}

Aqui mi solución de principiante 3n 3 lineas:

  let arrayCopy = new Array(...products);  
  let orderPrice1 = arrayCopy.sort((a, b) => a.price - b.price);
  return orderPrice1.sort((b, a) => a.inStock - b.inStock); 

🛡️Escudo anti-spoilers🛡️

*
Mi solución:

export function sortByAvailabilityAndPrice(products) {
  let list = [...products];
  list.sort((a, b) => a.price - b.price);
  list.sort((a, b) => b.inStock - a.inStock);
  return list
}

Hola, me gustaría compartir mi solución 😄
.
.
.
.
.
.
.
.
.

No es código bonito pero resuelve el problema… 😃

function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  let trueprod = [...products].filter(prod => prod.inStock === true).sort((a, b) => {

    return a.price - b.price;
  });
  let falseprod = [...products].filter(prod => prod.inStock === false).sort((a, b) => {
    return a.price - b.price;
  })

  return [...trueprod, ...falseprod];

}  

aprendí con este reto que true equivale a 1 y false a 0 pero ya había hecho esta:

export function sortByAvailabilityAndPrice(products) {
  const itemsAviable = products.filter(item => item.inStock).sort((a, b) => a.price - b.price)
  const itemsUnAviable = products.filter(item => !item.inStock).sort((a, b) => a.price - b.price)

  return itemsAviable.concat(itemsUnAviable)
}

pero es esta la manera mas correcta :

export function sortByAvailabilityAndPrice(products) {
  return [...products].sort((producta, productb) => (productb.inStock - producta.inStock ||  producta.price - productb.price));
}

Mi solución
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  const organizedProducts = [...products];

  organizedProducts.sort((a, b) => a.price - b.price).sort((a, b) => b.inStock - a.inStock);

  return organizedProducts;
}

Como true = 1 y false = 0, para JavaScript, se puede hacer la resta sin ningun problema.

Mi solución:

export function sortByAvailabilityAndPrice(products) {
  let newList = [...products]
  newList.sort((a, b) => a.price - b.price)
  newList.sort((a, b) => b.inStock - a.inStock)
  return newList
}
function sortByAvailabilityAndPrice(products) {
    // Tu código aquí 👈
    let sort=[...products]
    
    sort.sort((a, b) => a.price - b.price);
    sort.sort((a, b) =>  b.inStock-a.inStock);
    return sort;
    return products;
  }

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  const available = products.filter(product => product.inStock);
  const notAvailable = products.filter(product => !product.inStock);
  available.sort((a, b) => a.price - b.price);
  notAvailable.sort((a, b) => a.price - b.price);
  return available.concat(notAvailable);
}

Esta es mi solución, cuidado con los spoiler!:
.
.
.
.
.
.
.
.
.
.
.
Me gusta después de terminar el ejercicio leer los comentarios para ver otras soluciones y me sorprende como lo hicieron con un sort!!, mi resultado tiene algunos pasos extra pero igual funciona.

export function sortByAvailabilityAndPrice(products) {
  let myProducts = [...products];

  let avalibles = myProducts.filter(item => item.inStock)
  let noAvalibles = myProducts.filter(item => !item.inStock);

  avalibles.sort((a, b) => a.price - b.price);
  noAvalibles.sort((a, b) => a.price - b.price)

  return avalibles.concat(noAvalibles);
}

wooo

export function sortByAvailabilityAndPrice(products) {
  let newproducts = [...products];
  newproducts.sort(function (a, b) {
    if (b.inStock > a.inStock) return 1;
    if (b.inStock < a.inStock) return -1;
    if (a.price > b.price) return 1;
    if (a.price < b.price) return -1;
  })
  return newproducts;
}

mi solución:
.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  return [...products]
    .sort((productA, productB) => {
      return (productB.inStock - productA.inStock) || (productA.price - productB.price);
    })
}

Mi solución
.
.
.
.
.
.

function sortByAvailabilityAndPrice(products) {
  const productList = new Array(...products)
  const sortedProducts = productList.sort((a, b) => a.price - b.price).sort((a, b) => b.inStock - a.inStock)
  return sortedProducts
}

Mi solución:
.
.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  return Array.from(products).sort((a, b) => a.price - b.price).sort((a, b) => b.inStock - a.inStock)
}

Aquí mi solución al reto:

function sortByAvailabilityAndPrice(products) {
    // filtrando todos los produts con stock
    const productsWithStock = products.filter(item => item.inStock);
    // filtrando todos los produts sin stock
    const productsOutOfStock = products.filter(item => !item.inStock);
    // aplicando ordenamiento ascendente a ambos grupos
    productsWithStock.sort((a, b) => a.price - b.price);
    productsOutOfStock.sort((a, b) => a.price - b.price);
    //concatenando ambos arrays
    return productsWithStock.concat(...productsOutOfStock);
  
  }

😋Acá mi solución, no es tan corta en líneas de código,pero considero que mejora mucho la legibilidad de esta.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  const availableProducts = products.filter((product) => product.inStock);
  const noAvailableProducts = products.filter((product) => !product.inStock);

  availableProducts.sort((a, b) => a.price - b.price);
  noAvailableProducts.sort((a, b) => a.price - b.price);

  return availableProducts.concat(noAvailableProducts);
}

Mi Solución…

function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  const availableProds = [];
  const notAvailableProds = [];

  products.forEach(prod => prod.inStock ? availableProds.push(prod) : notAvailableProds.push(prod));
  availableProds.sort((prodA, prodB) => prodA.price - prodB.price);
  notAvailableProds.sort((prodA, prodB) => prodA.price - prodB.price);

  return [...availableProds, ...notAvailableProds];
}

¡Hola, Desafío cumplido 😃!
Objetivo

Mi solución,
Se detalla hasta abajo.⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇

export function sortByAvailabilityAndPrice(products) {
  let result = [...products];
  result.sort((a, b) => a.price - b.price);

  result.sort((a, b) => b.inStock - a.inStock);

  return (result);
}

Anti-Spoiler:
I’m trying to do it with a few lines of code .

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  return [...products].sort(
    (a, b) => b.inStock - a.inStock || a.price - b.price
  );
}

ANTISPOILER
.
.
.
.
.
.
.
.
.

  const copyProducts = [...products];
  console.log(copyProducts);
  copyProducts.sort((a, b) => {
    if (a.inStock === b.inStock) {
      return a.price - b.price;
    } else {
      return b.inStock - a.inStock;
    }
  });

  return copyProducts;

Solución… 😄
.
Para el reto, no se debe modificar el array original, puesto que el método sort() lo hace, utilizaremos el spread operator para generar una copia del array original.
,
Sobre esta copia, podremos realizar el ordenamiento con las condiciones correspondientes.
.
Retornamos el nuevo array ordenado.
.

export function sortByAvailabilityAndPrice(products) {
  let sorted = [...products].sort((a, b) => a.price - b.price).sort((a, b) => b.inStock - a.inStock);

  return sorted;
}

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

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  return [...products].sort((a, b) => {
    if (a.inStock == b.inStock) {
      return a.price - b.price
    }
    else {
      return a.inStock ? -1 : 1
    };
  })
}

Mi solución:-

function sortByAvailabilityAndPrice(products) {
  return [...products].sort((a,b)=>a.price-b.price).sort((a,b)=>b.inStock-a.inStock);
}

ANTI SPOILER

export function sortByAvailabilityAndPrice(products) {
  let productsCopy = [...products];
  productsCopy.sort((p1, p2) => { 
    return (p1.inStock == p2.inStock) ? p1.price - p2.price : (p1.inStock) ? -1 : 1;
  });
  return productsCopy;
}

.
. -------------------------
. Spoilers :3
. -------------------------
.
.
.
.
…
.
.
.
.
.

.
.
.
.
.
.
.

.

Mi solucion :3

export function sortByAvailabilityAndPrice(products) {
  const productsSorted = [...products];
  productsSorted.sort((a, b) => a.price - b.price)
  productsSorted.sort((a, b) => b.inStock - a.inStock)
  return productsSorted;
}

Solución

export function sortByAvailabilityAndPrice(products) {
  // Tu código aquí 👈
  let list = [...products];
  list.sort((p1, p2) => (p1.price - p2.price));
  list.sort((p1, p2) => (p2.inStock - p1.inStock));
  return list;
}

Uhhhhhhhhhhhhhhhh baby!! Buenisimo reto, les dejo la solución abajo.

.
.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  return JSON.parse(JSON.stringify(products))
    .sort((a, b) => a.price - b.price)
    .sort((a, b) => b.inStock - a.inStock)
}
export function sortByAvailabilityAndPrice(products) {
  let response = [...products];
  response.sort(function (a, b) {
    if (a.inStock && !b.inStock) return -1;
    else if (a.inStock === b.inStock) return a.price - b.price;
    else return 1;
  });
  return response;
} 

Comparto mi solución!
.
.
.
.
.
.
.
.
.
.
Divido el arreglo de productos que recibo como parámetro en dos listas de productos. Una lista contiene los productos con stock y la otra los productos sin stock. Una vez obtenida la lista las ordena según su precio y retorna la lista de productos disponibles concatenada con la lista de productos sin stock

export function sortByAvailabilityAndPrice(products) {
  //Inicializo los arreglos que van a almacenar los productos con y sin stock
  const disponibles = []
  const sinStock = []

  //Si el producto tiene stock lo pusheo en disponibles, sino en sinStock
  const procesarProducto = (producto) => {
    (producto['inStock']) ? disponibles.push(producto):sinStock.push(producto)
  }

  //Ordena por precio un arreglo que recibe como parámetro
  const ordenarProductos = (productos) => {
    return productos.sort((a,b) => a.price-b.price)
  }

  //Ejecuta la función procesarProducto para cada elemento de products
  products.forEach(producto => {
    procesarProducto(producto)
  })

  //Retorna un array que concatena los productos disponibles con los productos sin stock
  return ordenarProductos(disponibles).concat(ordenarProductos(sinStock))
}

Hola. Comparto mi solución
.
.
.
.
.
Consiste en
.
.
.
.
.
.
.
.
La creación de 2 buffers en los que almaceno elementos (.push) dependiendo del valor de ‘inStock’ (if-else) a medida que recorro el arreglo ‘productos’ con el forEach. Luego aplico un sorting por ‘price’ a cada arreglo y finalmente los concateno para dar la respuesta.

export function sortByAvailabilityAndPrice(products) {
  let hay = []
  let noHay = []
  products.forEach(p => {
    if (p.inStock) hay.push(p)
    else noHay.push(p)
  })
  hay.sort((a, b) => a.price - b.price)
  noHay.sort((a, b) => a.price - b.price)
  return hay.concat(noHay)
}

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

function sortByAvailabilityAndPrice(products) {
    let arr = [...products].sort((a,b) => {
        if(a.inStock === b.inStock){
            return a.price < b.price ? -1 : 
            a.price > b.price ? 1 : 0;
        }else{
            return b.inStock - a.inStock;
        }
    });

    return arr;
};
undefined