JavaScript

//lancio di un errore

function myFunction() {

console.log('ciao');

throw new Error('an error has occured'); // se metto l'errore dopo

di console.log("ciao"), allora la riga precedente verrà eseguita

}

try {

myFunction();

} catch (e) {

console.log(e);

}

//oggetto : assegno chiave-valore, analogo di una struttura in #C

obj = {

nome: 'aspirapolvere',

tipo: 'elettronico',

marca: {

nome: 'samsung',

anno: 2000,

},

};

console.log(obj.nome);

// dichiarazione di una funzione

function fun(x) {

return x + 1;

}

console.log(fun(4));

// dichiarazione di variabile

let a; // variabile mutabile

const b = 0; // costante, non può essere riassegnata

// dichiarazione di array

const fruits = ['pere', 'banana', 'mela'];

// come iterare / stampare i frutti di fruits ?

for (const fruit in fruits) {

//itero la posizione

console.log(fruit);

}

for (const fruit of fruits) {

//stampo i frutti

console.log(fruit);

}

// funzioni vengono dichiarate all'interno di altre funzioni,

programmazione funzionale

fruits.forEach(function (fruit) {

//fruit =>

console.log(fruit);

});

// dichiarazione funzioni

function fun1(x){

return x + 1

}

const fun2 = x => {

return x + 1

}

// funzione che ritorna solo un istruzione, forma più contratta

const fun3 = (x) => x + 1

// iterare sull'array in maniera più efficace

const numbrs = [0,1,2,3,4];

numbrs.forEach( n => { // accetta un altra funzione come argomento

console.log(n);

})

// metodo alternativo poco efficace

function iter(n){

console.log(n);

}

numbrs.forEach(iter); // noi non chiamiamo la funzione iter(), noi

vogliamo passare la funzione iter come argomento

// ulteriore metodo

const iter2 = (n) => {

console.log(n);

}

// map, filter, reduce accettano come primo argomento una funzione, che

definisce che cosa andrà a fare per ogni loop

//MAP : a partire di un array il map crea un array equivalente alla

quale applica una funzione di trasformazione per ogni elemento

const numbers = [1,2,3,4,5]

const result1 = numbers.map( number => { // .map è una funzione di

trasformazione che agisce sull'array numbers

return number + 1

})

// uguale a scrivere :

const result2 = numbers.map( function(n) {

return number + 1

})

console.log(result1)

// inoltre se la funzione è una sola riga posso omettere le parentesi

const result3 = numbers.map( n => n*2)

// metodo alternativo al map poco efficace

const doubleNumbers = [];

for(const number of numbers){

doubleNumbers.push(numbers * 2);

}

// ---------------------------------------

let j = 0

for(const Number of Numbers){

double[j] = Numbers[Number] * 2

j++

}

// CLONO NUMBERS

const numbers2 = numbers.map( number => {

return number

})

console.log(numbers2)

// map non deve perforza ritornare il tipo di elemento che gli passa,

ad esempio se lavora su un array di numeri può anche ritornare un array

di oggetti

// esempio : input : Numberi --> outpus : Stringhe

const frutta = numbers.map( n => {

if(n === 0) return "apple";

else if(n === 1) return "ananas";

else return "orange";

})

console.log(fruitta)

// concetto di immutabilita', se vogliamo modificare un'array non

andiamo mai a toccare i suoi elementi, ma ne usiamo una copia che

modifichiamo

// ad esempio .push muterebbe l'array numbers : numbers.push

// la funzione filter : vuole che il risultato di ritorno della

callback sia o True (tenere l'elemento) o False (scartare l'elemento)

const numbersAbove2 = numbers.filter( n =>{ // mi va a togliere degli

elementi

if(n > 2){

return true // oppure 1 -- è un valore truety

}else{

return false // oppure false -- è un valore falsy

}

})

console.log(numbersAbove2);

// come potrei semplificarla ???

const numbersabove2 = numbers.filter( n =>{ // mi va a togliere degli

elementi

return n > 2;

})

// ulteriore semplificazione

const numberabove2 = numbers.filter( n => n > 2)

//

---------------------------------------------------------------------

const num = [1,2,3,4,5]

const num1 = [...num, 7, 8, 9] // aggiungo num+ 7+ 8+ 9

console.log(num1)

const person = {

name : "Marco"

}

const person2 = {

...person,

surname : "Bravo",

age : 18,

email : "marco.bravo@gmail.com"

}

// DESTRUTTURAZIONE

const nome = person.name

// array di utenti

const users = [

{id: 200, username: "marco_433"},

{id: 201, username: "elisa_012"},

{id: 202, username: "federico_987"},

]

// funzione per trovare user : federico, sapendo il suo id

const idFederico = 202;

const findFedericoUsernameById = () => {

const res = users.find(user =>{

return user.id === idFederico;

} )

/*

const res = users.find(user =>{

const isFederico = user.id === idFederico;

return isFederico;

} )

*/

console.log(res)

}

// ci trova l'elemento dell'array che ci interessava

//findIndex mi ritorna l'indice dell'array nella posizione in cui si

trova, se non me lo trova ritorna -1 (no undefined)

const findFedericoPosition = () => {

const res = users.findIndex(user =>{

return user.id === idFederico;

} )

}

// funzioni interessanti : .every() , .includes() , .reduce() , .sort()

// gli array vengono visti come oggetti

// operatore ternario

const flag = true; // è il test

const f1 = ()=>{};

const f2 = ()=>{};

flag ? f1() : f2();

// se non ho l'else

flag && f1();

//metodo classico poco efficace

if(flag)

f1()

else f2()

//

TYPESCRIPT

let n : number = 3;

let n1 = 3; //inferenza : capire il tipo di variabile dal contesto, il

primo valore che assegno diventa il suo tipo

let s : string = "marco";

let f : boolean;

let fruits: string[] = ["a", "b"];

let fruits1: [string] = ["b"]; // array con un solo elemento e

quell'elemento è una stringa

let array: [string, boolean] = ["b", false];

console.log(fruits);

//---------------------------------------------------------------

const user : {

name : string,

surname : string,

age : number,

}={ name : "elisa",

surname : "meggiolaro",

age : 20,

}

//posso dichiarare fuori i tipi - Alias e usarlo nel codice

type User2 ={

name : string,

surname : string,

age : number,

}

const user2 : User2 = {

name : "elisa",