ฉันอ่านออนไลน์แล้วและบางแห่งบอกว่าเป็นไปไม่ได้บางคนบอกว่ามันเป็นแบบนั้นจากนั้นให้ยกตัวอย่างและคนอื่น ๆ ปฏิเสธตัวอย่างเป็นต้น

1. ฉันจะประกาศอาร์เรย์ 2 มิติใน JavaScript ได้อย่างไร (สมมติว่าเป็นไปได้)

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 = [[]];

วิธีสร้างอาร์เรย์สองมิติที่ว่างเปล่า (หนึ่งบรรทัด)

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

2 และ 4 เป็นมิติแรกและมิติที่สองตามลำดับ

เรากำลังใช้ประโยชน์Array.fromซึ่งสามารถใช้พารามิเตอร์แบบอาเรย์และการทำแผนที่ตัวเลือกสำหรับแต่ละองค์ประกอบ

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

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

เคล็ดลับเดียวกันนี้สามารถใช้สร้างอาร์เรย์ JavaScript ที่มี 1 ... N

อีกทางหนึ่ง (แต่ไม่มีประสิทธิภาพมากกว่า 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

ขณะที่มันจะกลับมาที่ต้องการเห็นได้ชัดอาร์เรย์สองมิติ ( [ [ <4 empty items> ], [ <4 empty items> ] ]) มีการจับได้ครั้งแรกอาร์เรย์มิติที่ได้รับการคัดลอกโดยการอ้างอิง นั่นหมายความว่าarr[0][0] = 'foo'จริงจะเปลี่ยนสองแถวแทนหนึ่ง

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

เหตุผลที่บางคนบอกว่ามันเป็นไปไม่ได้เพราะอาเรย์สองมิติเป็นเพียงอาร์เรย์อาเรย์ ความคิดเห็นอื่น ๆ ที่นี่ให้วิธีการที่ถูกต้องสมบูรณ์ในการสร้างอาร์เรย์สองมิติใน JavaScript แต่มุมมองที่บริสุทธิ์ที่สุดคือคุณมีอาร์เรย์หนึ่งมิติของวัตถุแต่ละวัตถุเหล่านั้นจะเป็นอาร์เรย์มิติหนึ่งซึ่งประกอบด้วยสององค์ประกอบ

นั่นคือสาเหตุของมุมมองที่ขัดแย้งกัน

มีเพียงไม่กี่คนที่แสดงให้เห็นถึงการใช้งานของพุช:
เพื่อนำสิ่งใหม่ ๆ มาให้ฉันจะแสดงวิธีเริ่มต้นเมทริกซ์ด้วยค่าบางค่าตัวอย่างเช่น 0 หรือสตริงว่าง ""
เตือนว่าถ้าคุณมี 10 องค์ประกอบอาร์เรย์ในจาวาสคริปต์ดัชนีสุดท้ายจะเป็น 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);

มันจะสร้างอาร์เรย์ a ของความยาว 10 ที่เต็มไปด้วยอาร์เรย์ (Push เพิ่มองค์ประกอบให้กับอาร์เรย์และส่งคืนความยาวใหม่)

คำตอบ sanest ดูเหมือนจะเป็น

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

โปรดทราบว่าเราไม่สามารถเติมแถวได้โดยตรงเนื่องจากการเติมใช้ตัวสร้างสำเนาตื้นดังนั้นทุกแถวจะแชร์หน่วยความจำเดียวกัน ... นี่คือตัวอย่างที่แสดงให้เห็นว่าแต่ละแถวจะแชร์ได้อย่างไร (นำมาจากคำตอบอื่น):

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

อาร์เรย์สองมิติถูกสร้างขึ้นเช่นเดียวกับอาร์เรย์มิติเดียว 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 เราสามารถสร้างอาเรย์ก่อนแล้วจึงเพิ่มอาร์เรย์ในรูปแบบของมัน วิธีนี้จะส่งคืนอาร์เรย์ 2 มิติพร้อมจำนวนแถวและคอลัมน์ที่กำหนด

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

เพื่อสร้าง Array ให้ใช้วิธีนี้ดังต่อไปนี้

var array = Create2DArray(10,20);

ในการสร้างอาร์เรย์ "2D" แบบไม่กระจาย (x, y) ด้วยดัชนีทั้งหมดที่กำหนดแอดเดรสได้และตั้งค่าเป็นศูนย์:

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

Array "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 และสูงกว่าคุณสามารถใช้array comprehensionsเพื่อสร้างอาร์เรย์สองมิติ นอกจากนี้คุณยังสามารถกรองและ / หรือจัดการรายการในขณะที่เติมอาร์เรย์และไม่ต้องใช้ลูป

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

วิธีการของฉันคล้ายกับคำตอบ @Binesh แต่มีวิธีการทั่วไปที่มากกว่า

คุณสามารถประกาศ double array ดังนี้

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 ฉันทำการทดสอบบน MacOs HighSierra 10.13.6 บน Chrome v79.0, Safari v13.0.4 และ Firefox v72.0 สำหรับโซลูชันที่เลือก

สรุปสำหรับอาเรย์ 2d ที่ไม่ได้กำหนดค่าเริ่มต้น

• โซลูชันลึกลับ{}/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 ช้าที่สุดสำหรับทุกอาร์เรย์ในเบราว์เซอร์ทั้งหมด

ข้อสรุปสำหรับอาร์เรย์ 2 มิติที่เริ่มต้น

• โซลูชันที่ใช้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 องค์ประกอบ) - คุณสามารถทำการทดสอบบนเครื่องของคุณที่นี่
• อาร์เรย์ขนาดใหญ่ (1 ล้านองค์ประกอบ) - คุณสามารถทำการทดสอบบนเครื่องของคุณได้ที่นี่

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

ทดสอบโซลูชันที่เติมเอาต์พุต (initialise) อาร์เรย์

เราทดสอบความเร็วของโซลูชันสำหรับ

• อาร์เรย์ขนาดเล็ก (12 องค์ประกอบ) - คุณสามารถทำการทดสอบบนเครื่องของคุณที่นี่
• อาร์เรย์ขนาดใหญ่ (1 ล้านองค์ประกอบ) - คุณสามารถทำการทดสอบบนเครื่องของคุณได้ที่นี่

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 ไม่สนับสนุนอาร์เรย์สองมิติ แต่เราเก็บอาร์เรย์ไว้ในอาร์เรย์อื่นแล้วดึงข้อมูลจากอาร์เรย์นั้นขึ้นอยู่กับตำแหน่งของอาร์เรย์นั้นที่คุณต้องการเข้าถึง โปรดจำไว้ว่าอาร์เรย์เลขเริ่มต้นที่ศูนย์

ตัวอย่างรหัส:

/* 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 + สามารถทำได้ในวิธีที่ง่ายยิ่งขึ้น

การสร้างอาร์เรย์ 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"
}

อย่าลังเลที่จะเพิ่มประสิทธิภาพและ / หรือชี้ข้อบกพร่องใด ๆ :)

นี่เป็นวิธีที่รวดเร็วที่ฉันพบว่าสร้างอาร์เรย์สองมิติ

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และสร้างเลเยอร์ที่สอง ( y)

ด้านล่างหนึ่งสร้างเมทริกซ์ 5x5 และเติมด้วย null

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

console.log(md);

แถวและคอลัมน์ขนาดของอาร์เรย์ที่รู้จักกันเท่านั้นที่เวลาทำงานแล้ววิธีต่อไปนี้สามารถนำมาใช้สำหรับการสร้างอาร์เรย์ 2 มิติแบบไดนามิก

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