Convenzioni di Denominazione nella Programmazione — camelCase, snake_case e Oltre

Apri un codice sorgente per la prima volta e vedi getUserName, get_user_name e GetUserName tutto nello stesso file. Immediatamente sai che qualcosa è andato storto. Le convenzioni di denominazione sono una di quelle cose che sembrano banali finché non lavori in un team — poi diventano essenziali.

La denominazione coerente non è una questione di preferenza personale. Si tratta di rendere il codice leggibile per la prossima persona che lo toccherà, che spesso sei tu stesso sei mesi dopo.

Perché le Convenzioni di Denominazione Contano

Tre cose si rompono quando un progetto manca di denominazione coerente:

• La leggibilità soffre — Quando gli stili delle variabili cambiano ogni poche righe, il tuo cervello spreca cicli analizzando il formato invece di capire la logica
• La collaborazione del team si frattura — Le pull request diventano campi di battaglia sullo stile piuttosto che sul contenuto. L'inserimento di nuovi sviluppatori richiede più tempo perché non c'è uno schema prevedibile
• Gli strumenti smettono di funzionare correttamente — Linter, auto-completamento, generatori di codice e strumenti di refactoring si basano su schemi di denominazione prevedibili

La convenzione che scegli conta molto meno che sceglierne una e mantenerla. Un codice sorgente con snake_case coerente ovunque è infinitamente migliore di uno che mescola tre stili diversi.

La Guida Completa alle Convenzioni di Denominazione

camelCase

La prima parola è in minuscolo e ogni parola successiva inizia con la maiuscola. Nessun separatore.

// JavaScript / TypeScript
const userName = "Alice";
let itemCount = 42;
function getUserProfile(userId) {
  return fetchData(`/users/${userId}`);
}

Dove si usa: JavaScript, TypeScript e Java usano camelCase per variabili, nomi di funzioni e metodi. È anche lo standard in Swift per variabili locali e parametri di funzione.

PascalCase

Ogni parola inizia con la maiuscola. Chiamato anche UpperCamelCase.

// TypeScript / C#
class UserProfile {
  firstName: string;
  lastName: string;
}

interface DatabaseConnection {
  host: string;
  port: number;
}

// Componente React
function NavigationBar({ items }: NavProps) {
  return <nav>{/* ... */}</nav>;
}

Dove si usa: C# usa PascalCase per quasi tutto ciò che è pubblico — classi, metodi, proprietà. TypeScript e JavaScript lo usano per classi, interfacce, alias di tipo ed enum. React richiede PascalCase per i nomi dei componenti perché JSX deve distinguere i componenti dagli elementi HTML.

In Go, PascalCase ha un significato speciale: qualsiasi identificatore che inizia con la maiuscola è esportato (pubblico).

snake_case

Tutte le parole in minuscolo, separate da underscore.

# Python
user_name = "Alice"
item_count = 42

def get_user_profile(user_id):
    return fetch_data(f"/users/{user_id}")

class UserProfile:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

Dove si usa: Python usa snake_case per praticamente tutto tranne i nomi delle classi. Ruby segue lo stesso schema. Rust usa snake_case per variabili, funzioni e moduli. Gli schemi dei database usano quasi universalmente snake_case per nomi di tabelle e colonne.

SCREAMING_SNAKE_CASE

Tutto in maiuscolo con underscore. Riservato per costanti e valori che non dovrebbero mai cambiare.

// Costanti nella maggior parte dei linguaggi
const MAX_RETRY_COUNT = 3;
const API_BASE_URL = "https://api.example.com";
const DEFAULT_TIMEOUT_MS = 5000;

Dove si usa: Quasi tutti i linguaggi usano SCREAMING_SNAKE_CASE per le costanti. Il formato tutto maiuscolo è un segnale universale che dice "non riassegnare questo valore".

kebab-case

Tutto in minuscolo con trattini come separatori.

/* Nomi di classi CSS */
.navigation-bar {
  background-color: #1a1a2e;
}

.user-profile-card {
  border-radius: 8px;
}

# Flag CLI
npm install --save-dev eslint
git commit --no-verify

Dove si usa: CSS e HTML favoriscono fortemente kebab-case. Gli slug URL lo usano. Gli strumenti da riga di comando e i flag lo seguono.

dot.case

Parole separate da punti.

// Nomi di pacchetti Java
package com.example.userservice.controllers;

import org.springframework.boot.SpringApplication;

Dove si usa: Denominazione dei pacchetti Java, estensioni dei file, chiavi di proprietà di configurazione in Spring Boot e framework simili.

Title Case

Ogni parola principale è maiuscola. Le parole minori come "e", "il" e "di" rimangono in minuscolo.

Dove si usa: Intestazioni dell'interfaccia, titoli di pagina, elementi di menu, sezioni di documentazione e nomi propri.

path/case

Parole separate da barre, seguendo le convenzioni del file system o dei namespace.

Dove si usa: Percorsi del file system, percorsi dei moduli, gerarchie dei namespace e strutture di routing degli URL.

Tabella delle Convenzioni per Linguaggio

Errori Comuni e Come Correggerli

1. Mescolare convenzioni nello stesso ambito

// ❌ Incoerente
const user_name = "Alice";
const itemCount = 42;
const MaxRetries = 3;

// ✅ camelCase coerente
const userName = "Alice";
const itemCount = 42;
const maxRetries = 3;

2. Usare la convenzione sbagliata per il linguaggio

# ❌ Usare camelCase in Python
def getUserProfile(userId):
    userName = fetchUser(userId)
    return userName

# ✅ Usare snake_case come Python si aspetta
def get_user_profile(user_id):
    user_name = fetch_user(user_id)
    return user_name

3. Abbreviazioni e acronimi

// ❌ Gestione incoerente degli acronimi
const XMLParser = new XmlParser();
const htmlToJSON = convert(HTMLString);

// ✅ Trattare gli acronimi come parole
const xmlParser = new XmlParser();
const htmlToJson = convert(htmlString);

4. Nomi booleani senza prefissi is/has/can

// ❌ Booleano ambiguo
const active = true;

// ✅ Intenzione chiara del booleano
const isActive = true;

Conversione Automatica tra Convenzioni

Quando lavori tra linguaggi, convertire manualmente le convenzioni di denominazione è noioso e soggetto a errori.

Il nostro Convertitore di Casi di Testo gestisce questo automaticamente. Incolla qualsiasi identificatore e convertilo tra camelCase, PascalCase, snake_case, kebab-case e altro con un solo clic.

Ulteriori Letture

• JSON Formatting Best Practices — Struttura i tuoi dati in modo pulito come nomini le tue variabili
• Regex Cheat Sheet — Riferimento per il pattern matching per validazione e elaborazione di testo
• SQL Formatting Best Practices — Scrivi query SQL leggibili

---

Pronto a convertire le convenzioni di denominazione automaticamente? Prova il nostro Convertitore di Casi di Testo — incolla qualsiasi identificatore e trasformalo tra camelCase, snake_case, PascalCase, kebab-case e altro. Senza registrazione, senza dati inviati ai server, completamente gratuito.