මම මාර්ගගතව කියවා ඇති අතර සමහර ස්ථාන පවසන්නේ එය කළ නොහැකි බවයි, සමහරු එය එසේ යැයි පවසමින් පසුව උදාහරණයක් ලබා දෙන අතර තවත් සමහරු ආදර්ශය ප්‍රතික්ෂේප කරති.

1. ජාවාස්ක්‍රිප්ට් හි ද්විමාන අරාවක් ප්‍රකාශ කරන්නේ කෙසේද? (එය කළ හැකි යැයි උපකල්පනය කරමින්)

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

සක්‍රිය කිරීමේ පිළිතුරට සමානව, 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)]

ජාවාස්ක්‍රිප්ට් සතුව ඇත්තේ 1-මාන අරා පමණි, නමුත් අනෙක් අය පෙන්වා දුන් පරිදි ඔබට අරා අරා සෑදිය හැකිය.

ස්ථාවර මානයන්හි 2-d පෙළක් තැනීම සඳහා පහත ශ්‍රිතය භාවිතා කළ හැකිය:

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

හිස් ද්විමාන අරාවක් (එක් පේළියක්) නිර්මාණය කරන්නේ කෙසේද

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

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

පහසුම ක්‍රමය:

var myArray = [[]];

සමහරු එය කළ නොහැකි යැයි පැවසීමට හේතුව ද්විමාන අරාව සැබවින්ම අරා සමූහයක් වීමයි. මෙහි ඇති අනෙක් අදහස් ජාවාස්ක්‍රිප්ට් හි ද්විමාන අරා නිර්මාණය කිරීම සඳහා පරිපූර්ණ වලංගු ක්‍රමවේදයන් සපයයි, නමුත් පිරිසිදු දෘෂ්ටි කෝණය නම් ඔබට එක් මානයන්හි වස්තු සමූහයක් තිබීමයි, එම සෑම වස්තුවක්ම මූලද්‍රව්‍ය දෙකකින් සමන්විත ඒක මාන අරාවක් වනු ඇත.

ඉතින්, ගැටුම්කාරී දෘෂ්ටි කෝණයන් සඳහා හේතුව එයයි.

තල්ලු කිරීමේ භාවිතය ස්වල්ප දෙනෙක් පෙන්වයි:
අළුත් දෙයක් ගෙන ඒමට, යම් අගයකින් අනුකෘතිය ආරම්භ කරන්නේ කෙසේදැයි මම ඔබට පෙන්වන්නම්, උදාහරණ: 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);

එය අරා වලින් පුරවා ඇති දිග 10 ක අරාවක් ජනනය කරනු ඇත. (තල්ලු කිරීම අරාවකට මූලද්‍රව්‍යයක් එකතු කර නව දිග ලබා දෙයි)

වඩාත්ම සැනසිලිදායක පිළිතුර එයයි

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

මේ නිසා මට බයිනෙෂ්කුමාර් අක්ෂර වින්‍යාසය ලැබුණා

තනි මාන මාන අරා ඇති ආකාරයටම ද්විමාන අරා නිර්මාණය වේ. ඔබ ඒවාට ප්‍රවේශ වන්න array[0][1].

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

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

කවුරුහරි මෙයට පිළිතුරු දී ඇත්දැයි මට විශ්වාස නැත, නමුත් මෙය මට හොඳින් වැඩ කළ බව මට පෙනී ගියේය -

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

උදා:

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

උදාහරණයක් ලෙස ද්විමාන අරාවක් සඳහා.

සියලු දර්ශක ආමන්ත්‍රණය කළ හැකි හා අගයන් ශුන්‍ය ලෙස සකසා ඇති විරල නොවන "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) කාල සංකීර්ණතාවයක් ඇති බව සැලකිල්ලට ගත යුතුය, එබැවින් එය ඉතා විශාල අරා සඳහා සුදුසු නොවේ.

ජාවාස්ක්‍රිප්ට් හි 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);

එක් ලයිනර් පෙම්වතුන් සඳහා Array.from ()

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

තවත් එකක් (dmitry_romanov අදහස් දැක්වීමෙන්) Array () භාවිතා කරන්න . පුරවන්න ()

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

අරා අවබෝධය භාවිතා කරන්න

ජාවාස්ක්‍රිප්ට් 1.7 සහ ඊට වැඩි ද්විමාන අරා නිර්මාණය කිරීම සඳහා ඔබට අරාව අවබෝධය භාවිතා කළ හැකිය . අරාව පුරවන අතරතුර ඔබට ඇතුළත් කිරීම් පෙරීම සහ / හෝ හැසිරවිය හැකි අතර ලූප භාවිතා කිරීමට අවශ්‍ය නැත.

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

තවත් උදාහරණ සහ ලේඛන මෙහි සොයාගත හැකිය .

මෙය තවමත් සම්මත අංගයක් නොවන බව කරුණාවෙන් සලකන්න .

කාර්ය සාධනය

අද 2020.02.05 තෝරාගත් විසඳුම් සඳහා මම මැක් ඕස් හයිසෙයිරා 10.13.6 ක්‍රෝම් v79.0, සෆාරි v13.0.4 සහ ෆයර්ෆොක්ස් v72.0 මත පරීක්ෂණ සිදු කරමි.

ආරම්භක නොවන 2d අරාව සඳහා නිගමන

• එසෝටරික් ද්‍රාවණය {}/arr[[i,j]](එන්) විශාල හා කුඩා අරා සඳහා වේගවත් වන අතර එය විශාල විරල අරා සඳහා හොඳ තේරීමක් බව පෙනේ
• for-[]/while(A, G) මත පදනම් වූ විසඳුම් වේගවත් වන අතර ඒවා කුඩා අරා සඳහා හොඳ තේරීමක් වේ.
• විසඳුම් for-[](බී, සී) වේගවත් වන අතර ඒවා විශාල අරා සඳහා හොඳ තේරීමක් වේ
• Array..map/from/fill(I, J, K, L, M) මත පදනම් වූ විසඳුම් කුඩා අරා සඳහා තරමක් මන්දගාමී වන අතර විශාල අරා සඳහා තරමක් වේගවත් වේ
• surprinsingly for-Array(n)(B, C) ට වඩා සෆාරි මත බෙහෙවින් අඩු වේ for-[](A)
• surprinsingly for-[]විශාල අරාව සඳහා වන (අ) සියලු බ්රව්සර් මත සෙමින්
• විසඳුම් සියලු බ්‍රව්සර් සඳහා කුඩා අරා සඳහා මන්දගාමී වේ
• 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 විසඳුම් ක්‍රෝම් සහ සෆාරි මත මධ්‍යම හෝ වේගවත් නමුත් ෆයර්ෆොක්ස් මත මන්දගාමී වේ.
• {}/arr[[i,j]]සියලුම බ්‍රව්සර්වල කුඩා හා විශාල අරා සඳහා එසෝටරික් ද්‍රාවණය (එන්) මන්දගාමී වේ

විස්තර

නිමැවුම් අරාව පුරවා නැති (ආරම්භක) විසඳුම් සඳහා පරීක්ෂණය

විසඳුම් සඳහා අපි වේගය පරීක්ෂා කරමු

• කුඩා අරා (මූලද්‍රව්‍ය 12) - ඔබට ඔබේ යන්ත්‍රයේ පරීක්ෂණ සිදු කළ හැකිය මෙතැන
• විශාල අරා (මූලද්‍රව්‍ය මිලියනය) අරා - ඔබට ඔබේ යන්ත්‍රය මත පරීක්ෂණ සිදු කළ හැකිය මෙතැන

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) - ඔබට ඔබේ යන්ත්‍රයේ පරීක්ෂණ සිදු කළ හැකිය මෙතැන
• විශාල අරා (මූලද්‍රව්‍ය මිලියනය) අරා - ඔබට ඔබේ යන්ත්‍රය මත පරීක්ෂණ සිදු කළ හැකිය මෙතැන

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

මගේ ප්‍රවේශය ine බිනීෂ් පිළිතුරට බොහෝ සෙයින් සමාන නමුත් වඩාත් පොදු ප්‍රවේශයකින්.

ඔබට ද්විත්ව අරාව පහත පරිදි ප්‍රකාශ කළ හැකිය:

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

ජාවාස්ක්‍රිප්ට් ද්විමාන අරා සඳහා සහය නොදක්වයි, ඒ වෙනුවට අපි වෙනත් අරාවක් තුළ අරාවක් ගබඩා කර එම අරාවෙහි දත්ත ලබා ගන්නේ ඔබට ප්‍රවේශ වීමට අවශ්‍ය එම අරාවේ කුමන ස්ථානයටද යන්න මතය. අරාව සංඛ්‍යා ආරම්භ වන්නේ 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 + ට මෙය වඩාත් සරල ආකාරයකින් කළ හැකිය

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), ඉදිකිරීම්කරු විසින් භාවිතා කරනු ඇතargumentsArray වස්තුව නිවැරදිව ක්ෂණිකව හා ජනගහනය කිරීමට .

මෙම හේතුව නිසා, අපට භාවිතා කළ හැකිය 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);

ධාවන වේලාවේ පමණක් දන්නා අරාවක පේළි සහ තීරු ප්‍රමාණයන් පසුව ගතික 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

4x6 අරාවක් සෑදීමට, මෙය කරන්න

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

0 පුරවා ඇති am * n 2 මාන අරාව නිර්මාණය කිරීමට එක් ලයිනර්.

new Array(m).fill(new Array(n).fill(0));