我有一个数组的数组，就像这样:
[
[1,2,3],
[1,2,3],
[1,2,3],
]
我想把它转置得到下面的数组:
[
[1,1,1],
[2,2,2],
[3,3,3],
]
用循环来实现这一点并不难:
function transposeArray(array, arrayLength){
var newArray = [];
for(var i = 0; i < array.length; i++){
newArray.push([]);
};
for(var i = 0; i < array.length; i++){
for(var j = 0; j < arrayLength; j++){
newArray[j].push(array[i][j]);
};
};
return newArray;
}
然而，这看起来很笨重，我觉得应该有更简单的方法来做到这一点。是吗?
当前回答
由于到目前为止还没有人提到函数式递归方法，所以我在这里介绍一下。Haskell's Data.List.transpose的改编。
Var转置= as => as。长度呢?[0]。长度呢?(如。Reduce ((rs, a) => a.length ?(rs.push(a[0])， rs): rs, [] ),…转置(如。Map (a => a.slice(1)))]: 置(as.slice (1)): []， MTX = [ [1], (1、2), [1,2,3] ]; console.log(转置(mtx)) .as-console-wrapper { Max-height: 100% ｝
其他回答
由于到目前为止还没有人提到函数式递归方法，所以我在这里介绍一下。Haskell's Data.List.transpose的改编。
Var转置= as => as。长度呢?[0]。长度呢?(如。Reduce ((rs, a) => a.length ?(rs.push(a[0])， rs): rs, [] ),…转置(如。Map (a => a.slice(1)))]: 置(as.slice (1)): []， MTX = [ [1], (1、2), [1,2,3] ]; console.log(转置(mtx)) .as-console-wrapper { Max-height: 100% ｝
output = array[0].map((_, colIndex) => array.map(row => row[colIndex]));
Map按顺序为数组中的每个元素调用一次所提供的回调函数，并根据结果构造一个新数组。回调只对数组中已赋值的索引调用;对于已删除或从未赋值的索引，不调用该方法。
callback调用时带有三个参数:元素的值、元素的索引和被遍历的Array对象。(来源)
您可以通过使用以下方法在不使用循环的情况下实现这一点。
数组 Array.prototype.map Array.prototype.reduce Array.prototype.join String.prototype.split
它看起来非常优雅，它不需要任何依赖，如jQuery的Underscore.js。
function transpose(matrix) {
return zeroFill(getMatrixWidth(matrix)).map(function(r, i) {
return zeroFill(matrix.length).map(function(c, j) {
return matrix[j][i];
});
});
}
function getMatrixWidth(matrix) {
return matrix.reduce(function (result, row) {
return Math.max(result, row.length);
}, 0);
}
function zeroFill(n) {
return new Array(n+1).join('0').split('').map(Number);
}
缩小
function transpose(m){return zeroFill(m.reduce(function(m,r){return Math.max(m,r.length)},0)).map(function(r,i){return zeroFill(m.length).map(function(c,j){return m[j][i]})})}function zeroFill(n){return new Array(n+1).join("0").split("").map(Number)}
这是我做的一个演示。注意没有循环:-)
// Create a 5 row, by 9 column matrix. var m = CoordinateMatrix(5, 9); // Make the matrix an irregular shape. m[2] = m[2].slice(0, 5); m[4].pop(); // Transpose and print the matrix. println(formatMatrix(transpose(m))); function Matrix(rows, cols, defaultVal) { return AbstractMatrix(rows, cols, function(r, i) { return arrayFill(cols, defaultVal); }); } function ZeroMatrix(rows, cols) { return AbstractMatrix(rows, cols, function(r, i) { return zeroFill(cols); }); } function CoordinateMatrix(rows, cols) { return AbstractMatrix(rows, cols, function(r, i) { return zeroFill(cols).map(function(c, j) { return [i, j]; }); }); } function AbstractMatrix(rows, cols, rowFn) { return zeroFill(rows).map(function(r, i) { return rowFn(r, i); }); } /** Matrix functions. */ function formatMatrix(matrix) { return matrix.reduce(function (result, row) { return result + row.join('\t') + '\n'; }, ''); } function copy(matrix) { return zeroFill(matrix.length).map(function(r, i) { return zeroFill(getMatrixWidth(matrix)).map(function(c, j) { return matrix[i][j]; }); }); } function transpose(matrix) { return zeroFill(getMatrixWidth(matrix)).map(function(r, i) { return zeroFill(matrix.length).map(function(c, j) { return matrix[j][i]; }); }); } function getMatrixWidth(matrix) { return matrix.reduce(function (result, row) { return Math.max(result, row.length); }, 0); } /** Array fill functions. */ function zeroFill(n) { return new Array(n+1).join('0').split('').map(Number); } function arrayFill(n, defaultValue) { return zeroFill(n).map(function(value) { return defaultValue || value; }); } /** Print functions. */ function print(str) { str = Array.isArray(str) ? str.join(' ') : str; return document.getElementById('out').innerHTML += str || ''; } function println(str) { print.call(null, [].slice.call(arguments, 0).concat(['<br />'])); } #out { white-space: pre; } <div id="out"></div>
我觉得这样可读性更强一点。它使用Array.from，逻辑与使用嵌套循环相同:
Var arr = [ [1,2,3,4]， [1,2,3,4]， [1,2,3,4] ]; ／* * arr[0]。Length = 4 =结果行数 加勒比海盗。长度= 3 =结果cols的个数 * / var result = Array.from({长度:arr[0].)长度}，函数(x，行){ 返回Array.from({长度:arr。长度}，函数(x, col) { 返回arr (col)(行); })； })； console.log(结果);
如果你在处理长度不等的数组，你需要替换arr[0]。长度与其他东西:
Var arr = [ (1、2), [1,2,3]， [1,2,3,4] ]; ／* * arr[0]。Length = 4 =结果行数 加勒比海盗。长度= 3 =结果cols的个数 * / var result = Array.from({长度:arr. from)Reduce(函数(max, item){返回item。长度>最大长度?项。长度:max;}， 0)}，函数(x，行){ 返回Array.from({长度:arr。长度}，函数(x, col) { 返回arr (col)(行); })； })； console.log(结果);
扩展语法不应该用作push的替代品，它只应该在你不想改变现有数组的时候使用。
算法: 对于每一列，只要检查该列是否在结果矩阵中有一行，如果已经有一行，那么简单地推元素，否则创建一个新的行数组，然后推。
因此，与上面的许多其他解决方案不同，这个解决方案不会一次又一次地创建新数组，而是将相同的数组推入。
另外，花点时间了解Nullish Coalescing Operator的用法。
常量 转置= arr => arr。foreach ((v, i) => (m[i]) ??= []， m[i].push(v)))， m)， [])， 矩阵= [[1,2,3]，[1,2,3]，[1,2,3]] console.log(转置矩阵)
