[Article] Tableau à double entrée et plus

Bonjour.

Suite à quelques questions posées de façon récurrente dans le forum, je vous propose un petit tour dans le monde des tableaux

Un tableau est un objet mathématique bien défini. il s’agit d’une structure mathématique contenant un nombre n entier d’objets pris dans un ensemble K

Si on se réfère à cette «*définition», tous les éléments d’un tableau font partie d’un même ensemble. Et leur nombre est fini.

Chaque élément du tableau est repéré par sa position dans le tableau.

Tous les langages informatiques proposent une structure de donnée qui se rapproche plus où moins de cela. Et JavaScript ne déroge pas à la règle et propose donc la structure Array.

Cette structure correspond-elle à la définition*?
C’est bien une structure qui contient des éléments. La taille du tableau peut paraitre non définie, mais on peut considérer qu’elle est Number.MAX_VALUE, qui est le plus gros entier représentable en JavaScript. C’est donc bien un entier fini.
La définition mathématique impose que tous les éléments du tableau soient des éléments d’un même ensemble. Et en JavaScript un tableau peut contenir n’importe quoi. Enfin n’importe quel objet. Donc un tableau en JavaScript et un tableau d’objet.

La capacité dynamique du langage permet d’avoir des tableaux dont la taille change. Cela correspond mathématiquement à la définition dynamique d’un nouveau tableau.

Mais la mathématique nous offre des structures de tableau plus complexes. Les tableaux à double entrée. Il s’agit d’une structure mathématique contenant un nombre nXm (n entier, m entier) d’objets pris dans un ensemble K. n est dit nombre de lignes et m nombre de colonnes. Chaque élément est repéré par deux positions la ligne et la colonne.

On peut très facilement conclure que toutes les lignes comptent m éléments et toutes les colonnes comptent n éléments.

JavaScript ne propose pas de structure de donnée pour un tel objet mathématique. D’autres langages de programmation proposent des structures de données pour ce genre d’objet, mais JavaScript ne propose rien.

il est important d’en être conscient, car pour représenter de tels objets le développeur va devoir définir sa propre structure et le langage ne lui apportera aucun soutien pour garantir que la structure choisie est en adéquation avec l’objet mathématique «*Tableau à double entrée*»

Nous avons vu qu’un tableau JavaScript et un tableau au sens mathématique et qu’il peut contenir tout type d’objet. Très souvent, nous allons utiliser cette capacité pour faire un tableau de tableau.
Par exemple*: un tableau de n lignes qui sont des tableaux de m éléments ou alors un tableau de m colonnes qui sont des tableaux de n éléments.

La simple formulation de cette approche montre les limites. Nous avons soit un tableau de ligne et la notion de colonnes disparait soit un tableau de colonnes et c’est la notion de ligne qui disparait.

Autre limite*: quelle que soit l’approche choisie, nous avons un tableau contenant des tableaux et ces derniers doivent tous avoir la même taille, mais rien ne nous le garantit.

Dans un cas comme dans l’autre nous sommes donc loin d’un tableau à double entrée.
Ce sera donc à vous développeur de faire le nécessaire.

De la même façon, travailler avec des tableaux à n entrée ne pourra se faire qu’au travers de vos propres structures.

Alors, soyez conscient de ces limitations, ne considérez jamais que vos structures sont de fait conforme aux objets mathématiques qu’elles sont censées représenter.

A+JYT

J'ai un peu de mal à te suivre. La définition mathématique que tu donnes d'un tableau présente davantage de contraintes que celle au sens Javascript. Alors quelles sont ces limitations dont tu parles ? Peux-tu donner un cas concret ?

un tableau à double entrée est une structure qui a n lignes et m colonnes et tous les éléments appartiennent à l'ensemble K

supposons que les éléments de K aient tous la propriété p notée ainsi e.p. on peu donc normalement écrire

Code:

---

1 2	for (i in [0,n[, j in [0, m[) tab[i,j].p

---

si nous représentons ce tableau en JavaScript par un tableau de n ligne et m éléments nous allons avoir quelque chose comme

Code:

---

var a = Array(...);

---

et nous pouvons envisager d'écrire a[i][j] pour représenter l'élément tab[i,j]Or nous déjà ici un problème. a est un tableau à 1 dimension qui contient des objets
Donc a[i] est un objet. Rien ne nous garantit que ce soit un tableau.
Pour être sur, il nous faut soit avoir un code qui empêche qu'il en soit autrement soit tester une éventuelle erreur.

Puis, nous avons un deuxième problème si a[i] est bien un tableau il n'est pas du tout sur que nous ayons j+1 éléments dedans donc a[i][j] n'existe peut être pas.

et enfin si a[i][j] existe c'est un objet et donc pas nécessairement un élément de l'ensemble K. et si ce n'est pas un élément de l'ensemble K, nous ne pouvons pas écrire a[i][j].p pour accéder à la propriété p

L’écriture simpliste

Code:

---

1 2 3

for (var i = 0; i < n; i++) for (var j = 0; j < m; j++) a[i][j].p;

---

est donc complètement fause car elle ommet le fait que a est un tableau d'objet et non un tableau de tableau, elle ommet que si les élement de a sont des tableaux leur taille n'est pas garantie et elle ommet le fait que ces tableau contient des objet qui ne sont peut être pas dans l'ensemble k

ce n'est qu'une représentation très partielle d'un tableau à double entrée.
et c'est à vous développeurs de palier ces manques

A+JYT

Donc en fait ça revient à dire que Javascript est limité car il est non typé. Je ne considère pas ça comme une limitation mais plutôt comme un excès de permissivité.

A l'inverse on pourrait dire qu'un tableau en Java est limité car ne peut pas contenir d'éléments de types différents ou changer dynamiquement de nombre de dimensions.

Citation:

---

Envoyé par SylvainPV

Donc en fait ça revient à dire que Javascript est limité car il est non typé. Je ne considère pas ça comme une limitation mais plutôt comme un excès de permissivité.
...

---

non ça signifie que les tableau à double entrée sont des objet mathématique qui n'existe pas en javascript et qu'il faut prendre garde à la représentation qu'on va utiliser. il n'est pas question ici de limitation du langage mais d'héviter une confusion commune

un tableau de tableau n'est pas un tableau à double entrée cesont mathématiquement des objets différents qui on des propriétés différentes;

A+JYT

Je ne comprends toujours pas

Citation:

---

il faut prendre garde à la représentation qu'on va utiliser.

---

De quelle autre représentation veux-tu parler ?

Et quelle est la différence entre stocker un objet dans tab[i][j] par rapport à tab[i,j] ? Ce n'est qu'une notation, et on peut passer de l'une à l'autre en manipulant les index.

J'ai du mal à voir de quels problèmes tu veux parler quand il s'agit d'utiliser des tableaux 2D en Javascript. Ca ne m'a jamais causé le moindre souci.

si tu utilise un tableau de tableau pour représenter un tableau à double entré tu utilise UNE représentation
il existe bien d'autre représentation

Citation:

---

Et quelle est la différence entre stocker un objet dans tab[i][j] par rapport à tab[i,j] ? Ce n'est qu'une notation, et on peut passer de l'une à l'autre en manipulant les index.

---

non il ne s'agit pas de notation c'est justement le sujet de ce post
un tableau de tableau n'a pas les même propriété mathématique qu'un tableau à double entrée. utiliser le premier en pensant que c'est équivalent à utiliser le second est une erreur grossière.

Citation:

---

J'ai du mal à voir de quels problèmes tu veux parler quand il s'agit d'utiliser des tableaux 2D en Javascript. Ca ne m'a jamais causé le moindre souci.

---

c'est justement parce que le forum est peuplé de questions autour de ce sujet. que j'ai fais ce post.

NON on ne peut pas utiliser un tableau de tableau à la place d'un tableau à double entrée sans prendre de précaussions.

Oui on peut utiliser un tableau de tableau pour représenté un tableau à double entrée si on est conscient des limites de cette représentation, et qu'on fais le nécéssaire pour palier ses manques (où limiter sa permissivité)

A+JYT

Bonjour

Le JS est ultra permissif et on a pris l'habitude de pouvoir modifier n'importe quoi à partir de n'importe où.

Je ne prétends pas avoir la solution à ta question (j'en suis toujours au message n° 1), je veux simplement rappeler que l'on dispose déjà de moyens de constructions plus élaborés et un peu moins faciles à pervertir qu'un simple Array.

Je vous laisse jouer avec mon exemple (tester sous Chrome et Firefox), je suis en décalage horaire, j'ai sommeil ! :aie:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

var colonnesLength = 10, Matrice = Object.create( {}, { 0 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), // 10 float "enumerable" : true }, 1 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true }, 2 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true }, 3 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true }, 4 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true }, 5 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true }, 6 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true }, 7 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true }, 8 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true }, 9 : { "value" : new Float64Array( new ArrayBuffer( 8 * colonnesLength ) ), "enumerable" : true } }), lignes = Object.keys( Matrice ), lignesLength = lignes.length;   console.log( lignes, lignesLength );   for( var i = 0; i < lignesLength; i++ ){ for( var j = 0; j < colonnesLength; j++ ){ Matrice[ i ][ j ] = (0.125 + i) * j; } }   console.log( Matrice );

---