TypeScript - Funzioni: Una Guida per Principianti

Ciao, aspiranti programmatori! Oggi ci imbarcheremo in un viaggio emozionante nel mondo delle funzioni di TypeScript. Non preoccuparti se non hai mai scritto una riga di codice prima – sarò la tua guida amichevole, e affronteremo tutto passo per passo. Alla fine di questo tutorial, resterai sorpreso di quello che puoi fare con le funzioni in TypeScript!

Cos'è una Funzione?

Prima di addentrarci nei dettagli, capiremo cos'è una funzione. Immagina una funzione come una ricetta riutilizzabile. Proprio come segui una ricetta per cuocere un dolce, una funzione è un insieme di istruzioni che esegue un compito specifico nel tuo programma.

Ecco una semplice funzione in TypeScript:

function greet(name: string): string {
return `Ciao, ${name}!`;
}

console.log(greet("Alice")); // Output: Ciao, Alice!

In questo esempio, greet è la nostra funzione. Accetta un name come input e restituisce un messaggio di saluto. La : string dopo il parametro e dopo le parentesi indica che la funzione accetta una stringa come input e restituisce una stringa.

Parametri Opzionali

A volte, potresti voler rendere un parametro opzionale. In TypeScript, puoi fare questo aggiungendo un ? dopo il nome del parametro.

function introduce(name: string, age?: number): string {
if (age) {
return `Ciao, sono ${name} e ho ${age} anni.`;
} else {
return `Ciao, sono ${name}.`;
}
}

console.log(introduce("Bob")); // Output: Ciao, sono Bob.
console.log(introduce("Charlie", 30)); // Output: Ciao, sono Charlie e ho 30 anni.

In questa funzione, age è opzionale. Se è fornito, lo includiamo nella presentazione; altrimenti, lo saltiamo.

Parametri Rest

I parametri rest ti permettono di lavorare con più parametri come un array. È come dire, "Non so quanti ingredienti mi darai, ma li userò tutti nella mia ricetta!"

function makeShake(...fruits: string[]): string {
return `Ho fatto un frullato con ${fruits.join(", ")}.`;
}

console.log(makeShake("banana")); // Output: Ho fatto un frullato con banana.
console.log(makeShake("fragola", "mango", "kiwi")); // Output: Ho fatto un frullato con fragola, mango, kiwi.

La sintassi ...fruits dice a TypeScript di prendere tutti gli argomenti forniti e metterli in un array chiamato fruits.

Parametri Predefiniti

I parametri predefiniti sono come avere un piano di riserva. Se qualcuno non fornisce un valore, useremo uno predefinito.

function orderCoffee(size: string = "medio", type: string = "latte"): string {
return `Hai ordinato un ${size} ${type}.`;
}

console.log(orderCoffee()); // Output: Hai ordinato un medio latte.
console.log(orderCoffee("grande")); // Output: Hai ordinato un grande latte.
console.log(orderCoffee("piccolo", "espresso")); // Output: Hai ordinato un piccolo espresso.

Se non specifici una dimensione o un tipo, il valore predefinito è un latte medio. Quanto è comodo!

Funzioni Anonime

Le funzioni anonime sono come gli agenti segreti – non hanno un nome! Vengono spesso utilizzate quando hai bisogno di una funzione rapida che userai solo una volta.

let greet = function(name: string): string {
return `Ciao, ${name}!`;
};

console.log(greet("David")); // Output: Ciao, David!

Qui, abbiamo assegnato una funzione anonima alla variabile greet. Possiamo poi usare greet proprio come una funzione regolare.

Costruttore di Funzioni

Il costruttore di funzioni è un modo per creare funzioni dinamicamente. È come costruire un robot che può eseguire compiti basati sulle istruzioni che gli dai.

let multiply = new Function('a', 'b', 'return a * b');

console.log(multiply(4, 5)); // Output: 20

In questo esempio, stiamo creando una funzione che moltiplica due numeri. L'ultimo argomento è sempre il corpo della funzione, e il resto sono i nomi dei parametri.

Ricorsione e Funzioni TypeScript

La ricorsione è quando una funzione chiama se stessa. È come le bambole russe – ogni bambole contiene una versione più piccola di se stessa.

function countdown(n: number): void {
if (n <= 0) {
console.log("Decollo!");
} else {
console.log(n);
countdown(n - 1);
}
}

countdown(3);
// Output:
// 3
// 2
// 1
// Decollo!

Questa funzione conta down da un numero dato a zero. Chiama se stessa con un numero più piccolo fino a raggiungere zero.

Funzioni Lambda

Le funzioni lambda, anche dette arrow functions, sono un modo sintetico per scrivere funzioni. Sono come le abbreviazioni di testo per le funzioni!

let add = (a: number, b: number): number => a + b;

console.log(add(3, 4)); // Output: 7

Questa sintassi compatta è particolarmente utile per funzioni brevi e semplici.

Variazioni Sintattiche

TypeScript offre vari modi per definire funzioni. Ecco una tabella che riassume le diverse sintassi:

Sintassi	Esempio
Dichiarazione di Funzione	function greet(name: string): string { returnCiao, ${name}!; }
Espressione di Funzione	let greet = function(name: string): string { returnCiao, ${name}!; };
Funzione Arrow	let greet = (name: string): string =>Ciao, ${name}!;
Metodo in Oggetto	let obj = { greet(name: string): string { returnCiao, ${name}!; } };
Funzione Asincrona	async function fetchData(): Promise<void> { /* ... */ }

Sovraccarico di Funzioni

Il sovraccarico di funzioni ti permette di definire più firme di funzione per la stessa funzione. È come avere più ricette per lo stesso piatto, a seconda degli ingredienti che hai.

function makeNoise(animal: "cat"): string;
function makeNoise(animal: "dog"): string;
function makeNoise(animal: string): string {
switch(animal) {
case "cat":
return "Miao";
case "dog":
return "Bau";
default:
return "Animale sconosciuto";
}
}

console.log(makeNoise("cat")); // Output: Miao
console.log(makeNoise("dog")); // Output: Bau

Questa funzione può gestire diversi tipi di animali e fare il rumore appropriato.

Eccoci! Abbiamo coperto molto terreno oggi, dai concetti di base delle funzioni ai concetti più avanzati come la ricorsione e il sovraccarico di funzioni. Ricorda, imparare a codificare è come imparare una nuova lingua – richiede pratica e pazienza. Non aver paura di sperimentare con questi concetti e creare le tue funzioni. Prima di sapere, sarai in grado di scrivere programmi complessi con facilità. Buon coding, e alla prossima lezione!

Credits: Image by storyset