Taules de valors a Ninox

Taules simples

Manipular taules de text o de nombres és senzill:

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

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

myArray order this;

També es pot ordenar amb order, sort i unsort per a taules de text o de nombres.
Per a més funcions relacionades amb les taules, consulteu la documentació de Ninox.

Taules bidimensionals

Ninox no admet directament les taules bidimensionals. En lloc d'això, feu servir una taula d'objectes JSON.
Per exemple, per ordenar la taula pel segon element del camp d2:

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

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

Aquest codi retorna: [{"d2":["b","B"]},{"d2":["c","C"]},{"d2":["d","D"]},{"d2":["a","Z"]}]

Filtrar taules

Podeu filtrar les taules igual que el resultat d'un select. Per a les taules de text o de nombres, feu servir this per referir-vos al valor que es filtra:

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

Per a les taules JSON, feu servir directament la clau:

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

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

Aquest codi retorna una taula de JSON: [{"prénom":"Fred","nom":"Baillot"}, {"prénom":"Jan","nom":"Augustin"}]

Operacions personalitzades sobre taules JSON

Per a les taules JSON, hi podeu incloure un bloc de codi (entre parèntesis) que executi operacions personalitzades a cada iteració. Igual que amb for in, el tipus de la taula resultant correspon a la darrera línia de codi del bloc.

Exemple: calcular la longitud dels 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;

Aquest codi retorna una taula de nombres [10, 11] que representen les longituds dels noms complets.

Inicialitzar una taula buida amb tipus

A Ninox, el truc habitual per crear una taula buida que conservi el tipus de registre correcte és executar un select filtrat amb where false.
La consulta no retorna cap registre, però en preserva el tipus dels elements de la taula.

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

t és ara una taula els elements de la qual són del tipus Invoice Item.
Com que és buida però amb tipus, es pot reutilitzar amb tota seguretat com a punt de partida d'operacions array().

Per què no fer servir simplement []?

El literal [] és una taula sense tipus. Sovint funciona, però quan es combina amb array() sobre col·leccions de registres, Ninox pot queixar-se d'incoherències de tipus.
El patró select … where false evita completament aquest problema.

Crear una taula buida per a tipus primitius (nombre, text, JSON...)

Quan necessiteu una taula buida per a valors escalars —nombres, cadenes de text o objectes JSON— no hi ha cap taula subjacent d'on fer un select.
Tot i així podeu obtenir una taula buida amb tipus sembrant [] amb un element fictici i filtrant-lo immediatament:

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

[1] produeix una taula numèrica d'un sol element; el filtre [false] n'elimina aquest element i deixa una taula buida que conserva el tipus nombre.
Feu servir un literal de text o de JSON en lloc d'1 si necessiteu aquests tipus concrets.

Aplanar una taula bidimensional

Cada Invoice conté la seva pròpia subtaula Invoice Items. Per obtenir una sola llista amb tots els elements de totes les factures, recorreu les factures i concateneu-ne les subtaules.

"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

Com funciona

for i in Invoices do … end recorre tots els registres Invoice.
array(t, i.'Invoice Items') concatena el valor actual de t amb la taula d'elements d'aquesta factura.
- A la primera iteració s'hi afegeixen els elements de la primera factura.
- A la segona iteració s'hi afegeixen els de la segona factura, i així successivament.
Quan acaba el bucle, t conté tots els elements de totes les factures en una sola taula plana.

Ara ja podeu fer operacions com ara count(t) per saber el nombre total d'elements, o recórrer i filtrar t directament.