私はオンラインで読んでいますが、不可能だと言う場所もあれば、可能だと言って例を挙げたり、例に反論したりする場所もあります.
JavaScript で 2 次元配列を宣言するにはどうすればよいですか? (可能だと仮定して)
そのメンバーにアクセスするにはどうすればよいですか? (
myArray[0][1]
またはmyArray[0,1]
?)
私はオンラインで読んでいますが、不可能だと言う場所もあれば、可能だと言って例を挙げたり、例に反論したりする場所もあります.
JavaScript で 2 次元配列を宣言するにはどうすればよいですか? (可能だと仮定して)
そのメンバーにアクセスするにはどうすればよいですか? (myArray[0][1]
またはmyArray[0,1]
?)
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);
配列内の各項目を配列にするだけです。
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 次元配列は実際には単なる配列の配列だからです。ここでの他のコメントは、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 を生成します。(Push は要素を配列に追加し、新しい長さを返します)
最もまともな答えは
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'
2 次元配列は、1 次元配列と同じ方法で作成されます。のようにアクセスしますarray[0][1]
。
var arr = [1, 2, [3, 4], 5];
alert (arr[2][1]); //alerts "4"
今日 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
は高速であり、小さな配列に適しています。for-[]
(B、C) は高速であり、大きなアレイに適していますArray..map/from/fill
は、小さな配列では非常に遅く、大きな配列では非常に高速ですfor-Array(n)
よりもサファリでははるかに遅いfor-[]
for-[]
に (A) 大きな配列の場合、すべてのブラウザで遅い初期化された 2 次元配列の結論
for/while
は、すべてのブラウザーで小さな配列に対して最速/非常に高速ですfor
は、すべてのブラウザーで大きな配列に対して最速/非常に高速ですArray..map/from/fill
は、すべてのブラウザーで小さい配列に対して中速または低速です。{}/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
誰かがこれに答えたかどうかはわかりませんが、これは私にとってかなりうまくいったことがわかりました-
var array = [[,],[,]]
例えば:
var a = [[1,2],[3,4]]
たとえば、2次元配列の場合。
4x6 配列を作成するには、これを行うだけです
const x = [...new Array(6)].map(elem => new Array(4))
通常は、w 個のランダムな値を入力するのではなく、空の配列から始めることをお勧めします。(通常、配列const x = []
は 1D の場合と同じように宣言するので、2D では w empty から開始することをお勧めします。)
すべてのインデックスがアドレス指定可能で、値が 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) 時間の複雑さがあるため、非常に大きな配列にはおそらく適していないことに注意してください。
以下は最も簡単な方法です。
var array1 = [[]];
array1[0][100] = 5;
alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);
私のアプローチは@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
ES6+、ES2015+ はこれをさらに簡単な方法で行うことができます
true で満たされた 3 x 2 配列の作成
[...Array(3)].map(item => Array(2).fill(true))
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);
これは、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
)。
必要に応じて「レコード」を追加し、それらを更新して、さらに処理するためにデータベースに送信する前に必要な計算を実行できるように、柔軟な配列関数を作成する必要がありました。これがコードです。お役に立てば幸いです:)。
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次元配列のサイズを事前に定義する必要のない別の解決策があり、それは非常に簡潔です。
var table = {}
table[[1,2]] = 3 // Notice the double [[ and ]]
console.log(table[[1,2]]) // -> 3
これが機能するのは、[1,2]
が文字列に変換され、オブジェクトの文字列キーとして使用されるためです。table
0 で埋められた am*n 2 次元配列を作成するための 1 つのライナー。
new Array(m).fill(new Array(n).fill(0));
1 の下に、5x5 マトリックスを作成し、それらを埋めます。null
var md = [];
for(var i=0; i<5; i++) {
md.push(new Array(5).fill(null));
}
console.log(md);
各行が同じ長さの配列である行の配列を割り当てることができます。または、rows*columns 要素を持つ 1 次元配列を割り当て、行/列座標を要素インデックスにマップするメソッドを定義することもできます。
どちらの実装を選択しても、それをオブジェクトにラップすると、プロトタイプでアクセサ メソッドを定義して、API を使いやすくすることができます。
このコードがうまくいくことがわかりました:
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];
}
}
}
多次元配列関数を作成するための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]]
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
次のような 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 配列を作成することもできます。
多次元配列を作成する再帰関数:
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]);
Array.from({length: rows}).map(e => new Array(columns));
var _field = (function()
{
var array = [];
for(var y = 0; y != 3; y++) { array[y] = new Array(5); }
return array;
})();
// var item = _field[2][4];
Googleチャートの2D配列を使用している場合、それを行う最良の方法は
var finalData = [];
[["key",value], ["2013-8-5", 13.5], ["2013-7-29",19.7]...]
私の解決策は最善の解決策ではありませんが、ユーザー定義の多次元配列を作成するための解決策を提供するだけです。
行と列を受け入れるこの関数は、
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);