Çevrimiçi okuyordum ve bazı yerler bunun mümkün olmadığını söylüyor, bazıları bunun olduğunu söylüyor ve sonra bir örnek veriyor ve diğerleri örneği reddediyor, vb.

1. JavaScript'te 2 boyutlu bir diziyi nasıl bildirebilirim? (mümkün olduğunu varsayarsak)

2. Üyelerine nasıl erişebilirim? ( myArray[0][1]veya myArray[0,1]?)

Dizideki her öğeyi bir dizi haline getirirsiniz.

var x = new Array(10);

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

console.log(x);

Activa'nın cevabına benzer şekilde, n-boyutlu bir dizi oluşturmak için bir fonksiyon:

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'in yalnızca 1 boyutlu dizileri vardır, ancak diğerlerinin belirttiği gibi diziler dizileri oluşturabilirsiniz.

Aşağıdaki işlev 2 boyutlu sabit boyutlar dizisi oluşturmak için kullanılabilir:

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

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

  return arr;
}

Sütun sayısı gerçekten önemli değildir, çünkü bir diziyi kullanmadan önce boyutunu belirtmek gerekli değildir.

Ardından şunları arayabilirsiniz:

var arr = Create2DArray(100);

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

En kolay yol:

var myArray = [[]];

Boş bir iki boyutlu dizi nasıl oluşturulur (tek satır)

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

2 ve 4 sırasıyla birinci ve ikinci boyutlardır.

Array.fromHer bir öğe için dizi benzeri bir param ve isteğe bağlı bir eşleme alabilen kullanıyoruz .

Array.from (arrayLike [, mapFn [, thisArg]])

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

1 ... N içeren bir JavaScript dizisi oluşturmak için aynı hile kullanılabilir

Alternatif olarak (ancak % 12 daha fazla verimsizn = 10,000 )

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

Performans düşüşü, ilk boyut değerlerinin çalıştırılmak üzere başlatılması gerektiğidir .map. ArrayKonumları siz sipariş verene .fillveya doğrudan değer atamasına sipariş etmeden ayırmayacağınızı unutmayın .

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

Takip et

İşte doğru görünen ancak sorunları olan bir yöntem .

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

Görünüşte istenen iki boyutlu diziyi ( [ [ <4 empty items> ], [ <4 empty items> ] ]) döndürürken, bir catch: birinci boyutlu diziler referans olarak kopyalanmıştır. Bu, arr[0][0] = 'foo'a'nın aslında bir yerine iki satırı değiştireceği anlamına gelir .

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

Bazılarının mümkün olmadığını söylemesinin nedeni, iki boyutlu bir dizinin gerçekten sadece diziler dizisidir. Buradaki diğer yorumlar, JavaScript'te iki boyutlu diziler oluşturmak için mükemmel geçerli yöntemler sağlar, ancak en saf bakış açısı, tek boyutlu bir nesne diziniz olması, bu nesnelerin her birinin iki öğeden oluşan tek boyutlu bir dizi olması olacaktır.

Yani, çelişen bakış açılarının nedeni budur.

Birkaç kişi itme kullanımını gösterir:
Yeni bir şey getirmek için, matrisi bir değerle nasıl başlatacağınızı göstereceğim, örneğin: 0 veya boş bir dize "".
10 element dizisine sahipseniz, javascript'te son dizinin 9 olacağını hatırlatırız!

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

kullanım örnekleri:

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

İki astar:

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

Dizilerle doldurulmuş, uzunluğu 10 olan bir dizi üretecektir. (Push, bir diziye bir öğe ekler ve yeni uzunluğu döndürür)

En güzel cevap,

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);

Dolgu sığ kopya oluşturucu kullandığından doğrudan satırlarla dolduramayacağımızı unutmayın , bu nedenle tüm satırlar aynı belleği paylaşır ... işte her satırın nasıl paylaşılacağını gösteren örnek (diğer yanıtlardan alınmıştır):

// 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);

En kolay yol:

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'

Ben ne elde etti:

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

Bu beni bineeshkumar olarak heceledi

İki boyutlu diziler, tek boyutlu diziler gibi oluşturulur. Ve onlara böyle erişiyorsun array[0][1].

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

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

Kimsenin bunu yanıtlayıp yanıtlamadığından emin değilim ama bunun benim için gayet iyi çalıştığını gördüm -

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

Örneğin:

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

Örneğin 2 boyutlu bir dizi için.

JavaScript'te bir 2D dizi oluşturmak için önce bir Dizi oluşturabilir ve ardından Dizileri öğe olarak ekleyebiliriz. Bu yöntem, verilen sayıda satır ve sütun içeren bir 2D dizi döndürür.

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

Array oluşturmak için bu yöntemi aşağıdaki gibi kullanın.

var array = Create2DArray(10,20);

Tüm dizinler adreslenebilir ve değerler null olarak ayarlanmış seyrek olmayan bir "2D" dizi (x, y) oluşturmak için:

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

bonus "3D" Dizi (x, y, z)

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

Bu konuda varyasyonlar ve düzeltmeler yorumlarda ve bu soruya yanıt olarak çeşitli noktalarda belirtilmiştir, ancak gerçek bir cevap olarak değil, bu yüzden buraya ekliyorum.

(Diğer cevapların çoğuna benzer şekilde) bunun O (x * y) zaman karmaşıklığına sahip olduğuna dikkat edilmelidir, bu nedenle muhtemelen çok büyük diziler için uygun değildir.

Dizi Anlamalarını Kullan

JavaScript 1.7 ve sonraki sürümlerinde, iki boyutlu diziler oluşturmak için dizi kavrayışlarını kullanabilirsiniz . Diziyi doldururken girdileri filtreleyebilir ve / veya değiştirebilirsiniz ve döngüler kullanmak zorunda kalmazsınız.

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"]
         ]
*/

İstediğiniz n x mdiziyi oluşturabilir ve arayarak varsayılan bir değerle doldurabilirsiniz.

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],
         ]
*/

Daha fazla örnek ve dokümantasyon burada bulunabilir .

Bunun henüz standart bir özellik olmadığını lütfen unutmayın .

Bir astar severler için Array.from ()

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

Başka bir (dmitry_romanov tarafından yapılan yorumdan) Array () kullanın . Fill ()

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

ES6 + kullanma yayılmış operatörü (InspiredJW tarafından "ilham" cevap :))

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

Yaklaşımım @Bineesh cevabına çok benziyor ama daha genel bir yaklaşımla.

Çift diziyi aşağıdaki gibi bildirebilirsiniz:

var myDoubleArray = [[]];

Ve içeriklerin aşağıdaki şekilde depolanması ve erişilmesi:

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'],) 

Bu beklenen çıktıyı yazdıracaktır

[ 9, 8 ] 9 123

Aşağıda bulduğum en basit yol:

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

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

Verim

Bugün 2020.02.05 Seçilen çözümler için Chrome v79.0, Safari v13.0.4 ve Firefox v72.0 üzerinde MacOs HighSierra 10.13.6 üzerinde testler yapıyorum.

Başlatılmamış 2d dizisi için sonuçlar

• ezoterik çözüm {}/arr[[i,j]](N) büyük ve küçük diziler için en hızlıdır ve büyük seyrek diziler için iyi bir seçim gibi görünüyor
• for-[]/while(A, G) tabanlı çözümler hızlıdır ve küçük diziler için iyi bir seçimdir.
• çözümler for-[](B, C) hızlıdır ve büyük diziler için iyi bir seçimdir
• Array..map/from/fill(I, J, K, L, M) tabanlı çözümler küçük diziler için oldukça yavaş ve büyük diziler için oldukça hızlıdır
• surprinsingly for-Array(n)(B, C) safaride for-[](A) ' dan çok daha yavaştır
• for-[]büyük dizi için surprinsingly (A) tüm tarayıcılarda yavaş
• çözümleri K, tüm tarayıcılar için küçük diziler için yavaştır
• A, E, G çözümleri tüm tarayıcılar için büyük diziler için yavaştır
• M çözümü, tüm tarayıcılardaki tüm diziler için en yavaş çözümdür

Başlatılmış 2d dizisi için sonuçlar

• for/while(A, B, C, D, E, G) tabanlı çözümler tüm tarayıcılardaki küçük diziler için en hızlı / oldukça hızlıdır
• for(A, B, C, E) tabanlı çözümler tüm tarayıcılarda büyük diziler için en hızlı / oldukça hızlıdır
• Array..map/from/fill(I, J, K, L, M) tabanlı çözümler tüm tarayıcılardaki küçük diziler için orta hızlı veya yavaştır
• büyük diziler için çözümler F, G, H, I, J, K, L krom ve safari üzerinde orta veya hızlı, ancak firefox'ta en yavaştır.
• ezoterik çözüm {}/arr[[i,j]](N) tüm tarayıcılarda küçük ve büyük diziler için en yavaş çözümdür

ayrıntılar

Çıkış dizisini doldurmayan (başlatan) çözümleri test edin

İçin çözümlerin hızını test ediyoruz

• küçük diziler (12 eleman) - BURADA makinenizde testler yapabilirsiniz
• büyük diziler (1 milyon eleman) diziler - BURADA makinenizde testler yapabilirsiniz

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

Çıkış dizisini dolduran (başlatan) çözümleri test edin

İçin çözümlerin hızını test ediyoruz

• küçük diziler (12 eleman) - BURADA makinenizde testler yapabilirsiniz
• büyük diziler (1 milyon eleman) diziler - BURADA makinenizde testler yapabilirsiniz

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 iki boyutlu dizileri desteklemez, bunun yerine bir diziyi başka bir dizinin içine kaydeder ve dizinin hangi konumuna erişmek istediğinize bağlı olarak verileri bu diziden alırız. En dizi numaralama başlar hatırla ZERO .

Kod Örneği:

/* 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 + bunu daha basit bir şekilde yapabilir

True ile dolu 3 x 2 Dizi oluşturma

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

Ben i gerektiği gibi "kayıtları" eklemek için esnek bir dizi işlevi yapmak ve onları güncellemek ve daha fazla işlem için bir veritabanına göndermeden önce gerekli ne hesaplamalar e yapabilmek zorunda kaldı. İşte kod, umarım yardımcı olur :).

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

Herhangi bir hatayı optimize etmek ve / veya belirtmek için çekinmeyin :)

İşte iki boyutlu bir dizi yapmak için bulduğum hızlı bir yol.

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

Bu işlevi kolayca bir ES5 işlevine de dönüştürebilirsiniz.

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

Neden işe yarıyor: Kurucu, new Array(n)prototipine sahip bir nesne oluşturur Array.prototypeve sonra nesnenin nesnelerini atar ve lengthbu da doldurulmamış bir diziye neden olur. Gerçek üye olmayışı nedeniyle bu Array.prototype.mapişlevi yerine getiremiyoruz.

Böyle yapmanız olduğu gibi yapıcı, birden fazla argüman sağlamak Ancak, Array(1, 2, 3, 4), yapıcı kullanacak argumentsörneğini ve doldurmak An nesneArray doğru nesneyi.

Bu nedenle kullanabiliriz Array.apply(null, Array(x)), çünkü applyişlev argümanları yapıcıya yayar. Açıklamak Array.apply(null, Array(3))için yapmak yapmaya eşdeğerdir Array(null, null, null).

Artık gerçek bir nüfus dizisi oluşturduğumuza göre, tek yapmamız gereken mapikinci katmanı ( y) çağırmak ve oluşturmak .

Birinin altında, 5x5'lik bir matris oluşturur ve bunları null

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

console.log(md);

Yalnızca çalışma zamanında bilinen bir dizinin satır ve sütun boyutları, dinamik bir 2d dizisi oluşturmak için aşağıdaki yöntem kullanılabilir .

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

Sizi 2d dizisinin boyutunu önceden tanımlamaya zorlamayan ve çok özlü olan başka bir çözüm var.

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

Bu, çünkü [1,2]bir dize dönüştürülür, bu nesne için dize anahtarı olarak kullanılır çünkü çalışır table.

4x6 dizi oluşturmak için bunu yapmanız yeterlidir

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