Combining parallel arrays into single object array and sort

From what I understand, you end up with three arrays. These arrays will be of consistent length, with the index representing which row in the table they are. What you want is to sort the indices of all three arrays based on the values of one. This means that you need to ensure whenever a value in one array is moved, the values of all other arrays are moved from identically.

Unfortunately, there is no way of doing this that I'm aware of with native functions. You'd have to implement the sort yourself to manage it that way.

On the front end, It's better to have associated data structured as an an array of objects rather than a set of associated table-like arrays. That way, you can more intuitively perform sorts, searches, filters, etc. Let's go over how to do that.

I'll use your test object:

var testObject = {
  id_values: [20, 10, 40],
  od_values: [30, 15, 2],
  qty_values: [6, 3, 15]
};

To convert the associated arrays to an array of objects containing associated data, I'll instantiate a zero-filled array with the same number of indices as the tables. Then, we map over this blank array, creating an object from the data in each table:

const dataArray = new Array(obj[by].length).fill(0).map((_, i) => {
  return {
    id_values: testObject.id_values[i],
    od_values: testObject.od_values[i],
    qty_values: testObject.qty_values[i]
  }
}) .sort((a, b) => a[by] > b[by])

At this point, the tables will be converted into the more JavaScript-friendly array of objects, which will look like this:

const dataArray = [ 
  { id_values: 20, od_values: 30, qty_values: 6 },  
  { id_values: 10, od_values: 15, qty_values: 3 },  
  { id_values: 40, od_values: 2, qty_values: 15 } 
]

Now THAT can be easily sorted using the native array sort:

dataArray.sort((a, b) => a.od_values > b.od_values)

Which will result in it being sorted!

const sortedData = [ 
  { id_values: 40, od_values: 2, qty_values: 15 },  
  { id_values: 10, od_values: 15, qty_values: 3 },  
  { id_values: 20, od_values: 30, qty_values: 6 } 
]

The values can the be destructured into their associated tables by reducing the array of objects:

dataArray.reduce((acc, el) => {
  Object.keys(el).map(col => {
    acc[col].push(el[col])
  })
  return acc
}, {
  id_values: [],
  od_values: [],
  qty_values: []
})

Resulting in the original data structure, but sorted by the selected attribute:

const sortedArrays = { 
  id_values: [ 40, 10, 20 ],  
  od_values: [ 2, 15, 30 ],  
  qty_values: [ 15, 3, 6 ] 
}

Putting it all together:

var testObject = {
  id_values: [20, 10, 40],
  od_values: [30, 15, 2],
  qty_values: [6, 3, 15]
};

const sortTableObj = (obj, by) => {
  const dataArray = new Array(obj[by].length).fill(0).map((_, i) => {
    return {
      id_values: testObject.id_values[i],
      od_values: testObject.od_values[i],
      qty_values: testObject.qty_values[i]
    }
  }).sort((a, b) => a[by] > b[by])
  console.log('dataArray: ', dataArray) 

  return dataArray.reduce((acc, el) => {
    Object.keys(el).map(col => {
      acc[col].push(el[col])
    })
    return acc
  }, {
    id_values: [],
    od_values: [],
    qty_values: []
  })
}

sortTableObj(testObject, 'od_values')

Let me know if you have any questions!