js判断对多个版本号进行排序怎么做？

Question

1.例如现在存在一组版本号，['0.1.1', '2.3.3', '0.3002.1', '4.2', '4.3.5', '4.3.4.5']，怎么对这个版本号进行排序，实现最后排序的结果为['4.3.5','4.3.4.5','2.3.3','0.3002.1','0.1.1']；不知道各位大神有什么好的实现方法？

Answer 1

var arr=['0.1.1', '2.3.3', '0.3002.1', '4.2', '4.3.5', '4.3.4.5'];
    arr.sort(function(a,b){
        return a>b?-1:1;
    });
    console.log(arr);

Answer 2

var arr = ['0.1.1', '2.3.3', '0.3002.1', '4.2', '4.3.5', '4.3.4.5']
arr.sort((a,b)=>{
    var items1 = a.split('.')
    var items2 = b.split('.')
    var len = Math.max(items1.length, items2.length)
    var k = 0
    for (let i = 0; i < len; i++) {
      let a1 = items1[i]
      let b1 = items2[i]
      if (typeof a1 === 'undefined') {
        k = -1
        break
      } else if (typeof b1 === 'undefined') {
        k = 1
        break
      } else {
        if (a1 === b1) {
          continue
        }
        k = Number(a1) - Number(b1)
        break
      }
    }
    return k
})
console.log(arr)

Answer 3

// 使用的是选择排序
const versionSort = version => {
  const temp = version.map(v => v.split('.'));
  for (let i = 0; i < temp.length; i++) {
    let minIndex = i;
    for (let j = i; j < temp.length; j++) {
      for (let k = 0; k < temp[j].length; k++) {
        const current = +temp[j][k],
        min = +temp[minIndex][k];
        if (current < min) {
          minIndex = j;
        }
        // 只要不等，就立刻结束最内层遍历！
        if (current !== min) {
          break
        }
      }
    }
    [temp[i], temp[minIndex]] = [temp[minIndex], temp[i]];
  }
  return temp.map(v = > v.join('.'))
};

Answer 4

手动实现 sort

const versionSort = versionArr => {
    if (versionArr.length <= 1) return;

    const arr = versionArr.map(version => version.split('.'));

    outer: for(let i = 0; i < arr.length; i++) {
        let minIndex = i;
        // console.log('\n\n outer: i', i, 'arr', arr.map(item => item.join('.')));

        // 找到最小版本号
        middle: for (let j = i + 1; j < arr.length; j++) {
            // console.log('\n middle: j',j,'arr[j]', arr[j].join('.'))
            inner: for(let k = 0; k < arr[j].length; k++) {
                const current = Number(arr[j][k] || 0);
                const min = Number(arr[minIndex][k] || 0);

                // console.log('k',k, 'current', current, 'min', min);
                if (current < min) {
                    minIndex = j;
                    // console.log('current < min', minIndex)
                    continue middle;
                } else if (current > min) {
                    // console.log('current > min', minIndex)
                    continue middle;
                }
            }
            // console.log('arr[j]遍历完毕,且没有比较出结果,说明只能通过更后的数才能比较出结果, 即arr[j]位数<=arr[minIndex]位数');
            // console.log('arr[j]', arr[j].join('.'), 'arr[minIndex]', arr[minIndex].join('.'))

            minIndex = j;
        }
        // console.log('change: ', 'i', i, 'minIndex', minIndex, arr[i].join('.'), arr[minIndex].join('.'));
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
    }
    return arr.map(item => item.join('.'));
}

var arr = ['1.5.4', '1.5.1', '1.5.0', '1.5', '1.41', '1.10.12', '1.4.2', '3.2', '9', '0.1', '0.0.2.3', '1.5.3.2', '1.5.3'];
console.log(versionSort(arr))

利用数组 sort：

arr.sort((a, b) => {
    const listA = a.split('.');
    const listB = b.split('.');
    let k = undefined;

    for (let i in listA) {
        let itemA = Number(listA[i] || 0);
        let itemB = Number(listB[i] || 0);

        if (itemA === itemB) {
            continue;
        } else {
            k = Number(itemA) - Number(itemB);
            break;
        }
    }
    if (k === undefined) {
        k = listA.length - listB.length;
    }
    return k;
});

Answer 5

zzgzzg00 同学的回答简单优雅，但是适用性并不强。实际上可能换个case就会导致排序结果不准确：

['0.5.1','0.1.1','2.3.3','0.302.1','4.2','4.3.5','4.3.4.5'];

更适合的方式是利用循环

arr.sort((a, b) => {
    let i = 0;
    const arr1 = a.split('.');
    const arr2 = b.split('.');

    while (true) {
        const s1 = arr1[i];
        const s2 = arr2[i++];

        if (s1 === undefined || s2 === undefined) {
            return arr2.length - arr1.length;
        }

        if (s1 === s2) continue;

        return s2 - s1;
    }
});

console.log(arr)

我写了篇文章解释了为什么字符串比较能够实现排序、以及更多排序方式及其适用场景：https://segmentfault.com/a/11...

Answer 6

// 双指针比较两个版本的大小
const compareVersion = (version1, version2) => {
  let v1 = version1.split('.')
  let v2 = version2.split('.')
  
  v1 = v1.map((it) => parseInt(it))
  v2 = v2.map((it) => parseInt(it))

  let len1 = v1.length
  let len2 = v2.length

  let i = 0
  let j = 0

  while (i < len1 && j < len2) {
    if (v1[ i ] < v2[ j ]) {
      return -1
    } else if (v1[ i ] > v2[ j ]) {
      return 1
    } else {
      i++
      j++
    }
  }

  if (i === len1 && j === len2) {
    return 0
  }

  if (i === len1) {
    return v2.slice(j).some((it) => it !== 0) ? -1 : 0
  }

  if (j === len2) {
    return v1.slice(i).some((it) => it !== 0) ? 1 : 0
  }
}
// 快排比较数组中的各项大小
const sortVersion = (list) => {
  if (list.length < 1) {
    return list
  }
  const middleIndex = Math.floor(list.length / 2)
  const middleVal = list.splice(middleIndex, 1)[0]

  let leftArr = []
  let rightArr = []

  for (let i = 0, len = list.length; i < len; i++) {
    if (compareVersion(list[ i ], middleVal) === -1) {
      leftArr.push(list[ i ])
    } else {
      rightArr.push(list[ i ])
    }
  }

  return sortVersion(leftArr).concat([ middleVal ], sortVersion(rightArr))
}