6. Array

In MALDA gli array sono collezioni dinamiche, indicizzate da zero, che possono contenere valori di qualsiasi tipo.

6.1 Dichiarazione di array

Gli array si creano con parentesi quadre e valori separati da virgola:

var arr = [1, 2, 3, 4, 5];
var names = ["Alice", "Bob", "Charlie"];
var empty = [];
var mixed = [1, "two", 3.0, true];  // Arrays can hold mixed types

6.2 Accesso agli array

Gli elementi si accedono con indicizzazione a base zero:

var arr = [10, 20, 30];
var first = arr[0];   // first = 10
var second = arr[1];  // second = 20
arr[2] = 40;          // Modify element
var length = arr.length;  // Built-in property returns array length

6.3 Operazioni sugli array

Ridimensionamento dinamico

Gli array possono crescere e ridursi in modo dinamico:

var arr = [1, 2, 3];
arr[3] = 4;  // Array automatically grows
// arr is now [1, 2, 3, 4]

Array multidimensionali

MALDA supporta array multidimensionali (array di array):

var matrix = [[1, 2], [3, 4]];
var value = matrix[0][1];  // value = 2
matrix[1][0] = 5;          // matrix is now [[1, 2], [5, 4]]

6.4 Metodi degli array

Gli array sono oggetti con metodi built-in:

append(item)

Aggiunge un elemento in fondo all'array e restituisce l'array:

var arr = [1, 2];
arr.append(3);  // arr is now [1, 2, 3]

pop()

Rimuove e restituisce l'ultimo elemento:

var arr = [1, 2, 3];
var last = arr.pop();  // last = 3, arr is now [1, 2]

popOrNull()

Rimuove e restituisce l'ultimo elemento, oppure null se l'array è vuoto:

var arr = [];
var value = arr.popOrNull();  // null

shift()

Rimuove e restituisce il primo elemento:

var arr = [1, 2, 3];
var first = arr.shift();  // first = 1, arr is now [2, 3]

shiftOrNull()

Rimuove e restituisce il primo elemento, oppure null se l'array è vuoto:

var arr = [];
var value = arr.shiftOrNull();  // null

concat(otherArray)

Restituisce un nuovo array con gli elementi di entrambi gli array:

var a = [1, 2];
var b = [3, 4];
var c = a.concat(b);  // c is [1, 2, 3, 4], a and b unchanged

map(fn)

Restituisce un nuovo array in cui ogni elemento è trasformato dalla funzione:

var doubled = [1, 2, 3].map(x => x * 2);  // [2, 4, 6]
var squared = [1, 2, 3].map(x => x * x);  // [1, 4, 9]

filter(fn)

Restituisce un nuovo array che contiene solo gli elementi che soddisfano il predicato:

var evens = [1, 2, 3, 4].filter(x => x % 2 == 0);  // [2, 4]
var positives = [-1, 2, -3, 4].filter(x => x > 0);  // [2, 4]

reduce(fn, initialValue?)

Riduce l'array a un singolo valore applicando la funzione a ogni elemento:

var sum = [1, 2, 3].reduce((acc, x) => acc + x, 0);  // 6
var product = [2, 3, 4].reduce((acc, x) => acc * x, 1);  // 24
var max = [3, 1, 4, 2].reduce((acc, x) => x > acc ? x : acc);  // 4

forEach(fn)

Itera su ogni elemento e chiama la funzione (per gli effetti collaterali):

[1, 2, 3].forEach(x => print(x));  // Prints 1, 2, 3

find(fn)

Restituisce il primo elemento che soddisfa il predicato, oppure null se non ne trova nessuno:

var found = [1, 2, 3].find(x => x > 1);  // 2
var notFound = [1, 2, 3].find(x => x > 10);  // null

findIndex(fn)

Restituisce l'indice del primo elemento che soddisfa il predicato, oppure -1 se non ne trova nessuno:

var idx = [1, 2, 3].findIndex(x => x > 1);  // 1
var notFound = [1, 2, 3].findIndex(x => x > 10);  // -1

some(fn)

Restituisce true se almeno un elemento soddisfa il predicato:

var hasEven = [1, 2, 3].some(x => x % 2 == 0);  // true
var allOdd = [1, 3, 5].some(x => x % 2 == 0);  // false

every(fn)

Restituisce true se tutti gli elementi soddisfano il predicato:

var allPositive = [1, 2, 3].every(x => x > 0);  // true
var allEven = [1, 2, 3].every(x => x % 2 == 0);  // false

sort(comparator?)

Ordina l'array in place. Con una funzione comparator, ordina in base al risultato del confronto (negativo se a < b, 0 se uguali, positivo se a > b). Senza comparator, usa il confronto di default:

var arr = [3, 1, 2];
arr.sort((a, b) => a - b);  // arr is now [1, 2, 3]
var names = ["Charlie", "Alice", "Bob"];
names.sort();  // Default string comparison: ["Alice", "Bob", "Charlie"]

reverse()

Inverte l'array in place e restituisce l'array:

var arr = [1, 2, 3];
arr.reverse();  // arr is now [3, 2, 1]

slice(start, end?)

Restituisce un nuovo array con gli elementi dall'indice start (incluso) all'indice end (escluso). Se end è omesso, include tutti gli elementi fino alla fine. Gli indici negativi contano dalla fine:

var arr = [1, 2, 3, 4, 5];
var sub = arr.slice(1, 3);  // [2, 3]
var rest = arr.slice(2);  // [3, 4, 5]
var lastTwo = arr.slice(-2);  // [4, 5]

get(index, fallback?)

Restituisce l'elemento all'indice index, oppure il fallback opzionale se è fuori dai limiti. Gli indici negativi contano dalla fine:

var arr = [10, 20, 30];
print(arr.get(1));          // 20
print(arr.get(-1));         // 30
print(arr.get(10, "n/a"));  // n/a

at(index)

Restituisce l'elemento all'indice index, oppure null se è fuori dai limiti. Gli indici negativi contano dalla fine:

var arr = [10, 20, 30];
print(arr.at(0));   // 10
print(arr.at(-1));  // 30
print(arr.at(9));   // null

indexOf(value)

Restituisce l'indice della prima occorrenza di value, oppure -1 se non lo trova:

var idx = [1, 2, 3].indexOf(2);  // 1
var notFound = [1, 2, 3].indexOf(5);  // -1

includes(value)

Restituisce true se l'array contiene value:

var hasTwo = [1, 2, 3].includes(2);  // true
var hasFive = [1, 2, 3].includes(5);  // false

join(separator?)

Unisce gli elementi dell'array in una stringa con il separatore indicato (default: ","):

var arr = ["a", "b", "c"];
var str = arr.join();  // "a,b,c"
var str2 = arr.join("-");  // "a-b-c"

6.5 Aggregazione di array numerici

Per gli array numerici, MALDA offre anche helper built-in di aggregazione:

var scores = [10, 20, 30];
var total = sum(scores);       // 60
var avg = average(scores);     // 20.0
var smallest = min(scores);    // 10
var largest = max(scores);     // 30

var total2 = scores.sum();     // 60
var avg2 = scores.average();   // 20.0
var smallest2 = scores.min();  // 10
var largest2 = scores.max();   // 30

sum(array) restituisce il totale di un array numerico. average(array) restituisce la media aritmetica di un array numerico non vuoto, come float. min(array) e max(array) restituiscono l'elemento numerico più piccolo e più grande di un array numerico non vuoto.

Le stesse operazioni sono disponibili anche come metodi di array: array.sum(), array.average(), array.min() e array.max().

Le forme scalari min(a, b) e max(a, b) restano disponibili per confrontare due valori numerici.

6.6 Lunghezza degli array

La proprietà length restituisce il numero di elementi dell'array:

var arr = [1, 2, 3, 4, 5];
print(arr.length);  // Prints 5