Arrays en Ninox

Arrays simples

Manipular arrays de texto o de números es sencillo:

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

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

myArray order this;

La ordenación también se puede hacer con order, sort y unsort en arrays de texto o de números.
Para más funciones relacionadas con los arrays, consulte la documentación de Ninox.

Arrays bidimensionales

Ninox no admite directamente los arrays bidimensionales. En su lugar, use un array de objetos JSON.
Por ejemplo, para ordenar el array por el segundo elemento del campo d2:

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

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

Este código devuelve: [{"d2":["b","B"]},{"d2":["c","C"]},{"d2":["d","D"]},{"d2":["a","Z"]}]

Filtrar arrays

Puede filtrar arrays igual que el resultado de un select. En los arrays de texto o de números, use this para referirse al valor que se filtra:

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

En los arrays JSON, use directamente la clave:

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

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

Este código devuelve un array de JSON: [{"prénom":"Fred","nom":"Baillot"}, {"prénom":"Jan","nom":"Augustin"}]

Operaciones personalizadas sobre arrays JSON

En los arrays JSON puede incluir un bloque de código (entre paréntesis) para ejecutar operaciones personalizadas en cada iteración. Igual que en for in, el tipo del array resultante es el de la última línea de código del bloque.

Ejemplo: calcular la longitud de los nombres completos (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;

Este código devuelve un array de números [10, 11] con las longitudes de los nombres completos.

Inicializar un array vacío con tipo

En Ninox, el truco habitual para crear un array vacío que conserve el tipo de registro correcto consiste en ejecutar un select filtrado con where false.
La consulta no devuelve ningún registro, pero conserva el tipo de los elementos del array.

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

t es ahora un array cuyos elementos son del tipo Invoice Item.
Como está vacío pero tipado, se puede reutilizar sin riesgo como punto de partida de operaciones array().

¿Por qué no usar simplemente []?

El literal [] es un array sin tipo. A menudo funciona, pero al combinarlo con array() sobre colecciones de registros, Ninox puede quejarse de incoherencias de tipo.
El patrón select … where false evita por completo ese problema.

Crear un array vacío para tipos primitivos (número, texto, JSON…)

Cuando necesita un array vacío de valores escalares —números, cadenas de texto u objetos JSON— no hay ninguna tabla subyacente sobre la que hacer un select.
Aun así puede obtener un array vacío con tipo sembrando [] con un elemento ficticio y filtrándolo de inmediato:

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

[1] produce un array numérico de un solo elemento; el filtro [false] elimina ese elemento y deja un array vacío que conserva el tipo number.
Use un literal de texto o JSON en lugar de 1 si necesita esos tipos concretos.

Aplanar un array bidimensional

Cada Invoice contiene su propio subarray Invoice Items. Para obtener una sola lista con todas las líneas de todas las facturas, recorra las facturas y concatene sus subarrays.

"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

Cómo funciona

for i in Invoices do … end recorre todos los registros Invoice.
array(t, i.'Invoice Items') concatena el valor actual de t con el array de líneas de esa factura.
- En la primera vuelta se añaden las líneas de la primera factura.
- En la segunda vuelta se añaden las de la segunda factura, y así sucesivamente.
Cuando termina el bucle, t contiene todas las líneas de todas las facturas en un único array plano.

Ya puede realizar operaciones como count(t) para conocer el número total de líneas, o recorrer y filtrar t directamente.