Revisions to How can I sort an array based on a couple parameters?

added 18 characters in body

Source Link

edited May 29, 2022 at 20:51

7.7k
3
18
36

You need to take undefined into consideration. I think it's a waste of resources to sort an array multiple times, because there areof the numerous loops going onthat the sortings will demand.

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]


const sortAll = (arr) => {
  const UNSORTED = 0;
  let tempA, tempB, result   = 0;

  return arr
    .sort((a, b) => {
        result = compareProperties(a.pet?.isFavorite, b.pet?.isFavorite)

        // if (result == UNSORTED) {
        //  result = compareProperties(a.pet?.type, b.pet?.type)
        // }
        
        // if (result == UNSORTED) {
        // ...

        return result
    })
}

const compareProperties = (tempA, tempB) => {
  if (tempA !== tempB) {
    if (typeof tempA == 'undefined') { return 1  }
    if (typeof tempB == 'undefined') { return -1 }
    if (tempA < tempB)               { return 1  }
    if (tempA > tempB)               { return -1 }
  }

  return 0
}

console.log('sorted', sortAll(currentPets));

You need to take undefined into consideration. I think it's a waste of resources to sort an array multiple times, because there are numerous loops going on.

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]


const sortAll = (arr) => {
  const UNSORTED = 0;
  let tempA, tempB, result = 0;

  return arr
    .sort((a, b) => {
        result = compareProperties(a.pet?.isFavorite, b.pet?.isFavorite)

        // if (result == UNSORTED) {
        //  result = compareProperties(a.pet?.type, b.pet?.type)
        // }
        
        // if (result == UNSORTED) {
        // ...

        return result
    })
}

const compareProperties = (tempA, tempB) => {
  if (tempA !== tempB) {
    if (typeof tempA == 'undefined') { return 1  }
    if (typeof tempB == 'undefined') { return -1 }
    if (tempA < tempB)               { return 1  }
    if (tempA > tempB)               { return -1 }
  }

  return 0
}

console.log('sorted', sortAll(currentPets));

You need to take undefined into consideration. I think it's a waste of resources to sort an array multiple times, because of the numerous loops that the sortings will demand.

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]


const sortAll = (arr) => {
  const UNSORTED = 0;
  let   result   = 0;

  return arr
    .sort((a, b) => {
        result = compareProperties(a.pet?.isFavorite, b.pet?.isFavorite)

        // if (result == UNSORTED) {
        //  result = compareProperties(a.pet?.type, b.pet?.type)
        // }
        
        // if (result == UNSORTED) {
        // ...

        return result
    })
}

const compareProperties = (tempA, tempB) => {
  if (tempA !== tempB) {
    if (typeof tempA == 'undefined') { return 1  }
    if (typeof tempB == 'undefined') { return -1 }
    if (tempA < tempB)               { return 1  }
    if (tempA > tempB)               { return -1 }
  }

  return 0
}

console.log('sorted', sortAll(currentPets));

Expanded upon the code.

Source Link

edited May 29, 2022 at 20:45

Rickard Elimää

7.7k
3
18
36

And how is how it should look like if you refactored the code:

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]


const sortAll = (arr) => {
  const UNSORTED = 0;
  let tempA, tempB, result = 0;

  return arr
    .sort((a, b) => {
        result = compareProperties(a.pet?.isFavorite, b.pet?.isFavorite)

        // if (result == UNSORTED) {
        //  result = compareProperties(a.pet?.type, b.pet?.type)
        // }
        
        // if (result == UNSORTED) {
        // ...

        return result
    })
}

const compareProperties = (tempA, tempB) => {
  if (tempA !== tempB) {
    if (typeof tempA == 'undefined') { return 1  }
    if (typeof tempB == 'undefined') { return -1 }
    if (tempA < tempB)               { return 1  }
    if (tempA > tempB)               { return -1 }
  }

  return 0
}

console.log('sorted', sortAll(currentPets));

And how is how it should look like if you refactored the code:

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]


const sortAll = (arr) => {
  const UNSORTED = 0;
  let tempA, tempB, result = 0;

  return arr
    .sort((a, b) => {
        result = compareProperties(a.pet?.isFavorite, b.pet?.isFavorite)

        // if (result == UNSORTED) {
        //  result = compareProperties(a.pet?.type, b.pet?.type)
        // }
        
        // if (result == UNSORTED) {
        // ...

        return result
    })
}

const compareProperties = (tempA, tempB) => {
  if (tempA !== tempB) {
    if (typeof tempA == 'undefined') { return 1  }
    if (typeof tempB == 'undefined') { return -1 }
    if (tempA < tempB)               { return 1  }
    if (tempA > tempB)               { return -1 }
  }

  return 0
}

console.log('sorted', sortAll(currentPets));

Had a brain fart

Source Link

edited May 29, 2022 at 20:34

Rickard Elimää

7.7k
3
18
36

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]

let tempA, tempB;

const sortAll = () => {
  let tempA, tempB;

  return currentPets
    .sort((a, b) => {
        tempA = a.pet?.isFavorite
        tempB = b.pet?.isFavorite

        if// (tempAyou ===should tempB)refactor this if statement
        if (tempA {!== returntempB) 0{
  }
        if (typeof tempA == 'undefined') { return 1  }
          if (typeof tempB == 'undefined') { return -1 }
          if (tempA < tempB)               { return 1  }
          if (tempA > tempB)               { return -1 }
        }

        // tempA = a.pet?.type
        // tempB = b.pet?.type
 
        //if expand(tempA here,!== buttempB) remove{
 the `return 0` line above if you do  // ...
        //}

        return 0
    })
}

console.log('sorted', sortAll());

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]

let tempA, tempB;

const sortAll = () => {
  return currentPets
    .sort((a, b) => {
        tempA = a.pet?.isFavorite
        tempB = b.pet?.isFavorite

        if (tempA === tempB)             { return 0  }
        if (typeof tempA == 'undefined') { return 1  }
        if (typeof tempB == 'undefined') { return -1 }
        if (tempA < tempB)               { return 1  }
        if (tempA > tempB)               { return -1 }

        // tempA = a.pet?.type
        // tempB = b.pet?.type
 
        // expand here, but remove the `return 0` line above if you do.
    })
}

console.log('sorted', sortAll());

const currentPets = [
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'quartz', level: 3, isFavorite: false}},
  { state: 'equipped', pet: { type: 'quartz', level: 6, isFavorite: true}},
  { state: 'occupied', pet: { type: 'quartz', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 5, isFavorite: false}},
  { state: 'occupied', pet: { type: 'obsidian', level: 6, isFavorite: true}},
  { state: 'empty', pet: null},
  { state: 'empty', pet: null},
  { state: 'occupied', pet: { type: 'agate', level: 1, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 2, isFavorite: false}},
  { state: 'occupied', pet: { type: 'agate', level: 4, isFavorite: true}},
]


const sortAll = () => {
  let tempA, tempB;

  return currentPets
    .sort((a, b) => {
        tempA = a.pet?.isFavorite
        tempB = b.pet?.isFavorite

        // you should refactor this if statement
        if (tempA !== tempB) {
          if (typeof tempA == 'undefined') { return 1  }
          if (typeof tempB == 'undefined') { return -1 }
          if (tempA < tempB)               { return 1  }
          if (tempA > tempB)               { return -1 }
        }

        // tempA = a.pet?.type
        // tempB = b.pet?.type
        //if (tempA !== tempB) {
          // ...
        //}

        return 0
    })
}

console.log('sorted', sortAll());

Source Link

answered May 29, 2022 at 20:24

Rickard Elimää

7.7k
3
18
36

Loading

Collectives™ on Stack Overflow

Return to Answer