1288

私はオンラインで読んでいますが、不可能だと言う場所もあれば、可能だと言って例を挙げたり、例に反論したりする場所もあります.

  1. JavaScript で 2 次元配列を宣言するにはどうすればよいですか? （可能だと仮定して）

  2. そのメンバーにアクセスするにはどうすればよいですか? (myArray[0][1]またはmyArray[0,1]?)

4

54 に答える 54

1355 

var items = [
  [1, 2],
  [3, 4],
  [5, 6]
];
console.log(items[0][0]); // 1
console.log(items[0][1]); // 2
console.log(items[1][0]); // 3
console.log(items[1][1]); // 4
console.log(items);

于 2009-06-08T18:27:28.803 に答える
487

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

var x = new Array(10);

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

console.log(x);

于 2009-06-08T18:28:58.537 に答える
218

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)]
于 2009-06-08T20:49:18.583 に答える
92

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;
// ...
于 2009-06-08T18:32:00.467 に答える
83

最も簡単な方法:

var myArray = [[]];
于 2013-01-22T18:47:57.463 に答える
46

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

だから、それが相反する視点の原因です。

于 2009-06-08T18:33:44.817 に答える
37

プッシュの使用法を示す人はほとんどいません。
何か新しいものをもたらすために、行列を何らかの値 (例: 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
于 2013-08-08T02:22:30.170 に答える
29

ツーライナー:

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

配列で埋められた、長さ 10 の配列 a を生成します。(Push は要素を配列に追加し、新しい長さを返します)

于 2014-05-26T10:00:12.427 に答える
28

最もまともな答えは

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);
于 2016-02-15T04:19:33.903 に答える
23

最も簡単な方法:

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'
于 2013-12-27T08:59:10.193 に答える
17

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

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

alert (arr[2][1]); //alerts "4"
于 2009-06-08T18:27:57.447 に答える
17

パフォーマンス

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

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

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

ここに画像の説明を入力

初期化された 2 次元配列の結論

  • (A、B、C、D、E、G)に基づくソリューションfor/whileは、すべてのブラウザーで小さな配列に対して最速/非常に高速です
  • (A,B,C,E)に基づくソリューションforは、すべてのブラウザーで大きな配列に対して最速/非常に高速です
  • (I,J,K,L,M) に基づくソリューションArray..map/from/fillは、すべてのブラウザーで小さい配列に対して中速または低速です。
  • 大きな配列のソリューション F、G、H、I、J、K、L は、chrome と safari では中程度または高速ですが、firefox では最も遅くなります。
  • 難解なソリューション{}/arr[[i,j]](N) は、すべてのブラウザーで小さい配列と大きい配列で最も遅い

ここに画像の説明を入力

詳細

出力配列を埋めない (初期化しない) 解をテストする

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

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

出力配列を埋める (初期化する) ソリューションのテスト

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

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

ここに画像の説明を入力

于 2020-01-17T17:22:34.883 に答える
15

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

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

例えば：

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

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

于 2012-07-01T03:28:50.897 に答える
15

4x6 配列を作成するには、これを行うだけです

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

通常は、w 個のランダムな値を入力するのではなく、空の配列から始めることをお勧めします。(通常、配列const x = []は 1D の場合と同じように宣言するので、2D では w empty から開始することをお勧めします。)

于 2020-03-01T21:56:43.490 に答える
15

すべてのインデックスがアドレス指定可能で、値が 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) 時間の複雑さがあるため、非常に大きな配列にはおそらく適していないことに注意してください。

于 2018-09-08T18:31:27.923 に答える
8

以下は最も簡単な方法です。

var array1 = [[]];   
array1[0][100] = 5; 
    
alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);

于 2014-04-15T09:14:47.127 に答える
8

私のアプローチは@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
于 2016-12-04T04:36:48.977 に答える
6

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

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

[...Array(3)].map(item => Array(2).fill(true))
于 2019-12-09T22:04:17.653 に答える
6 

var playList = [
  ['I Did It My Way', 'Frank Sinatra'],
  ['Respect', 'Aretha Franklin'],
  ['Imagine', 'John Lennon'],
  ['Born to Run', 'Bruce Springsteen'],
  ['Louie Louie', 'The Kingsmen'],
  ['Maybellene', 'Chuck Berry']
];

function print(message) {
  document.write(message);
}

function printSongs( songs ) {
  var listHTML;
  listHTML = '<ol>';
  for ( var i = 0; i < songs.length; i += 1) {
    listHTML += '<li>' + songs[i][0] + ' by ' + songs[i][1] + '</li>';
  }
  listHTML += '</ol>';
  print(listHTML);
}

printSongs(playList);

于 2017-10-03T15:22:59.697 に答える
5

これは、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)。

于 2016-03-25T05:56:18.570 に答える
5

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

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

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

于 2012-10-12T10:59:19.343 に答える
5

2次元配列のサイズを事前に定義する必要のない別の解決策があり、それは非常に簡潔です。

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

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

于 2018-01-22T01:58:03.150 に答える
5

0 で埋められた am*n 2 次元配列を作成するための 1 つのライナー。

new Array(m).fill(new Array(n).fill(0));
于 2017-01-03T01:07:45.877 に答える
5

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

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

console.log(md);

于 2016-10-23T05:33:08.737 に答える
3

各行が同じ長さの配列である行の配列を割り当てることができます。または、rows*columns 要素を持つ 1 次元配列を割り当て、行/列座標を要素インデックスにマップするメソッドを定義することもできます。

どちらの実装を選択しても、それをオブジェクトにラップすると、プロトタイプでアクセサ メソッドを定義して、API を使いやすくすることができます。

于 2009-06-08T18:32:38.797 に答える
3

このコードがうまくいくことがわかりました：

var map = [
    []
];

mapWidth = 50;
mapHeight = 50;
fillEmptyMap(map, mapWidth, mapHeight);

...

function fillEmptyMap(array, width, height) {
    for (var x = 0; x < width; x++) {
        array[x] = [];
        for (var y = 0; y < height; y++) {

            array[x][y] = [0];
        }
    }
}
于 2014-06-14T15:46:56.410 に答える
2

多次元配列関数を作成するためのMatthew Crumleyの回答を修正しました。配列変数として渡される配列の次元を追加しました。別の変数 -valueがあり、多次元配列の最後の配列の要素の値を設定するために使用されます。

/*
*   Function to create an n-dimensional array
*
*   @param array dimensions
*   @param any type value
*
*   @return array array
 */
function createArray(dimensions, value) {
    // Create new array
    var array = new Array(dimensions[0] || 0);
    var i = dimensions[0];

    // If dimensions array's length is bigger than 1
    // we start creating arrays in the array elements with recursions
    // to achieve multidimensional array
    if (dimensions.length > 1) {
        // Remove the first value from the array
        var args = Array.prototype.slice.call(dimensions, 1);
        // For each index in the created array create a new array with recursion
        while(i--) {
            array[dimensions[0]-1 - i] = createArray(args, value);
        }
    // If there is only one element left in the dimensions array
    // assign value to each of the new array's elements if value is set as param
    } else {
        if (typeof value !== 'undefined') {
            while(i--) {
                array[dimensions[0]-1 - i] = value;
            }
        }
    }

    return array;
}

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

createArray([2], 'empty');    // ['empty', 'empty']

createArray([3, 2], 0);       // [[0, 0],
                              //  [0, 0],
                              //  [0, 0]]
于 2015-02-20T09:31:00.680 に答える
1

nodejs + lodashバージョン:

var _ = require("lodash");
var result = _.chunk(['a', 'b', 'c', 'd', 'e', 'f'], 2);
console.log(result);
console.log(result[2][0]);

出力：

[ [ 'a', 'b' ], [ 'c', 'd' ], [ 'e', 'f' ] ]
e
于 2015-12-26T20:38:20.160 に答える
1

次のような 2D 配列を作成する関数を作成することもできます。

var myTable = [];

function createArray(myLength) {
    myTable = new Array(myLength);
    var cols, rows;
    for (cols = 0; cols < myLength; cols++) {
        myTable[cols] = new Array(myLength);
    }
}

以下を使用して呼び出すことができます。これにより、10x10 の 2D 配列が得られます。

createArray(10);

この方法を使用して 3D 配列を作成することもできます。

于 2015-09-24T12:07:44.150 に答える
1

多次元配列を作成する再帰関数:

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

    arr = new Array(dims[0]);

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

    return arr;
}

2x3x4x2 の 4D 配列を構築します。

var array = makeArray([2, 3, 4, 2]);
于 2015-04-19T15:13:38.363 に答える
1 
Array.from({length: rows}).map(e => new Array(columns));
于 2019-06-08T20:04:20.187 に答える
0 
var _field = (function()
{
    var array = [];
    for(var y = 0; y != 3; y++) { array[y] = new Array(5); }
    return array;
})();

// var item = _field[2][4];
于 2014-04-03T20:54:58.890 に答える
0

Googleチャートの2D配列を使用している場合、それを行う最良の方法は

var finalData = [];
[["key",value], ["2013-8-5", 13.5], ["2013-7-29",19.7]...]

有効 な 2 次元配列の Google チャートではありません

于 2013-11-21T01:33:43.350 に答える
-1

私の解決策は最善の解決策ではありませんが、ユーザー定義の多次元配列を作成するための解決策を提供するだけです。

行と列を受け入れるこの関数は、

function createArray(row,column) {
let arr = [];

for(var i=0; i<row; i++){
    arr[i] = [Math.floor(Math.random() * (10))];

    for(var j=0;j<column;j++){
        arr[i][j]= [Math.floor(Math.random() * (20))];
    }
}

return arr;
}

var arrVal = createArray(4, 5);

console.log(arrVal);
于 2021-08-17T05:50:10.187 に答える