隆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

Playground - Ordena los productos

49/99

Aportes 70

Preguntas 0

Ordenar por:

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

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;
})

馃洝锔廍scudo 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)
  })
}

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

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 soluci贸n

function sortByAvailabilityAndPrice(products) {
  const orderProducts = [...products]
  const inStock = [];
  const outStock = [];
  orderProducts.forEach(product => {
    if(product.inStock == true) {
      inStock.push(product);
    } else {
      outStock.push(product);
    }
  })
  inStock.sort((a, b) => a.price - b.price);
  outStock.sort((a,b) => a.price - b.price);
  const productsByAvailability = [...inStock, ...outStock];
  return productsByAvailability;
}
export function sortByAvailabilityAndPrice(products) {
  const sortedProducts = [...products];

  sortedProducts.sort((a, b) => {
    // Ordenar por disponibilidad en inventario (true primero)
    if (a.inStock && !b.inStock) {
      return -1;
    } else if (!a.inStock && b.inStock) {
      return 1;
    }

    // Ordenar por precio ascendente
    return a.price - b.price;
  });

  return sortedProducts;
}

Aqui esta mi solucion:

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

  return nuevoArray
}

Mi soluci贸n

export function sortByAvailabilityAndPrice(products) {

let new_products = [...products].sort((a, b) => a.price - b.price)
let resultado = [...new_products].sort((a, b) => b.inStock - a.inStock)
 return resultado
}

Soluci贸n al desafio:

Mi soluci贸n:

export function sortByAvailabilityAndPrice(products) {
  // Tu c贸digo aqu铆 馃憟

  let inStock = products.filter(product => product.inStock === true);
  let outStock = products.filter(product => product.inStock === false);

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

  let sortedProducts = inStock.concat(outStock);

  return sortedProducts;
}

Mi aporte

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

Spoiler





function sortByAvailabilityAndPrice(products) {
    // clasificar podructos
    let productosDisponibles = products.filter(function(producto){
        return producto.inStock == true  
    });
    let productosNoDisponibles = products.filter(function(producto){
        return producto.inStock == false  
    });

    //ordenar productos disponibles
    productosDisponibles.sort((a, b) => a.price - b.price);

    //ordenar productos no disponibles
    productosNoDisponibles.sort((a, b) => a.price - b.price);

    //concatenar lista de productos
    let productosOrdenados = productosDisponibles.concat(productosNoDisponibles);
    return productosOrdenados;
}
const products = [
  { name: "product1", price: 10, inStock: true },
  { name: "product2", price: 20, inStock: false },
  { name: "product3", price: 15, inStock: true },
  { name: "product4", price: 5, inStock: false },
]

console.log(sortByAvailabilityAndPrice(products));

Array.prototype.filterInStock = function (inStock = true) {
  return this.filter(product => product.inStock === inStock);
}

Array.prototype.sortByPrice = function (ord = 'ASC') { 
  return this.sort((a, b) => ord === 'ASC' ? a.price - b.price : b.price - a.price);
}

export const sortByAvailabilityAndPrice = (products) => {
  const stock = products.filterInStock().sortByPrice();
  const outStock = products.filterInStock(false).sortByPrice();
  return stock.concat(outStock);
}

export function sortByAvailabilityAndPrice(products) {
  const array1 = [...products]
    .filter((e) => e.inStock === true)
    .sort((x, y) => x.price - y.price);

  const array2 = [...products]
    .filter((e) => e.inStock === false)
    .sort((x, y) => x.price - y.price);

  return array1.concat(array2);
}
export function sortByAvailabilityAndPrice(products) {
  // Tu c贸digo aqu铆 馃憟
  let listResult = [...products];
  listResult.sort((a, b) => a.price - b.price);
  listResult.sort((a, b) => b.inStock - a.inStock);
  return listResult;
}


.
.
.
.
.
.

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

dejo mi solucion!
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sortByAvailabilityAndPrice(products) {
  // Tu c贸digo aqu铆 馃憟
  const inStock = products.filter(product => product.inStock === true)
  const notInStrock = products.filter(product => product.inStock === false);
  const sortedArray = [...inStock.sort((a, b) => a.price - b.price), ...notInStrock.sort((a, b) => a.price - b.price)]

  return sortedArray;  
}

export function sortByAvailabilityAndPrice(products) {
  // Tu c贸digo aqu铆 馃憟
  const prodoSort = [...products];


  prodoSort.sort(function (a, b) {
    if (a.inStock === b.inStock) {
   
      return a.price - b.price;
    } else {
      
      return (a.inStock ? -1 : 1);
    }
  });

  return prodoSort;
}

Otra manera ser铆a esta=>

  return [...products].sort((a, b) =>
    a.inStock > b.inStock ? -1 :
      a.inStock < b.inStock ? 1 :
        a.price > b.price ? 1 :
          a.price < b.price ? -1 : 0
  );

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

Mi soluci贸n al reto:

export function sortByAvailabilityAndPrice(products) {
  let ordenedByStock = [];
  let ordenedByPrice = [];
  ordenedByPrice = products.filter(item => item.inStock).sort((a, b) => a.price - b.price)
  ordenedByStock = products.filter(item => !item.inStock).sort((a, b) => a.price - b.price)
  ordenedByPrice = ordenedByPrice.concat(ordenedByStock)
  return ordenedByPrice;
}

mi solucion:
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞
馃憞

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

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

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

Hola, Mi soluci贸n al Reto:

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

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

export function sortByAvailabilityAndPrice(products) {
  const productsSorted = [...products];

  productsSorted.sort((productA, productB) => {
    if (productA.inStock !== productB.inStock) {
      return productA.inStock ? -1 : 1;
    }

    // console.log(`${productA.price} - ${productB.price}: ${ productA.price - productB.price}`)
    return productA.price - productB.price;

  });

  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鈥檓 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 鈥榠nStock鈥 (if-else) a medida que recorro el arreglo 鈥榩roductos鈥 con el forEach. Luego aplico un sorting por 鈥榩rice鈥 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