Les tableaux dans Ninox

Tableaux simples

Manipuler des tableaux de textes ou de nombres est simple :

var myArray := ["a", "b", "d"];

index(myArray, "b");
myArray := array(myArray, ["c"]);

myArray order this;

Le tri peut aussi se faire avec order, sort et unsort pour les tableaux de textes ou de nombres.
Pour d'autres fonctions liées aux tableaux, reportez-vous à la documentation Ninox.

Tableaux à deux dimensions

Ninox ne prend pas en charge directement les tableaux à deux dimensions. Utilisez à la place un tableau d'objets JSON.
Par exemple, pour trier le tableau sur le deuxième élément du champ d2 :

var myArray := [{'d2':["a", "Z"]}, {'d2':["b", "B"]}, {'d2':["c", "C"]}, {'d2':["d", "D"]}];

(myArray order by item('d2', 1));

Ce code renvoie : [{"d2":["b","B"]},{"d2":["c","C"]},{"d2":["d","D"]},{"d2":["a","Z"]}]

Filtrer des tableaux

Vous pouvez filtrer des tableaux comme le résultat d'un select. Pour les tableaux de textes ou de nombres, utilisez this pour désigner la valeur filtrée :

var myArray := ["Jan", "Fred", "Jacques"];
myArray[this like "J"] order this;

Pour les tableaux JSON, utilisez directement la clé :

var myArray := [
  { 'prénom' : "Jan", nom : "Augustin" },
  { 'prénom' : "Fred", nom : "Baillot" },
  { 'prénom' : "Jacques", nom : "Tur" }
];

myArray[nom like "i"] order 'prénom';

Ce code renvoie un tableau de JSON : [{"prénom":"Fred","nom":"Baillot"}, {"prénom":"Jan","nom":"Augustin"}]

Opérations sur mesure sur les tableaux JSON

Pour les tableaux JSON, vous pouvez ajouter un bloc de code (entre parenthèses) pour effectuer des opérations sur mesure à chaque itération. Comme avec for in, le type du tableau obtenu correspond à la dernière ligne de code du bloc.

Exemple : calculer la longueur des noms complets (prénom + nom) :

var myArray := [
  { 'prénom' : "Leo", nom : "Martin" },
  { 'prénom' : "Paul", nom : "Garnet" },
  { 'prénom' : "Pierre", nom : "Dur" }
];

var nameLengths := myArray[nom like "a"].(
    var fullName := ---{'prénom'} {nom}---;
    length(fullName)
);
nameLengths;

Ce code renvoie un tableau de nombres [10, 11], qui représente les longueurs des noms complets.

Initialiser un tableau vide typé

Dans Ninox, l'astuce habituelle pour créer un tableau vide qui porte tout de même le bon type d'enregistrement consiste à exécuter un select filtré par where false.
La requête ne renvoie aucun enregistrement, mais conserve le type des éléments du tableau.

"Empty Invoice Item array:";
let t := (select 'Invoice Item' where false);

t est désormais un tableau dont les éléments sont du type Invoice Item.
Comme il est vide tout en étant typé, il peut servir sans risque de point de départ à des opérations array().

Pourquoi ne pas simplement utiliser [] ?

Le littéral [] est un tableau non typé. Il fonctionne souvent, mais combiné à array() sur des collections d'enregistrements, Ninox peut se plaindre d'incohérences de type.
Le motif select … where false évite complètement ce problème.

Créer un tableau vide pour des types primitifs (nombre, texte, JSON…)

Lorsque vous avez besoin d'un tableau vide de valeurs scalaires — nombres, chaînes de texte ou objets JSON —, il n'y a pas de table sous-jacente sur laquelle faire un select.
Vous pouvez tout de même obtenir un tableau vide typé en amorçant [] avec un élément factice, aussitôt filtré :

"Empty number / text / JSON array:";
let t := [1][false];   "t is now an empty but number typed array";

[1] produit un tableau numérique à un élément ; le filtre [false] retire cet élément et laisse un tableau vide qui conserve le type nombre.
Utilisez un littéral texte ou JSON à la place de 1 si vous avez besoin de ces types-là.

Aplatir un tableau à deux dimensions

Chaque Invoice contient son propre sous-tableau Invoice Items. Pour obtenir une seule liste rassemblant les articles de toutes les factures, parcourez les factures et concaténez leurs sous-tableaux.

"Initialize empty array:";
let t := (select 'Invoice Item' where false);

"Iterate over each invoice and add its items:";
for i in Invoices do
    t := array(t, i.'Invoice Items')
end;

"Return the flattened list:";
t

Comment cela fonctionne

for i in Invoices do … end parcourt chaque enregistrement Invoice.
array(t, i.'Invoice Items') concatène la valeur courante de t avec le tableau des articles de cette facture.
- À la première itération, les articles de la première facture sont ajoutés.
- À la deuxième itération, ceux de la deuxième facture s'y ajoutent, et ainsi de suite.
Une fois la boucle terminée, t contient tous les articles de toutes les factures dans un seul tableau à plat.

Vous pouvez alors effectuer des opérations comme count(t) pour connaître le nombre total d'articles, ou parcourir et filtrer t directement.