这里有很多好答案!我把它们合并成一个答案，并更新了一些代码以获得更现代的语法:

灵感来自Fawad Ghafoor和Óscar Gómez Alcañiz的俏皮话

function transpose(matrix) {
  return matrix[0].map((col, i) => matrix.map(row => row[i]));
}

function transpose(matrix) {
  return matrix[0].map((col, c) => matrix.map((row, r) => matrix[r][c]));
}

由Andrew Tatomyr设计的函数方法风格

function transpose(matrix) {
  return matrix.reduce((prev, next) => next.map((item, i) =>
    (prev[i] || []).concat(next[i])
  ), []);
}

洛达什/马塞尔的下划线

function tranpose(matrix) {
  return _.zip(...matrix);
}

// Without spread operator.
function transpose(matrix) {
  return _.zip.apply(_, [[1,2,3], [1,2,3], [1,2,3]])
}

Vigrant的更简单的Lodash/Underscore解决方案

_.unzip(matrix);

香草的方法

function transpose(matrix) {
  const rows = matrix.length, cols = matrix[0].length;
  const grid = [];
  for (let j = 0; j < cols; j++) {
    grid[j] = Array(rows);
  }
  for (let i = 0; i < rows; i++) {
    for (let j = 0; j < cols; j++) {
      grid[j][i] = matrix[i][j];
    }
  }
  return grid;
}

由伊曼纽尔·萨林根启发的香草ES6方法

function transpose(matrix) {
  for (var i = 0; i < matrix.length; i++) {
    for (var j = 0; j < i; j++) {
      const temp = matrix[i][j];
      matrix[i][j] = matrix[j][i];
      matrix[j][i] = temp;
    }
  }
}

// Using destructing
function transpose(matrix) {
  for (var i = 0; i < matrix.length; i++) {
    for (var j = 0; j < i; j++) {
      [matrix[i][j], matrix[j][i]] = [matrix[j][i], matrix[i][j]];
    }
  }
}

由于到目前为止还没有人提到函数式递归方法，所以我在这里介绍一下。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% ｝

这个，不仅是一个超级高效的解，而且是一个很短的解。

算法时间复杂度:O(n log n)

const matrix = [
   [1,1,1,1],
   [2,2,2,2],
   [3,3,3,3],
   [4,4,4,4]
];

matrix.every((r, i, a) => (
   r.every((_, j) => (
      j = a.length-j-1,
      [ r[j], a[j][i] ] = [ a[j][i], r[j] ],
      i < j-1
   )), 
   i < length-2
));

console.log(matrix);
/*
Prints:
[
   [1,2,3,4],
   [1,2,3,4],
   [1,2,3,4],
   [1,2,3,4]
]
*/

上面的例子将只进行6次迭代。 对于更大的矩阵，比如100x100，它将进行4900次迭代，这比这里提供的任何其他解决方案快51%。

原理很简单，你只遍历矩阵对角线的上半部分，因为对角线永远不会改变，下对角线的下半部分和上半部分互换了，所以没有理由也遍历它。这样可以节省大量的运行时间，特别是在大型矩阵中。

我觉得这样可读性更强一点。它使用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(结果);

你可以在原地只做一次:

function transpose(arr,arrLen) {
  for (var i = 0; i < arrLen; i++) {
    for (var j = 0; j <i; j++) {
      //swap element[i,j] and element[j,i]
      var temp = arr[i][j];
      arr[i][j] = arr[j][i];
      arr[j][i] = temp;
    }
  }
}

不改变给定数组的一行程序。

a[0].map((col, i) => a.map(([...row]) => row[i]))