---
title: "Numeri binari ed esadecimali"
domain: networking
level: foundations
duration: "30 min"
objectives:
  - "Spiegare che cosa sono un bit e un byte e perché i computer usano il sistema binario."
  - "Convertire numeri tra decimale e binario (da 0 a 255)."
  - "Convertire numeri tra binario ed esadecimale e riconoscere l'esadecimale in un indirizzo MAC."
  - "Leggere un indirizzo IPv4 come quattro numeri a 8 bit."
lang: it
source_hash: b634e1d9b232
---

# Numeri binari ed esadecimali

## Perché è importante
Apri le impostazioni del tuo router di casa e vedrai numeri come `192.168.1.10`. Guarda i dettagli della tua scheda Wi-Fi e troverai qualcosa come `00:00:5e:00:53:01`. Scegli un colore in una pagina web e viene scritto `#FF8800`. Sembrano codici segreti, ma sono tutti la stessa cosa: numeri normali scritti in un modo che a un computer riesce facile gestire.

Non serve essere bravi in matematica per leggerli. Serve una sola abilità: saper contare in un altro modo. In questa lezione la impari passo dopo passo. I moduli successivi sull'indirizzamento IP e sul subnetting si basano direttamente su di essa, quindi qualche minuto di pratica ora ti evita molta confusione più avanti.

## Obiettivi di apprendimento
- Spiegare che cosa sono un bit e un byte e perché i computer usano il sistema binario.
- Convertire numeri tra decimale e binario (da 0 a 255).
- Convertire numeri tra binario ed esadecimale e riconoscere l'esadecimale in un indirizzo MAC.
- Leggere un indirizzo IPv4 come quattro numeri a 8 bit.

## Concetti chiave

### Due stati: bit e byte
Pensa a un interruttore della luce. È acceso o spento, e non c'è nulla in mezzo. Dentro un computer ci sono miliardi di minuscoli interruttori elettronici, e ognuno trasporta un segnale oppure no. Distinguere «acceso» da «spento» è facile e molto affidabile, anche quando il segnale è debole o disturbato. Distinguere dieci livelli diversi sarebbe molto più difficile e causerebbe errori. Ecco perché i computer usano solo due stati.

Scriviamo i due stati con le cifre `1` (acceso) e `0` (spento). Una di queste cifre è un **bit**, abbreviazione di *binary digit* (cifra binaria). Un singolo bit può dire solo sì o no, quindi i computer raggruppano i bit. Un gruppo di 8 bit è un **byte**.

Quanti valori diversi può contenere un byte? Ogni bit ha 2 possibilità e i bit sono 8, quindi ci sono 2 × 2 × 2 × 2 × 2 × 2 × 2 × 2 = **256** combinazioni diverse. Le usiamo per contare da 0 a 255. (I valori sono 256, ma il più grande è 255, perché si comincia a contare da 0.)

Un numero scritto solo con le cifre 0 e 1 si chiama numero **binario**. I numeri che usi ogni giorno, con le cifre da 0 a 9, sono numeri **decimali**.

> [!CHECK]
> Quanti valori diversi può contenere un byte (8 bit)?
>
> - [ ] 8
> - [ ] 255
> - [x] 256
> - [ ] 1.024
>
> Ciascuno degli 8 bit ha 2 stati possibili, quindi ci sono 2 alla ottava = 256 combinazioni. Rappresentano i numeri da 0 a 255, ed è per questo che 255 è il valore massimo, non la quantità di valori.

### Valori posizionali: come si conta davvero
Sai già leggere il binario. Solo che non lo sai ancora, perché funziona esattamente come il decimale. Guarda il numero decimale 407:

| Valore posizionale | 100 | 10 | 1 |
|---|---|---|---|
| Cifra | 4 | 0 | 7 |

Il numero significa 4 × 100 + 0 × 10 + 7 × 1 = 407. Ogni colonna vale **10 volte** la colonna alla sua destra, perché il decimale ha dieci cifre (da 0 a 9). Quando una colonna finisce le cifre, si passa alla successiva: dopo il 9 viene il 10.

Il binario ha solo due cifre, quindi ogni colonna vale **2 volte** la colonna alla sua destra. Per un byte ci sono 8 colonne:

| Valore posizionale | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
|---|---|---|---|---|---|---|---|---|

Partendo da destra si raddoppia ogni volta: 1, 2, 4, 8, 16, 32, 64, 128. Impara a memoria questa riga: la userai di continuo. Una cifra `1` in una colonna significa «conta questa colonna»; uno `0` significa «salta».

![Un byte disegnato come otto colonne con valori posizionali 128, 64, 32, 16, 8, 4, 2 e 1 da sinistra a destra. Il byte di esempio è 1 0 1 1 0 0 1 0. Le colonne che contengono un 1 sono 128, 32, 16 e 2 e contano; le altre vengono saltate. Sommando le colonne che contano si ottiene 128 + 32 + 16 + 2 = 178.](../../../assets/diagrams/binhex-place-values.it.svg)

*Figura 1. Per leggere un numero binario, somma i valori delle colonne che contengono un 1.*

### Da binario a decimale
Per trasformare un numero binario in decimale, scrivilo sotto la riga dei valori posizionali e somma le colonne che contengono un 1.

**Esempio pratico: `00101101`**

| Valore posizionale | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
|---|---|---|---|---|---|---|---|---|
| Bit | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 |

Le colonne con un 1 sono 32, 8, 4 e 1. Sommale: 32 + 8 + 4 + 1 = **45**. Quindi `00101101` è 45 in decimale.

Due casi facili da ricordare: `00000000` è 0 e `11111111` è 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255, il valore più grande che un byte può contenere.

### Da decimale a binario
Per fare il percorso inverso, scorri le colonne da sinistra a destra. A ogni colonna chiediti: «Questo valore posizionale ci sta in quello che mi resta?» Se sì, scrivi `1` e sottrailo. Se no, scrivi `0`.

**Esempio pratico: 200**

| Passo | Valore posizionale | Ci sta in quello che resta? | Bit | Resta dopo |
|---|---|---|---|---|
| 1 | 128 | Sì (200 ≥ 128) | 1 | 200 − 128 = 72 |
| 2 | 64 | Sì (72 ≥ 64) | 1 | 72 − 64 = 8 |
| 3 | 32 | No (8 < 32) | 0 | 8 |
| 4 | 16 | No | 0 | 8 |
| 5 | 8 | Sì (8 ≥ 8) | 1 | 8 − 8 = 0 |
| 6 | 4 | No | 0 | 0 |
| 7 | 2 | No | 0 | 0 |
| 8 | 1 | No | 0 | 0 |

Leggendo la colonna Bit dall'alto in basso si ottiene `11001000`. Controlla tornando indietro: 128 + 64 + 8 = 200. Controlla sempre: bastano cinque secondi.

> [!TIP]
> Scrivi sempre tutti gli 8 bit, aggiungendo zeri a sinistra (`101` diventa `00000101`). Nelle reti i numeri vengono quasi sempre mostrati come byte completi.

> [!CHECK]
> Quanto vale `00001010` in decimale?
>
> - [ ] 5
> - [x] 10
> - [ ] 12
> - [ ] 1010
>
> Le colonne con un 1 sono 8 e 2, e 8 + 2 = 10. Le cifre binarie `1010` non significano «milledieci»; ogni cifra vale quanto vale la sua colonna.

### Esadecimale: un modo più breve per scrivere i bit
Il binario è esatto, ma lungo: un byte sono 8 cifre e un indirizzo MAC ne sarebbe 48. Copiando tanti zeri e uni è facile sbagliare. L'**esadecimale** (o *hex*) è una scorciatoia. Ha **16** cifre invece di 10: le solite da 0 a 9, poi le lettere da A a F per i valori da dieci a quindici.

| Cifra hex | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Valore | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |

Le lettere possono essere maiuscole o minuscole: `5E` e `5e` sono lo stesso numero.

Perché 16? Perché 16 è esattamente 2 × 2 × 2 × 2. Una cifra hex contiene esattamente **4 bit**, e 4 bit (un **nibble**) possono contenere i valori da 0 a 15. Quindi un byte, che è fatto di 8 bit, corrisponde sempre a esattamente **due cifre hex**.

Per convertire un byte da binario a hex, dividilo in due gruppi di 4 bit e converti ogni gruppo separatamente, usando i valori posizionali 8, 4, 2, 1:

**Esempio pratico: `10110010`**
- Il primo gruppo `1011` = 8 + 2 + 1 = 11, che è la cifra hex **B**.
- Il secondo gruppo `0010` = 2, che è la cifra **2**.
- Il byte è `B2` in hex.

Per tornare indietro, trasforma ogni cifra hex in 4 bit. In `C8`, `C` = 12 = `1100` e `8` = `1000`, quindi `C8` è `11001000`: lo stesso 200 della sezione precedente.

![Il byte 1 0 1 1 0 0 1 0 viene diviso in due gruppi di quattro bit. Il primo gruppo, 1011, vale 8 + 2 + 1 = 11, cioè la cifra esadecimale B. L'ultimo gruppo, 0010, vale 2, cioè la cifra 2. Quindi il byte è B2 in esadecimale. Una striscia sotto elenca le sedici cifre esadecimali con i loro valori: da 0 a 9 valgono da 0 a 9, poi A vale 10, B vale 11, C vale 12, D vale 13, E vale 14 e F vale 15.](../../../assets/diagrams/binhex-hex-digits.it.svg)

*Figura 2. Un byte sono due cifre hex: converti ogni gruppo di 4 bit separatamente.*

> [!NOTE]
> I numeri hex a volte si scrivono con un prefisso come `0x` (`0xB2`) o `#` (`#FF8800`) per far capire che sono esadecimali. Il prefisso non fa parte del numero. Alcuni contesti, come un indirizzo MAC, non usano alcun prefisso.

> [!CHECK]
> Il byte `11110000` viene diviso in due gruppi di 4 bit. Quale numero hex è?
>
> - [ ] `0F`
> - [x] `F0`
> - [ ] `E0`
> - [ ] `1F`
>
> Il primo gruppo `1111` = 15 = F e il secondo gruppo `0000` = 0, quindi il byte è `F0`. Mantieni i gruppi nello stesso ordine dei bit.

### Dove incontri questi numeri
Ora sai leggere tre cose che prima erano misteriose.

**Un indirizzo IPv4** come `192.168.1.10` è fatto di **quattro byte**, scritti in decimale e separati da punti. Questo stile si chiama *decimale puntato* (*dotted decimal*). Ognuno dei quattro numeri è un byte, quindi è compreso tra 0 e 255. Ecco perché `192.168.1.256` non può esistere: 256 non sta in un byte. In totale un indirizzo IPv4 ha 4 × 8 = 32 bit. I computer gestiscono i 32 bit; le persone leggono i quattro numeri decimali.

**Un indirizzo MAC** (Media Access Control, controllo di accesso al mezzo) è l'indirizzo hardware di una scheda di rete, usato nella tua rete locale. Sono **sei byte**, ciascuno scritto con due cifre hex, di solito separati da due punti o trattini. L'indirizzo `00:00:5e:00:53:01` è fatto di sei byte: `00`, `00`, `5e`, `00`, `53`, `01`. È uno degli indirizzi riservati agli esempi nella documentazione (RFC 7042), quindi nessuna scheda reale lo possiede.

**Un colore web** come `#FF8800` sono **tre byte** in hex: rosso `FF` (255), verde `88` (136) e blu `00` (0). Rosso al massimo, un po' più di metà verde e niente blu danno l'arancione. È un esempio comodo perché puoi scrivere un altro numero hex e vedere il colore cambiare.

![Tre righe. Un indirizzo IPv4 come 192.168.1.10 è fatto di quattro byte, ognuno scritto in decimale da 0 a 255 e separati da punti. Un indirizzo MAC come 00:00:5e:00:53:01 è fatto di sei byte, ognuno scritto con due cifre esadecimali e separati da due punti. Un colore web come #FF8800 è fatto di tre byte in esadecimale per rosso, verde e blu, cioè 255, 136 e 0, con un campione di colore arancione accanto.](../../../assets/diagrams/binhex-where.it.svg)

*Figura 3. Notazioni diverse, stessa idea: pochi byte scritti in modo leggibile.*

> [!CHECK]
> Perché `10.20.30.300` non è un indirizzo IPv4 valido?
>
> - [ ] Perché ha troppi punti
> - [x] Perché 300 è maggiore di 255, il valore massimo di un byte
> - [ ] Perché gli indirizzi non possono iniziare con 10
> - [ ] Perché gli indirizzi IPv4 devono essere scritti in hex
>
> Ognuno dei quattro numeri è un byte, quindi deve essere compreso tra 0 e 255. Il decimale puntato è il modo usuale di scrivere gli indirizzi IPv4.

## Come funziona
Mettendo tutto insieme, ecco l'intero percorso di un indirizzo, `192.168.1.10`, da ciò che leggi a ciò che il computer memorizza.

1. Leggi quattro numeri decimali: 192, 168, 1 e 10.
2. Ognuno è un byte. Con il metodo delle sottrazioni: 192 = 128 + 64 = `11000000`; 168 = 128 + 32 + 8 = `10101000`; 1 = `00000001`; 10 = 8 + 2 = `00001010`.
3. Il computer memorizza i quattro byte uno dopo l'altro, come 32 bit: `11000000 10101000 00000001 00001010`.
4. Se volessi una forma più breve, scriveresti ogni byte in hex: `C0 A8 01 0A`.

Lungo la strada non cambia nulla. È lo stesso numero, scritto in tre modi diversi. Scegli il modo più adatto a chi legge: bit per il computer, decimale per gli indirizzi IP, hex per le cose compatte come gli indirizzi MAC.

> [!CHECK]
> Quale affermazione è vera su `192.168.1.10`, `11000000.10101000.00000001.00001010` e `C0.A8.01.0A`?
>
> - [ ] Sono tre indirizzi diversi
> - [x] Sono lo stesso indirizzo scritto in decimale, binario e hex
> - [ ] Solo il primo può essere usato in una rete
> - [ ] La forma hex è un altro indirizzo, più corto
>
> Decimale, binario ed esadecimale sono solo notazioni diverse. Il valore memorizzato nel computer è lo stesso.

## Esempio pratico
Convertiamo l'indirizzo `203.0.113.5`, uno degli esempi riservati alla documentazione (RFC 5737).

| Decimale | Valori posizionali usati | Binario |
|---|---|---|
| 203 | 128 + 64 + 8 + 2 + 1 | `11001011` |
| 0 | nessuno | `00000000` |
| 113 | 64 + 32 + 16 + 1 | `01110001` |
| 5 | 4 + 1 | `00000101` |

Controlliamo 203: 203 − 128 = 75; 75 − 64 = 11; 11 − 8 = 3; 3 − 2 = 1; 1 − 1 = 0. I bit che ci stanno sono 128, 64, 8, 2 e 1, che danno `11001011`. L'indirizzo completo in binario è `11001011.00000000.01110001.00000101`.

## Errori comuni
- **Leggere il binario come un numero decimale** — `1010` non è milledieci; è 10. Usa sempre le colonne.
- **Dimenticare gli zeri iniziali** — `101` e `00000101` sono lo stesso numero, ma nelle reti servono tutti gli 8 bit per mantenere allineate le colonne.
- **Confondere le lettere e i valori hex** — da `A` a `F` sono i valori da 10 a 15, non da 1 a 6. E `10` in hex è 16, non dieci.
- **Pensare che l'hex sia un numero diverso** — `FF` e `255` sono lo stesso valore. Cambia la notazione, non il numero.
- **Dare per scontato che un numero sia decimale quando non lo è** — `10` può significare dieci (decimale), due (binario) o sedici (hex). Lo dicono il contesto o un prefisso come `0x`.

## Considerazioni sulla sicurezza
Binario ed esadecimale non sono di per sé un tema di sicurezza, ma alcune abitudini aiutano. Quando copi un indirizzo IP o MAC in una regola del firewall o in una lista di controllo degli accessi, una sola cifra sbagliata fa puntare la regola a un altro dispositivo, quindi ricontrolla rileggendolo byte per byte. Ricorda anche che un indirizzo MAC non è un segreto né una prova di identità: si può cambiare via software, quindi non fare mai affidamento solo su di esso per decidere chi può accedere a una rete. Infine, i dump esadecimali dei dati non sono cifrati. Scrivere qualcosa in hex o in binario ne cambia solo l'aspetto, non chi può leggerlo.

## Riepilogo
- I computer usano due stati (acceso e spento), scritti 1 e 0. Una cifra è un bit; 8 bit formano un byte, che contiene 256 valori (da 0 a 255).
- Le colonne binarie valgono 128, 64, 32, 16, 8, 4, 2, 1. Per passare da binario a decimale, somma le colonne con un 1. Per passare da decimale a binario, sottrai, da sinistra a destra, il più grande valore posizionale che ci sta.
- L'esadecimale ha 16 cifre (da 0 a 9 e da A a F). Una cifra hex sono 4 bit, quindi un byte sono due cifre hex.
- Un indirizzo IPv4 sono quattro byte in decimale, separati da punti. Un indirizzo MAC sono sei byte in hex. Un colore web sono tre byte in hex.

## Glossario
| Termine | Definizione |
|---|---|
| bit | Una cifra binaria: un singolo 0 o 1. La più piccola unità di dati di un computer. |
| byte | Un gruppo di 8 bit. Può contenere 256 valori diversi, da 0 a 255. |
| binario | Un sistema numerico con solo due cifre, 0 e 1. Ogni colonna vale il doppio di quella alla sua destra. |
| decimale | Il sistema numerico di tutti i giorni, con dieci cifre, da 0 a 9. Ogni colonna vale dieci volte quella alla sua destra. |
| esadecimale (hex) | Un sistema numerico con 16 cifre, da 0 a 9 e da A a F. Una cifra hex rappresenta 4 bit. |
| nibble | Un gruppo di 4 bit, cioè mezzo byte e esattamente una cifra hex. |
| indirizzo MAC | Media Access Control address: l'indirizzo hardware di sei byte di una scheda di rete, scritto in hex, per esempio `00:00:5e:00:53:01`. |
| decimale puntato | Il modo usuale di scrivere un indirizzo IPv4: quattro byte in decimale separati da punti, per esempio `192.168.1.10`. |

## Verifica la comprensione
1. Converti 77 in binario, poi in hex. Controlla la risposta binaria risommando le colonne.
2. Un amico dice: «`11111111` è un numero enorme, quindi non sta in un byte». Che numero è, e il tuo amico ha ragione?
3. Nell'indirizzo MAC `00:00:5e:00:53:01`, quanti byte ci sono e quanto vale in decimale il terzo byte?

## Riferimenti
- [RFC 791](https://www.rfc-editor.org/rfc/rfc791): Internet Protocol (dove è definito l'indirizzo IPv4 a 32 bit)
- [RFC 7042](https://www.rfc-editor.org/rfc/rfc7042): IANA considerations for IEEE 802 parameters (l'intervallo di indirizzi MAC per la documentazione)
- [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737): IPv4 address blocks reserved for documentation
