Introduzione
Quando un’applicazione deve decidere quali operazioni può eseguire un utente, le strutture condizionali sono uno strumento essenziale. Un caso concreto è la gestione dei ruoli e dei permessi: un amministratore può modificare i dati, un moderatore può revisionare i contenuti, mentre un visitatore può soltanto consultarli.
In questo tutorial costruiremo una funzione JavaScript capace di determinare quali azioni sono disponibili in base al ruolo dell’utente e alla sezione richiesta. Utilizzeremo if, else e switch in modo complementare:
- if sarà utile per controllare condizioni specifiche;
- else gestirà il caso alternativo;
- switch permetterà di confrontare chiaramente più ruoli o sezioni.
Questo esempio è utile in dashboard, pannelli amministrativi, sistemi di gestione documentale e API che devono autorizzare operazioni diverse senza duplicare la logica.
Codice completo
const utenti = [
{
nome: "Marta",
ruolo: "admin",
sezione: "utenti"
},
{
nome: "Luca",
ruolo: "moderator",
sezione: "contenuti"
},
{
nome: "Sara",
ruolo: "viewer",
sezione: "report"
},
{
nome: "Paolo",
ruolo: "guest",
sezione: "impostazioni"
}
];
function verificaPermessi(utente) {
let azione;
let messaggio;
// switch confronta il ruolo con diversi casi possibili
switch (utente.ruolo) {
case "admin":
// L´amministratore può accedere a tutte le sezioni
azione = "accesso completo";
messaggio = `Benvenuta ${utente.nome}: puoi gestire la sezione ${utente.sezione}.`;
break;
case "moderator":
// Il moderatore può operare soltanto sui contenuti
if (utente.sezione === "contenuti") {
azione = "modifica contenuti";
messaggio = `${utente.nome} può revisionare i contenuti.`;
} else {
azione = "accesso in sola lettura";
messaggio = `${utente.nome} può consultare questa sezione, ma non modificarla.`;
}
break;
case "viewer":
// Un viewer può leggere i report, ma non modificarli
if (utente.sezione === "report") {
azione = "visualizzazione report";
messaggio = `${utente.nome} può visualizzare i report.`;
} else {
azione = "accesso negato";
messaggio = `${utente.nome} non può accedere a questa sezione.`;
}
break;
default:
// Caso di sicurezza per ruoli sconosciuti o non autenticati
azione = "accesso negato";
messaggio = "Ruolo non riconosciuto: operazione bloccata.";
}
return {
utente: utente.nome,
ruolo: utente.ruolo,
sezione: utente.sezione,
azione,
messaggio
};
}
for (const utente of utenti) {
const risultato = verificaPermessi(utente);
console.log({
utente: risultato.utente,
azione: risultato.azione,
messaggio: risultato.messaggio
});
}Spiegazione
1. Rappresentare i dati dell’utente
Ogni oggetto dell’array utenti contiene tre proprietà: nome, ruolo e sezione. Separare questi dati rende la funzione riutilizzabile: possiamo passarle utenti diversi senza riscrivere la logica di autorizzazione.
2. Usare switch per i ruoli
La struttura switch è adatta quando dobbiamo confrontare una stessa espressione con diversi valori. In questo caso controlliamo utente.ruolo. Ogni blocco case descrive un comportamento:
admin: accesso completo;moderator: controllo più specifico sulla sezione;viewer: accesso limitato;default: comportamento sicuro per valori sconosciuti.
La parola chiave break interrompe l’esecuzione del blocco corrente. Senza break, JavaScript continuerebbe nei casi successivi, provocando il cosiddetto fall-through.
3. Inserire if ed else nei casi complessi
Nel caso del moderatore non basta controllare il ruolo: dobbiamo verificare anche la sezione. Qui entra in gioco if:
if (utente.sezione === "contenuti") {
// Permesso specifico
} else {
// Comportamento alternativo
}L’operatore === confronta valore e tipo, evitando conversioni automatiche. È preferibile a == nella maggior parte dei casi perché rende le condizioni più prevedibili.
4. Gestire il default
Il ramo default non deve essere considerato un dettaglio secondario. In un sistema reale possono arrivare ruoli scritti male, dati incompleti o valori manipolati. Negare l’accesso in caso di ruolo sconosciuto segue il principio di sicurezza fail closed: quando qualcosa non è riconosciuto, l’operazione viene bloccata.
Best practice
- Usa nomi espliciti:
ruolo,sezioneeazionespiegano immediatamente lo scopo dei dati. - Confronta con ===: evita risultati inattesi dovuti alla conversione implicita dei tipi.
- Inserisci sempre un default: gestisce valori non previsti e migliora la sicurezza.
- Non confondere interfaccia e sicurezza: nascondere un pulsante nel browser non protegge davvero un’operazione. I permessi devono essere verificati anche sul server.
- Riduci la complessità: se uno
switchdiventa molto lungo, valuta una struttura dati o funzioni separate per ogni ruolo. - Normalizza gli input: prima del confronto puoi usare
trim()etoLowerCase()se i dati provengono dall’utente.
const ruoloNormalizzato = ruolo.trim().toLowerCase();
if (ruoloNormalizzato === "admin") {
console.log("Accesso amministrativo");
} else {
console.log("Accesso standard");
}Riepilogo
Le strutture condizionali permettono di trasformare regole di autorizzazione in codice leggibile e organizzato. switch è particolarmente efficace per distinguere più ruoli, mentre if ed else permettono di aggiungere controlli più precisi all’interno di ogni caso.
Un buon sistema deve prevedere anche valori imprevisti, usare confronti rigorosi e applicare una politica sicura per gli accessi non riconosciuti. Ricorda inoltre che il codice JavaScript eseguito nel browser non è sufficiente per proteggere dati o operazioni importanti: la verifica definitiva deve essere effettuata dal backend.