Comment convertir simple tableau en tableau à deux dimensions (matrice) avec Javascript

Imaginer que j'ai un tableau:

A = Array(1, 2, 3, 4, 5, 6, 7, 8, 9);

Et je veux les convertir en tableau en 2 dimensions (matrice de N x M), par exemple comme ceci:

A = Array(Array(1, 2, 3), Array(4, 5, 6), Array(7, 8, 9));

Remarque, que les lignes et colonnes de la matrice est variable.

Array.prototype.toMatrix=function(per){return this.reduce(function(prev,current,i){if(i%per==0)prev.push([current]);else prev[prev.length-1].push(current);return prev;},[])}

OriginalL'auteur Bakhtiyor | 2010-12-20

Quelque chose comme cela?

function listToMatrix(list, elementsPerSubArray) {
    var matrix = [], i, k;

    for (i = 0, k = -1; i < list.length; i++) {
        if (i % elementsPerSubArray === 0) {
            k++;
            matrix[k] = [];
        }

        matrix[k].push(list[i]);
    }

    return matrix;
}

Utilisation:

var matrix = listToMatrix([1, 2, 3, 4, 4, 5, 6, 7, 8, 9], 3);
//result: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

OriginalL'auteur jwueller

25

Vous pouvez utiliser le Array.prototype.reduce fonction pour faire cela en une seule ligne.

ECMAScript 6 style:
```
myArr.reduce((rows, key, index) => (index % 3 == 0 ? rows.push([key]) 
  : rows[rows.length-1].push(key)) && rows, []);
```
"Normal" JavaScript:
```
myArr.reduce(function (rows, key, index) { 
  return (index % 3 == 0 ? rows.push([key]) 
    : rows[rows.length-1].push(key)) && rows;
}, []);
```
Vous pouvez modifier la 3 tout ce que vous voulez le nombre de colonnes à être, ou, mieux encore, de le mettre dans une réutilisables fonction:

ECMAScript 6 style:
```
const toMatrix = (arr, width) => 
    arr.reduce((rows, key, index) => (index % width == 0 ? rows.push([key]) 
      : rows[rows.length-1].push(key)) && rows, []);
```
"Normal" JavaScript:
```
function toMatrix(arr, width) {
  return arr.reduce(function (rows, key, index) { 
    return (index % width == 0 ? rows.push([key]) 
      : rows[rows.length-1].push(key)) && rows;
  }, []);
}
```
N'est-il pas une bonne idée pour éviter de muter les "lignes" tableau? const toMatrix = (arr, largeur) => arr.réduire((les lignes, les principaux, index) => (indice % largeur === 0) ? [...lignes, [clé]] : [...lignes.slice(0,-1), [...lignes[lignes.longueur -1], clé]], []);
Dans le reduce() fonction, le premier paramètre de la fonction de rappel est la valeur que vous renvoyez. Il n'y a pas de mal dans la mutation parce qu'il a été fait nouvelle pour cette (initialisé avec le deuxième paramètre de reduce()). Il n'est pas nécessaire pour les frais généraux supplémentaires d'éviter des mutations sur elle (en fait, la mutation est probablement plus performant). Il est encore admissible en tant que "fonctionnelle" de la programmation.

OriginalL'auteur samanime

Comment au sujet de quelque chose comme:

var matrixify = function(arr, rows, cols) {
    var matrix = [];
    if (rows * cols === arr.length) {
        for(var i = 0; i < arr.length; i+= cols) {
            matrix.push(arr.slice(i, cols + i));
        }
    }

    return matrix;
};

var a = [0, 1, 2, 3, 4, 5, 6, 7];
matrixify(a, 2, 4);

http://jsfiddle.net/andrewwhitaker/ERAUs/

OriginalL'auteur Andrew Whitaker

Simplement utiliser deux boucles for:

var rowNum = 3;
var colNum = 3;
var k = 0;
var dest = new Array(rowNum);

for (i=0; i<rowNum; ++i) {
  var tmp = new Array(colNum);
  for (j=0; j<colNum; ++j) {
    tmp[j] = src[k];
    k++;
  }
  dest[i] = tmp;
}

Pourriez-vous ré-écrire en C# s'il vous plaît?

OriginalL'auteur Vincent Mimoun-Prat

function matrixify( source, count )
{
    var matrixified = [];
    var tmp;
    //iterate through the source array
    for( var i = 0; i < source.length; i++ )
    {
        //use modulous to make sure you have the correct length.
        if( i % count == 0 )
        {
            //if tmp exists, push it to the return array
            if( tmp && tmp.length ) matrixified.push(tmp);
            //reset the temporary array
            tmp = [];
        }
        //add the current source value to the temp array.
        tmp.push(source[i])
    }
    //return the result
    return matrixified;
}

Si vous souhaitez remplacer un tableau les valeurs internes, je crois que vous pouvez appeler le suivant:

source.splice(0, source.length, matrixify(source,3));

OriginalL'auteur cwallenpoole

2

Ce code est générique pas besoin de vous soucier de la taille et de la matrice, des œuvres universellement
```
  function TwoDimensional(arr, size) 
    {
      var res = []; 
      for(var i=0;i < arr.length;i = i+size)
      res.push(arr.slice(i,i+size));
      return res;
    }
```
1. Définition de tableau vide.
2. Itération en fonction de la taille donc, nous aurons spécifié morceau.C'est pourquoi je suis incrémentation je avec taille, parce que la taille peut être 2,3,4,5,6......
3. Ici, d'abord, je suis découpage de je à (i+taille) et puis je suis en la poussant de tableau vide res.
4. Retourner le tableau à deux dimensions.
OriginalL'auteur Bhanu Prakash H c

function matrixify(array, n, m) {
    var result = [];
    for (var i = 0; i < n; i++) {
        result[i] = array.splice(0, m);
    }
    return result;
}
a = matrixify(a, 3, 3);

OriginalL'auteur Jannic Beck

function chunkArrToMultiDimArr(arr, size) {

    var newArray = [];

    while(arr.length > 0)
    {
      newArray.push(arr.slice(0, size));
      arr = arr.slice(size);
    }

  return newArray;
}

//example - call function
chunkArrToMultiDimArr(["a", "b", "c", "d"], 2);

OriginalL'auteur SayedRakib

function changeDimension(arr, size) {  
  var arrLen = arr.length;
  var newArr = [];
  var count=0;
  var tempArr = [];

  for(var i=0; i<arrLen; i++) {
    count++;
    tempArr.push(arr[i]);

    if (count == size || i == arrLen-1) {
      newArr.push(tempArr);
      tempArr = [];
      count = 0;
    }    
  }  
  return newArr;
}

changeDimension([0, 1, 2, 3, 4, 5], 4);

Pouvez-vous expliquer ce qui se passe dans le if (count == taille || i == arrLen-1) {...} - ce qui se passe quand j' == arrLen-1?

OriginalL'auteur Sagar Mishra

Un impressionnant référentiel ici .

api : masfufa.js
de l'échantillon : masfufa.html

Selon cet exemple , l'extrait suivant de résoudre le problème :

  jsdk.getAPI('my');
  var A=[1, 2, 3, 4, 5, 6, 7, 8, 9];
  var MX=myAPI.getInstance('masfufa',{data:A,dim:'3x3'});

alors :

MX.get[0][0]  //-> 1 (first)
MX.get[2][2] // ->9 (last)

OriginalL'auteur Abdennour TOUMI

0

Réponse courte utilisation:
```
const gridArray=(a,b)=>{const d=[];return a.forEach((e,f)=>{const 
h=Math.floor(f/b);d[h]=d[h]||[],d[h][f%b]=a[f]}),d};
```
Où:
```
a: is the array
b: is the number of columns
```
Longue réponse, vous pouvez lire l'article:

Comment faire pour convertir un tableau de longueur " n " à la matrice de la grille

OriginalL'auteur Mustafa Dwekat

Vous devez vous connecter pour publier un commentaire.