Playground - Ordena los productos

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

🛡️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)
  })
}

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