另一种方法是从外部到内部迭代数组，并通过映射内部值来减小矩阵。

常量 转置=数组=>数组。Reduce ((r, a) => .map((v, i) =>[…(r[i] || [])， v])， [])， 矩阵= [[1,2,3]，[1,2,3]，[1,2,3]]; console.log(转置矩阵(矩阵));

你可以使用underscore.js

_.zip.apply(_, [[1,2,3], [1,2,3], [1,2,3]])

function invertArray(array,arrayWidth,arrayHeight) {
  var newArray = [];
  for (x=0;x<arrayWidth;x++) {
    newArray[x] = [];
    for (y=0;y<arrayHeight;y++) {
        newArray[x][y] = array[y][x];
    }
  }
  return newArray;
}

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

灵感来自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]];
    }
  }
}

ES6 1liner为:

let invert = a => a[0].map((col, c) => a.map((row, r) => a[r][c]))

所以和Óscar的一样，但你更愿意顺时针旋转它:

let rotate = a => a[0].map((col, c) => a.map((row, r) => a[r][c]).reverse())

let a = [
    [1,1,1]
    , ["_","_","1"]
]
let b = rotate(a);
let c = rotate(b);
let d = rotate(c);
console.log(`a ${a.join("\na ")}`);
console.log(`b ${b.join("\nb ")}`);
console.log(`c ${c.join("\nc ")}`);
console.log(`d ${d.join("\nd ")}`);

收益率

a 1,1,1 
a _,_,1

b _,1
b _,1
b 1,1 

c 1,_,_
c 1,1,1

d 1,1
d 1,_
d 1,_

output = array[0].map((_, colIndex) => array.map(row => row[colIndex]));

Map按顺序为数组中的每个元素调用一次所提供的回调函数，并根据结果构造一个新数组。回调只对数组中已赋值的索引调用;对于已删除或从未赋值的索引，不调用该方法。

callback调用时带有三个参数:元素的值、元素的索引和被遍历的Array对象。(来源)