JavaScript에서 2 차원 배열을 어떻게 만들 수 있습니까?

JavaScript에서 2 차원 배열을 어떻게 만들 수 있습니까?

---

나는 온라인에서 읽히는 어떤 곳은 그것이 불가능한 말하고 어떤 곳에서 가능하다는 것을 의미합니다.

1. JavaScript에서 2 차원 배열을 어떻게 확장합니까? (가능하다 가정)

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 차원 배열을 만드는 방법 (한 줄)

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> ] ])을 반환하는 동안 catch : 첫 번째 차원 배열이 참조로 복사되었습니다. 이는 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 차원 배열이라는 것입니다.

그래서 그것이 상충되는 관점의 원인입니다.

---

푸시를 사용하는 사람은 거의 없습니다.
새로운 것을 가져 오기 위해 0 또는 빈 페이지 ""과 같은 값으로 초기화하는 방법을 보여 드리겠습니다.
10 개의 요소 배열이있는 경우 자바 펼쳐져 있습니다.

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

---

채우기가 얕은 복사 생성시에 사용하는 행을 직접 채울 수 있습니다 ... 모든 행이 동일한 메모리를 공유합니다 ... 여기에 각 행이 공유되는 방법을 여기 예가 있습니다 (다른 답변에서 가져옴).

// 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 차원 배열의 경우.

---

JavaScript에서 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);

---

주소를 어떤 "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 (). 채우기 ()를 사용합니다.

// creates 8x8 array filed with "0"    
const arr2d = Array(8).fill(0).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);

---

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

---

필요한만큼 "레코드"를 추가하고 처리를 위해 데이터베이스로 보내기 전에 모든 계산을 수행 할 수있는 유연한 배열 함수를 정리했습니다. 다음은 코드입니다. 도움이되기를 바랍니다. :).

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올바르게 인스턴스화하고 채 웁니다 .

이제는 XML 함수가 생성자에 인수를 분산 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);

---

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

---

각 행이 동일한 길이의 배열 인 행 배열을 할당 할 수 있습니다. 또는 행 * 열 요소가있는 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];
        }
    }
}

---

간단한 예 :

var blocks = [];

blocks[0] = [];

blocks[0][0] = 7;

---

0으로 채워진 am * n 2 차원 배열을 만드는 라이너 하나.

new Array(m).fill(new Array(n).fill(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]]

참고 URL : https://stackoverflow.com/questions/966225/how-can-i-create-a-two-dimensional-array-in-javascript