Javascript 按顺序组合数组

我有几条棱边，我正试着按一定的顺序组合。例如，假设我有三个数组：

var arrayOne = [1a, 1b, 1c];
var arrayTwo = [2a, 2b, 2c];
var arrayThree [3a, 3b, 3c];

我怎样才能得到这样的东西

var combinedArray = [1a, 2a, 3a, 1b, 2b, 3b, 1c, 2c, 3c] 

编辑

好的，我将在这里为我的故事添加一点内容，因为我已经从每个人那里得到了一些很好的回应和答案。也许这会更清楚。我有一个SharePoint列表，我从中获取所有信息。我正在使用SPServices从列表中获取数据。我还将获取每个列表项的版本历史记录，并将它们放入数组中，这样我就可以从SPServices循环中提取数据，并在SharePoint内容之外使用它，这样我就可以尝试按需要排序和显示它。（请不要将此移动到SharePoint。）). 这一切都必须在运行时发生。因此，这里是第一部分。我为我的每个列表项声明全局变量：

var proModified6 = new Array();
var proHistory = new Array();
var assignedTo = new Array();
var startDate = new Array();
var endDate = new Array();
var status = new Array();
var project = new Array();
var history = new Array();


var listItems = new Array();


var regex = new RegExp("");

var i = 0;

然后我用SharePoint列表信息填充数组（我不会把它们全部放进去，但每个数组都有一个这样的调用）

每个列表都会有所不同。对于每个用户，它们的数量也不会相同。我刚将列表设置为静态，以便首先进行构建。列表动态稍后将是另一个问题：0

---

有没有办法像我在简单示例中所问的那样处理这些数组？看看我为什么先简单一下。lol.

编辑：更新了比较器，正如Salmon指出的，它应该返回

-1

，

0

或

1

试试下面

var arrayOne = ["1a", "1b", "1c"];
var arrayTwo = ["2a", "2b", "2c"];
var arrayThree = ["3a", "3b", "3c"];

var combinedArray = arrayOne
    .concat(arrayTwo, arrayThree) //Concatenate the array.. can add any number of arrays
    .sort(function(a, b) { //Custom comparator for your data
       var a1 = a.charAt(1);
       var b1 = b.charAt(1);

       if (a1 == b1) return 0;
       if (a1 < b1) return -1;
       return 1;
    });

var arrayOne=[“1a”、“1b”、“1c”]；
var arrayTwo=[“2a”、“2b”、“2c”]；
变量数组树=[“3a”、“3b”、“3c”]；
var combinedArray=arrayOne
.concat（arrayTwo，arraytree）//连接数组..可以添加任意数量的数组
.sort（函数（a，b）{//数据的自定义比较器
变量a1=a.charAt（1）；
var b1=b.charAt（1）；
如果（a1==b1）返回0；
如果（a1

注意：自定义比较器函数非常特定于您的数据。请根据需要更新该函数

---

如果三个阵列的长度始终相同：

var arrayOne = ["1a", "1b", "1c"];
var arrayTwo = ["2a", "2b", "2c"];
var arrayThree = ["3a", "3b", "3c"];

var newArray = [];
for (var i = 0, len = arrayOne.length; i < len; i++) {
    newArray.push(arrayOne[i], arrayTwo[i], arrayThree[i]);
}

console.log(newArray); //1a,2a,3a,1b,2b,3b,1c,2c,3c

var arrayOne=[“1a”、“1b”、“1c”]；
var arrayTwo=[“2a”、“2b”、“2c”]；
变量数组树=[“3a”、“3b”、“3c”]；
var newArray=[]；
对于（变量i=0，len=arrayOne.length；i

但是，如果数组的长度不总是相同的，我们需要使用三个数组中的最大长度，并跳过缺少的索引，因此如下所示：

var arrayOne = ["1a", "1b", "1c", "1d"];
var arrayTwo = ["2a", "2b", "2c"];
var arrayThree = ["3a", "3b"];

var newArray = [];
var len = Math.max(arrayOne.length, arrayTwo.length, arrayThree.length);

for (var i = 0; i < len; i++) {
    if (i in arrayOne) {
        newArray.push(arrayOne[i]);
    }
    if (i in arrayTwo) {
        newArray.push(arrayTwo[i]);
    }
    if (i in arrayThree) {
        newArray.push(arrayThree[i]);
    }
}

console.log(newArray); //1a,2a,3a,1b,2b,3b,1c,2c,1d

var arrayOne=[“1a”、“1b”、“1c”、“1d”]；
var arrayTwo=[“2a”、“2b”、“2c”]；
var ArraythTree=[“3a”，“3b”]；
var newArray=[]；
var len=Math.max（arrayOne.length、arrayTwo.length、arraytree.length）；
对于（变量i=0；i

在arr中使用

i（作为其他检查的区别）的原因是，这将允许您保持任何falsish值
0，“、false、null、未定义、NaN
完好无损。否则很难将它们单独保留（特别是数组中的
未定义的
值）

在我的答案和当前投票最多的方法之间，我建议使用默认的JS
sort（）
方法和某种回调。如果数组中的元素都像
/[0-9][a-z]/
，这将为您提供所需的结果：

//concat arrays first, of course
function specialSort(a,b)
{
    if(a[1] < b[1])
    {
        return -1;
    }
    if(a[1] > b[1])
    {
        return 1;
    }
    return 0;
}
//using wsanville's expample: combinedArray = ["1a", "1b", "1c", "2a", "2b", "2c", "3a", "3b", "3c"]
combinedArray = combinedArray.sort(specialSort);
//result: combinedArray = ["1a", 2a", "3a", "1b", "2b", "3b", "1c", "2c", "3c"]

//当然，首先是concat数组
功能特殊排序（a、b）
{
if（a[1]b[1]）
{
返回1；
}
返回0；
}
//使用wsanville的表达式：combinedArray=[“1a”、“1b”、“1c”、“2a”、“2b”、“2c”、“3a”、“3b”、“3c”]
combinedArray=combinedArray.sort（specialSort）；
//结果：组合阵列=[“1a”、“2a”、“3a”、“1b”、“2b”、“3b”、“1c”、“2c”、“3c”]

希望这对您有用…
您只需执行以下操作：

var arrayOne = ["1a", "1b", "1c"];
var arrayTwo = ["2a", "2b", "2c", "2d", "2e"];
var arrayThree = ["3a", "3b", "3c", "3d"];
var combinedArray = [];

for (var i = 0, j = Math.max(arrayOne.length, arrayTwo.length, arrayThree.length); i < j; i++) {
    if (arrayOne.length) combinedArray.push(arrayOne.shift());
    if (arrayTwo.length) combinedArray.push(arrayTwo.shift());
    if (arrayThree.length) combinedArray.push(arrayThree.shift());
}

alert(combinedArray.join(", "));​

var arrayOne=[“1a”、“1b”、“1c”]；
var arrayTwo=[“2a”、“2b”、“2c”、“2d”、“2e”]；
变量数组树=[“3a”、“3b”、“3c”、“3d”]；
var combinedArray=[]；
对于（var i=0，j=Math.max（arrayOne.length，arrayTwo.length，arraytree.length）；i

这可能适用于可变长度数组。
据我所知，您正在寻找一个
zip
函数，例如。javascript中没有内置的函数，但很容易编写，例如：

zip = function() {
    var 
        args = [].slice.call(arguments, 0),
        len = Math.max.apply(Math, args.map(function(x) { return x.length })),
        out = [];
    for (var i = 0; i < len; i++)
        out.push(args.map(function(x) { return x[i] }));
    return out;
}

这将创建一个嵌套数组：

[["1a", "2a", "3a"], ["1b", "2b", "3b"], ["1c", "2c", "3c"]]

可以按原样使用或转换为平面：

 flat = [].concat.apply([], zipped)

数组长度是否总是相同的？例如，这里是3。根据条目的不同，有些数组会变小或变大。我从sharepoint列表中获取数组数据。我使用的每个数组都代表每个项目的版本。因此，当它交给用户时，我不知道每个数组中有多少项目。有点（解释：）我只是想让你知道我在做什么。谢谢如果数组的长度不同，你认为会发生什么…你能举个例子吗？我想简单一点，因为我正在做的有点复杂。我试图不太了解我正在做的事情。抱歉，说得含糊不清。我想要的是空白值或未定义值都可以。我知道我的问题是不知道数组的长度。欢迎来到我的噩梦。我希望如果我能将它们组织起来，我就能够对它们进行排序。这就是为什么我的问题如此简单的原因让我们来看看
var arrayOne = ["1a", "1b", "1c"];
var arrayTwo = ["2a", "2b", "2c"];
var arrayThree = ["3a", "3b", "3c"];

zipped = zip(arrayOne, arrayTwo, arrayThree);

[["1a", "2a", "3a"], ["1b", "2b", "3b"], ["1c", "2c", "3c"]]

 flat = [].concat.apply([], zipped)