私はオンラインで読んでいて、それが不可能だと言う人もいれば、それが可能だと言って、例を挙げたり、他の人がその例に反論したりするところもあります。

1. JavaScriptで2次元配列を宣言するにはどうすればよいですか？（それが可能であると仮定）

2. メンバーにアクセスするにはどうすればよいですか？（myArray[0][1]またはmyArray[0,1]？）

配列内の各項目を配列にするだけです。

var x = new Array(10);

for (var i = 0; i < x.length; i++) {
  x[i] = new Array(3);
}

console.log(x);

activaの答えと同様に、n次元配列を作成する関数を次に示します。

function createArray(length) {
    var arr = new Array(length || 0),
        i = length;

    if (arguments.length > 1) {
        var args = Array.prototype.slice.call(arguments, 1);
        while(i--) arr[length-1 - i] = createArray.apply(this, args);
    }

    return arr;
}

createArray();     // [] or new Array()

createArray(2);    // new Array(2)

createArray(3, 2); // [new Array(2),
                   //  new Array(2),
                   //  new Array(2)]

JavaScriptには1次元配列しかありませんが、他の人が指摘するように、配列の配列を構築できます。

次の関数を使用して、固定次元の2次元配列を作成できます。

function Create2DArray(rows) {
  var arr = [];

  for (var i=0;i<rows;i++) {
     arr[i] = [];
  }

  return arr;
}

使用する前に配列のサイズを指定する必要がないため、列の数はそれほど重要ではありません。

その後、単に呼び出すことができます：

var arr = Create2DArray(100);

arr[50][2] = 5;
arr[70][5] = 7454;
// ...

最も簡単な方法：

var myArray = [[]];

空の2次元配列（1行）を作成する方法

Array.from(Array(2), () => new Array(4))

図２および４は、それぞれ第１および第２の次元である。

ここではArray.from、配列のようなparamと各要素のオプションのマッピングを使用できるを使用しています。

Array.from（arrayLike [、mapFn [、thisArg]]）

var arr = Array.from(Array(2), () => new Array(4));
arr[0][0] = 'foo';
console.info(arr);

同じトリックを使用して、1 ... Nを含むJavaScript配列を作成できます。

または（ただし、を使用すると 12％効率が低下しますn = 10,000）

Array(2).fill(null).map(() => Array(4))

パフォーマンスの低下は、実行するために最初のディメンション値を初期化する必要があるという事実に伴います.map。それを忘れないでください Arrayあなたを介してそれを注文するまでポジションを割り当てません.fillか、直接値を代入。

var arr = Array(2).fill(null).map(() => Array(4));
arr[0][0] = 'foo';
console.info(arr);

ファローアップ

正しいように見えますが、問題がある方法は次のとおりです。

 Array(2).fill(Array(4)); // BAD! Rows are copied by reference

明らかに望ましい2次元配列（[ [ <4 empty items> ], [ <4 empty items> ] ]）は返されますが、最初の次元配列が参照によってコピーされているという問題があります。つまり、arr[0][0] = 'foo'実際には1行ではなく2行が変更されます。

var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo';
console.info(arr);
console.info(arr[0][0], arr[1][0]);

不可能だと言う人がいる理由は、2次元配列は実際には単なる配列の配列だからです。ここでの他のコメントは、JavaScriptで2次元配列を作成する完全に有効な方法を提供しますが、最も純粋な観点は、オブジェクトの1次元配列を持ち、これらの各オブジェクトは2つの要素で構成される1次元配列になるということです。

だから、それが意見の対立の原因です。

プッシュの使用を示す人はほとんどいません。
何か新しいものをもたらすために、いくつかの値でマトリックスを初期化する方法を示します。例：0または空の文字列 ""。
10要素の配列がある場合、JavaScriptでは最後のインデックスが9になることを思い出してください！

function matrix( rows, cols, defaultValue){

  var arr = [];

  // Creates all lines:
  for(var i=0; i < rows; i++){

      // Creates an empty line
      arr.push([]);

      // Adds cols to the empty line:
      arr[i].push( new Array(cols));

      for(var j=0; j < cols; j++){
        // Initializes:
        arr[i][j] = defaultValue;
      }
  }

return arr;
}

使用例：

x = matrix( 2 , 3,''); // 2 lines, 3 cols filled with empty string
y = matrix( 10, 5, 0);// 10 lines, 5 cols filled with 0

ツーライナー：

var a = []; 
while(a.push([]) < 10);

配列で満たされた長さ10の配列aを生成します。（プッシュは配列に要素を追加し、新しい長さを返します）

正直な答えは

var nrows = ~~(Math.random() * 10);
var ncols = ~~(Math.random() * 10);
console.log(`rows:${nrows}`);
console.log(`cols:${ncols}`);
var matrix = new Array(nrows).fill(0).map(row => new Array(ncols).fill(0));
console.log(matrix);

fillは浅いコピーコンストラクターを使用するため、行を直接埋めることはできません。したがって、すべての行が同じメモリを共有します。ここでは、各行が共有される方法を示す例を示します（他の回答から取得）。

// DON'T do this: each row in arr, is shared
var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo'; // also modifies arr[1][0]
console.info(arr);

最も簡単な方法：

var arr  = [];

var arr1 = ['00','01'];
var arr2 = ['10','11'];
var arr3 = ['20','21'];

arr.push(arr1);
arr.push(arr2);
arr.push(arr3);

alert(arr[0][1]); // '01'
alert(arr[1][1]); // '11'
alert(arr[2][0]); // '20'

これは私が達成したものです：

var appVar = [[]];
appVar[0][4] = "bineesh";
appVar[0][5] = "kumar";
console.log(appVar[0][4] + appVar[0][5]);
console.log(appVar);

これは私にbineeshkumarを綴った

2次元配列は、1次元配列と同じ方法で作成されます。そして、あなたはそれらのようにそれらにアクセスしますarray[0][1]。

var arr = [1, 2, [3, 4], 5];

alert (arr[2][1]); //alerts "4"

誰かがこれに答えたかどうかはわかりませんが、これはかなりうまくいきました-

var array = [[,],[,]]

例えば：

var a = [[1,2],[3,4]]

たとえば、2次元配列の場合。

javaScriptで2D配列を作成するには、まず配列を作成してから、要素として配列を追加します。このメソッドは、指定された数の行と列を持つ2D配列を返します。

function Create2DArray(rows,columns) {
   var x = new Array(rows);
   for (var i = 0; i < rows; i++) {
       x[i] = new Array(columns);
   }
   return x;
}

配列を作成するには、次のようにこのメソッドを使用します。

var array = Create2DArray(10,20);

アドレス可能なすべてのインデックスと値がnullに設定された非スパースの「2D」配列（x、y）を作成するには：

let 2Darray = new Array(x).fill(null).map(item =>(new Array(y).fill(null))) 

ボーナス「3D」配列（x、y、z）

let 3Darray = new Array(x).fill(null).map(item=>(new Array(y).fill(null)).map(item=>Array(z).fill(null)))

これに関するバリエーションや修正は、コメントやさまざまな時点でこの質問への回答として言及されていますが、実際の回答ではないため、ここに追加します。

（他のほとんどの回答と同様に）これはO（x * y）時間の複雑さがあるため、非常に大きな配列にはおそらく適さないことに注意してください。

配列内包表記を使用する

JavaScript 1.7以降では、配列内包表記を使用して2次元配列を作成できます。また、配列を埋めながらエントリをフィルタリングまたは操作したり、ループを使用したりする必要はありません。

var rows = [1, 2, 3];
var cols = ["a", "b", "c", "d"];

var grid = [ for (r of rows) [ for (c of cols) r+c ] ];

/* 
         grid = [
            ["1a","1b","1c","1d"],
            ["2a","2b","2c","2d"],
            ["3a","3b","3c","3d"]
         ]
*/

あなたがn x m望む任意の配列を作成し、それをデフォルト値で満たすことができます

var default = 0;  // your 2d array will be filled with this value
var n_dim = 2;
var m_dim = 7; 

var arr = [ for (n of Array(n_dim)) [ for (m of Array(m_dim) default ]] 
/* 
         arr = [
            [0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0],
         ]
*/

その他の例とドキュメントはここにあります。

これはまだ標準機能ではないことに注意してください。

ライナー愛好家のためのArray.from（）

// creates 8x8 array filed with "0"    
const arr2d = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => "0"))

別のもの（dmitry_romanovによるコメントから）はArray（）。fill（）を使用します

// creates 8x8 array filed with "0"    
const arr2d = Array(8).fill(0).map(() => Array(8).fill("0"))

ES6 + スプレッドオペレーターの使用（InspiredJW 回答による「インスピレーション」:)）

// same as above just a little shorter
const arr2d = [...Array(8)].map(() => Array(8).fill("0"))

私のアプローチは@Bineeshの回答に非常に似ていますが、より一般的なアプローチです。

次のようにdouble配列を宣言できます。

var myDoubleArray = [[]];

また、次の方法でコンテンツを保存およびアクセスします。

var testArray1 = [9,8]
var testArray2 = [3,5,7,9,10]
var testArray3 = {"test":123}
var index = 0;

myDoubleArray[index++] = testArray1;
myDoubleArray[index++] = testArray2;
myDoubleArray[index++] = testArray3;

console.log(myDoubleArray[0],myDoubleArray[1][3], myDoubleArray[2]['test'],) 

これは期待される出力を印刷します

[ 9, 8 ] 9 123

以下が最も簡単な方法です：

var array1 = [[]];   
array1[0][100] = 5; 

alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);

パフォーマンス

今日2020.02.05私は選択したソリューションについて、Chrome v79.0、Safari v13.0.4、Firefox v72.0のMacOs HighSierra 10.13.6でテストを実行します。

初期化されていない2次元配列の結論

• 難解なソリューション{}/arr[[i,j]]（N）は、大小の配列で最も高速であり、大きなスパース配列に適しているようです
• に基づくソリューション for-[]/while（A、G）には高速であり、小規模なアレイに適しています。
• ソリューション for-[]（B、C）は高速で、大きなアレイに適しています
• に基づくソリューション Array..map/from/fill（I、J、K、L、M）には、小さな配列ではかなり遅く、大きな配列ではかなり速い
• 驚くべきことに、for-Array(n)（B、C）はサファリでよりもはるかに遅いfor-[]（A）
• 驚くほど for-[]（A）大きな配列ではすべてのブラウザで遅い
• ソリューションKは、すべてのブラウザーの小さな配列では遅い
• ソリューションA、E、Gは、すべてのブラウザーの大きなアレイでは遅い
• ソリューションMは、すべてのブラウザーのすべてのアレイで最も遅い

初期化された2Dアレイの結論

• for/while（A、B、C、D、E、G）に基づくソリューションは、すべてのブラウザーの小さなアレイに対して最速/非常に高速です
• for（A、B、C、E）に基づくソリューションは、すべてのブラウザーの大きなアレイに対して最速/非常に高速です
• Array..map/from/fill（I、J、K、L、M）に基づくソリューションは、すべてのブラウザーの小さなアレイに対して中速または低速です
• 大きなアレイのソリューションF、G、H、I、J、K、Lは、クロムとサファリでは中程度または高速ですが、Firefoxでは最も低速です。
• 難解なソリューション{}/arr[[i,j]]（N）は、すべてのブラウザーの大小のアレイで最も遅い

詳細

出力配列を満たさない（初期化する）ソリューションのテスト

ソリューションの速度をテストします

• 小さな配列（12要素）- ここでマシン上でテストを実行できます
• 大きな配列（100万要素）の配列- ここでマシン上でテストを実行できます

function A(r) {
  var arr = [];
  for (var i = 0; i < r; i++) arr[i] = [];
  return arr;
}

function B(r, c) {
  var arr = new Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = new Array(c);
  return arr;
}

function C(r, c) {
  var arr = Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = Array(c);
  return arr;
}

function D(r, c) {
  // strange, but works
  var arr = [];
  for (var i = 0; i < r; i++) {
    arr.push([]);
    arr[i].push(Array(c));
  }
  return arr;
}

function E(r, c) {
  let array = [[]];
  for (var x = 0; x < c; x++) {
    array[x] = [];
    for (var y = 0; y < r; y++) array[x][y] = [0];
  }
  return array;
}

function F(r, c) {
  var makeArray = function(dims, arr) {
    if (dims[1] === undefined) {
      return Array(dims[0]);
    }

    arr = Array(dims[0]);

    for (var i = 0; i < dims[0]; i++) {
      arr[i] = Array(dims[1]);
      arr[i] = makeArray(dims.slice(1), arr[i]);
    }

    return arr;
  }
  return makeArray([r, c]);
}

function G(r) {
  var a = [];
  while (a.push([]) < r);
  return a;
}

function H(r,c) {
  function createArray(length) {
    var arr = new Array(length || 0),
        i = length;

    if (arguments.length > 1) {
        var args = Array.prototype.slice.call(arguments, 1);
        while(i--) arr[length-1 - i] = createArray.apply(this, args);
    }

    return arr;
  }
  return createArray(r,c);
}

function I(r, c) {
  return [...Array(r)].map(x => Array(c));
}

function J(r, c) {
  return Array(r).fill(0).map(() => Array(c));
}

function K(r, c) {
  return Array.from(Array(r), () => Array(c));
}

function L(r, c) {
  return Array.from({length: r}).map(e => Array(c));
}

function M(r, c) {
  return Array.from({length: r}, () => Array.from({length: c}, () => {}));
}

function N(r, c) {
  return {}
}



// -----------------------------------------------
// SHOW
// -----------------------------------------------

log = (t, f) => {
  let A = f(3, 4); // create array with 3 rows and 4 columns
  A[1][2] = 6 // 2-nd row 3nd column set to 6
  console.log(`${t}[1][2]: ${A[1][2]}, full: ${JSON.stringify(A).replace(/null/g,'x')}`);
}

log2 = (t, f) => {
  let A = f(3, 4); // create array with 3 rows and 4 columns
  A[[1,2]] = 6 // 2-nd row 3nd column set to 6
  console.log(`${t}[1][2]: ${A[[1,2]]}, full: ${JSON.stringify(A).replace(/null/g,'x')}`);
}

log('A', A);
log('B', B);
log('C', C);
log('D', D);
log('E', E);
log('F', F);
log('G', G);
log('H', H);
log('I', I);
log('J', J);
log('K', K);
log('L', L);
log('M', M);
log2('N', N);

This is presentation of solutions - not benchmark

出力配列を満たす（初期化する）ソリューションのテスト

ソリューションの速度をテストします

• 小さな配列（12要素）- ここでマシン上でテストを実行できます
• 大きな配列（100万要素）の配列- ここでマシン上でテストを実行できます

function A(r, c, def) {
  var arr = [];
  for (var i = 0; i < r; i++) arr[i] = Array(c).fill(def);
  return arr;
}

function B(r, c, def) {
  var arr = new Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = new Array(c).fill(def);
  return arr;
}

function C(r, c, def) {
  var arr = Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = Array(c).fill(def);
  return arr;
}

function D(r, c, def) {
  // strange, but works
  var arr = [];
  for (var i = 0; i < r; i++) {
    arr.push([]);
    arr[i].push(Array(c));
  }
  for (var i = 0; i < r; i++) for (var j = 0; j < c; j++) arr[i][j]=def
  return arr;
}

function E(r, c, def) {
  let array = [[]];
  for (var x = 0; x < c; x++) {
    array[x] = [];
    for (var y = 0; y < r; y++) array[x][y] = def;
  }
  return array;
}

function F(r, c, def) {
  var makeArray = function(dims, arr) {
    if (dims[1] === undefined) {
      return Array(dims[0]).fill(def);
    }

    arr = Array(dims[0]);

    for (var i = 0; i < dims[0]; i++) {
      arr[i] = Array(dims[1]);
      arr[i] = makeArray(dims.slice(1), arr[i]);
    }

    return arr;
  }
  return makeArray([r, c]);
}

function G(r, c, def) {
  var a = [];
  while (a.push(Array(c).fill(def)) < r);
  return a;
}

function H(r,c, def) {
  function createArray(length) {
    var arr = new Array(length || 0),
        i = length;

    if (arguments.length > 1) {
        var args = Array.prototype.slice.call(arguments, 1);
        while(i--) arr[length-1 - i] = createArray.apply(this, args).fill(def);
    }

    return arr;
  }
  return createArray(r,c);
}

function I(r, c, def) {
  return [...Array(r)].map(x => Array(c).fill(def));
}

function J(r, c, def) {
  return Array(r).fill(0).map(() => Array(c).fill(def));
}

function K(r, c, def) {
  return Array.from(Array(r), () => Array(c).fill(def));
}

function L(r, c, def) {
  return Array.from({length: r}).map(e => Array(c).fill(def));
}

function M(r, c, def) {
  return Array.from({length: r}, () => Array.from({length: c}, () => def));
}

function N(r, c, def) {
  let arr={};
  for (var i = 0; i < r; i++) for (var j = 0; j < c; j++) arr[[i,j]]=def;
  return arr;
}



// -----------------------------------------------
// SHOW
// -----------------------------------------------

log = (t, f) => {
  let A = f(1000,1000,7); // create array with 1000 rows and 1000 columns, 
                          // each array cell initilised by 7
  A[800][900] = 5         // 800nd row and 901nd column set to 5
  console.log(`${t}[1][2]: ${A[1][2]}, ${t}[800][901]: ${A[800][900]}`);
}

log2 = (t, f) => {
  let A = f(1000,1000,7); // create array with 1000 rows and 1000 columns, 
                          // each array cell initilised by 7
  A[[800,900]] = 5            // 800nd row 900nd column set to 5
  console.log(`${t}[1][2]: ${A[[1,2]]}, ${t}[800][900]: ${A[[800,900]]}`);
}

log('A', A);
log('B', B);
log('C', C);
log('D', D);
log('E', E);
log('F', F);
log('G', G);
log('H', H);
log('I', I);
log('J', J);
log('K', K);
log('L', L);
log('M', M);
log2('N', N);

This is presentation of solutions - not benchmark

JavaScriptは2次元配列をサポートしていません。代わりに、配列を別の配列内に格納し、アクセスする配列の位置に応じて、その配列からデータをフェッチします。配列の列挙はZEROから始まることに注意してください。

コード例：

/* Two dimensional array that's 5 x 5 

       C0 C1 C2 C3 C4 
    R0[1][1][1][1][1] 
    R1[1][1][1][1][1] 
    R2[1][1][1][1][1] 
    R3[1][1][1][1][1] 
    R4[1][1][1][1][1] 
*/

var row0 = [1,1,1,1,1],
    row1 = [1,1,1,1,1],
    row2 = [1,1,1,1,1],
    row3 = [1,1,1,1,1],
    row4 = [1,1,1,1,1];

var table = [row0,row1,row2,row3,row4];
console.log(table[0][0]); // Get the first item in the array

ES6 +、ES2015 +はこれをさらに簡単な方法で実行できます

trueで満たされた3 x 2配列の作成

[...Array(3)].map(item => Array(2).fill(true))

必要に応じて「レコード」を追加し、更新してデータベースに送信してさらに処理する前に必要な計算を実行できるように、柔軟な配列関数を作成する必要がありました。ここにコードがあります、それが役に立てば幸いです:)

function Add2List(clmn1, clmn2, clmn3) {
    aColumns.push(clmn1,clmn2,clmn3); // Creates array with "record"
    aLine.splice(aPos, 0,aColumns);  // Inserts new "record" at position aPos in main array
    aColumns = [];    // Resets temporary array
    aPos++ // Increments position not to overlap previous "records"
}

バグを自由に最適化および/または指摘してください:)

これが、2次元配列を作成するための簡単な方法です。

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(e => Array(y));
}

この関数を簡単にES5関数に変換することもできます。

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(function(e) {
        return Array(y);
    });
}

これが機能する理由：new Array(n)コンストラクターはのプロトタイプを使用してオブジェクトを作成し、そのオブジェクトにをArray.prototype割り当てますlength。その結果、配列が作成されません。実際のメンバーが不足しているため、Array.prototype.map関数を実行できません。

ただし、のように、コンストラクターに複数の引数を指定すると、コンストラクターArray(1, 2, 3, 4)はargumentsオブジェクトを使用してインスタンスを作成し、Array正しくます。

このような理由から、我々は使用することができますArray.apply(null, Array(x))ので、apply関数がコンストラクタに引数を分散します。明確にするために、行うことArray.apply(null, Array(3))は行うことと同等Array(null, null, null)です。

これで、実際にデータが入力された配列が作成されたのでmap、2番目のレイヤー（y）を呼び出して作成するだけです。

1つ下で、5x5マトリックスを作成し、それらで埋めます null

var md = [];
for(var i=0; i<5; i++) {
    md.push(new Array(5).fill(null));
}

console.log(md);

実行時にのみ既知の配列の行と列のサイズは、動的な2D配列を作成するために次の方法を使用できます。

var num = '123456';
var row = 3; // Known at run time
var col = 2; // Known at run time
var i = 0;

var array2D = [[]];
for(var r = 0; r < row; ++r)
{
    array2D[r] = [];
    for(var c = 0; c < col; ++c)
    {
        array2D[r][c] = num[i++];
    }
}
console.log(array2D); 
// [[ '1', '2' ], 
//  [ '3', '4' ], 
//  [ '5', '6' ]]

console.log(array2D[2][1]); // 6

2D配列のサイズを事前に定義することを強制しない別の解決策があり、それは非常に簡潔です。

var table = {}
table[[1,2]] = 3 // Notice the double [[ and ]]
console.log(table[[1,2]]) // -> 3

これは、オブジェクトの文字列キー[1,2]として使用される文字列に変換されるため機能します。table

4x6アレイを作成するには、これを実行するだけです

const x = [...Array(6)].map(elem => new Array(4))