Le unità rappresentano uno degli strumenti più importanti del linguaggio Pascal. Grazie a esse è possibile organizzare il codice in modo modulare, mantenere separati i diversi componenti di un'applicazione e favorire il riutilizzo delle funzionalità.

Le unità in Pascal: organizzare il codice in modo professionale

Pubblicato il: 30-6-2026

Ultima Modifica: 30-6-2026

Introduzione

Quando si inizia a programmare in Pascal, è normale scrivere tutto il codice all'interno di un unico file. Per piccoli programmi questo approccio può essere sufficiente, ma man mano che il progetto cresce il codice diventa sempre più difficile da leggere, modificare e mantenere.

Per risolvere questo problema, il linguaggio Pascal mette a disposizione uno strumento estremamente potente: le unità (Unit).

Una unità è un modulo contenente procedure, funzioni, variabili, costanti, tipi di dato e classi che possono essere riutilizzati da altri programmi. Utilizzando le unità è possibile suddividere un progetto in più file, ciascuno con uno scopo ben preciso.

📦 Pensate a una unità come a una cassetta degli attrezzi: contiene strumenti pronti all'uso che possono essere impiegati in qualunque programma.

Perché utilizzare le unità?

L'utilizzo delle unità offre numerosi vantaggi.

Tra i principali troviamo:

✔ codice più ordinato

✔ maggiore leggibilità

✔ riutilizzo del codice

✔ manutenzione semplificata

✔ compilazione più veloce nei progetti di grandi dimensioni

✔ migliore collaborazione tra più programmatori

Nei software professionali è praticamente impensabile sviluppare tutto all'interno di un unico file sorgente.

La struttura di una unità

Una tipica unità Pascal è composta da diverse sezioni.

unit NomeUnita;

interface


			uses
  ...

const
...

type
...

var

			...

procedure ...
function ...

implementation

			
...

initialization

...

finalization


			...

end.

Vediamo ora ciascuna parte nel dettaglio.

La dichiarazione della unità

Ogni unità inizia con la parola chiave unit, seguita dal nome.

Esempio:

unit OperazioniMatematiche;

⚠️ Il nome della unità deve coincidere con quello del file.

Ad esempio:

OperazioniMatematiche.pas

La sezione Interface

La sezione interface rappresenta la parte pubblica della unità.

Tutto ciò che viene dichiarato qui sarà visibile ai programmi che utilizzeranno questa unità.

Esempio:

interface

procedure Saluta;

			function Somma(A, B: Integer): Integer;

Il codice vero e proprio verrà scritto nella sezione implementation.

La sezione Implementation

Qui vengono inserite le implementazioni delle procedure e delle funzioni dichiarate nell'interfaccia.

Esempio:

implementation

procedure 
			Saluta;
begin
  Writeln('Benvenuto!');
end;


			function Somma(A, B: Integer): Integer;
begin
  Result := 
			A + B;
end;

Questa parte rimane nascosta ai programmi che utilizzano la unità.

🔒 Il programma conosce cosa può usare, ma non come è stato realizzato.

Creiamo la nostra prima unità

Supponiamo di voler raccogliere alcune semplici operazioni matematiche.

unit Operazioni;

interface

			
function Somma(A, B: Integer): Integer;
function 
			Moltiplica(A, B: Integer): Integer;

implementation


			function Somma(A, B: Integer): Integer;
begin
  Result := 
			A + B;
end;

function Moltiplica(A, B: Integer): Integer;

			begin
  Result := A * B;
end;

end.

Questa unità potrà essere utilizzata in tutti i nostri progetti.

Utilizzare una unità

Per utilizzare una unità è sufficiente inserirla nella clausola uses.

program Esempio;

uses
  
			Operazioni;

begin
  Writeln(Somma(10,20));
  
			Writeln(Moltiplica(5,6));
end.

Il compilatore collegherà automaticamente il programma con la unità.

🚀 Non è necessario copiare il codice ogni volta.

La clausola Uses

La clausola uses serve a importare una o più unità.

Esempio:

uses
  SysUtils,
  
			Classes,
  Operazioni;

Le unità possono essere sia quelle fornite dal compilatore sia quelle create dal programmatore.

Variabili globali della unità

È possibile dichiarare variabili visibili a tutto il programma.

interface

var
  
			Contatore: Integer;

Successivamente potranno essere utilizzate normalmente.

Contatore := Contatore + 1;

⚠️ È buona norma limitare l'uso delle variabili globali, preferendo variabili locali o proprietà delle classi, per rendere il codice più sicuro e più facile da mantenere.

Costanti

Le costanti sono molto utilizzate.

const
  Versione = '1.0';
  
			MaxUtenti = 100;

Potranno essere lette da qualsiasi programma che utilizza la unità.

Tipi personalizzati

Una unità può contenere nuovi tipi di dato.

type
  TPersona = record
    
			Nome: String;
    Eta: Integer;
  end;

Qualunque programma che utilizzi questa unità potrà dichiarare variabili di tipo TPersona.

Record, array e classi

Le unità possono contenere praticamente qualsiasi elemento del linguaggio.

Ad esempio:

type
  TVoti = array[1..10] of 
			Integer;

oppure

type
  TColore = (
    
			Rosso,
    Verde,
    Blu
  
			);

Nei progetti Object Pascal possono contenere anche classi molto complesse.

🏗️ È proprio grazie alle unità che Lazarus e Delphi sono in grado di gestire progetti con migliaia di file sorgente.

La sezione Initialization

Una caratteristica molto interessante è la sezione initialization.

Il codice presente qui viene eseguito automaticamente quando il programma carica la unità.

Esempio:

initialization

Writeln('Unità 
			caricata');

Non è necessario richiamare alcuna procedura.

La sezione Finalization

Questa sezione viene eseguita quando il programma termina.

Esempio:

finalization

Writeln('Chiusura 
			della unità');

Può essere utilizzata per:

liberare memoria
chiudere file
chiudere connessioni
salvare dati

🧹 È il luogo ideale per eseguire le operazioni di pulizia prima della chiusura dell'applicazione.

Nascondere le implementazioni

Uno dei principali vantaggi delle unità consiste nel poter rendere private alcune procedure.

Ad esempio:

interface

procedure Avvia;

			
implementation

procedure ProceduraInterna;
begin
  
			...
end;

procedure Avvia;
begin
  
			ProceduraInterna;
end;

ProceduraInterna non sarà visibile all'esterno della unità.

Questo migliora l'incapsulamento del codice e riduce il rischio di utilizzi impropri.

Organizzare un progetto

In un progetto di medie dimensioni conviene dividere il codice in più unità.

Un possibile schema potrebbe essere:

Main.pas

Clienti.pas

Ordini.pas

Magazzino.pas

Database.pas

Stampe.pas

Utility.pas

Ogni file si occupa esclusivamente di uno specifico aspetto dell'applicazione.

📁 Questa organizzazione rende il progetto molto più semplice da comprendere e mantenere.

Evitare le dipendenze circolari

Un errore piuttosto comune consiste nel creare unità che si richiamano a vicenda.

Ad esempio:

UnitA usa UnitB

UnitB usa UnitA

Questo genera una dipendenza circolare, che può causare errori di compilazione o rendere il progetto difficile da gestire.

Per evitarla è consigliabile progettare con attenzione le responsabilità di ogni unità e, quando necessario, spostare gli elementi condivisi in una terza unità comune.

Convenzioni di denominazione

È buona norma scegliere nomi chiari e significativi.

Ad esempio:

✔ Database

✔ Clienti

✔ Fatture

✔ Grafica

✔ Utility

Sono invece da evitare nomi poco descrittivi come:

Test1

Prova

Varie

MioFile

Un nome ben scelto rende il progetto più comprensibile anche a distanza di tempo.

Buone pratiche

Per creare unità realmente professionali è consigliabile seguire alcune semplici regole:

✔ una sola responsabilità per ogni unità

✔ mantenere pubblici solo gli elementi realmente necessari

✔ utilizzare nomi chiari

✔ commentare il codice più complesso

✔ evitare variabili globali quando possibile

✔ suddividere le unità troppo grandi in moduli più piccoli

✔ riutilizzare il codice invece di duplicarlo

Conclusioni

Imparare a progettare correttamente le proprie unità fin dalle prime esperienze di programmazione permette di realizzare software più ordinato, più semplice da estendere e molto più facile da mantenere nel tempo. Che si tratti di una piccola utility o di un'applicazione complessa sviluppata con Lazarus o Delphi, una buona organizzazione del codice è sempre un investimento che ripaga con maggiore qualità, produttività e affidabilità.