js 数组降序映射排序

Question

这种数据格式如何变成下面这种，data中的数字要和fiel映射排序

var globVal = [
 
  {
    ip: "HJDB",
    data: [2, 79, 1, 0, 0, 5, 73, 0],
    fiel: [
      "TBS_ZHANGS",
      "TBS_YHIAITS",
      "TBS_YHIAS",
      "TBS_YHIAICE",
      "TBS_YHIAOMC",
      "TBS_YHIAOMS",
      "TBS_YHHJDS",
      "TBS_YHINFOSEC",
    ],
    sortStatus: "HJDB",
  },
  {
    ip: "TADB",
    data: [2, 4, 33, 0, 0, 75, 73, 70, 73, 0, 0, 0, 0, 0, 0, 2, 77],
    fiel: [
      "SYSTEM",
      "SYSAUX",
      "USERS",
      "TBS_YHIT",
      "TBS_YHAGTA",
      "TBS_YHETF",
      "TBS_YHRXTA",
      "TBS_YHTA2",
      "TBS_YHTA4",
      "TBS_YHTAAOP",
      "TBS_YHCFTA",
      "TBS_DSG",
      "TBS_YHOCR",
      "TBS_YHZBDG",
      "TBS_YHZBDGAPP",
      "TBS_ZHANGS",
      "TBS_YHOA",
    ],
    sortStatus: "TADB",
  },

];

{
    ip: "HJDB",
    data: [79, 73,5,2,  1, 0, 0,  0],
    fiel: [
     "TBS_YHIAITS",
     "TBS_YHHJDS",
     "TBS_YHIAOMS",
      "TBS_ZHANGS",
      "TBS_YHIAS",
      "TBS_YHIAICE",
      "TBS_YHIAOMC",
   
     
      "TBS_YHINFOSEC",
    ],
    sortStatus: "HJDB",
  },

Answer 1

function sort (input = []) {
    return input.map(item => {
        const { data, fiel } = item;

        const map = {};
        for (let i = data.length - 1; -1 < i; i -= 1) {
            map[fiel[i]] = data[i];
        }

        const _fiel = Array.from(fiel)
            .sort((m, n) => map[n] - map[m]);

        return {
            ...item,
            data: _fiel.map(v => map[v]),
            fiel: _fiel,
        };
    });
}

Answer 2

既然问题是映射排序，那就只讲映射排序的问题，设：

const data = [2, 79, 1, 0, 0, 5, 73, 0];
const fiel = [
    "TBS_ZHANGS",
    "TBS_YHIAITS",
    "TBS_YHIAS",
    "TBS_YHIAICE",
    "TBS_YHIAOMC",
    "TBS_YHIAOMS",
    "TBS_YHHJDS",
    "TBS_YHINFOSEC",
];

data 和 fiel 中的元素是一一对应关系。在排序的过程中 data 中的元素顺序会改变，fiel 中的顺序会对应改变，那有两种办法可以处理：

1. 排序过程中会交换元素，交换 data 元素的同时，对 fiel 中对应位置的元素也进行交换。这种处理方式主要就是保持两个数组的元素位置同步。代码比较好写，但是也比较容易出错。
2. 把 data 和 fiel 中的元素一一绑定在一起（对象，或者数组），交换的时候就直接交换了。排序完之后再分离出来。
3. 还有一种方法，就是建立两个数组之间的映射关系。但这种方式要求 data 数组中数据唯一，显然它不符合这个条件，所以这种方法只能拉倒。

下面是第二种方法的代码

const result = data
    .map((v, i) => [v, fiel[i]])
    .sort(([a], [b]) => b - a)
    .map(([, f]) => f);

过程是：

1. 先把元素一一绑定，变成 [1, "TBS_ZHANGS"] 这种 Pair 的数组
2. 按 Pair 的第 1 个元素从大到小排序（数组自带的 sort 好像是快速排序，所以权值相同的元素顺序可能不稳定），这里使用了参数解构语法。
3. 从 Pair 里把第 2 个元素分离出来组成新的数组，就是关联排序的结果

不过按要求，应该需要拆分出来两个列表，代码修改一下，先拿到排序的 Pair 列表，再分别拆出来。

const sorted = data
    .map((v, i) => [v, fiel[i]])
    .sort(([a], [b]) => b - a);

const sortedData = sorted.map(([v]) => v);
const sortedField = sorted.map(([, v]) => v);

分离两次需要两次遍历，也可以改用 reduce 在一次遍历中完成

const [sortedData, sortedField] = data
    .map((v, i) => [v, fiel[i]])
    .sort(([a], [b]) => b - a)
    .reduce(
        ([r1, r2], [v, f]) => {
            r1.push(v);
            r2.push(f);
            return [r1, r2];
        },
        [[], []]
    );