37 Array 2
Potrebbe risultare scomodo dover ricordare quanti elementi sono stati inseriti in un array,
Per questo esiste già una proprietà predefinita che è il lenght che se richiamata restituisce il numero di elementi inseriti
arr2[arr2.length] = "hello"; //sempre in fondo writeln(arr2, true);
arr2.lenght restituisce nel nostro caso il numero 3, quindi l’elemento viene aggiunto sempre in fondo.
arr2[3] = "hello";
Se mettiamo un numero di indice superiore a quello reale, i posti mancanti vengono riempiti dal valore undefined e l’elemento viene aggiunto nell’ indice specificato
arr2[20] = "hello"; writeln(arr2, true);
alla posizione 20 sarà aggiunta la stringa hello, mentre i posti intermedi tra quelli pieni e il ventesimo saranno occupati (dal 4 al 19).
Possiamo anche usare il lenght per estendere il valore degli elementi dal 21 fino al quarantesimo i valori saranno riempiti
arr2.length = 40; writeln(arr2, true);
Si può anche accorciare, eliminando però gli elementi in eccesso
arr2.length = 10; writeln(arr2, true);
Similmente al pop che toglie l’ultimo elemento, possiamo togliere il primo tramite shift che oltre a togliere il primo elemento lo restituisce anche, cosicché possiamo memorizzarlo per es in una variabile
let primo = arr2.shift(); writeln(arr2, true); writeln(primo);
Simile nella logica, ma con maggiore flessibilità è il comando splice() che permette di estrarre un intervallo di elementi.
splice restituisce un array comprendente gli elementi tolti e vuole come parametro un indice di partenza e come secondo quanti elementi togliere:
let eliminati = arr2.splice(1,3); writeln(arr2, true); writeln(eliminati);
splice(1,3) parti dall’elemento 1 compreso e toglimi tutti i successivi elementi fino all’elemto 3.
Se omettiamo il secondo parametro elimina tutti gli elementi a partire dalla posizione 1 in avanti
arr2.splice(1); elimina tutti gli elementi a partire dalla posizione 1
Possiamo anche specificare dopo i parametri, anche l’inserimento di nuovi a partire dalla posizione di quelli eliminati
eliminati.splice(1,1,"aggiunto1", "aggiunto2"); writeln(eliminati);
togli l’elemento 1 e aggiungimi aggiunto1 e aggiunto2.
Una funzione fondamentale quando si ha a che fare con un elenco di dati è la ricerca tra questi. Si presenta utile in questo senso il comando indexOf che restituisce la posizione dell’elemento e vuole come parametro l’elemento da ricercare:
let posTrovato = eliminati.indexOf("aggiunto22");
if ( posTrovato>-1 )
{ eliminati.splice(posTrovato, 1);}
else
{writeln("elemento non trovato");}
writeln(eliminati);
In questo caso aggiunto22 non sarà trovato quindi posTrovato restituirà la posizione -1, di conseguenza non partirà l’if, ma solo l’else che restituirà elemento non trovato. Sostituendo aggiunto22 con aggiunto2, quest’ultimo elemento verrà eliminato dall’array.
Vediamo un nuovo esempio di script:
let casuali = [];
for(let i=0; i<30; i++)
{ casuali.push( Math.floor( Math.random()*100) ) ;}
Creo un array vuoto, parte un ciclo con 30 interazioni, random mi crea 1 numero casuale tra 0 e 1, lo moltiplico per 100, arrotondo ad interi con floor e su ogni numero applico il metodo push che mi aggiunge il valore all’array casuali.
L’ array casuali ci serve solo per mostrare l’utilizzo di un nuovo metodo il map, che applica una funzione, indicata come parametro del metodo stesso, su ciascuno degli elementi dell’array
let resti = casuali.map( (elemento) => { elemento%7 } );
writeln(casuali);
writeln(resti);
map restituisce un array che contiene tutti i valori elaborati (che noi memorizziamo nell’array resti ) che grazie alla funzione elemento verranno generati dal resto della divisione per 7.
Un nuovo concetto da osservare sono le funzioni freccia ((elemento) => { elemento%7 }) che oltre ad eliminare il la keyword function e il nome da dare alla funzione, possono eliminare anche le graffe.
( (elemento) => elemento%7 );
rendendo il codice maggiormente più snello, oppure come in questo caso, trattandosi di un solo elemento è possibile eliminare anche le tonde, ottenendo una forma di codice davvero snella
( elemento => elemento%7 );
Come si vede le funzioni freccia iniziano direttamente coi parametri (o col parametro) seguita da => e l’espressione che deve essere restituita (elemento%7) senza dover utilizzare il return.
Una sintassi davvero veloce e comoda che permette di snellire il codice.
La funzione potrebbe aver bisogno di più parametri, a quel punto reintroduciamo le tonde:
( (elemento,indice, a) => elemento%7);
oltre al parametro elemento, posso aggiungere l’indice e per esempio l’array stesso.
Ecco il codice completo del resto della divisione per 7 di 30 numeri casuali:
let casuali = [];
for(let i=0; i<30; i++)
{ casuali.push( Math.floor( Math.random()*100) ) ;}
let resti = casuali.map( (elemento,indice, a) => elemento%7 );
writeln(casuali);
writeln(resti);