Italiano (Italian)

TypeScript - Sintassi di Base

Ciao there, futuri maghi di TypeScript! ? Sono entusiasta di essere il tuo guida in questo emozionante viaggio nel mondo di TypeScript. Come qualcuno che ha insegnato programmazione per anni, posso dirti che TypeScript è come una versione potenziata di JavaScript, e renderà la tua vita di programmazione molto più facile. Immersione!

TypeScript - Basic Syntax

Il Tuo Primo Codice TypeScript

Bene, immagina di essere pronto a scrivere la tua prima riga in una nuova lingua. Emozionante, vero? Iniziamo con il classico programma "Ciao, Mondo!" in TypeScript.

console.log("Ciao, Mondo!");

Ora, potresti essere pensando, "Aspetta un momento, questo sembra proprio come JavaScript!" E avresti ragione! TypeScript è un superinsieme di JavaScript, il che significa che tutto il codice JavaScript è anche valido in TypeScript. Ma non preoccuparti, presto vedremo le caratteristiche specifiche di TypeScript.

Proviamo qualcosa di più tipico di TypeScript:

let messaggio: string = "Ciao, TypeScript!";
console.log(messaggio);

Ecco cosa sta succedendo:

Stiamo dichiarando una variabile chiamata messaggio
La parte : string dice a TypeScript che questa variabile dovrebbe contenere solo valori di tipo stringa
Assegniamo la stringa "Ciao, TypeScript!" a questa variabile
Infine, la stampiamo sulla console

Questo è solo un assaggio del sistema di tipizzazione di TypeScript, una delle sue caratteristiche più potenti. È come avere un assistente robot amichevole che cattura i tuoi errori prima che tu esegua il codice!

Compilare ed Eseguire un Programma TypeScript

Ora che abbiamo scritto del codice TypeScript, come lo eseguiamo davvero? Beh, i browser e Node.js non capiscono direttamente TypeScript, quindi dobbiamo prima compilerlo in JavaScript. È come tradurre da TypeScript a un linguaggio che i computer già conoscono.

Ecco come farlo:

Salva il tuo codice TypeScript in un file con estensione .ts, ad esempio hello.ts
Apri il terminale o la riga di comando
Naviga alla directory che contiene il tuo file
Esegui il compilatore TypeScript:

tsc hello.ts

Questo creerà un nuovo file chiamato hello.js nella stessa directory. È il tuo codice TypeScript tradotto in JavaScript!

Per eseguirlo, puoi usare Node.js:

node hello.js

E voilà! Dovresti vedere il tuo messaggio stampato sulla console.

Flag del Compilatore

Il compilatore TypeScript è piuttosto intelligente, ma a volte vuoi dargli istruzioni specifiche. È qui che entrano in gioco le flag del compilatore. Sono come comandi speciali che puoi dare al compilatore per modificare il suo comportamento.

Ecco una tabella di alcune flag del compilatore comuni:

Flag	Descrizione
--outDir	Specifica una cartella di output per tutti i file generati
--target	Specifica la versione di ECMAScript di destinazione
--watch	Vigila sui file di input
--strict	Abilita tutte le opzioni di controllo di tipo rigoroso

Ad esempio, se vuoi compilare il tuo TypeScript in una versione più vecchia di JavaScript per motivi di compatibilità, potresti usare:

tsc --target ES5 hello.ts

Questo dice al compilatore di generare JavaScript compatibile con ECMAScript 5, supportato dai browser più vecchi.

Identificatori in TypeScript

Nella programmazione, usiamo identificatori per nominare cose come variabili, funzioni e classi. Pensa a loro come etichette per le diverse parti del tuo codice. In TypeScript, ci sono alcune regole per questi nomi:

Possono contenere lettere, numeri, underscore e dollari
Devono iniziare con una lettera, underscore o dollaro
Sono sensibili alla maiuscola e minuscola (quindi myVariable e MyVariable sono diverse)
Non possono essere parole riservate (ne parleremo dopo!)

Ecco alcuni identificatori validi:

let nome: string = "John";
let _conteggio: number = 5;
let $prezzo: number = 9.99;
let camelCaseIsCommon: boolean = true;

E alcuni invalidi:

let 123abc: string = "Invalid"; // Non può iniziare con un numero
let my-variable: number = 10; // Non può usare trattini
let class: string = "Parola riservata"; // Non può usare parole riservate

TypeScript ─ Parole Chiave

Le parole chiave sono parole che hanno un significato specifico in TypeScript. Sono come il vocabolario del linguaggio. Non puoi usarle come identificatori perché TypeScript ha già assegnato loro un lavoro da fare.

Ecco una tabella di alcune parole chiave comuni:

Parola Chiave	Descrizione
let	Dichiarare una variabile a scoping di blocco
const	Dichiarare una costante a scoping di blocco
if	Inizia una dichiarazione if
for	Inizia un ciclo for
function	Dichiarare una funzione
class	Dichiarare una classe
interface	Dichiarare un'interfaccia
type	Dichiarare un alias di tipo

Ad esempio:

let x: number = 5;
const PI: number = 3.14159;

if (x > 0) {
console.log("x è positivo");
}

for (let i = 0; i < 5; i++) {
console.log(i);
}

function saluta(nome: string): void {
console.log(`Ciao, ${nome}!`);
}

class Persona {
nome: string;
constructor(nome: string) {
this.nome = nome;
}
}

interface Forma {
area(): number;
}

type Punto = {
x: number;
y: number;
};

Ogni una di queste parole chiave ha uno scopo specifico nella strutturazione e definizione del tuo codice.

Commenti in TypeScript

I commenti sono come piccole note che lasci per te stesso (o altri sviluppatori) nel tuo codice. Sono ignorati dal compilatore, quindi puoi usarli per spiegare cosa fa il tuo codice senza influenzare il suo funzionamento.

TypeScript supporta tre tipi di commenti:

Commenti a riga singola:

// Questo è un commento a riga singola
let x: number = 5; // Puoi anche metterli alla fine di una riga

Commenti a più righe:

/* Questo è un commento a più righe
Può coprire più linee
Útil per spiegazioni più lunghe */
let y: number = 10;

Commenti di documentazione:
```
/**
```

Questo è un commento di documentazione
È spesso usato per generare documentazione per funzioni o classi
@param nome Il nome da salutare
@returns Un messaggio di saluto */ function saluta(nome: string): string { return Ciao, ${nome}!; }

Ricorda, buoni commenti spiegano perché stai facendo qualcosa, non solo cosa stai facendo. Il codice stesso dovrebbe essere chiaro abbastanza per mostrare cosa sta succedendo.

TypeScript e Programmazione Orientata agli Oggetti

Una delle grandi cose di TypeScript è il suo supporto per la programmazione orientata agli oggetti (OOP). Se sei nuovo alla programmazione, pensa all'OOP come un modo di organizzare il tuo codice attorno a "oggetti" che hanno proprietà e comportamenti.

Creiamo una semplice classe Car per dimostrare:

class Car {
// Proprietà
make: string;
model: string;
year: number;

// Costruttore
constructor(make: string, model: string, year: number) {
this.make = make;
this.model = model;
this.year = year;
}

// Metodo
describe(): string {
return `Questo è un ${this.year} ${this.make} ${this.model}.`;
}
}

// Creazione di un'istanza di Car
let miaMacchina = new Car("Toyota", "Corolla", 2022);

console.log(miaMacchina.describe()); // Output: Questo è un 2022 Toyota Corolla.

Ecco un riassunto:

Definiamo una classe Car con proprietà per make, model e year
Il constructor è un metodo speciale chiamato quando creiamo un nuovo Car
Il metodo describe restituisce una stringa che descrive l'auto
Creiamo un nuovo oggetto Car e chiamiamo il suo metodo describe

Il sistema di tipizzazione di TypeScript brilla veramente nell'OOP. Può catturare errori come assegnare una stringa alla proprietà year o chiamare un metodo inesistente.

Ecco fatto! Hai appena fatto i tuoi primi passi nel mondo di TypeScript. Ricorda, imparare a programmare è un viaggio, non una destinazione. Non preoccuparti se tutto non diventa chiaro subito - continua a praticare, esperimentare e, soprattutto, divertiti! Prima di sapere, sarai scrivendo applicazioni TypeScript complesse e chiedendoti come hai mai vissuto senza la tipizzazione statica. Buon divertimento con il coding! ?

Credits: Image by storyset

Tutorial precedente:

TypeScript - Configurazione dell'ambiente

Prossimo tutorial:

TypeScript vs. JavaScript