Question

我有几个arrray，我试图按一定的顺序组合。例如，假设我有三个数组：

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列表信息填充数组（我不打算将它们全部放入，但每个都有这样的调用）

$().SPServices({
  operation: "GetVersionCollection",
      async: false,
      webURL: "http://devchrisl01/test",
      strlistID: "NewProjects",
      strlistItemID: proID[i],
      strFieldName: "Title",         

      completefunc: function (xdata, Status) {

        $(xdata.responseText).find("Version").each(function() {

       //alert(xdata.responseXML.xml);

       var xitem = $(this);
            var ID = xitem.attr('ID');
            var Project = xitem.attr('Title');
            var Modified = xitem.attr('Modified').split('T')[0];
            var ModifiedTime = xitem.attr('Modified').substring(11, 19);
           //var modifiedUl = "<td><b>" + Modified + " " + ModifiedTime + "</b></td>";
  //$('#versionList'+i+'').append(modifiedUl);

                  project.push(Project);
                  proModified2.push(Modified + ModifiedTime)


    // just looking at my data here not really part of my problem       
var data = "<tr><td><b>" + Modified + " " + ModifiedTime + "</b></td><td>" + Project + "</td></tr>";


$('#versionList'+i+'').append(data);

        });  

      }

});

之后是我的问题发挥作用的地方。我得到了我需要的所有数据。我没有找到一种更好的方法来存储所有列表信息并将其从SPServices中拉出来，除了为每个列表信息使用一个数组。踢球者是我不知道将会有多少阵列或多长时间。最终这将是动态的。（在ASS中痛苦）所以这里是数组：

var modifiedDate = [proModified1, proModified2, proModified3, proModified4, proModified5, proModified6];
var projectHistory = [history];
var projectTitle = [project];
var projectAssignedTo = [assignedTo];
var projectStartDate = [startDate];
var projectEndDate = [endDate];
var projectStatus = [status];

每个人都会有所不同。对于每个用户，它们的数量不会相同。我刚刚建立了我的列表静态构建。列表动态将是后来的另一个问题：0

就像我在简单示例中提到的那样，我是否可以使用这些数组？看看我为什么简单的第一次大声笑。

Answer 1

编辑：更新比较器，因为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;
    });

注意：自定义比较器功能非常适合您的数据。根据需要更新功能。

DEMO

Answer 2

如果三个数组的长度总是彼此相同：

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", "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

使用i in arr（作为其他检查的差异）的原因是因为这将允许您保持任何虚假值0,"",false,null,undefined,NaN完整。否则，将它们单独留下是非常困难的（特别是undefined数组内的值）

在我的回答和当前最受欢迎的Performance tests

之间

answer

Answer 3

根据我的理解，您正在寻找zip功能，例如in python。 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;
}

应用于您的数组

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)

Answer 4

我建议使用默认的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"]

希望这对你有用......

Answer 5

您可以这样做：

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(", "));

这可能适用于可变长度数组。 Demo here

在Order JavaScript中组合数组

5 个答案: