根据另一阵列的顺序

Question

我有尺寸这样的阵列对数组排序最终是这样的：

var arr = [ 
    'small', 
    'small', 
    'medium', 
    'medium', 
    'big', 

    'small', 
    'small', 
    'medium', 
    'medium', 
    'big' 

    ... 
]; 

我所知道的其他类似的问题在左右，但我无法找到任何物品迄今为止。我不确定如何解决这个问题。我在想sort应该做，但我测试什么？这似乎很简单，但我卡住了，不知道从哪里开始。任何提示？

Answer 1

好了，我终于结束了这个解决方案，它的工作原理：

function orderBy(arr, order) { 
    var result = [], 
     i = 0, len = arr.length, 
     index; 

    while (result.length < len) { 
    index = arr.indexOf(order[i]); 
    result.push(arr[index]); 
    arr.splice(index, 1); 
    i = i >= order.length-1 ? 0 : ++i; 
    } 

    return result; 
} 

它修改了原始数组，但没关系。

演示：http://jsbin.com/umizat/1/edit

Answer 2

只需为您的排序方法定义一个记录器即可。 这是你的代码。试试吧

var init_arr = ['small', 'big', 'big', 'medium']; 

var scorer = { 
    small: 0, 
    medium: 1, 
    big: 2 
} 

// You can use the same array too. I am creating new one. 
var final_arr = init_arr.sort(function(a,b) { 
    return scorer[a]-scorer[b]; 
}); 

alert(final_arr); //small, medium, big, big 

Working Fiddle

Answer 3

你为什么不创建3个数组和分裂根据尺寸数据，那么您可以在一个给定的顺序检索数据。

like;

SMALL[]; 
MEDIUM[]; 
BIG[]; 

for(i,j,k : upto array lengths : i++,j++,k++){ 

    nwArray.add(SMALL[i]); 
    nwArray.add(SMALL[++i]); 
    nwArray.add(MEDIUM[j]); 
    nwArray.add(MEDIUM[++j]); 
    nwArray.add(BIG[k]); 

} 

return newArray; 

Answer 4

我的方法是遍历顺序数组，并拉出元素，直到数组为空或没有所需的元素。

var sorted = []; 
var arr = [ 
    'small', 
    'small', 
    'small', 
    'small', 
    ... 
    'medium', 
    'medium', 
    'medium', 
    'medium', 
    ... 
    'big', 
    'big', 
    ... 
]; 
var order = ['small', 'small', 'medium', 'medium', 'big']; 

out: 
while (true) { 
    for (var i = 0; i < order.length; i++) { 
    var index = arr.indexOf(order[i]); 
    if ((index === -1) or (arr.length === 0)) { 
     break out; 
    } else { 
     var elem = arr.splice(index, 1); 
     sorted.append(elem[0]); 
    } 
} 

Answer 5

这个答案只针对你所描述的确切情况下，即其中数组的长度的偶数倍5和值分为小，中，大，有两倍多的每个中小企业都很大。

它可以连续工作值，其中length % 5 == 0的任何排序数组，但结果却可能是想你想：

function reOrder(array) { 
    var result = []; 
    var f = array.length/5; // this must be an integer 
    var t; 

    for (var i=0; i<f; i++) { 
    t = i*2; 
    result.push.call(result, array.slice(t, t+2)); 
    t = f*2 + i*2; 
    result.push.call(result, array.slice(t, t+2)); 
    t = f*4 + i; 
    result.push.call(result, array.slice(t, t+1)); 
    } 
    return result; 
} 

var a = ['s','s','s','s','s','s','m','m','m','m','m','m','b','b','b']; 
alert(reOrder(a)); // s,s,m,m,b,s,s,m,m,b,s,s,m,m,b 

Answer 6

我知道这个问题是旧的，你有你当前使用的是答案，但我想提供了一个解决方案这个例子和JSFiddle将与任何类型的修改工作，你可能会结束。

注意原始数组中剩余的任何内容都会被添加到新数组的末尾，并且不会被排除。如果阵列中的项目不足以满足order的要求，则会从订单中跳过缺失的元素。现在

，给该函数：

function mySort(arr, order) { 
    var newAr = []; 
    var orIndex = 0; 
    while(arr.length != 0) { 
     var type = order[orIndex]; 
     var ind = arr.indexOf(type); 
     if(ind != -1) { 
      newAr.push(type); 
      arr.splice(ind, 1); 
     } 
     orIndex++; 
     if(orIndex >= order.length) { 
      orIndex = 0; 
     } 
    } 
    return newAr; 
} 

这个做什么，是需要你的例子数组：

var arrTest = [ 
    'small', 
    'small', 
    'small', 
    'small', 
    'small', 
    'small', 
    'small', 
    'small', 
    'medium', 
    'medium', 
    'medium', 
    'medium', 
    'medium', 
    'medium', 
    'medium', 
    'medium', 
    'big', 
    'big', 
    'big', 
    'big', 
]; 
var orderTest = ['small', 'small', 'medium', 'medium', 'big']; 

现在，你可以改变这些所有你想要的，但它确实对它们进行文本搜索，所以如果你想对它进行排序，请确保它在完整数组和顺序数组中都是相同的。现在，使用的功能，你会怎么做：

var sortedArray = mySort(arrTest, orderTest); 

或者，我在小提琴如何证明：

alert(mySort(arrTest, orderTest).join('\n')); 

这应该涉及两个任何情况下工作，并且为了能很容易被修改。

希望有帮助！