Scrivere Compilare Ed Eseguire Il Primo Programma

Il punto di partenza è sempre una cartella di progetto aperta in VS Code. Il codice presente nell’editor diventa disponibile agli strumenti esterni quando viene salvato sul disco. Un pallino sulla scheda segnala modifiche ancora non salvate: prima di eseguire, usa File → Salva.

La sequenza cambia secondo il linguaggio. Un browser legge HTML e CSS; Node.js esegue JavaScript; Python e PHP utilizzano il proprio interprete; C e C++ richiedono la creazione di un eseguibile. Java compila in bytecode per la JVM. Il comando dotnet run coordina compilazione ed esecuzione di un progetto C#.

Schema esplicativo originale creato per il capitolo.

Torna all’indice della pagina

Per questo esempio servono due file nella stessa cartella. HTML descrive il contenuto; CSS ne determina la presentazione. Il collegamento href="stile.css" è relativo alla posizione di index.html.

<!doctype html>
<html lang="it">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Il primo file creato con VS Code</title>
  <link rel="stylesheet" href="stile.css">
</head>
<body>
  <main>
    <h1>Ciao da Visual Studio Code</h1>
    <p>Questa pagina usa due file: HTML per il contenuto e CSS per lo stile.</p>
  </main>
</body>
</html>

body {
  margin: 0;
  font-family: system-ui, sans-serif;
  background: #edf6ff;
  color: #153b60;
}
main {
  max-width: 48rem;
  margin: 3rem auto;
  padding: 2rem;
  background: white;
  border-top: 5px solid #087ec4;
  border-radius: 12px;
}

1. Salva entrambi i file.
2. Nell’Explorer del sistema operativo raggiungi la cartella del progetto.
3. Apri index.html con un browser.
4. Dopo una modifica al codice, salva e aggiorna la pagina del browser.

Non viene creato un eseguibile: il browser interpreta la pagina. Il pannello Output di VS Code non mostra il risultato visivo della pagina. Se compare il testo senza stile, controlla che stile.css sia nella stessa cartella e che il nome coincida con quello del collegamento HTML.

Per simulare un accesso HTTP locale, se Python è già installato, puoi usare un piccolo server dalla cartella HTML:

py -m http.server 8000 --bind 127.0.0.1

python3 -m http.server 8000 --bind 127.0.0.1

python3 -m http.server 8000 --bind 127.0.0.1

Apri http://127.0.0.1:8000 nel browser. Il terminale rimane occupato dal server e mostra le richieste ricevute; Ctrl+C lo arresta. Questo server serve file statici e non esegue PHP.

Torna all’indice della pagina

Qui JavaScript viene eseguito fuori dal browser, con Node.js installato nella pagina dedicata alla preparazione dell’ambiente. Non occorrono librerie aggiuntive né un progetto npm per un singolo file così semplice.

const nome = "Luca";
const prezzo = 12;
const quantita = 3;
const totale = prezzo * quantita;

console.log(`Ciao, ${nome}!`);
console.log(`Totale: ${totale} euro`);

Le variabili descrivono i dati dell’esempio; console.log scrive nel terminale. Salva app.js e, dalla sua cartella, esegui:

node app.js

Il risultato è Ciao, Luca! seguito da Totale: 36 euro. Il terminale torna al prompt quando il programma termina. Modificare il file non aggiorna automaticamente il risultato precedente: salva ed esegui nuovamente il comando.

Torna all’indice della pagina

TypeScript aggiunge annotazioni di tipo e controlli durante lo sviluppo. In questo percorso il compilatore TypeScript genera JavaScript, che viene poi eseguito con Node.js. Il servizio TypeScript incorporato nell’editor aiuta a scrivere, mentre il compilatore del progetto effettua il passaggio dichiarato nel terminale.

Apri la cartella typescript. Crea il manifesto con npm init -y, poi installa il compilatore nel progetto con npm install --save-dev typescript. Questo comando scarica un pacchetto: occorre accesso alla rete. package.json e package-lock.json descrivono la dipendenza, mentre node_modules contiene i file installati.

const nome: string = "Luca";
const prezzo: number = 12;
const quantita: number = 3;
const totale: number = prezzo * quantita;

console.log(`Ciao, ${nome}!`);
console.log(`Totale: ${totale} euro`);

Dalla stessa cartella:

npx tsc app.ts --target ES2022 --module commonjs --strict --noEmitOnError --outDir dist
node dist/app.js

Il primo comando usa il compilatore installato localmente, verifica il sorgente e genera dist/app.js. --noEmitOnError impedisce di emettere nuovi file se la compilazione segnala errori. Avvia il secondo comando solo quando il primo riesce. Node legge il JavaScript prodotto; le annotazioni : string e : number non compaiono nell’output JavaScript.

Su Windows, se la policy PowerShell impedisce di avviare gli script npm, puoi usare npm.cmd e npx.cmd con gli stessi argomenti. Dopo ogni modifica salva, ripeti la compilazione e avvia il file generato. Un output precedente può restare nella cartella anche quando una nuova compilazione fallisce.

Torna all’indice della pagina

Apri la cartella python, crea o apri main.py e seleziona Python: Select Interpreter dalla Command Palette. Se il progetto ha un ambiente virtuale, seleziona l’interprete di quell’ambiente; altrimenti quello installato sul sistema.

nome = "Luca"
prezzo = 12
quantita = 3
totale = prezzo * quantita

print(f"Ciao, {nome}!")
print(f"Totale: {totale} euro")

Schermata Microsoft, documentazione VS Code. Fonte · CC BY 3.0 US. Riprodotta senza modifiche; versione e lingua possono differire dalla tua installazione.

Puoi usare Run Python File in Terminal oppure digitare il comando direttamente:

py main.py

.\.venv\Scripts\python.exe main.py

python3 main.py

python3 main.py

Schermata Microsoft, documentazione VS Code. Fonte · CC BY 3.0 US. Riprodotta senza modifiche; versione e lingua possono differire dalla tua installazione.

L’esempio stampa le due righe già descritte per JavaScript. L’interprete selezionato dall’estensione e quello richiamato da un comando digitato a mano possono essere diversi: la selezione nell’editor non modifica automaticamente ogni comando del terminale.

Torna all’indice della pagina

Un file C non viene eseguito direttamente dal sistema operativo. Il compilatore legge main.c e produce un programma. La libreria standard consente di stampare il risultato attraverso printf.

#include <stdio.h>

int main(void) {
    const int prezzo = 12;
    const int quantita = 3;
    const int totale = prezzo * quantita;

    printf("Ciao da C!\n");
    printf("Totale: %d euro\n", totale);
    return 0;
}

gcc -std=c17 -Wall -Wextra main.c -o programma.exe
.\programma.exe

gcc -std=c17 -Wall -Wextra main.c -o programma
./programma

clang -std=c17 -Wall -Wextra main.c -o programma
./programma

L’opzione -o assegna il nome al file prodotto; -Wall e -Wextra abilitano gruppi utili di avvisi, senza coprire ogni possibile problema. Una compilazione riuscita può non stampare alcun messaggio. Il risultato appare quando avvii l’eseguibile: Ciao da C! e Totale: 36 euro.

Torna all’indice della pagina

La struttura è simile a C, ma il programma usa la libreria standard C++. È opportuno usare il comando del compilatore C++ perché coordina anche il collegamento delle relative librerie.

#include <iostream>

int main() {
    const int prezzo = 12;
    const int quantita = 3;
    const int totale = prezzo * quantita;

    std::cout << "Ciao da C++!\n";
    std::cout << "Totale: " << totale << " euro\n";
    return 0;
}

g++ -std=c++17 -Wall -Wextra main.cpp -o programma.exe
.\programma.exe

g++ -std=c++17 -Wall -Wextra main.cpp -o programma
./programma

clang++ -std=c++17 -Wall -Wextra main.cpp -o programma
./programma

Esegui il programma solo se la compilazione riesce. Quando modifichi il sorgente devi salvare, compilare e avviare nuovamente: l’eseguibile precedente non cambia semplicemente modificando main.cpp.

Torna all’indice della pagina

Questo esempio usa un JDK completo, che contiene sia javac sia java. Il nome della classe pubblica Main richiede un file chiamato esattamente Main.java.

public class Main {
    public static void main(String[] args) {
        int prezzo = 12;
        int quantita = 3;
        int totale = prezzo * quantita;

        System.out.println("Ciao da Java!");
        System.out.println("Totale: " + totale + " euro");
    }
}

Dalla cartella del file, su tutti e tre i sistemi:

javac Main.java
java Main

La prima istruzione produce Main.class. La seconda avvia la classe attraverso la JVM: si scrive Main, senza estensione .class. Il metodo main costituisce il punto d’ingresso. L’estensione Java può fornire il collegamento Run sopra il metodo e coordinare le stesse operazioni.

Se compare un errore sulla versione della classe, confronta javac -version e java -version: il compilatore potrebbe appartenere a un JDK più recente del runtime che il terminale sta utilizzando.

Torna all’indice della pagina

Per C# serve il .NET SDK, non soltanto il runtime. La procedura seguente genera il progetto con gli strumenti installati e poi utilizza il file sorgente scaricabile.

1. Apri una cartella di lavoro per C# e il relativo terminale.
2. Esegui dotnet new console -n PrimoProgramma -o PrimoProgramma.
3. Apri la cartella PrimoProgramma in VS Code.
4. Sostituisci il contenuto del Program.cs generato con quello dell’esempio e salva.
5. Dalla cartella che contiene PrimoProgramma.csproj, esegui dotnet run.

int prezzo = 12;
int quantita = 3;
int totale = prezzo * quantita;

Console.WriteLine("Ciao da C#!");
Console.WriteLine($"Totale: {totale} euro");

Il file .csproj descrive il progetto e viene generato dal tuo SDK; Program.cs contiene le istruzioni del programma. I modelli console moderni consentono istruzioni al livello principale e importazioni implicite: non è necessario aggiungere una classe contenitore a questo esempio.

dotnet run compila il progetto quando necessario e lo esegue. Il comando dotnet build permette di effettuare soltanto la compilazione. Cartelle come bin e obj vengono create dagli strumenti: non sono file sorgente da scrivere a mano.

Torna all’indice della pagina

Per uno script PHP nel terminale serve PHP CLI. Non occorre configurare Apache né un database per stampare due messaggi.

<?php
$prezzo = 12;
$quantita = 3;
$totale = $prezzo * $quantita;

echo 'Ciao da PHP!' . PHP_EOL;
echo 'Totale: ' . $totale . ' euro' . PHP_EOL;

Salva ed esegui dalla cartella php:

php main.php

Il risultato appare nel terminale. PHP_EOL aggiunge il separatore di riga del sistema. Aprire main.php con un URL file:// non esegue PHP: il browser non contiene un interprete PHP.

Per vedere una risposta PHP attraverso HTTP, il server di sviluppo integrato si avvia dalla cartella dello script:

php -S 127.0.0.1:8000

Apri http://127.0.0.1:8000/main.php nel browser. In questa modalità il browser riceve il testo prodotto dal server; i separatori di riga di testo semplice non diventano automaticamente elementi HTML. Le richieste e gli eventuali errori del server compaiono nel terminale. Arresta il server con Ctrl+C dopo l’uso; è uno strumento di sviluppo locale.

Torna all’indice della pagina

Un programma che termina restituisce il controllo alla shell. Un server resta attivo e occupa il terminale fino all’arresto. Ctrl+C, premuto nel terminale che ospita il processo, chiede normalmente di interromperlo. Se hai più terminali, seleziona quello corretto prima di inviare il comando.

Il pulsante triangolare di VS Code può avere significati diversi a seconda del linguaggio e delle estensioni installate. Prima di usarlo, leggi il suggerimento visualizzato passando il mouse: Run Python File, Start Debugging e i comandi di altre estensioni non sono la stessa operazione. I comandi espliciti di questa pagina rendono visibile quale strumento esegue il lavoro.

Torna all’indice della pagina