나는 온라인에서 읽었으며 일부 장소는 불가능하다고 말하고 일부는 예라고 말하고 다른 사람들은 예를 반박합니다.

1. JavaScript로 2 차원 배열을 어떻게 선언합니까? (가능하다고 가정)

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

빈 2 차원 배열을 만드는 방법 (한 줄)

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

2와 4는 각각 1 차원과 2 차원입니다.

우리는 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을 포함하는 JavaScript 배열 을 만들 수 있습니다.

또는 (하지만 더 비효율적 인 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

분명히 원하는 2 차원 배열 ( [ [ <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]);

일부 사람들이 불가능하다고 말하는 이유는 2 차원 배열이 실제로는 배열의 배열이기 때문입니다. 여기에있는 다른 의견은 JavaScript에서 2 차원 배열을 만드는 완벽하게 유효한 방법을 제공하지만 가장 순수한 관점은 1 차원 객체 배열을 갖는 것입니다. 각 해당 객체는 2 요소로 구성된 1 차원 배열입니다.

이것이 충돌하는 견해의 원인입니다.

push를 사용하는 사람은 거의 없습니다.
새로운 것을 가져 오기 위해 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

2 라이너 :

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

배열로 채워진 길이 10의 배열 a를 생성합니다. (푸시는 배열에 요소를 추가하고 새로운 길이를 반환합니다)

가장 정답은

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'

이것이 내가 달성 한 것입니다 :

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

이것은 나에게 Bineeshkumar를 철자

2 차원 배열은 1 차원 배열과 같은 방식으로 생성됩니다. 그리고 당신은 그들처럼 액세스합니다 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 차원 배열의 경우.

자바 스크립트에서 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);

주소를 지정할 수 있고 모든 값을 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) 시간 복잡성을 가지므로 매우 큰 배열에는 적합하지 않을 수 있습니다.

배열 이해 사용

JavaScript 1.7 이상에서는 배열 이해 를 사용하여 2 차원 배열을 만들 수 있습니다 . 배열을 채우는 동안 항목을 필터링 및 / 또는 조작 할 수 있으며 루프를 사용할 필요가 없습니다.

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 answer : "inspired" )

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

내 접근 방식은 @Bineesh 답변과 매우 유사하지만 더 일반적인 접근 방식입니다.

다음과 같이 이중 배열을 선언 할 수 있습니다.

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 Chrome v79.0, Safari v13.0.4 및 Firefox v72.0의 MacOs HighSierra 10.13.6에서 선택한 솔루션에 대한 테스트를 수행합니다.

초기화되지 않은 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은 모든 브라우저에서 모든 어레이에 대해 가장 느립니다.

초기화 된 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]](N)은 모든 브라우저에서 작고 큰 배열에서 가장 느립니다.

세부

출력 배열을 채우지 않는 (초기화) 솔루션 테스트

솔루션 속도를 테스트합니다.

• 작은 배열 (12 개 요소)-컴퓨터에서 테스트를 수행 할 수 있습니다 여기
• 큰 배열 (1 개 백만 요소) 배열 - 당신은 당신의 시스템에서 테스트를 수행 할 수 HERE

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 개 요소)- 여기 에서 컴퓨터에서 테스트를 수행 할 수 있습니다.
• 큰 배열 (1 개 백만 요소) 배열 - 당신은 당신의 시스템에서 테스트를 수행 할 수 HERE

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는 2 차원 배열을 지원하지 않습니다. 대신 배열을 다른 배열에 저장하고 액세스하려는 배열의 위치에 따라 해당 배열에서 데이터를 가져옵니다. 배열 수는 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 +는 훨씬 간단한 방법으로이 작업을 수행 할 수 있습니다

true로 채워진 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"
}

버그를 최적화 및 / 또는 지적 해 주시기 바랍니다 :)

다음은 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))하게하기 위해하는 것은 doing 과 같습니다 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

2D 어레이의 크기를 미리 정의하지 않아도되는 또 다른 솔루션이 있으며 매우 간결합니다.

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

때문에이 작품 [1,2]A와 사용되는 문자열로 변환되는 문자열 키 을위한 table객체입니다.

4x6 배열을 만들려면 간단히

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