diff --git a/2-ui/1-document/03-dom-navigation/1-dom-children/solution.md b/2-ui/1-document/03-dom-navigation/1-dom-children/solution.md
index decfa62c7..ff0e25e4d 100644
--- a/2-ui/1-document/03-dom-navigation/1-dom-children/solution.md
+++ b/2-ui/1-document/03-dom-navigation/1-dom-children/solution.md
@@ -1,27 +1,27 @@
-There are many ways, for instance:
+E' possibile farlo in diversi modi, ad esempio:
 
 
-The `<div>` DOM node:
+Il nodo DOM `<div>`:
 
 ```js
 document.body.firstElementChild
-// or
+// oppure
 document.body.children[0]
-// or (the first node is space, so we take 2nd)
+// oppure (il primo nodo è uno spazio, quindi prendiamo il secondo)
 document.body.childNodes[1]
 ```
 
-The `<ul>` DOM node:
+Il nodo DOM `<ul>`:
 
 ```js
 document.body.lastElementChild
-// or
+// oppure
 document.body.children[1]
 ```
 
-The second `<li>` (with Pete):
+Il secondo `<li>` (con Pete):
 
 ```js
-// get <ul>, and then get its last element child
+// prendi <ul>, e quindi il suo ultimo elemento figlio
 document.body.lastElementChild.lastElementChild
 ```
diff --git a/2-ui/1-document/03-dom-navigation/1-dom-children/task.md b/2-ui/1-document/03-dom-navigation/1-dom-children/task.md
index d97f2748a..3f425f099 100644
--- a/2-ui/1-document/03-dom-navigation/1-dom-children/task.md
+++ b/2-ui/1-document/03-dom-navigation/1-dom-children/task.md
@@ -2,14 +2,14 @@ importance: 5
 
 ---
 
-# DOM children
+# Figli nel DOM
 
-Look at this page:
+Guardiamo questa pagina:
 
 ```html
 <html>
 <body>
-  <div>Users:</div>
+  <div>Utenti:</div>
   <ul>
     <li>John</li>
     <li>Pete</li>
@@ -18,7 +18,7 @@ Look at this page:
 </html>
 ```
 
-For each of the following, give at least one way of how to access them:
-- The `<div>` DOM node?
-- The `<ul>` DOM node?
-- The second `<li>` (with Pete)?
+Per ciascuno dei seguenti, fornire almeno un modo per accedervi:
+- Il nodo DOM `<div>` ?
+- Il nodo DOM `<ul>` ?
+- Il secondo `<li>` (con Pete)?
diff --git a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
index d76936320..207f6dddf 100644
--- a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
+++ b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/solution.md
@@ -1,6 +1,6 @@
-1. Yes, true. The element `elem.lastChild` is always the last one, it has no `nextSibling`.
-2. No, wrong, because `elem.children[0]` is the first child *among elements*. But there may exist non-element nodes before it. So `previousSibling` may be a text node.
+1. Si, è vero. L'elemento `elem.lastChild` è sempre l'ultimo, non ha `nextSibling`.
+2. No, è falso, perché `elem.children[0]` è il primo figlio tra i nodi di tipo *elemento*, ma potrebbero esserci nodi di tipo diverso. Ad esempio `previousSibling` potrebbe essere un nodo di testo.
 
-Please note: for both cases if there are no children, then there will be an error.
+Nota: in entrambi i casi, se non ci sono figli si verificherà un errore.
 
-If there are no children, `elem.lastChild` is `null`, so we can't access `elem.lastChild.nextSibling`. And the collection `elem.children` is empty (like an empty array `[]`).
+Se non ci sono figli, `elem.lastChild` è `null`, quindi non possiamo accedere a `elem.lastChild.nextSibling`. E la collection `elem.children` sarà vuota (come un array vuoto `[]`).
diff --git a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/task.md b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/task.md
index 235e83a0c..174c19889 100644
--- a/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/task.md
+++ b/2-ui/1-document/03-dom-navigation/3-navigation-links-which-null/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# The sibling question
+# La questione dei fratelli
 
-If `elem` -- is an arbitrary DOM element node...
+Se `elem` è un nodo arbitrario del DOM...
 
-- Is it true that `elem.lastChild.nextSibling` is always `null`?
-- Is it true that `elem.children[0].previousSibling` is always `null` ?
+- E' vero che `elem.lastChild.nextSibling` è sempre `null`?
+- E' vero che `elem.children[0].previousSibling` è sempre `null`?
diff --git a/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/solution.md b/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/solution.md
index f2aa86302..c13600c61 100644
--- a/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/solution.md
+++ b/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/solution.md
@@ -1 +1 @@
-We'll be using `rows` and `cells` properties to access diagonal table cells.
+Useremo le proprietà `rows` e `cells` per accedere alle celle sulla diagonale della tabella.
diff --git a/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/source.view/index.html b/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/source.view/index.html
index ad835f9f6..db4b18025 100644
--- a/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/source.view/index.html
+++ b/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/source.view/index.html
@@ -54,7 +54,7 @@
   <script>
     let table = document.body.firstElementChild;
 
-    // your code
+    // il tuo codice
   </script>
 </body>
 </html>
diff --git a/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/task.md b/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/task.md
index 23be59fc1..ce096b580 100644
--- a/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/task.md
+++ b/2-ui/1-document/03-dom-navigation/4-select-diagonal-cells/task.md
@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Select all diagonal cells
+# Seleziona tutte le celle sulla diagonale
 
-Write the code to paint all diagonal table cells in red.
+Scrivi il codice per evidenziare in rosso tutte celle sulla diagonale  della tabella.
 
-You'll need to get all diagonal `<td>` from the `<table>` and paint them using the code:
+Dovrai estrarre tutte i `<td>` in diagonale da `<table>` ed evidenziarli usando il codice:
 
 ```js
-// td should be the reference to the table cell
+// td dovrebbe essere il riferimento alla cella della tabella
 td.style.backgroundColor = 'red';
 ```
 
-The result should be:
+Il risultato dovrebbe essere:
 
 [iframe src="solution" height=180]
diff --git a/2-ui/1-document/03-dom-navigation/article.md b/2-ui/1-document/03-dom-navigation/article.md
index f7123d70d..8b2366d6d 100644
--- a/2-ui/1-document/03-dom-navigation/article.md
+++ b/2-ui/1-document/03-dom-navigation/article.md
@@ -5,37 +5,37 @@ libs:
 ---
 
 
-# Walking the DOM
+# Percorrere il DOM
 
-The DOM allows us to do anything with elements and their contents, but first we need to reach the corresponding DOM object.
+Il DOM ci consente di fare qualsiasi cosa con gli elementi ed il loro contenuto, ma prima dobbiamo essere in grado di raggiungere l'oggetto DOM corrispondente.
 
-All operations on the DOM start with the `document` object. That's the main "entry point" to DOM. From it we can access any node.
+Tutte le operazioni sul DOM iniziano con l'oggetto `document`. Questo è il principale "punto di ingresso" per il DOM, dal quale possiamo accedere a qualsiasi nodo.
 
-Here's a picture of links that allow for travel between DOM nodes:
+Ecco un'immagine dei collegamenti che consentono di muoversi tra i nodi del DOM:
 
 ![](dom-links.svg)
 
-Let's discuss them in more detail.
+Esaminiamoli nel dettaglio.
 
-## On top: documentElement and body
+## In cima: documentElement e body
 
-The topmost tree nodes are available directly as `document` properties:
+I nodi in cima all'albero sono disponibili direttamente come proprietà di `document`:
 
 `<html>` = `document.documentElement`
-: The topmost document node is `document.documentElement`. That's the DOM node of the `<html>` tag.
+: Il nodo del DOM più in alto è `document.documentElement`, esso corrisponde al tag `<html>`.
 
 `<body>` = `document.body`
-: Another widely used DOM node is the `<body>` element -- `document.body`.
+: Un altro nodo DOM largamente utilizzato è l'elemento `<body>`, ossia `document.body`.
 
 `<head>` = `document.head`
-: The `<head>` tag is available as `document.head`.
+: Il tag `<head>` è disponibile come `document.head`.
 
-````warn header="There's a catch: `document.body` can be `null`"
-A script cannot access an element that doesn't exist at the moment of running.
+````warn header="C'è un problema: `document.body` può essere `null`"
+Uno script non può accedere ad un elemento che non esiste al momento dell'esecuzione.
 
-In particular, if a script is inside `<head>`, then `document.body` is unavailable, because the browser did not read it yet.
+In particolare, se uno script si trova all'interno di `<head>`, `document.body` non è disponibile, perché il browser non lo ha ancora letto.
 
-So, in the example below the first `alert` shows `null`:
+Quindi, nell'esempio sottostante, il primo `alert` mostra `null`:
 
 ```html run
 <html>
@@ -43,7 +43,7 @@ So, in the example below the first `alert` shows `null`:
 <head>
   <script>
 *!*
-    alert( "From HEAD: " + document.body ); // null, there's no <body> yet
+    alert( "Da HEAD: " + document.body ); // null, <body> non esiste ancora
 */!*
   </script>
 </head>
@@ -51,7 +51,7 @@ So, in the example below the first `alert` shows `null`:
 <body>
 
   <script>
-    alert( "From BODY: " + document.body ); // HTMLBodyElement, now it exists
+    alert( "Da BODY: " + document.body ); // HTMLBodyElement, ora <body> esiste
   </script>
 
 </body>
@@ -59,49 +59,49 @@ So, in the example below the first `alert` shows `null`:
 ```
 ````
 
-```smart header="In the DOM world `null` means \"doesn't exist\""
-In the DOM, the `null` value means "doesn't exist" or "no such node".
+```smart header="Nel mondo del DOM `null` significa \"non esiste\""
+Nel DOM, il valore `null` significa "non esiste" o "nessun nodo trovato".
 ```
 
-## Children: childNodes, firstChild, lastChild
+## Nodi figli: childNodes, firstChild, lastChild
 
-There are two terms that we'll use from now on:
+Ci sono due termini che useremo d'ora in poi:
 
-- **Child nodes (or children)** -- elements that are direct children. In other words, they are nested exactly in the given one. For instance, `<head>` and `<body>` are children of `<html>` element.
-- **Descendants** -- all elements that are nested in the given one, including children, their children and so on.
+- **Nodi figli** (children o child node) : elementi che sono figli diretti, ossia che sono annidati al primo livello del nodo specificato. Ad esempio, `<head>` e `<body>` sono figli dell'elemento `<html>`.
+- **Discendenti** : Tutti gli elementi che sono annidati a qualsiasi livello nell'elemento specificato. Sono inclusi i figli, i figli dei figli, e così via.
 
-For instance, here `<body>` has children `<div>` and `<ul>` (and few blank text nodes):
+Ad esempio, qui `<body>` ha come figli `<div>` e `<ul>` (ed alcuni nodi di testo vuoti):
 
 ```html run
 <html>
 <body>
-  <div>Begin</div>
+  <div>Inizio</div>
 
   <ul>
     <li>
-      <b>Information</b>
+      <b>Informazione</b>
     </li>
   </ul>
 </body>
 </html>
 ```
 
-...And descendants of `<body>` are not only direct children `<div>`, `<ul>` but also more deeply nested elements, such as `<li>` (a child of `<ul>`) and `<b>` (a child of `<li>`) -- the entire subtree.
+...E come discendenti di `<body>`, oltre a `<div>` e `<ul>`, abbiamo anche gli elementi annidati più in profondità, come `<li>` (figlio di  `<ul>`) e `<b>` (figlio di `<li>`). In pratica l'intero albero sotto a `<body>`.
 
-**The `childNodes` collection lists all child nodes, including text nodes.**
+**La collection `childNodes` raccoglie tutti i nodi figlio, inclusi quelli di testo**
 
-The example below shows children of `document.body`:
+L'esempio qui sotto mostra i figli di `document.body`:
 
 ```html run
 <html>
 <body>
-  <div>Begin</div>
+  <div>Inizio</div>
 
   <ul>
-    <li>Information</li>
+    <li>Informazione</li>
   </ul>
 
-  <div>End</div>
+  <div>Fine</div>
 
   <script>
 *!*
@@ -110,81 +110,81 @@ The example below shows children of `document.body`:
     }
 */!*
   </script>
-  ...more stuff...
+  ...altro...
 </body>
 </html>
 ```
 
-Please note an interesting detail here. If we run the example above, the last element shown is `<script>`. In fact, the document has more stuff below, but at the moment of the script execution the browser did not read it yet, so the script doesn't see it.
+Da notare un particolare interessante. Se eseguiamo l'esempio, l'ultimo elemento mostrato è `<script>`. Di fatto l'ultimo elemento sarebbe "...altro...", ma al momento dell'esecuzione dello script esso non è ancora stato letto, quindi non viene visto.
 
-**Properties `firstChild` and `lastChild` give fast access to the first and last children.**
+**Le proprietà `firstChild` e `lastChild` permettono un accesso più veloce al primo ed all'ultimo figlio.**
 
-They are just shorthands. If there exist child nodes, then the following is always true:
+Sono delle semplici scorciatoie. Se sono presenti dei nodi figlio, allora le seguenti espressioni sono sempre vere :
 ```js
 elem.childNodes[0] === elem.firstChild
 elem.childNodes[elem.childNodes.length - 1] === elem.lastChild
 ```
 
-There's also a special function `elem.hasChildNodes()` to check whether there are any child nodes.
+Esiste anche la funzione speciale `elem.hasChildNodes()`, per verificare se sono presenti nodi figlio.
 
 ### DOM collections
 
-As we can see, `childNodes` looks like an array. But actually it's not an array, but rather a *collection* -- a special array-like iterable object.
+Come possiamo vedere, `childNodes` sembra un array. Ma in realtà non è un array, ma piuttosto una *collection*: uno speciale oggetto iterabile, simile ad un array.
 
-There are two important consequences:
+Questo comporta due importanti conseguenze:
 
-1. We can use `for..of` to iterate over it:
+1. Possiamo usare `for..of` per iterare:
   ```js
   for (let node of document.body.childNodes) {
-    alert(node); // shows all nodes from the collection
+    alert(node); // mostra tutti i nodi della collection
   }
   ```
-  That's because it's iterable (provides the `Symbol.iterator` property, as required).
+  Questo perché è iterabile (ha la proprietà `Symbol.iterator` che contraddistingue gli iterabili).
 
-2. Array methods won't work, because it's not an array:
+2. I metodi degli array non funzionano, perché non è un array:
   ```js run
-  alert(document.body.childNodes.filter); // undefined (there's no filter method!)
+  alert(document.body.childNodes.filter); // undefined (il metodo filter non c'è!)
   ```
 
-The first thing is nice. The second is tolerable, because we can use `Array.from` to create a "real" array from the collection, if we want array methods:
+Il primo punto è ottimo, il secondo è tollerabile. Infatti nel caso avessimo bisogno dei metodi degli array possiamo usare `Array.from` e creare un "vero" array a partire dalla collection:
 
   ```js run
   alert( Array.from(document.body.childNodes).filter ); // function
   ```
 
-```warn header="DOM collections are read-only"
-DOM collections, and even more -- *all* navigation properties listed in this chapter are read-only.
+```warn header="Le DOM collections funzionano in sola lettura"
+Le DOM collections, ed in generale *tutte* le proprietà utili alla navigazione elencate in questo capitolo, funzionano in sola lettura.
 
-We can't replace a child by something else by assigning `childNodes[i] = ...`.
+Non possiamo sostituire un nodo figlio con qualcos'altro con l'assegnazione `childNodes[i] = ...`.
 
-Changing DOM needs other methods. We will see them in the next chapter.
+Modificare il DOM richiede l'utilizzo di altri metodi, che vedremo nel prossimo capitolo.
 ```
 
-```warn header="DOM collections are live"
-Almost all DOM collections with minor exceptions are *live*. In other words, they reflect the current state of DOM.
+```warn header="Le DOM collections sono vive"
+Salvo poche eccezioni, tutte le DOM collections sono *vive*. In altre parole, riflettono lo stato corrente del DOM.
 
-If we keep a reference to `elem.childNodes`, and add/remove nodes into DOM, then they appear in the collection automatically.
+Se prendiamo come riferimento `elem.childNodes`, ed aggiungiamo o rimuoviamo nodi dal DOM, essi appariranno o scompariranno automaticamente dalla collection.
 ```
 
-````warn header="Don't use `for..in` to loop over collections"
-Collections are iterable using `for..of`. Sometimes people try to use `for..in` for that.
+````warn header="Non usare `for..in` per eseguire cicli sulle collections"
+Le collections sono iterabili usando `for..of`, ma a volte qualcuno prova ad usare `for..in`.
 
-Please, don't. The `for..in` loop iterates over all enumerable properties. And collections have some "extra" rarely used properties that we usually do not want to get:
+E' una pratica sconsigliata. I cicli `for..in` iterano su tutte le proprietà enumerabili, e le collections possiedono alcune proprietà "extra", che vengono usate raramente, e che in genere non vorremmo ci fossero restituite dal ciclo:
 
 ```html run
 <body>
 <script>
-  // shows 0, 1, length, item, values and more.
+  // mostra 0, 1, length, item, values ed altro.
   for (let prop in document.body.childNodes) alert(prop);
 </script>
 </body>
 ````
 
-## Siblings and the parent
+## I fratelli (*siblings*) ed il genitore (*parent*)
 
-*Siblings* are nodes that are children of the same parent.
+I fratelli sono nodi figli dello stesso genitore.
 
-For instance, here `<head>` and `<body>` are siblings:
+Ad esempio, qui `<head>` e `<body>` sono fratelli:
 
 ```html
 <html>
@@ -192,75 +192,75 @@ For instance, here `<head>` and `<body>` are siblings:
 </html>
 ```
 
-- `<body>` is said to be the "next" or "right" sibling of `<head>`,
-- `<head>` is said to be the "previous" or "left" sibling of `<body>`.
+- `<body>` è chiamato fratello "successivo" o "a destra" di `<head>`,
+- `<head>` è chiamato fratello "precedente" o "a sinistra" di `<body>`.
 
-The next sibling is in `nextSibling` property, and the previous one - in `previousSibling`.
+Il fratello successivo è nella proprietà `nextSibling`, quello precedente in `previousSibling`.
 
-The parent is available as `parentNode`.
+Il genitore è disponibile come `parentNode`.
 
-For example:
+Ad esempio
 
 ```js run
-// parent of <body> is <html>
+// il genitore di <body> è <html>
 alert( document.body.parentNode === document.documentElement ); // true
 
-// after <head> goes <body>
+// dopo di <head> c'è <body>
 alert( document.head.nextSibling ); // HTMLBodyElement
 
-// before <body> goes <head>
+// prima di <body> c'è <head>
 alert( document.body.previousSibling ); // HTMLHeadElement
 ```
 
-## Element-only navigation
+## Navigazione solo tra elementi
 
-Navigation properties listed above refer to *all* nodes. For instance, in `childNodes` we can see both text nodes, element nodes, and even comment nodes if there exist.
+Le proprietà di navigazione viste finora fanno riferimento a *tutti* i nodi. Ad esempio, in `childNodes` possiamo trovare: nodi elemento, nodi di testo, ed anche nodi commento se ce ne sono.
 
-But for many tasks we don't want text or comment nodes. We want to manipulate element nodes that represent tags and form the structure of the page.
+Ma per alcuni compiti non vogliamo nodi di testo o di commento. Vogliamo solo manipolare nodi che rappresentano i tags e che costituiscono la struttura della pagina.
 
-So let's see more navigation links that only take *element nodes* into account:
+Quindi vediamo altri collegamenti di navigazione che prendono in considerazione solo *nodi elemento*:
 
 ![](dom-links-elements.svg)
 
-The links are similar to those given above, just with `Element` word inside:
+I collegamenti sono simili a quelli visti prima, ma con l'aggiunta della parola `Element`:
 
-- `children` -- only those children that are element nodes.
-- `firstElementChild`, `lastElementChild` -- first and last element children.
-- `previousElementSibling`, `nextElementSibling` -- neighbor elements.
-- `parentElement` -- parent element.
+- `children` -- solo i figli che sono nodi elemento.
+- `firstElementChild`, `lastElementChild` -- il primo e l'ultimo elemento figlio.
+- `previousElementSibling`, `nextElementSibling` -- gli elementi vicini.
+- `parentElement` -- l'elemento genitore.
 
-````smart header="Why `parentElement`? Can the parent be *not* an element?"
-The `parentElement` property returns the "element" parent, while `parentNode` returns "any node" parent. These properties are usually the same: they both get the parent.
+````smart header="Perché `parentElement`? Può un genitore *non* essere un elemento?"
+La proprietà `parentElement` restituisce l'elemento genitore, mentre `parentNode` restituisce "qualsiasi nodo" genitore. Queste proprietà in genere coincidono: entrambe restituiscono lo stesso genitore.
 
-With the one exception of `document.documentElement`:
+Con l'unica eccezione di `document.documentElement`:
 
 ```js run
 alert( document.documentElement.parentNode ); // document
 alert( document.documentElement.parentElement ); // null
 ```
 
-The reason is that the root node `document.documentElement` (`<html>`) has `document` as its parent. But `document` is not an element node, so `parentNode` returns it and `parentElement` does not.
+La ragione è che il nodo radice `document.documentElement` (`<html>`) ha `document` come genitore, ma document non è un nodo elemento, quindi `parentNode` lo restituisce, mentre `parentElement` no. 
 
-This detail may be useful when we want to travel up from an arbitrary element `elem` to `<html>`, but not to the `document`:
+Questo dettaglio può essere utile quando vogliamo risalire da un elemento arbitrario `elem` verso `<html>`, ma senza arrivare a `document`: 
 ```js
-while(elem = elem.parentElement) { // go up till <html>
+while(elem = elem.parentElement) { // su, fino a <html>
   alert( elem );
 }
 ```
 ````
 
-Let's modify one of the examples above: replace `childNodes` with `children`. Now it shows only elements:
+Modifichiamo uno degli esempi sopra, sostituendo `childNodes` con` children`. Ora vengono mostrati solo gli elementi:
 
 ```html run
 <html>
 <body>
-  <div>Begin</div>
+  <div>Inizio</div>
 
   <ul>
-    <li>Information</li>
+    <li>Informazione</li>
   </ul>
 
-  <div>End</div>
+  <div>Fine</div>
 
   <script>
 *!*
@@ -274,60 +274,61 @@ Let's modify one of the examples above: replace `childNodes` with `children`. No
 </html>
 ```
 
-## More links: tables [#dom-navigation-tables]
+## Ulteriori collegamenti: tabelle [#dom-navigation-tables]
 
-Till now we described the basic navigation properties.
+Finora abbiamo descritto le proprietà base per la navigazione.
 
-Certain types of DOM elements may provide additional properties, specific to their type, for convenience.
+Alcuni tipi di elemento DOM possono fornire proprietà aggiuntive, specifiche per il loro tipo.
 
-Tables are a great example of that, and represent a particularly important case:
+Le tabelle ne sono un esempio, e rappresentano un caso particolarmente importante:
 
-**The `<table>`** element supports (in addition to the given above) these properties:
-- `table.rows` -- the collection of `<tr>` elements of the table.
-- `table.caption/tHead/tFoot` -- references to elements `<caption>`, `<thead>`, `<tfoot>`.
-- `table.tBodies` -- the collection of `<tbody>` elements (can be many according to the standard, but there will always be at least one -- even if it is not in the source HTML, the browser will put it in the DOM).
+**L'elemento `<table>`** supporta (in aggiunta a quelle trattate sinora) le seguenti proprietà:
+- `table.rows` -- la collection degli elementi `<tr>` della tabella.
+- `table.caption/tHead/tFoot` -- riferimenti agli elementi `<caption>`, `<thead>`, `<tfoot>`.
+- `table.tBodies` -- la collection degli elementi `<tbody>` (secondo lo standard possono essere molti, ma ce ne sarà sempre almeno uno. Anche se non è nell'HTML di origine, il browser lo inserirà automaticamente nel DOM).
 
-**`<thead>`, `<tfoot>`, `<tbody>`** elements provide the `rows` property:
-- `tbody.rows` -- the collection of `<tr>` inside.
+**Gli elementi `<thead>`, `<tfoot>`, `<tbody>`** hanno la proprietà `rows`:
+- `tbody.rows` -- la collection degli elementi `<tr>` contenuti.
 
 **`<tr>`:**
-- `tr.cells` -- the collection of `<td>` and `<th>` cells inside the given `<tr>`.
-- `tr.sectionRowIndex` -- the position (index) of the given `<tr>` inside the enclosing `<thead>/<tbody>/<tfoot>`.
-- `tr.rowIndex` -- the number of the `<tr>` in the table as a whole (including all table rows).
+- `tr.cells` -- la collection delle celle `<td>` e `<th>` contenute nel `<tr>` specificato.
+- `tr.sectionRowIndex` -- la posizione (index) di un dato `<tr>` incluso in `<thead>/<tbody>/<tfoot>`.
+- `tr.rowIndex` -- il numero di `<tr>` nella tabella nel suo insieme (include tutte le righe della tabella).
 
-**`<td>` and `<th>`:**
-- `td.cellIndex` -- the number of the cell inside the enclosing `<tr>`.
+**`<td>` e `<th>`:**
+- `td.cellIndex` -- il numero della celle all'interno del contenitore `<tr>`.
 
-An example of usage:
+Un esempio di utilizzo:
 
 ```html run height=100
 <table id="table">
   <tr>
-    <td>one</td><td>two</td>
+    <td>uno</td><td>due</td>
   </tr>
   <tr>
-    <td>three</td><td>four</td>
+    <td>tre</td><td>quattro</td>
   </tr>
 </table>
 
 <script>
-  // get td with "two" (first row, second column)
+  // estrai td con "two" (prima riga, seconda colonna)
   let td = table.*!*rows[0].cells[1]*/!*;
-  td.style.backgroundColor = "red"; // highlight it
+  td.style.backgroundColor = "red"; // evidenzialo
 </script>
 ```
 
-The specification: [tabular data](https://html.spec.whatwg.org/multipage/tables.html).
+La specifica: [tabular data](https://html.spec.whatwg.org/multipage/tables.html).
 
-There are also additional navigation properties for HTML forms. We'll look at them later when we start working with forms.
+Proprietà di navigazione aggiuntive, sono anche disponibili per i moduli HTML. Le esamineremo più avanti, quando inizieremo a lavorare con i moduli.
 
-## Summary
+## Riepilogo
 
-Given a DOM node, we can go to its immediate neighbors using navigation properties.
+Dato un nodo DOM, possiamo spostarci tra i suoi vicini usando le proprietà di navigazione.
 
-There are two main sets of them:
+Ne esistono due tipi principali:
 
-- For all nodes: `parentNode`, `childNodes`, `firstChild`, `lastChild`, `previousSibling`, `nextSibling`.
-- For element nodes only: `parentElement`, `children`, `firstElementChild`, `lastElementChild`, `previousElementSibling`, `nextElementSibling`.
+- Per tutti i nodi: `parentNode`, `childNodes`, `firstChild`, `lastChild`, `previousSibling`, `nextSibling`.
+- Solo per i nodi elemento: `parentElement`, `children`, `firstElementChild`, `lastElementChild`, `previousElementSibling`, `nextElementSibling`.
 
-Some types of DOM elements, e.g. tables, provide additional properties and collections to access their content.
+Alcuni tipi di elemento DOM, es. le tabelle, 
+Some types of DOM elements, e.g. tables, forniscono proprietà e collections aggiuntive per accedere al loro contenuto.
