Gli array in Ninox

Array semplici

Manipolare array di testo o di numeri è immediato:

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

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

myArray order this;

L'ordinamento si può ottenere anche con order, sort e unsort per gli array di testo o di numeri.
Per altre funzioni legate agli array, consultate la documentazione Ninox.

Array bidimensionali

Ninox non supporta direttamente gli array bidimensionali. Al loro posto si usa un array di oggetti JSON.
Per esempio, per ordinare l'array in base al secondo elemento del campo d2:

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

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

Questo codice restituisce : [{"d2":["b","B"]},{"d2":["c","C"]},{"d2":["d","D"]},{"d2":["a","Z"]}]

Filtrare gli array

Potete filtrare gli array come fareste con il risultato di un select. Per gli array di testo o di numeri, usate this per riferirvi al valore filtrato:

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

Per gli array JSON, usate direttamente la chiave:

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

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

Questo codice restituisce un array di JSON : [{"prénom":"Fred","nom":"Baillot"}, {"prénom":"Jan","nom":"Augustin"}]

Operazioni personalizzate sugli array JSON

Per gli array JSON potete inserire un blocco di codice (tra parentesi) che esegue operazioni personalizzate a ogni iterazione. Come per for in, il tipo dell'array risultante corrisponde all'ultima riga di codice del blocco.

Esempio: calcolare la lunghezza dei nomi completi (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;

Questo codice restituisce un array di numeri [10, 11] che rappresentano le lunghezze dei nomi completi.

Inizializzare un array vuoto tipizzato

In Ninox, il trucco abituale per creare un array vuoto che conservi comunque il tipo di record corretto consiste nell'eseguire un select filtrato con where false.
La query non restituisce alcun record, ma preserva il tipo degli elementi dell'array.

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

t è ora un array i cui elementi sono di tipo Invoice Item.
Essendo vuoto ma tipizzato, può essere riutilizzato senza rischi come punto di partenza per operazioni con array().

Perché non usare semplicemente []?

Il letterale [] è un array non tipizzato. Spesso funziona, ma se combinato con array() su insiemi di record, Ninox può segnalare incoerenze di tipo.
Lo schema select … where false evita del tutto il problema.

Creare un array vuoto per i tipi primitivi (numero, testo, JSON…)

Quando serve un array vuoto per valori scalari – numeri, stringhe di testo od oggetti JSON – non c'è una tabella sottostante su cui fare select.
Potete comunque ottenere un array vuoto tipizzato inizializzando [] con un elemento fittizio ed escludendolo subito con un filtro:

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

[1] produce un array numerico di un solo elemento; il filtro [false] rimuove quell'elemento, lasciando un array vuoto che conserva il tipo numero.
Usate un letterale di testo o JSON al posto di 1 se vi servono quei tipi specifici.

Appiattire un array bidimensionale

Ogni Invoice contiene il proprio sotto-array Invoice Items. Per ottenere un unico elenco con tutte le voci di tutte le fatture, scorrete le fatture e concatenate i loro sotto-array.

"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

Come funziona

for i in Invoices do … end scorre ogni record Invoice.
array(t, i.'Invoice Items') concatena il valore corrente di t con l'array delle voci contenute in quella fattura.
- Alla prima iterazione vengono aggiunte le voci della prima fattura.
- Alla seconda iterazione vengono aggiunte le voci della seconda fattura, e così via.
Al termine del ciclo, t contiene tutte le voci di tutte le fatture in un unico array piatto.

Potete ora eseguire operazioni come count(t) per conoscere il numero totale di voci, oppure scorrere e filtrare direttamente t.