Question

我有一个包含3种类型值的数组，我希望对它们进行排序。

如果我只使用一个变量，它会很好，但是当我想使用3种类型的变量来确定排序顺序时，一切都会出错。

第一个变量条件：如果obj.sortorder == 999999将它发送到该行的末尾（这个只有一个）;

如果不是，那么

如果（日期＆lt;其他日期）将其放在前一个

之前

如果（日期＆gt;其他日期）将其置于另一个

之后

如果日期相等请查看sortorder以确定apppear的顺序。

然后循环数组，重置所有排序顺序变量，使其按新顺序正确升序。

然后拼接一个新值（第15个），但它不会出现在另一个旁边，即使它们有重复值。

我试图弄清楚这个问题让我很痛苦，我似乎无法以正确的顺序得到它们。

基本上他们在这里创建的方式应该是第一种。但是，除了我想要的地方之外，第一种情况与整个地方的价格混乱。

第二种方式奇怪地按正确顺序排列，但是将16位放在两位十五位之间，而五位位置则相互靠近。并且不知何故，第24次结束后，作为重新分配后的9999，而第29次应该仍然是最后一次。

谁可以帮我这个？

如果按下运行代码段，您将获得我目前获得的乱码输出。第一组是所有其他人应该看起来的样子，除了最后一个15岁应该互相拥抱的人.f

elements = [];
for (var c = 0; c < 30; c++) {
    elements[c] = {
        sortorder: c,
        getDate: function () {
            return new Date(2015, 06, this.sortorder)
        }
    };
}

function log(what) {
    var elem = document.getElementById('sortorder');
    elem.appendChild(document.createTextNode(what + "\n"));
}
for (c = 1; c < elements.length; c++) {
    log(c + " = " + elements[c].getDate() + " - " + elements[c].sortorder)
}
log('--------------------------------');
elements[elements.length - 1].sortorder = 9999999;

this.elements.sort(function (one, two) {
    /**
     * Failsafe to prevent the last element to be placed in the middle
     */
    if (one.sortorder >= 9999998) {
      return 1;
    }
    if (two.sortorder >= 9999998) {
      return -1;
    }
    if (one.getDate() < two.getDate()) {
      return -1
    } 
    if (two.getDate() > one.getDate()) {
      return 1;
    }
    if (one.sortorder < two.sortorder) {
       return -1;
    }
    if (one.sortOrder > two.sortorder) {
       return 1;
    }
    return 0;
             
});

function log(what) {
    var elem = document.getElementById('sortorder');
    elem.appendChild(document.createTextNode(what + "\n"));
}
for (c = 1; c < elements.length; c++) {
    log(c + " = " + elements[c].getDate() + " - " + elements[c].sortorder)
}
log('--------------------------------------------------------------');
elements.splice(17, 0, {
    sortorder: 15,
    getDate: function () {
        return new Date(2015, 06, 15)
    }
});
for (var c = 1; c < this.elements.length; c++) {
    if (c < this.elements.length - 1) {
        this.elements[c].sortorder = c;
    } else {
        this.elements[c].sortorder = 9999999;
    }
}
for (c = 1; c < elements.length; c++) {
    log(c + " = " + elements[c].getDate() + " - " + elements[c].sortorder)
}

<pre id="sortorder">
</pre>

Answer 1

不太确定你的意思是“然后拼接一个新的值（第15个），但它不会出现在另一个旁边，即使它们有重复的值。”

除了那之外，它可以做任何事情。

      var last;
var newArray = [];
for(var obj in array){
  obj = array[obj];
  if(obj.sortorder === 999999)
    last = obj;
  else {
    for(var item in newArray){
      if(obj.date.getTime() < newArray[item].date.getTime()){
        newArray.splice(item, 0, obj);
        break;
      }
      if(obj.date.getTime() === newArray[item].date.getTime()){
        if(obj.sortorder > newArray[item].sortorder){
          newArray.splice(item, 0, obj);
          break;
      }
        else{
          newArray.splice(item + 1, 0, obj);
          break;
      }
      }
    }
  }
}
newArray.push(last);
var sortorder = 1;
for(var item in newArray){
  if(newArray[item].date.getTime() > newArray[item - 1].date.getTime())
  newArray[item].sortorder = ++sortorder;
}

Answer 2

经过一些实验，摆弄，咒骂，谷歌搜索，在这种情况下的正常过程我终于得到了解决方案。我想我再次推翻了事情。

感谢您的帮助和思考。

  elements.sort(function(one,two) 
        {
        var ret = 0;
        /**
         * Failsafe to prevent the last element to be placed in the middle
         */
        if(one.sortorder >= 9999998) {

            ret = 1;
        }
        else {
            if(two.sortorder >= 9999998) {

                ret = -1;
            }
            else {
                if(one.getDate() - two.getDate() !== 0) {
                    ret = one.getDate() - two.getDate();
                }
                else {
                    ret = one.sortorder - two.sortorder;                        
                    }

            }
        }
        console.log(ret);
        return ret;
        });

基于3个变量的数组排序

2 个答案: