Merge pull request #40 from fiji-flo/unslugging-it

Unslugging it

32 files changed, 53 insertions, 1638 deletions

diff --git a/files/it/web/javascript/una_reintroduzione_al_javascript/index.html b/files/it/web/javascript/a_re-introduction_to_javascript/index.html
index 4dc4a484a7..e0d779e1b1 100644
--- a/files/it/web/javascript/una_reintroduzione_al_javascript/index.html
+++ b/files/it/web/javascript/a_re-introduction_to_javascript/index.html
@@ -1,7 +1,8 @@
 ---
 title: Una reintroduzione al Java Script (Tutorial JS)
-slug: Web/JavaScript/Una_reintroduzione_al_JavaScript
+slug: Web/JavaScript/A_re-introduction_to_JavaScript
 translation_of: Web/JavaScript/A_re-introduction_to_JavaScript
+original_slug: Web/JavaScript/Una_reintroduzione_al_JavaScript
 ---
 <h2 id="Introduzione">Introduzione</h2>
 
diff --git a/files/it/web/javascript/cosè_javascript/index.html b/files/it/web/javascript/about_javascript/index.html
index c850023b92..04dc002900 100644
--- a/files/it/web/javascript/cosè_javascript/index.html
+++ b/files/it/web/javascript/about_javascript/index.html
@@ -1,7 +1,8 @@
 ---
 title: Cos'è JavaScript
-slug: Web/JavaScript/Cosè_JavaScript
+slug: Web/JavaScript/About_JavaScript
 translation_of: Web/JavaScript/About_JavaScript
+original_slug: Web/JavaScript/Cosè_JavaScript
 ---
 <div>{{JsSidebar}}</div>
 
diff --git a/files/it/web/javascript/chiusure/index.html b/files/it/web/javascript/closures/index.html
index deee56e54b..b45bf70944 100644
--- a/files/it/web/javascript/chiusure/index.html
+++ b/files/it/web/javascript/closures/index.html
@@ -1,7 +1,8 @@
 ---
 title: Chiusure
-slug: Web/JavaScript/Chiusure
+slug: Web/JavaScript/Closures
 translation_of: Web/JavaScript/Closures
+original_slug: Web/JavaScript/Chiusure
 ---
 <div>{{jsSidebar("Intermediate")}}</div>
 
diff --git a/files/it/web/javascript/getting_started/index.html b/files/it/web/javascript/getting_started/index.html
deleted file mode 100644
index d9c0357ebb..0000000000
--- a/files/it/web/javascript/getting_started/index.html
+++ /dev/null
@@ -1,331 +0,0 @@
----
-title: Getting Started (JavaScript Tutorial)
-slug: Web/JavaScript/Getting_Started
-translation_of: Learn/Getting_started_with_the_web/JavaScript_basics
-translation_of_original: Web/JavaScript/Getting_Started
----
-<h2 id="Why_JavaScript.3F" name="Why_JavaScript.3F">Perché JavaScript?</h2>
-<p>JavaScript è un linguaggio per computer potente, complicato, e spesso misconosciuto. Permette lo sviluppo rapido di applicazioni in cui gli utenti possono inserire i dati e vedere i risultati facilmente.</p>
-<p>Il vantaggio primario di JavaScript, che è anche conosciuto come ECMAScript, è che è centrato intorno al Web browser, così da avere la capacità di produrre gli stessi risultati su tutte le piattaforme supportate dal browser. Gli esempi in questa pagina, proprio come Google Maps, girano su Linux, Windows, e OS X. Con la recente crescita di numerose librerie JavaScript è ora più facile traversare un documento, selezionare gli elementi del DOM, creare animazioni, trattare eventi, e sviluppare applicazioni Ajax. Diversamente dalla promozione intorno alle altre tecnologie spinta da vari interessi proprietari, JavaScript è realmente il solo linguaggio di programmazione "cross-platform" e "client-side" che è sia libero che universalmente adottato.</p>
-<h2 id="What_you_should_already_know" name="What_you_should_already_know">Cosa dovresti già conoscere</h2>
-<p>Iniziare a programmare con JavaScript è molto semplice. Tutto quello che serve per cominciare è un editor di testo e un Web browser.</p>
-<p>Ci sono molte altre tecnologie che possono essere integrate e sviluppate insieme a Javascript che sono al di fuori di questo documento. Non aspettarti di fare un'intera applicazione come Google Maps tutta nel tuo primo giorno!</p>
-<h2 id="Getting_Started" name="Getting_Started">Come iniziare</h2>
-<p>Iniziare con JavaScript è molto semplice. Non devi aver precedentemente installato complicati programmi di sviluppo. Non devi conoscere come usare una shell, programmare Make, o usare un compilatore. JavaScript è interpretato dal tuo Web browser. Tutto quello che hai da fare è salvare il tuo programma come file testo e poi aprirlo nel tuo Web browser. E' tutto qui!</p>
-<p>JavaScript è un linguaggio di programmazione ideale per linguaggi di computer introduttivi. Permette ai nuovi studenti di avere risposte immediate e insegna loro strumenti che essi troveranno di facile uso nella loro vita reale. Ciò è in assoluto contrasto con C, C++, and Java che sono veramente facili solo per sviluppatori software specializzati.</p>
-<h2 id="Browser_Compatibility_Issues" name="Browser_Compatibility_Issues">Browser compatibility issues</h2>
-<p>There are variations between what functionality is available in the different browsers. Mozilla, Chrome, Microsoft IE, Apple Safari, and Opera fluctuate in behavior. You can mitigate these issues by using the various cross-platform JavaScript APIs that are available. These APIs provide common functionality and hide these browser fluctuations from you.</p>
-<h2 id="How_to_try_the_Examples" name="How_to_try_the_Examples">How to try the examples</h2>
-<p>The examples below have some sample code. There are many ways to try these examples out. If you already have your own website, then you should be able to just save these examples as new Web pages on your website.</p>
-<p>If you do not have your own website, you can save these examples as files on your computer and open them up with the Web browser you are using now. JavaScript is a very easy language to use for beginning programmers for this reason. You don't need a compiler or a development environment; you and your browser are all you need to get started!</p>
-<p>You can also take use of some online programs like <a href="http://jsfiddle.net/">jsfiddle.net</a></p>
-<h2 id="Example:_Catching_a_mouse_click" name="Example:_Catching_a_mouse_click">Example: Catching a mouse click</h2>
-<p>The specifics of event handling (event types, handler registration, propagation, etc.) are too extensive to be fully covered in this simple example. However, this example cannot demonstrate catching a mouse click without delving a little into the JavaScript event system. Just keep in mind that this example will only graze the full details about JavaScript events and that if you wish to go beyond the basic capabilities described here, read more about the JavaScript event system.</p>
-<p>'Mouse' events are a subset of the total events issued by a Web browser in response to user actions. The following is a list of the events emitted in response to a user's mouse action:</p>
-<ul>
- <li>Click - issued when a user clicks the mouse</li>
- <li>DblClick - issued when a user double-clicks the mouse</li>
- <li>MouseDown - issued when a user depresses a mouse button (the first half of a click)</li>
- <li>MouseUp - issued when a user releases a mouse button (the second half of a click)</li>
- <li>MouseOut - issued when the mouse pointer leaves the graphical bounds of the object</li>
- <li>MouseOver - issued when the mouse pointer enters the graphical bounds of the object</li>
- <li>MouseMove - issued when the mouse pointer moves while within the graphical bounds of the object</li>
- <li>ContextMenu - issued when the user clicks using the right mouse button</li>
-</ul>
-<p>Note that in the latest versions of HTML, the inline event handlers, i.e. the ones added as tag attributes, are expected to be all lowercase and that event handlers in script are always all lowercase.</p>
-<p>The simplest method for capturing these events, to register event handlers - using HTML - is to specify the individual events as attributes for your element. Example:</p>
-<pre class="brush:js">  &lt;span onclick="alert('Hello World!');"&gt;Click Here&lt;/span&gt;</pre>
-<p>The JavaScript code you wish to execute can be inlined as the attribute value or you can call a function which has been defined in a &lt;script&gt; block within the HTML page:</p>
-<pre class="brush:js">&lt;script&gt;
-  function clickHandler() {
-     alert("Hello, World!");
-  }
-&lt;/script&gt;
-&lt;span onclick="clickHandler();"&gt;Click Here&lt;/span&gt;</pre>
-<p>Additionally, the event object which is issued can be captured and referenced, providing the developer with access to specifics about the event such as which object received the event, the event's type, and which mouse button was clicked. Using the inline example again:</p>
-<pre class="brush:js">&lt;script&gt;
-  function clickHandler(event) {
-    var eType = event.type;
-    /* the following is for compatibility */
-    /* Moz populates the target property of the event object */
-    /* IE populates the srcElement property */
-    var eTarget = event.target || event.srcElement;
-
-    alert( "Captured Event (type=" + eType + ", target=" + eTarget + ")" );
-  }
-&lt;/script&gt;
-&lt;span onclick="clickHandler(event);"&gt;Click Here&lt;/span&gt;</pre>
-<p>In addition to registering to receive events in your HTML, you can likewise set the same attributes of any HTMLElement objects generated by your JavaScript. The example below instantiates (creates) a span object, appends it to the page body, and registers the span object to receive mouse-over, mouse-out, mouse-down, and mouse-up events.</p>
-<pre class="brush:js">&lt;body&gt;&lt;/body&gt;
-&lt;script&gt;
-  function mouseeventHandler(event) {
-    /* The following is for compatibility */
-    /* IE does NOT by default pass the event object */
-    /* obtain a ref to the event if one was not given */
-    if (!event) event = window.event;
-
-    /* obtain event type and target as earlier */
-    var eType = event.type;
-    var eTarget = event.target || event.srcElement;
-    alert(eType +' event on element with id: '+ eTarget.id);
-  }
-
- function onloadHandler() {
-   /* obtain a ref to the 'body' element of the page */
-   var body = document.body;
-   /* create a span element to be clicked */
-   var span = document.createElement('span');
-   span.id = 'ExampleSpan';
-   span.appendChild(document.createTextNode ('Click Here!'));
-
-   /* register the span object to receive specific mouse events -
-      notice the lowercase of the events but the free choice in the names of the handlers you replace them with.
-   */
-   span.onmousedown = mouseeventHandler;
-   span.onmouseup = mouseeventHandler;
-   span.onmouseover = mouseeventHandler;
-   span.onmouseout = mouseeventHandler;
-
-   /* display the span on the page */
-   body.appendChild(span);
-}
-
-window.onload = onloadHandler; // since we replace the handler, we do NOT have () after the function name
-&lt;/script&gt;</pre>
-<h2 id="Example:_Catching_a_keyboard_event" name="Example:_Catching_a_keyboard_event">Example: Catching a keyboard event</h2>
-<p>Similar to the "Catching a mouse event" example above, catching a keyboard event relies on exploring the JavaScript event system. Keyboard events are fired whenever any key is used on the keyboard.</p>
-<p>The list of available keyboard events emitted in response to a keyboard action is considerably smaller than those available for mouse:</p>
-<ul>
- <li>KeyPress - issued when a key is depressed and released</li>
- <li>KeyDown - issued when a key is depressed but hasn't yet been released</li>
- <li>KeyUp - issued when a key is released</li>
- <li>TextInput (available in Webkit browsers only at time of writing) - issued when text is input either by pasting, speaking, or keyboard. This event will not be covered in this article.</li>
-</ul>
-<p>In a <a class="new " href="/en-US/docs/DOM/event/keypress" rel="internal">keypress</a> event, the Unicode value of the key pressed is stored in either the <code>keyCode</code> or <code><a href="/en-US/docs/DOM/event.charCode" rel="internal">charCode</a></code> property, never both. If the key pressed generates a character (e.g., 'a'), <code>charCode</code> is set to the code of that character, respecting the letter case (i.e., <code>charCode</code> takes into account whether the shift key is held down). Otherwise, the code of the pressed key is stored in <code>keyCode</code>.</p>
-<p>The simplest method for capturing keyboard events is again to register event handlers within the HTML, specifying the individual events as attributes for your element. Example:</p>
-<pre class="brush:js">  &lt;input type="text" onkeypress="alert ('Hello World!');"&gt;
-</pre>
-<p>As with mouse events, the JavaScript code you wish to execute can be inlined as the attribute value or you can call a function which has been defined in a &lt;script&gt; block within the HTML page:</p>
-<pre class="brush:js">&lt;script&gt;
-  function keypressHandler() {
-    alert ("Hello, World!");
-  }
-&lt;/script&gt;
-
-&lt;input onkeypress="keypressHandler();" /&gt;
-</pre>
-<p>Capturing the event and referencing the target (i.e., the actual key that was pressed) is achieved in a similar way to mouse events:</p>
-<pre class="brush:js">&lt;script type="text/javascript"&gt;
-  function keypressHandler(evt) {
-      var eType = evt.type; // Will return "keypress" as the event type
-      /* here we again need to use a cross browser method
-         mozilla based browsers return which and others keyCode.
-         The <a href="/en-US/docs/JavaScript/Reference/Operators/Conditional_Operator" title="/en-US/docs/JavaScript/Reference/Operators/Conditional_Operator">Conditional operator</a> or ternary is a good choice */
-      var keyCode = evt.which?evt.which:evt.keyCode;
-      var eCode = 'keyCode is ' + keyCode;
-      var eChar = 'charCode is ' + <span class="typ" style="background-color: transparent; margin: 0px; padding: 0px; border: 0px; vertical-align: baseline; color: rgb(43, 145, 175);">String</span><span class="pun" style="background-color: transparent; color: rgb(0, 0, 0); margin: 0px; padding: 0px; border: 0px; vertical-align: baseline;">.</span><span class="pln" style="background-color: transparent; color: rgb(0, 0, 0); margin: 0px; padding: 0px; border: 0px; vertical-align: baseline;">fromCharCode(</span>keyCode); // or evt.charCode
-      alert ("Captured Event (type=" + eType + ", key Unicode value=" + eCode + ", ASCII value=" + eChar + ")");
-   }
-&lt;/script&gt;
-&lt;input onkeypress="keypressHandler(event);" /&gt;</pre>
-<p>Capturing any key event from the page can be done by registering the event at the document level and handling it in a function:</p>
-<pre class="brush:js">&lt;script&gt;
-  document.onkeypress = keypressHandler;
-  document.onkeydown = keypressHandler;
-  document.onkeyup = keypressHandler;
-&lt;/script&gt;</pre>
-<p>Here is a complete example that shows key event handling:</p>
-<pre class="brush:js">&lt;!DOCTYPE html&gt;
-&lt;html&gt;
-&lt;head&gt;
-  &lt;script&gt;
-    var metaChar = false;
-    var exampleKey = 16;
-    function keyEvent(event) {
-      var key = event.keyCode || event.which; // alternative to ternary - if there is no keyCode, use which
-      var keychar = String.fromCharCode(key);
-      if (key == exampleKey) {
-        metaChar = true;
-      }
-      if (key != exampleKey) {
-         if (metaChar) {
-            alert("Combination of metaKey + " + keychar)
-            metaChar = false;
-         } else {
-           alert("Key pressed " + key);
-         }
-      }
-    }
-    function metaKeyUp(event) {
-      var key = event.keyCode || event.which;
-      if (key == exampleKey) { metaChar = false; }
-    }
-  &lt;/script&gt;
-&lt;/head&gt;
-&lt;body onkeydown="keyEvent(event)" onkeyup="metaKeyUp(event)"&gt;
-    Try pressing any key!
-&lt;/body&gt;
-&lt;/html&gt;</pre>
-<h3 id="Browser_bugs_and_quirks">Browser bugs and quirks</h3>
-<p>The two properties made available through the key events are <code>keyCode</code> and <code>charCode</code>. In simple terms, <code>keyCode</code> refers to the actual keyboard key that was pressed by the user, while <code>charCode</code> is intended to return that key's ASCII value. These two values may not necessarily be the same; for instance, a lower case 'a' and an upper case 'A' have the same <code>keyCode</code>, because the user presses the same key, but a different <code>charCode</code> because the resulting character is different.</p>
-<p>The way in which browsers interpret the charCode is not a consistently-applied process. For example, Internet Explorer and Opera do not support <code>charCode</code>. However, they give the character information in <code>keyCode</code>, but only onkeypress. Onkeydown and onkeyup <code>keyCode</code> contain key information. Firefox uses a different word, "which", to distinguish the character.</p>
-<p>Refer to the Mozilla Documentation on <a href="/en-US/docs/DOM/Event/UIEvent/KeyboardEvent" title="https://developer.mozilla.org/en-US/docs/DOM/Event/UIEvent/KeyEvent">Keyboard Events</a> for a further treatment of keyboard events.</p>
-<p>{{ draft() }}</p>
-<h2 id="Example:_Dragging_images_around" name="Example:_Dragging_images_around">Example: Dragging images around</h2>
-<p>The following example allows moving the image of Firefox around the page:</p>
-<pre class="brush:js">&lt;!DOCTYPE html&gt;
-&lt;html&gt;
-&lt;head&gt;
-&lt;style&gt;
-img { position: absolute; }
-&lt;/style&gt;
-
-&lt;script&gt;
-window.onload = function() {
-
-  movMeId = document.getElementById("ImgMov");
-  movMeId.style.top = "80px";
-  movMeId.style.left = "80px";
-
-  document.onmousedown = coordinates;
-  document.onmouseup = mouseup;
-
-  function coordinates(e) {
-    if (e == null) { e = window.event;}
-
-    // e.srcElement holds the target element in IE, whereas e.target holds the target element in Firefox
-    // Both properties return the HTML element the event took place on.
-
-    var sender = (typeof( window.event ) != "undefined" ) ? e.srcElement : e.target;
-
-    if (sender.id=="ImgMov") {
-      mouseover = true;
-      pleft = parseInt(movMeId.style.left);
-      ptop = parseInt(movMeId.style.top);
-      xcoor = e.clientX;
-      ycoor = e.clientY;
-      document.onmousemove = moveImage;
-      return false;
-    }
-    return false;
-  }
-
-  function moveImage(e) {
-    if (e == null) { e = window.event; }
-    movMeId.style.left = pleft+e.clientX-xcoor+"px";
-    movMeId.style.top = ptop+e.clientY-ycoor+"px";
-    return false;
-  }
-
-  function mouseup(e) {
-    document.onmousemove = null;
-  }
-}
-&lt;/script&gt;
-&lt;/head&gt;
-
-&lt;body&gt;
-  &lt;img id="ImgMov" src="http://placehold.it/100x100&amp;text=JS" width="64" height="64"&gt;
-  &lt;p&gt;Drag and drop around the image in this page.&lt;/p&gt;
-&lt;/body&gt;
-
-&lt;/html&gt;</pre>
-<h2 id="Example:_Resizing_things" name="Example:_Resizing_things">Example: Resizing things</h2>
-<div>
- Example of resizing an image (the actual image is not resized, only the image's rendering.)
- <pre class="brush:js">  &lt;!DOCTYPE html&gt;
-  &lt;html&gt;
-    &lt;head&gt;
-      &lt;style&gt;
-        #resizeImage {
-          margin-left: 100px;
-        }
-      &lt;/style&gt;
-      &lt;script&gt;
-      window.onload = function() {
-
-        var resizeId = document.getElementById("resizeImage");
-        var resizeStartCoordsX,
-            resizeStartCoordsY,
-            resizeEndCoordsX,
-            resizeEndCoordsY;
-
-        var resizeEndCoords;
-        var resizing = false;
-
-        document.onmousedown = coordinatesMousedown;
-        document.onmouseup = coordinatesMouseup;
-
-        function coordinatesMousedown(e) {
-          if (e == null) {
-            e = window.event;
-          }
-
-          var element = (typeof( window.event ) != 'undefined' ) ? e.srcElement : e.target;
-
-          if (element.id == "resizeImage") {
-            resizing = true;
-            resizeStartCoordsX = e.clientX;
-            resizeStartCoordsY = e.clientY;
-          }
-          return false;
-        }
-
-        function coordinatesMouseup(e) {
-          if (e == null) {
-            e = window.event;
-          }
-
-          if (resizing === true) {
-            var currentImageWidth = parseInt(resizeId.width);
-            var currentImageHeight = parseInt(resizeId.height);
-
-            resizeEndCoordsX = e.clientX;
-            resizeEndCoordsY = e.clientY;
-
-            resizeId.style.height = currentImageHeight - (resizeStartCoordsY - resizeEndCoordsY) + 'px';
-            resizeId.style.width = currentImageWidth - (resizeStartCoordsX - resizeEndCoordsX) + 'px';
-
-            resizing = false;
-          }
-          return false;
-        }
-      }
-      &lt;/script&gt;
-    &lt;/head&gt;
-
-    &lt;body&gt;
-      &lt;img id="resizeImage" src="http://upload.wikimedia.org/wikipedia/commons/e/e7/Mozilla_Firefox_3.5_logo_256.png"
-width="64" height="64"&gt;
-      &lt;p&gt;Click on the image and drag for resizing.&lt;/p&gt;
-    &lt;/body&gt;
-
-  &lt;/html&gt;</pre>
-</div>
-<h2 id="Example:_Drawing_Lines" name="Example:_Drawing_Lines">Example: Drawing Lines</h2>
-<pre class="brush: html">&lt;!DOCTYPE html&gt;
-&lt;html&gt;
-&lt;head&gt;
-&lt;script&gt;
-function linedraw(ax,ay,bx,by)
-{
-    if(ay&gt;by)
-    {
-        bx=ax+bx;
-        ax=bx-ax;
-        bx=bx-ax;
-        by=ay+by;
-        ay=by-ay;
-        by=by-ay;
-    }
-    var calc=Math.atan((ay-by)/(bx-ax));
-    calc=calc*180/Math.PI;
-    var length=Math.sqrt((ax-bx)*(ax-bx)+(ay-by)*(ay-by));
-    document.body.innerHTML += "&lt;div id='line' style='height:" + length + "px;width:1px;background-color:black;position:absolute;top:" + (ay) + "px;left:" + (ax) + "px;transform:rotate(" + calc + "deg);-ms-transform:rotate(" + calc + "deg);transform-origin:0% 0%;-moz-transform:rotate(" + calc + "deg);-moz-transform-origin:0% 0%;-webkit-transform:rotate(" + calc  + "deg);-webkit-transform-origin:0% 0%;-o-transform:rotate(" + calc + "deg);-o-transform-origin:0% 0%;'&gt;&lt;/div&gt;"
-}
-&lt;/script&gt;
-&lt;/head&gt;
-&lt;body onload="linedraw(200,400,500,900);"&gt; &lt;!-- Replace with your co-ordinate --&gt;
-&lt;/body&gt;
-&lt;/html&gt;</pre>
-<p> </p>
diff --git a/files/it/web/javascript/guida/controllo_del_flusso_e_gestione_degli_errori/index.html b/files/it/web/javascript/guide/control_flow_and_error_handling/index.html
index 76e72f5cba..9d162aa359 100644
--- a/files/it/web/javascript/guida/controllo_del_flusso_e_gestione_degli_errori/index.html
+++ b/files/it/web/javascript/guide/control_flow_and_error_handling/index.html
@@ -1,13 +1,14 @@
 ---
 title: Controllo del flusso di esecuzione e gestione degli errori
-slug: Web/JavaScript/Guida/Controllo_del_flusso_e_gestione_degli_errori
+slug: Web/JavaScript/Guide/Control_flow_and_error_handling
 tags:
   - Controllo di flusso
   - Guide
   - JavaScript
   - Principianti
-  - 'l10n:priority'
+  - l10n:priority
 translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling
+original_slug: Web/JavaScript/Guida/Controllo_del_flusso_e_gestione_degli_errori
 ---
 <div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Grammar_and_types", "Web/JavaScript/Guide/Loops_and_iteration")}}</div>
 
diff --git a/files/it/web/javascript/guida/dettagli_object_model/index.html b/files/it/web/javascript/guide/details_of_the_object_model/index.html
index 1e2d4dc74f..5751006822 100644
--- a/files/it/web/javascript/guida/dettagli_object_model/index.html
+++ b/files/it/web/javascript/guide/details_of_the_object_model/index.html
@@ -1,11 +1,12 @@
 ---
 title: Dettagli del modello a oggetti
-slug: Web/JavaScript/Guida/Dettagli_Object_Model
+slug: Web/JavaScript/Guide/Details_of_the_Object_Model
 tags:
   - Guide
   - Intermediate
   - JavaScript
 translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
+original_slug: Web/JavaScript/Guida/Dettagli_Object_Model
 ---
 <div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Iterators_and_Generators")}}</div>
 
diff --git a/files/it/web/javascript/guida/functions/index.html b/files/it/web/javascript/guide/functions/index.html
index 4aca8d5a7b..274da563ca 100644
--- a/files/it/web/javascript/guida/functions/index.html
+++ b/files/it/web/javascript/guide/functions/index.html
@@ -1,7 +1,8 @@
 ---
 title: Funzioni
-slug: Web/JavaScript/Guida/Functions
+slug: Web/JavaScript/Guide/Functions
 translation_of: Web/JavaScript/Guide/Functions
+original_slug: Web/JavaScript/Guida/Functions
 ---
 <div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Loops_and_iteration", "Web/JavaScript/Guide/Expressions_and_Operators")}}</div>
 
diff --git a/files/it/web/javascript/guida/grammar_and_types/index.html b/files/it/web/javascript/guide/grammar_and_types/index.html
index 2a43d5230d..6fc3f276b9 100644
--- a/files/it/web/javascript/guida/grammar_and_types/index.html
+++ b/files/it/web/javascript/guide/grammar_and_types/index.html
@@ -1,7 +1,8 @@
 ---
 title: Grammatica e tipi
-slug: Web/JavaScript/Guida/Grammar_and_types
+slug: Web/JavaScript/Guide/Grammar_and_types
 translation_of: Web/JavaScript/Guide/Grammar_and_types
+original_slug: Web/JavaScript/Guida/Grammar_and_types
 ---
 <div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</div>
 
diff --git a/files/it/web/javascript/guida/index.html b/files/it/web/javascript/guide/index.html
index ba956f21f2..658194bd86 100644
--- a/files/it/web/javascript/guida/index.html
+++ b/files/it/web/javascript/guide/index.html
@@ -1,6 +1,6 @@
 ---
 title: JavaScript Guide
-slug: Web/JavaScript/Guida
+slug: Web/JavaScript/Guide
 tags:
   - AJAX
   - JavaScript
@@ -8,6 +8,7 @@ tags:
   - NeedsTranslation
   - TopicStub
 translation_of: Web/JavaScript/Guide
+original_slug: Web/JavaScript/Guida
 ---
 <div>{{jsSidebar("JavaScript Guide")}}</div>
 
diff --git a/files/it/web/javascript/guida/introduzione/index.html b/files/it/web/javascript/guide/introduction/index.html
index 3825ded91c..daa5a185ea 100644
--- a/files/it/web/javascript/guida/introduzione/index.html
+++ b/files/it/web/javascript/guide/introduction/index.html
@@ -1,10 +1,11 @@
 ---
 title: Introduzione
-slug: Web/JavaScript/Guida/Introduzione
+slug: Web/JavaScript/Guide/Introduction
 tags:
   - Guida
   - JavaScript
 translation_of: Web/JavaScript/Guide/Introduction
+original_slug: Web/JavaScript/Guida/Introduzione
 ---
 <div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}</div>
 
diff --git a/files/it/web/javascript/guida/iteratori_e_generatori/index.html b/files/it/web/javascript/guide/iterators_and_generators/index.html
index 49b220cdd1..dbfd114f2d 100644
--- a/files/it/web/javascript/guida/iteratori_e_generatori/index.html
+++ b/files/it/web/javascript/guide/iterators_and_generators/index.html
@@ -1,7 +1,8 @@
 ---
 title: Iteratori e generatori
-slug: Web/JavaScript/Guida/Iteratori_e_generatori
+slug: Web/JavaScript/Guide/Iterators_and_Generators
 translation_of: Web/JavaScript/Guide/Iterators_and_Generators
+original_slug: Web/JavaScript/Guida/Iteratori_e_generatori
 ---
 <div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Details_of_the_Object_Model", "Web/JavaScript/Guide/Meta_programming")}}</div>
 
diff --git a/files/it/web/javascript/guida/loops_and_iteration/index.html b/files/it/web/javascript/guide/loops_and_iteration/index.html
index c677151181..5e5332e541 100644
--- a/files/it/web/javascript/guida/loops_and_iteration/index.html
+++ b/files/it/web/javascript/guide/loops_and_iteration/index.html
@@ -1,12 +1,13 @@
 ---
 title: Cicli e iterazioni
-slug: Web/JavaScript/Guida/Loops_and_iteration
+slug: Web/JavaScript/Guide/Loops_and_iteration
 tags:
   - Guide
   - JavaScript
   - Loop
   - Sintassi
 translation_of: Web/JavaScript/Guide/Loops_and_iteration
+original_slug: Web/JavaScript/Guida/Loops_and_iteration
 ---
 <div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Control_flow_and_error_handling", "Web/JavaScript/Guide/Functions")}}</div>
 
diff --git a/files/it/web/javascript/guida/espressioni_regolari/index.html b/files/it/web/javascript/guide/regular_expressions/index.html
index f876045948..4e95f451a5 100644
--- a/files/it/web/javascript/guida/espressioni_regolari/index.html
+++ b/files/it/web/javascript/guide/regular_expressions/index.html
@@ -1,7 +1,8 @@
 ---
 title: Espressioni regolari
-slug: Web/JavaScript/Guida/Espressioni_Regolari
+slug: Web/JavaScript/Guide/Regular_Expressions
 translation_of: Web/JavaScript/Guide/Regular_Expressions
+original_slug: Web/JavaScript/Guida/Espressioni_Regolari
 ---
 <div>{{jsSidebar("Guida JavaScript")}} {{PreviousNext("Web/JavaScript/Guide/Text_formatting", "Web/JavaScript/Guide/Indexed_collections")}}</div>
 
diff --git a/files/it/web/javascript/introduzione_al_carattere_object-oriented_di_javascript/index.html b/files/it/web/javascript/introduzione_al_carattere_object-oriented_di_javascript/index.html
deleted file mode 100644
index 6281d7ef4b..0000000000
--- a/files/it/web/javascript/introduzione_al_carattere_object-oriented_di_javascript/index.html
+++ /dev/null
@@ -1,391 +0,0 @@
----
-title: Introduzione a JavaScript Object-Oriented
-slug: Web/JavaScript/Introduzione_al_carattere_Object-Oriented_di_JavaScript
-tags:
-  - Classe
-  - Costruttore
-  - Eredità
-  - Incapsulamento
-  - Membri
-  - Oggetto
-  - Orientato agli oggetti
-translation_of: Learn/JavaScript/Objects
-translation_of_original: Web/JavaScript/Introduction_to_Object-Oriented_JavaScript
----
-<p>{{jsSidebar("Introductory")}}</p>
-
-<p>Orientato agli oggetti fino dal nucleo, JavaScript offre funzionalità {{Glossary("OOP")}} potenti e flessibili. <span id="result_box" lang="it"><span class="hps">Questo</span> <span class="hps">articolo inizia</span> <span class="hps">con una introduzione</span> <span class="hps">alla</span> <span class="hps">programmazione</span> <span class="hps">orientata agli oggetti</span><span>,</span> quindi presenta <span class="hps">il</span> <span class="hps">modello di oggetti</span> <span class="hps">JavaScript</span> <span class="hps">e, infine,</span> <span class="hps">dimostra</span> <span class="hps">concetti della</span> <span class="hps">programmazione orientata agli oggetti</span> <span class="hps">in JavaScript</span><span>.</span></span></p>
-
-<h2 id="JavaScript_Review" name="JavaScript_Review">Riesame su JavaScript</h2>
-
-<p><span id="result_box" lang="it"><span class="hps">Se</span> <span class="hps">non ti senti</span> <span class="hps">sicuro su</span> <span class="hps">concetti</span> <span class="hps">JavaScript</span><span> come</span> <span class="hps">variabili, tipi</span><span>, funzioni e</span> <span class="hps">ambito di applicazione</span><span>,</span> <span class="hps">puoi leggere su</span> <span class="hps">questi argomenti</span> </span>in <a href="/it/JavaScript/Una_re-introduzione_a_JavaScript" title="it/JavaScript/Una_re-introduzione_a_JavaScript">A re-introduction to JavaScript</a>. Puoi<span lang="it"><span class="hps"> inoltre consultare</span> <span class="hps">la</span></span> <a href="/it/JavaScript/Guida" title="it/JavaScript/Guida">Core JavaScript 1.5 Guide</a>.</p>
-
-<h2 id="Object-oriented_programming" name="Object-oriented_programming">Programmazione object-oriented</h2>
-
-<p>La programmazione orientata agli oggetti è un paradigma di programmazione che usa astrazione ({{glossary("abstraction")}}) per creare modelli basati sul mondo reale. Utilizza diverse tecniche di paradigmi esistenti, tra cui la modularità ({{glossary("modularity")}}), il polimorfismo ({{glossary("polymorphism")}}) e l'incapsulamento ({{glossary("encapsulation")}}). Oggi molti linguaggi di programmazione (come Java, JavaScript, C #, C ++, Python, PHP, Ruby e Objective-C) supportano la programmazione orientata agli oggetti (OOP).</p>
-
-<p><span id="result_box" lang="it">OOP <span class="hps">ha una visione del</span> <span class="hps">software come</span> <span class="hps">un insieme di oggetti</span> <span class="hps">cooperanti</span><span>,</span> <span class="hps">piuttosto che </span><span class="hps">un insieme di funzioni</span> <span class="hps">o semplicemente </span><span class="hps">un elenco</span> <span class="hps">di istruzioni per il</span> <span class="hps">computer (come è nella visione tradizionale).</span> <span class="hps">In</span> <span class="hps">OOP</span><span>,</span> <span class="hps">ogni oggetto è</span> <span class="hps">in grado di ricevere</span> <span class="hps">messaggi</span><span>,</span> <span class="hps">elaborare dati</span><span>,</span> <span class="hps">e</span> <span class="hps">inviare messaggi</span> <span class="hps">ad altri oggetti</span><span>.</span> <span class="hps">Ogni oggetto</span> <span class="hps">può essere visto come</span> <span class="hps">una</span> <span class="hps">piccola macchina</span> <span class="hps">indipendente con</span> </span><span lang="it"><span class="hps">ruolo o</span> <span class="hps">responsabilità</span><span> distinti.</span></span></p>
-
-<p><span id="result_box" lang="it"><span class="hps">OOP</span> <span class="hps">promuove una maggiore</span> <span class="hps">flessibilità e</span> mantenibilità <span class="hps">nella</span> <span class="hps">programmazione</span><span>,</span> <span class="hps">ed è</span> <span class="hps">molto popolare</span> <span class="hps">in</span> <span class="hps">ingegneria del software su larga scala</span><span>.</span> <span class="hps">Poiché</span> <span class="hps">OOP</span> <span class="hps">sottolinea con forza</span> <span class="hps">la modularità</span><span>,</span> <span class="hps">il codice</span> <span class="hps">object-oriented</span> <span class="hps">è più semplice da</span> <span class="hps">sviluppare e</span> <span class="hps">più facile da capire</span> <span class="hps">in seguito.</span> <span class="hps">Il codice</span> <span class="hps">object-oriented</span> <span class="hps">promuove</span> <span class="hps">un'analisi</span><span>,</span> <span class="hps">codifica</span><span>,</span> <span class="hps">e comprensione</span> <span class="hps">di</span> <span class="hps">situazioni</span></span><span lang="it"><span class="hps"> e</span> <span class="hps">procedure</span></span><span id="result_box" lang="it"><span class="hps"> complesse</span></span><span lang="it"><span class="hps"> più</span> <span class="hps">diretta</span> <span class="hps">che con</span> <span class="hps">metodi di programmazione</span> <span class="hps">a minor modularità</span></span><sup>.</sup><a href="https://developer.mozilla.org/it/docs/Web/JavaScript/Introduzione_al_carattere_Object-Oriented_di_JavaScript$edit#cite-1"><sup>1</sup></a></p>
-
-<h2 id="Terminology" name="Terminology">Terminologia</h2>
-
-<dl>
- <dt>{{Glossary("Namespace")}}</dt>
- <dd><span id="result_box" lang="it"><span class="hps">Un contenitore</span> <span class="hps">che</span> <span class="hps">consente agli sviluppatori di</span> <span class="hps">includere tutte</span> <span class="hps">le funzionalità</span> <span class="hps">sotto</span> <span class="hps">un</span> <span class="hps">nome unico, specifico per l'</span><span class="hps">applicazione</span><span>.</span></span></dd>
- <dt>{{Glossary("Class")}}</dt>
- <dd><span id="result_box" lang="it"><span class="hps">Definisce</span> <span class="hps">le caratteristiche dell'oggetto</span><span>.</span> <span class="hps">Una classe</span> <span class="hps">è una definizione</span> <span class="hps">del modello,</span> <span class="hps">delle proprietà e dei metodi</span> <span class="hps">di un oggetto</span><span>.</span></span></dd>
- <dt>{{Glossary("Object")}}</dt>
- <dd>Istanza di una classe.</dd>
- <dt>{{Glossary("Property")}}</dt>
- <dd>Una caratteristica di un oggetto, come un colore.</dd>
- <dt>{{Glossary("Method")}}</dt>
- <dd>Una capacità di un oggetto, come ad esempio cammina. È una procedura o funzione associata a una classe.</dd>
- <dt>{{Glossary("Constructor")}}</dt>
- <dd>Un metodo invocato nel momento in cui l'oggetto viene istanziato. Di solito ha lo stesso nome della classe che lo contiene.</dd>
- <dt>{{Glossary("Inheritance")}}</dt>
- <dd>Una classe può ereditare caratteristiche da un'altra classe.</dd>
- <dt>{{Glossary("Encapsulation")}}</dt>
- <dd>Una modalità di raggruppamento di dati e metodi che ne fanno uso.</dd>
- <dt>{{Glossary("Abstraction")}}</dt>
- <dd>L'insieme del complesso di eredità, metodi e proprietà di un oggetto deve rispecchiare adeguatamente un modello reale.</dd>
- <dt>{{Glossary("Polymorphism")}}</dt>
- <dd><span id="result_box" lang="it"><span class="hps">Poly </span><span class="hps">significa</span> <span class="hps">"<em>molti</em>"</span> <span class="hps">e</span> <span class="hps">morfismo</span> <span class="hps">significa</span> <span class="hps">"<em>forme</em>"</span><span>.</span> <span class="hps">Classi diverse </span><span class="hps">potrebbero</span> <span class="hps">definire lo stesso</span> <span class="hps">metodo o proprietà</span><span>.</span></span></dd>
-</dl>
-
-
-
-<p><span id="result_box" lang="it"><span class="hps">Per una</span> <span class="hps">descrizione</span> </span><span lang="it"><span class="hps">più ampia</span> <span class="hps">della programmazione</span> <span class="hps">orientata agli oggetti</span><span>, vedi</span> </span>{{interwiki("wikipedia", "Object-oriented programming")}}<span lang="it"> <span class="hps">su Wikipedia</span><span>.</span></span></p>
-
-
-
-<h2 id="Programmazione_prototype-based">Programmazione  prototype-based</h2>
-
-<p><span id="result_box" lang="it"><span class="hps">La programmazione p</span></span>rototype-based<span lang="it"><span class="hps"> (basata</span> <span class="hps">sul prototipo)</span> <span class="hps">è un modello</span> <span class="hps">OOP</span> <span class="hps">che non utilizza</span> <span class="hps">le classi</span><span>,</span> <span class="hps">ma piuttosto</span> <span class="hps">prima</span> <span class="hps">completa</span> <span class="hps">il comportamento di</span> <span class="hps">qualsiasi classe</span> <span class="hps">e</span> <span class="hps">poi</span> <span class="hps">riutilizza</span> <span class="atn hps">(</span><span>equivalente</span> <span class="hps">all'</span><span class="hps">ereditarietà</span> <span class="hps">nei linguaggi</span> <span class="hps">basati su classi</span><span>)</span> arricchendo <span class="atn hps">(</span><span>o sviluppando</span><span>)</span> <span class="hps">oggetti <em>prototipo</em></span><span class="hps"> esistenti</span><span>.</span> <span class="atn hps">(</span><span>Chiamata anche</span> <span class="hps">senza classi (</span></span>classless<span lang="it"><span class="hps">)</span><span>,</span> <span class="hps">orientata al prototipo</span><span> (</span></span>prototype-oriented<span lang="it"><span>),</span> <span class="hps">o</span> <span class="hps">programmazione basata</span> su <span class="hps">istanza</span><span> (</span></span>instance-based<span lang="it"><span>).</span><span>)</span></span></p>
-
-<p><span id="result_box" lang="it"><span class="hps">L'esempio </span></span><span lang="it"><span class="hps">originale</span> <span class="atn hps">(</span><span>e più</span> <span class="hps">canonico</span><span>)</span> <span class="hps"> di un</span> <span class="hps">linguaggio basato sui prototipi</span> <span class="hps">è</span> </span>{{interwiki("wikipedia", "Self (programming language)", "Self")}}<span lang="it"> <span class="hps">sviluppato da</span> <span class="hps">David</span> <span class="hps">Ungar</span> <span class="hps">e Randall</span> <span class="hps">Smith</span><span>.</span> <span class="hps">Tuttavia lo</span> <span class="hps">stile di programmazione</span> <span class="atn hps">senza classi diventa</span> <span class="hps">sempre più popolare</span> <span class="hps">negli ultimi tempi,</span> <span class="hps">ed è stato adottato</span> <span class="hps">per</span> <span class="hps">i linguaggi di programmazione</span> <span class="hps">come JavaScript</span><span>,</span> <span class="hps">Cecil</span><span>,</span> <span class="hps">NewtonScript</span><span>,</span> <span class="hps">Io,</span> <span class="hps">MOO</span><span>,</span> <span class="hps">REBOL</span><span>,</span> <span class="hps">Kevo</span><span>,</span> <span class="hps">Squeak</span> <span class="atn hps">(</span><span>quando si utilizza il</span> <span class="hps">framework</span> </span>Viewer per<span lang="it"><span class="hps"> manipolare</span> <span class="hps">componenti</span> <span class="hps">Morphic</span><span>)</span><span>,</span> <span class="hps">e</span> <span class="hps">molti altri</span></span>.<a href="https://developer.mozilla.org/it/docs/Web/JavaScript/Introduzione_al_carattere_Object-Oriented_di_JavaScript$edit#cite-1"><sup>1</sup></a></p>
-
-<h2 id="JavaScript_Object_Oriented_Programming" name="JavaScript_Object_Oriented_Programming">Programmazione  Object Oriented in JavaScript</h2>
-
-<h3 id="Namespace">Namespace</h3>
-
-<p>Un namespace <span id="result_box" lang="it"><span class="hps">è un contenitore</span> <span class="hps">che</span> <span class="hps">consente agli sviluppatori di</span> <span class="hps">includere tutte</span> <span class="hps">le funzionalità</span> <span class="hps">sotto</span> <span class="hps">un</span> <span class="hps">nome unico, specifico per l'</span><span class="hps">applicazione</span></span>. <strong>In JavaScript un namespace è solo un altro oggetto che contiene metodi, proprietà e oggetti.</strong></p>
-
-<div class="note">
-<p><strong>Nota:</strong> È <span lang="it"><span>importante notare che</span> <span class="hps">in JavaScript</span> <span class="hps">non c'è alcuna differenza</span> <span class="hps">a livello di</span> <span class="hps">linguaggio</span> <span class="hps">tra oggetti</span> <span class="hps">regolari e </span>namespace<span>.</span> <span class="hps">Questo</span> <span class="hps">differenzia da molti altri</span> <span class="hps">linguaggi orientati agli oggetti</span> <span class="hps">e può essere fonte</span><span class="hps"> di confusione</span> <span class="hps">per i nuovi</span> <span class="hps">programmatori JavaScript</span></span>.</p>
-</div>
-
-<p><span id="result_box" lang="it"><span class="hps">L'idea alla base</span> del<span class="hps">la creazione di</span> <span class="hps">un namespace</span> <span class="hps">in JavaScript</span> <span class="hps">è</span> <span class="hps">semplice: creare</span> <span class="hps">un oggetto</span> <span class="hps">globale</span><span>,</span> <span class="hps">e</span> <span class="hps">tutte le variabili</span><span>,</span> <span class="hps">i metodi</span> <span class="hps">e le funzioni</span> <span class="hps">diventano</span> <span class="hps">proprietà di tale oggetto</span><span>.</span> <span class="hps">L'uso</span> <span class="hps">dei namespace</span> <span class="hps">riduce anche</span> <span class="hps">il rischio di</span> <span class="hps">conflitti tra nomi</span> <span class="hps">in un'applicazione</span><span>,</span> <span class="hps">poiché gli oggetti</span> <span class="hps">di ciascuna applicazione</span> <span class="hps">sono</span> <span class="hps">proprietà di un</span> <span class="hps">oggetto globale</span> <span class="hps">definito dall'applicazione</span><span>.</span></span></p>
-
-<p>Creiamo un oggetto globale chiamato MYAPP:</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="comment token">// global namespace</span>
-<span class="keyword token">var</span> MYAPP <span class="operator token">=</span> MYAPP <span class="operator token">||</span> <span class="punctuation token">{</span><span class="punctuation token">}</span><span class="punctuation token">;</span></code></pre>
-
-<p><span id="result_box" lang="it"><span class="hps">Nel</span> <span class="hps">codice di esempio di</span> <span class="hps">sopra</span> prima viene testato <span class="hps">se</span> <span class="hps">MYAPP</span> <span class="hps">è già definito</span> <span class="hps">(sia nello</span> <span class="hps">stesso o</span> <span class="hps">in un altro file</span><span>)</span><span>.</span> <span class="hps">Se sì, allora</span> <span class="atn hps">viene utilizzato l'</span><span class="hps">oggetto globale </span></span><span lang="it"><span>MYAPP già</span> <span class="hps">esistente</span><span>,</span> <span class="hps">altrimenti</span> viene creato<span class="hps"> un oggetto</span> <span class="hps">vuoto chiamato</span> <span class="hps">MYAPP</span> <span class="hps">che</span> <span class="hps">incapsula</span> <span class="hps">metodi,</span> <span class="hps">funzioni, variabili</span> <span class="hps">e oggetti</span><span>.</span></span></p>
-
-<p>Possaimo anche creare sotto-namespace (tieni presente che l'oggetto globale deve essere definito prima):</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="comment token">// sub namespace</span>
-MYAPP<span class="punctuation token">.</span>event <span class="operator token">=</span> <span class="punctuation token">{</span><span class="punctuation token">}</span><span class="punctuation token">;</span></code></pre>
-
-<p><span id="result_box" lang="it"><span class="hps">La seguente</span> <span class="hps">è</span> <span class="hps">la sintassi del codice</span> <span class="hps">per</span> <span class="hps">la creazione di un</span> namespace <span class="hps">e l'aggiunta di</span> <span class="hps">variabili, funzioni</span><span>,</span> <span class="hps">e</span> <span class="hps">un metodo:</span></span></p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="comment token">// Create container called MYAPP.commonMethod for common method and properties</span>
-MYAPP<span class="punctuation token">.</span>commonMethod <span class="operator token">=</span> <span class="punctuation token">{</span>
-  regExForName<span class="punctuation token">:</span> <span class="string token">""</span><span class="punctuation token">,</span> <span class="comment token">// define regex for name validation</span>
-  regExForPhone<span class="punctuation token">:</span> <span class="string token">""</span><span class="punctuation token">,</span> <span class="comment token">// define regex for phone no validation</span>
-  validateName<span class="punctuation token">:</span> <span class="keyword token">function</span><span class="punctuation token">(</span>name<span class="punctuation token">)</span><span class="punctuation token">{</span>
-    <span class="comment token">// Do something with name, you can access regExForName variable</span>
-    <span class="comment token">// using "this.regExForName"</span>
-  <span class="punctuation token">}</span><span class="punctuation token">,</span>
-
-  validatePhoneNo<span class="punctuation token">:</span> <span class="keyword token">function</span><span class="punctuation token">(</span>phoneNo<span class="punctuation token">)</span><span class="punctuation token">{</span>
-    <span class="comment token">// do something with phone number</span>
-  <span class="punctuation token">}</span>
-<span class="punctuation token">}</span>
-
-<span class="comment token">// Object together with the method declarations</span>
-MYAPP<span class="punctuation token">.</span>event <span class="operator token">=</span> <span class="punctuation token">{</span>
-    addListener<span class="punctuation token">:</span> <span class="keyword token">function</span><span class="punctuation token">(</span>el<span class="punctuation token">,</span> type<span class="punctuation token">,</span> fn<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-    <span class="comment token">// code stuff</span>
-    <span class="punctuation token">}</span><span class="punctuation token">,</span>
-    removeListener<span class="punctuation token">:</span> <span class="keyword token">function</span><span class="punctuation token">(</span>el<span class="punctuation token">,</span> type<span class="punctuation token">,</span> fn<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-    <span class="comment token">// code stuff</span>
-    <span class="punctuation token">}</span><span class="punctuation token">,</span>
-    getEvent<span class="punctuation token">:</span> <span class="keyword token">function</span><span class="punctuation token">(</span>e<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-    <span class="comment token">// code stuff</span>
-    <span class="punctuation token">}</span>
-
-    <span class="comment token">// Can add another method and properties</span>
-<span class="punctuation token">}</span>
-
-<span class="comment token">// Syntax for Using addListener method:</span>
-MYAPP<span class="punctuation token">.</span>event<span class="punctuation token">.</span><span class="function token">addListener</span><span class="punctuation token">(</span><span class="string token">"yourel"</span><span class="punctuation token">,</span> <span class="string token">"type"</span><span class="punctuation token">,</span> callback<span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
-
-<h3 id="Oggetti_incorporati_built-in_standard">Oggetti incorporati (built-in) standard</h3>
-
-<p><span id="result_box" lang="it"><span class="hps">JavaScript</span> <span class="hps">ha diversi</span> <span class="hps">oggetti inclusi</span> <span class="hps">nel suo nucleo</span><span>,</span> <span class="hps">per esempio ci</span> <span class="hps">sono</span> <span class="hps">oggetti come</span> </span>Math, Object, Array e String<span lang="it"><span>.</span> <span class="hps">L'esempio seguente mostra</span> <span class="hps">come utilizzare</span> <span class="hps">l'oggetto</span> <span class="hps">Math per</span> <span class="hps">ottenere</span> <span class="hps">un numero casuale</span> <span class="hps">utilizzando</span> <span class="hps">il suo</span> <span class="hps">metodo</span></span> <code>random()</code> <span lang="it"><span>.</span></span></p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js">console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
-
-<div class="note"><strong>Nota:</strong> <span id="result_box" lang="it"><span class="hps">Questo</span> <span class="hps">e</span> <span class="hps">tutti gli</span> <span class="hps">ulteriori esempi</span> presuppongono che <span class="hps">una funzione chiamata</span></span> {{domxref("console.log()")}} <span lang="it"><span class="hps">sia definita</span> <span class="hps">a livello globale</span><span>.</span> <span class="hps">La funzione</span> </span><code>console.log()</code> <span lang="it"><span class="hps">in realtà non</span> <span class="hps">è </span><span class="hps">parte</span> <span class="hps">di</span> <span class="hps">JavaScript</span> <span class="hps">in sé</span><span>,</span> <span class="hps">ma</span> <span class="hps">molti browser</span> la implementano <span class="hps">per aiutare</span> <span class="hps">il debug</span><span>.</span></span></div>
-
-<p>Vedi <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects" title="en-US/docs/Web/JavaScript/Reference/Global_Objects">JavaScript Reference: Standard built-in objects</a> for una lista degli oggetti di nucleo in JavaScript.</p>
-
-<p>Ogni oggetto in JavaScript è una instanza dell'oggetto <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>Object</code></a> e perciò ne eredita tutte le sue  proprietà e metodi.</p>
-
-<h3 id="Oggetti_utente">Oggetti utente</h3>
-
-<h4 id="La_classe">La classe</h4>
-
-<p><span id="result_box" lang="it"><span class="hps">JavaScript è un linguaggio</span> <span class="hps">basato sui prototipi</span> <span class="hps">e</span> <span class="hps">non contiene</span> <span class="hps">alcuna dichiarazione</span> <span class="hps">di classe</span><span>,</span> <span class="hps">come invece si trova</span> <span class="hps">in C</span> <span class="hps">++</span> <span class="hps">o Java</span><span>.</span> <span class="hps">Questo a volte è</span> <span class="hps">fonte di confusione per</span> <span class="hps">i programmatori</span> <span class="hps">abituati</span> <span class="hps">ai linguaggi</span> <span class="hps">con</span> <span class="hps">una dichiarazione</span></span> <code>class</code><span lang="it"><span>.</span> <span class="hps">JavaScript</span> <span class="hps">utilizza le funzioni</span> <span class="hps">come</span> <span class="hps">costruttori</span> <span class="hps">per le classi</span><span>.</span> <span class="hps">Definire una</span> <span class="hps">classe è</span> <span class="hps">facile come</span> <span class="hps">definire una funzione</span><span>.</span> <span class="hps">Nell'esempio sottostante</span> <span class="hps">si definisce una</span> <span class="hps">nuova</span> <span class="hps">classe chiamata</span> <span class="hps">Person con</span> <span class="hps">un</span> <span class="hps">costruttore vuoto</span><span>.</span></span></p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> Person <span class="operator token">=</span> <span class="keyword token">function</span> <span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span><span class="punctuation token">}</span><span class="punctuation token">;</span></code></pre>
-
-<h4 id="Loggetto_istanza_di_classe">L'oggetto (istanza di classe)</h4>
-
-<p>Per creare una nuova istanza di un oggetto <code>obj</code> utilizziamo l'istruzione <code>new obj</code> assegnando il risultato (che è di tipo <code>obj</code>) ad una variabile, per poi accedervi successivamente.</p>
-
-<p>Nell'esempio precedente abbiamo definito una classe chiamata  <code>Person</code>. In quello seguente creiamo due istanze (<code>person1</code> e <code>person2</code>).</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> person1 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="keyword token">var</span> person2 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
-
-<div class="note"><strong>Nota:</strong> Prego vedi {{jsxref("Object.create()")}} per un ulteriore nuovo metodo d'istanza che crea una istanza non inizializzata.</div>
-
-<h4 id="Il_costruttore">Il costruttore</h4>
-
-<p><span id="result_box" lang="it"><span class="hps">Il</span> <span class="hps">costruttore viene chiamato</span> quando si instanzia un oggetto <span class="atn hps">(</span><span>il momento in cui</span> <span class="hps">si crea</span> <span class="hps">l'istanza dell'oggetto</span><span>)</span><span>.</span> <span class="hps">Il</span> <span class="hps">costruttore è un</span> <span class="hps">metodo della classe</span><span>.</span> <span class="hps">In JavaScript</span> <span class="hps">la funzione</span> <span class="hps">funge da</span> <span class="hps">costruttore dell'oggetto</span><span>,</span> <span class="hps">pertanto</span> <span class="hps">non è necessario</span> <span class="hps">definire esplicitamente</span> <span class="hps">un</span> <span class="hps">metodo costruttore</span><span>.</span> <span class="hps">Ogni azione</span> <span class="hps">dichiarata</span> <span class="hps">nella classe</span> <span class="hps">viene eseguita</span> <span class="hps">al momento della</span> <span class="hps">creazione di un'istanza</span><span>.</span></span></p>
-
-<p><span id="result_box" lang="it"><span class="hps">Il costruttore</span> <span class="hps">viene utilizzato per</span> <span class="hps">impostare le proprietà</span> <span class="hps">dell'oggetto</span> <span class="hps">o</span> <span class="hps">per chiamare</span> <span class="hps">i metodi che</span> <span class="atn hps">preparano l'</span><span>oggetto per il suo uso</span><span>.</span> <span class="hps">L'aggiunta di</span> <span class="hps">metodi di classe</span> <span class="hps">e le loro definizioni</span> <span class="hps">si effettua </span><span class="hps">utilizzando una</span> <span class="hps">sintassi diversa</span> <span class="hps">descritta più avanti in</span> <span class="hps">questo</span> <span class="hps">articolo</span><span>.</span></span></p>
-
-<p>Nell'esempio seguente il costruttore della classe<code> Person</code> registra un messaggio quando viene istanziato un oggetto <code>Person</code>.</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> Person <span class="operator token">=</span> <span class="keyword token">function</span> <span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">'instance created'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="keyword token">var</span> person1 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="keyword token">var</span> person2 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
-
-<h4 id="La_proprietà_attributo_di_oggetto">La proprietà (attributo di oggetto)</h4>
-
-<p>Le proprietà sono variabili contenute nella classe; ogni istanza dell'oggetto ha queste proprietà. Le proprietà sono impostate nel costruttore (funzione) della classe in modo che siano creati su ogni istanza.</p>
-
-<p><span id="result_box" lang="it"><span class="hps">La</span> <span class="hps">parola chiave</span></span> <code>this</code>, <span lang="it"><span class="hps">che si riferisce</span> <span class="hps">all'oggetto</span> <span class="hps">corrente</span><span>,</span> <span class="hps">consente di lavorare</span> <span class="hps">con le proprietà</span> <span class="hps">all'interno della classe</span><span>.</span> <span class="hps">L'accesso</span> <span class="atn hps">(</span><span>in lettura o</span> <span class="hps">scrittura)</span> <span class="hps">ad una proprietà</span> <span class="hps">al di fuori</span> <span class="hps">della classe</span> <span class="hps">è fatto con</span> <span class="hps">la sintassi</span><span>:</span> </span><code>NomeIstanza.Proprietà</code><span lang="it"><span>,</span> <span class="hps">proprio come in</span> <span class="hps">C</span> <span class="hps">++</span><span>,</span> <span class="hps">Java</span><span>,</span> <span class="hps">e molti altri linguaggi</span><span>.</span> <span class="atn hps">(</span><span>All'interno della</span> <span class="hps">classe la</span> <span class="hps">sintassi </span></span><code>this.Proprietà</code><span lang="it"><span class="hps"> è utilizzata</span> <span class="hps">per ottenere o impostare</span> <span class="hps">il valore della proprietà</span><span>.</span><span>)</span></span></p>
-
-<p>Nell'esempio seguente, definiamo al momento della creazione  la proprietà <code>firstName</code> per la classe <code>Person</code>:</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> Person <span class="operator token">=</span> <span class="keyword token">function</span> <span class="punctuation token">(</span>firstName<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  <span class="keyword token">this</span><span class="punctuation token">.</span>firstName <span class="operator token">=</span> firstName<span class="punctuation token">;</span>
-  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">'Person instantiated'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="keyword token">var</span> person1 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="string token">'Alice'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="keyword token">var</span> person2 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="string token">'Bob'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-<span class="comment token">// Show the firstName properties of the objects</span>
-console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">'person1 is '</span> <span class="operator token">+</span> person1<span class="punctuation token">.</span>firstName<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// logs "person1 is Alice"</span>
-console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">'person2 is '</span> <span class="operator token">+</span> person2<span class="punctuation token">.</span>firstName<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// logs "person2 is Bob"</span></code></pre>
-
-<h4 id="I_metodi">I metodi</h4>
-
-<p>I metodi sono funzioni (e definiti come funzioni), ma per il resto seguono la stessa logica delle proprietà. Chiamare un metodo è simile all'accesso a una proprietà, ma si aggiunge () alla fine del nome del metodo, eventualmente con argomenti. Per definire un metodo va assegnata una funzione a una proprietà della proprietà <code>prototype</code> della classe. In seguito sarà possibile chiamare il metodo sull'oggetto utilizzando lo stesso nome assegnato alla funzione.</p>
-
-<p>Nell'esempio seguente definiamo e usiamo il metodo <code>sayHello()</code> per la classe <code>Person</code>.</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> Person <span class="operator token">=</span> <span class="keyword token">function</span> <span class="punctuation token">(</span>firstName<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  <span class="keyword token">this</span><span class="punctuation token">.</span>firstName <span class="operator token">=</span> firstName<span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-Person<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>sayHello <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">"Hello, I'm "</span> <span class="operator token">+</span> <span class="keyword token">this</span><span class="punctuation token">.</span>firstName<span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="keyword token">var</span> person1 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="string token">"Alice"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="keyword token">var</span> person2 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="string token">"Bob"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-<span class="comment token">// call the Person sayHello method.</span>
-person1<span class="punctuation token">.</span><span class="function token">sayHello</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// logs "Hello, I'm Alice"</span>
-person2<span class="punctuation token">.</span><span class="function token">sayHello</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// logs "Hello, I'm Bob"</span></code></pre>
-
-<p>In JavaScript i metodi sono oggetti funzione regolarmente associati a un oggetto come una proprietà, il che significa che è possibile richiamare i metodi "fuori dal contesto". Si consideri il seguente codice di esempio:</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> Person <span class="operator token">=</span> <span class="keyword token">function</span> <span class="punctuation token">(</span>firstName<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  <span class="keyword token">this</span><span class="punctuation token">.</span>firstName <span class="operator token">=</span> firstName<span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-Person<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>sayHello <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">"Hello, I'm "</span> <span class="operator token">+</span> <span class="keyword token">this</span><span class="punctuation token">.</span>firstName<span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="keyword token">var</span> person1 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="string token">"Alice"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="keyword token">var</span> person2 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span><span class="string token">"Bob"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="keyword token">var</span> helloFunction <span class="operator token">=</span> person1<span class="punctuation token">.</span>sayHello<span class="punctuation token">;</span>
-
-<span class="comment token">// logs "Hello, I'm Alice"</span>
-person1<span class="punctuation token">.</span><span class="function token">sayHello</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-<span class="comment token">// logs "Hello, I'm Bob"</span>
-person2<span class="punctuation token">.</span><span class="function token">sayHello</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-<span class="comment token">// logs "Hello, I'm undefined" (or fails</span>
-<span class="comment token">// with a TypeError in strict mode)</span>
-<span class="function token">helloFunction</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-<span class="comment token">// logs true</span>
-console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>helloFunction <span class="operator token">===</span> person1<span class="punctuation token">.</span>sayHello<span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-<span class="comment token">// logs true</span>
-console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>helloFunction <span class="operator token">===</span> Person<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>sayHello<span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-<span class="comment token">// logs "Hello, I'm Alice"</span>
-helloFunction<span class="punctuation token">.</span><span class="function token">call</span><span class="punctuation token">(</span>person1<span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
-
-<p>Come dimostra questo esempio tutti i riferimenti alla funzione <code>sayHello</code> — quello su  <code>person1</code>, su <code>Person.prototype</code>, nella variabile <code>helloFunction</code>, ecc.— si riferiscono tutti alla <em>stessa funzione</em>. Il valore di <code>this</code> nel corso di una chiamata alla funzione dipende da come noi lo chiamiamo. Più comunemente, quando chiamiamo <code>this</code>  in un'espressione dove abbiamo ottenuto la funzione da una proprietà di oggetto — <code>person1.sayHello()</code>— <code>this</code> è riferito all'oggetto da cui abbiamo ottenuto la funzione (<code>person1</code>), questa è la ragione per cui <code>person1.sayHello()</code> usa il  nome "Alice" e <code>person2.sayHello()</code> usa il nome "Bob".  Ma se lo chiamiamo in altri modi, <code>this</code> è impostato in modo diverso: chiamare <code>this</code> da una variabile— <code>helloFunction()</code>— <code>imposta this</code> come riferimento all'oggetto globale (<code>window</code>, sui browser). Dal momento che l'oggetto globale (probabilmente) non dispone di una proprietà <code>firstName</code> otteniamo "Hello, I'm undefined". (Questo accade in modalità blanda (loose mode); sarebbe stato diverso [un errore] in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode" title="/en/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">strict mode</a>, ma per evitare confusione qui non entreremo nei dettagli). Oppure si può impostare  <code>this</code> esplicitamente utilizzando <code>Function#call</code> (o <code>Function#apply</code>), come illustrato alla fine dell'esempio.</p>
-
-<div class="note"><strong>Nota:</strong> Vedi approfondimenti su <code>this</code> in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/call">Function#call</a> e <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/apply">Function#apply</a></div>
-
-<h4 id="Eredità">Eredità</h4>
-
-<p>L'ereditarietà è un modo per creare una classe come una versione specializzata di una o più classi (<em>JavaScript supporta solo l'ereditarietà singola</em>). La classe specializzata viene comunemente chiamata <em>figlio</em>, e l'altra classe viene comunemente chiamato <em>padre</em>. In JavaScript si esegue questa operazione assegnando un'istanza della classe padre alla classe figlio, e poi specializzandola. Nel browser moderni è anche possibile utilizzare <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create">Object.create</a> per implementare l'ereditarietà.</p>
-
-<div class="note">
-<p><strong>Nota:</strong> JavaScript non rileva  <code>prototype.constructor</code> della classe figlio (vedi <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype">Object.prototype</a>), quindi devi farlo manualmente. Vedi la domanda "<a href="http://stackoverflow.com/questions/8453887/why-is-it-necessary-to-set-the-prototype-constructor">Why is it necessary to set the prototype constructor?</a>" su Stackoverflow.</p>
-</div>
-
-<p>Nell'esempio seguente definiamo la classe  <code>Student</code> come classe figlio di <code>Person</code>. Quindi ridefiniamo il metodo <code>sayHello()</code> e aggiungiamo il metodo <code>sayGoodBye()</code> .</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="comment token">// Define the Person constructor</span>
-<span class="keyword token">var</span> Person <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span>firstName<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  <span class="keyword token">this</span><span class="punctuation token">.</span>firstName <span class="operator token">=</span> firstName<span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="comment token">// Add a couple of methods to Person.prototype</span>
-Person<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>walk <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">{</span>
-  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">"I am walking!"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-Person<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>sayHello <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">{</span>
-  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">"Hello, I'm "</span> <span class="operator token">+</span> <span class="keyword token">this</span><span class="punctuation token">.</span>firstName<span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="comment token">// Define the Student constructor</span>
-<span class="keyword token">function</span> <span class="function token">Student</span><span class="punctuation token">(</span>firstName<span class="punctuation token">,</span> subject<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  <span class="comment token">// Call the parent constructor, making sure (using Function#call)</span>
-  <span class="comment token">// that "this" is set correctly during the call</span>
-  Person<span class="punctuation token">.</span><span class="function token">call</span><span class="punctuation token">(</span><span class="keyword token">this</span><span class="punctuation token">,</span> firstName<span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-  <span class="comment token">// Initialize our Student-specific properties</span>
-  <span class="keyword token">this</span><span class="punctuation token">.</span>subject <span class="operator token">=</span> subject<span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="comment token">// Create a Student.prototype object that inherits from Person.prototype.</span>
-<span class="comment token">// Note: A common error here is to use "new Person()" to create the</span>
-<span class="comment token">// Student.prototype. That's incorrect for several reasons, not least </span>
-<span class="comment token">// that we don't have anything to give Person for the "firstName" </span>
-<span class="comment token">// argument. The correct place to call Person is above, where we call </span>
-<span class="comment token">// it from Student.</span>
-Student<span class="punctuation token">.</span>prototype <span class="operator token">=</span> Object<span class="punctuation token">.</span><span class="function token">create</span><span class="punctuation token">(</span>Person<span class="punctuation token">.</span>prototype<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// See note below</span>
-
-<span class="comment token">// Set the "constructor" property to refer to Student</span>
-Student<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>constructor <span class="operator token">=</span> Student<span class="punctuation token">;</span>
-
-<span class="comment token">// Replace the "sayHello" method</span>
-Student<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>sayHello <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">{</span>
-  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">"Hello, I'm "</span> <span class="operator token">+</span> <span class="keyword token">this</span><span class="punctuation token">.</span>firstName <span class="operator token">+</span> <span class="string token">". I'm studying "</span>
-              <span class="operator token">+</span> <span class="keyword token">this</span><span class="punctuation token">.</span>subject <span class="operator token">+</span> <span class="string token">"."</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="comment token">// Add a "sayGoodBye" method</span>
-Student<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>sayGoodBye <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">{</span>
-  console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">"Goodbye!"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="comment token">// Example usage:</span>
-<span class="keyword token">var</span> student1 <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Student</span><span class="punctuation token">(</span><span class="string token">"Janet"</span><span class="punctuation token">,</span> <span class="string token">"Applied Physics"</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-student1<span class="punctuation token">.</span><span class="function token">sayHello</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>   <span class="comment token">// "Hello, I'm Janet. I'm studying Applied Physics."</span>
-student1<span class="punctuation token">.</span><span class="function token">walk</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>       <span class="comment token">// "I am walking!"</span>
-student1<span class="punctuation token">.</span><span class="function token">sayGoodBye</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// "Goodbye!"</span>
-
-<span class="comment token">// Check that instanceof works correctly</span>
-console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>student1 <span class="keyword token">instanceof</span> <span class="class-name token">Person</span><span class="punctuation token">)</span><span class="punctuation token">;</span>  <span class="comment token">// true </span>
-console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>student1 <span class="keyword token">instanceof</span> <span class="class-name token">Student</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// true</span></code></pre>
-
-<p>Per quanto riguarda la linea <code>Student.prototype = Object.create(Person.prototype);</code> : in vecchi interpreti JavaScript senza  <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create" title="Object.create"><code>Object.create</code></a>, si può utilizzare un "polyfill" (anche detto "shim", vedi l'articolo collegato), oppure utilizzare una funzione che produce il medesimo risultato, come:</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">createObject</span><span class="punctuation token">(</span>proto<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-    <span class="keyword token">function</span> <span class="function token">ctor</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="punctuation token">}</span>
-    ctor<span class="punctuation token">.</span>prototype <span class="operator token">=</span> proto<span class="punctuation token">;</span>
-    <span class="keyword token">return</span> <span class="keyword token">new</span> <span class="class-name token">ctor</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-<span class="punctuation token">}</span>
-
-<span class="comment token">// Usage:</span>
-Student<span class="punctuation token">.</span>prototype <span class="operator token">=</span> <span class="function token">createObject</span><span class="punctuation token">(</span>Person<span class="punctuation token">.</span>prototype<span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
-
-<div class="note"><strong>Nota:</strong> Vedi <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create" title="Object.create">Object.create</a> per maggiori informazioni su ciò che fa uno shim per vecchi interpreti.</div>
-
-<p>Essere sicuri che  <code>this</code> punti alla cosa giusta a prescindere da come l'oggetto sia istanziato può essere difficile. Tuttavia c'e una tecnica semplice per renderlo più facile.</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> Person <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span>firstName<span class="punctuation token">)</span> <span class="punctuation token">{</span>
-  <span class="keyword token">if</span> <span class="punctuation token">(</span><span class="keyword token">this</span> <span class="keyword token">instanceof</span> <span class="class-name token">Person</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
-    <span class="keyword token">this</span><span class="punctuation token">.</span>firstName <span class="operator token">=</span> firstName<span class="punctuation token">;</span>
-  <span class="punctuation token">}</span> <span class="keyword token">else</span> <span class="punctuation token">{</span>
-    <span class="keyword token">return</span> <span class="keyword token">new</span> <span class="class-name token">Person</span><span class="punctuation token">(</span>firstName<span class="punctuation token">)</span><span class="punctuation token">;</span>
-  <span class="punctuation token">}</span>
-<span class="punctuation token">}</span></code></pre>
-
-<h4 id="Incapsulamento">Incapsulamento</h4>
-
-<p>Nell'esempio precedente <code>Student</code> non ha bisogno di sapere come sia realizzato il metodo <code>walk()</code> della classe <code>Person</code>, ma può comunque utilizzarlo; la classe <code>Student</code> non ha bisogno di definire in modo esplicito questo metodo se non vogliamo cambiarlo. Questo è chiamato <strong>incapsulamento</strong>, per cui ogni classe impacchetta dati e metodi in una singola unità.</p>
-
-<p>Il nascondere informazioni (information hiding) è una caratteristica comune ad altre linguaggi, spesso in forma di  metodi / proprietà private e protette. Anche se si potrebbe simulare qualcosa di simile in JavaScript, questo non è un requisito per fare programmazione Object Oriented.<a href="https://developer.mozilla.org/it/docs/Web/JavaScript/Introduzione_al_carattere_Object-Oriented_di_JavaScript$edit#cite-2"><sup>2</sup></a></p>
-
-<h4 id="Astrazione">Astrazione</h4>
-
-<p>L'astrazione è un meccanismo che permette di modellare la parte corrente del problema, sia con eredità (specializzazione) o la composizione. JavaScript ottiene la specializzazione per eredità, e la composizione permettendo che istanze di classe siano valori di attributi di altri oggetti.</p>
-
-<p>La classe Function di Javascript eredita dalla classe Object (questo dimostra la specializzazione del modello) e la proprietà Function.prototype è un'istanza di oggetto (ciò dimostra la composizione).</p>
-
-<p>The JavaScript Function class inherits from the Object class (this demonstrates specialization of the model) and the Function.prototype property is an instance of Object (this demonstrates composition).</p>
-
-<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> foo <span class="operator token">=</span> <span class="keyword token">function</span> <span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span><span class="punctuation token">}</span><span class="punctuation token">;</span>
-
-<span class="comment token">// logs "foo is a Function: true"</span>
-console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">'foo is a Function: '</span> <span class="operator token">+</span> <span class="punctuation token">(</span>foo <span class="keyword token">instanceof</span> <span class="class-name token">Function</span><span class="punctuation token">)</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
-
-<span class="comment token">// logs "foo.prototype is an Object: true"</span>
-console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="string token">'foo.prototype is an Object: '</span> <span class="operator token">+</span> <span class="punctuation token">(</span>foo<span class="punctuation token">.</span>prototype <span class="keyword token">instanceof</span> <span class="class-name token">Object</span><span class="punctuation token">)</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre>
-
-<h4 id="Polimorfismo">Polimorfismo</h4>
-
-<p>Così come tutti i metodi e le proprietà sono definite all'interno della proprietà prototype, classi diverse possono definire metodi con lo stesso nome; i metodi sono nell'ambito della classe in cui sono definiti, a meno che le due classi siano in un rapporto padre-figlio (cioè una eredita dall'altra in una catena di ereditarietà).</p>
-
-
-
-<h2 id="Notes" name="Notes">Note</h2>
-
-<p>Le tecniche presentate in questo articolo per attuare la programmazione orientata agli oggetti non sono le uniche che possono essere utilizzate in JavaScript, che è molto flessibile in termini di come la programmazione orientata agli oggetti possa essere eseguita.</p>
-
-<p>Allo stesso modo, le tecniche qui indicate non usano alcuna violazione di linguaggio, né imitano implementazioni di teorie di oggetti di altri linguaggi.</p>
-
-<p>Ci sono altre tecniche che rendono la programmazione orientata agli oggetti in JavaScript ancora più avanzata, ma sono oltre la portata di questo articolo introduttivo.</p>
-
-<h2 id="References" name="References">Riferimenti</h2>
-
-<ol>
- <li>{{ Ref() }} Mozilla. "Core JavaScript 1.5 Guide", http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Guide</li>
- <li>{{ Ref() }} wikipedia. "Object-oriented programming", <a class="external" href="http://en.wikipedia.org/wiki/Object-oriented_programming" rel="freelink">http://en.wikipedia.org/wiki/Object-...ed_programming</a></li>
-</ol>
-
-<div class="originaldocinfo">
-<p><strong>Original Document Information</strong></p>
-
-<ul>
- <li>Author(s): Fernando Trasviña &lt;f_trasvina at hotmail dot com&gt;</li>
- <li>Copyright Information: © 1998-2005 by individual mozilla.org contributors; content available under a <a class="external" href="http://www.mozilla.org/foundation/licensing/website-content.html">Creative Commons license</a></li>
-</ul>
-</div>
-
-<p>{{ languages( { "es": "es/Introducción_a_JavaScript_orientado_a_objetos"} ) }}</p>
diff --git a/files/it/web/javascript/il_dom_e_javascript/index.html b/files/it/web/javascript/javascript_technologies_overview/index.html
index 9f2b0fbb56..941f6468a3 100644
--- a/files/it/web/javascript/il_dom_e_javascript/index.html
+++ b/files/it/web/javascript/javascript_technologies_overview/index.html
@@ -1,11 +1,12 @@
 ---
 title: Il DOM e JavaScript
-slug: Web/JavaScript/Il_DOM_e_JavaScript
+slug: Web/JavaScript/JavaScript_technologies_overview
 tags:
   - DOM
   - JavaScript
   - Tutte_le_categorie
 translation_of: Web/JavaScript/JavaScript_technologies_overview
+original_slug: Web/JavaScript/Il_DOM_e_JavaScript
 ---
 <h3 id="Il_Grande_Disegno" name="Il_Grande_Disegno">Il Grande Disegno</h3>
 
diff --git a/files/it/web/javascript/gestione_della_memoria/index.html b/files/it/web/javascript/memory_management/index.html
index d1cd6c4dca..8fb72946cb 100644
--- a/files/it/web/javascript/gestione_della_memoria/index.html
+++ b/files/it/web/javascript/memory_management/index.html
@@ -1,7 +1,8 @@
 ---
 title: Gestione della memoria
-slug: Web/JavaScript/Gestione_della_Memoria
+slug: Web/JavaScript/Memory_Management
 translation_of: Web/JavaScript/Memory_Management
+original_slug: Web/JavaScript/Gestione_della_Memoria
 ---
 <div>{{JsSidebar("Advanced")}}</div>
 
diff --git a/files/it/web/javascript/reference/classes/costruttore/index.html b/files/it/web/javascript/reference/classes/constructor/index.html
index afc6c44526..49c7fc05cd 100644
--- a/files/it/web/javascript/reference/classes/costruttore/index.html
+++ b/files/it/web/javascript/reference/classes/constructor/index.html
@@ -1,7 +1,8 @@
 ---
 title: costruttore
-slug: Web/JavaScript/Reference/Classes/costruttore
+slug: Web/JavaScript/Reference/Classes/constructor
 translation_of: Web/JavaScript/Reference/Classes/constructor
+original_slug: Web/JavaScript/Reference/Classes/costruttore
 ---
 <div>{{jsSidebar("Classes")}}</div>
 
diff --git a/files/it/web/javascript/reference/functions_and_function_scope/arguments/index.html b/files/it/web/javascript/reference/functions/arguments/index.html
index c277074bca..e879c914e3 100644
--- a/files/it/web/javascript/reference/functions_and_function_scope/arguments/index.html
+++ b/files/it/web/javascript/reference/functions/arguments/index.html
@@ -1,7 +1,8 @@
 ---
 title: Oggetto 'arguments'
-slug: Web/JavaScript/Reference/Functions_and_function_scope/arguments
+slug: Web/JavaScript/Reference/Functions/arguments
 translation_of: Web/JavaScript/Reference/Functions/arguments
+original_slug: Web/JavaScript/Reference/Functions_and_function_scope/arguments
 ---
 <div>
 <div>{{jsSidebar("Functions")}}</div>
diff --git a/files/it/web/javascript/reference/functions_and_function_scope/arrow_functions/index.html b/files/it/web/javascript/reference/functions/arrow_functions/index.html
index 2dd258966d..eef7570ec0 100644
--- a/files/it/web/javascript/reference/functions_and_function_scope/arrow_functions/index.html
+++ b/files/it/web/javascript/reference/functions/arrow_functions/index.html
@@ -1,6 +1,6 @@
 ---
 title: Funzioni a freccia
-slug: Web/JavaScript/Reference/Functions_and_function_scope/Arrow_functions
+slug: Web/JavaScript/Reference/Functions/Arrow_functions
 tags:
   - ECMAScript6
   - Funzioni
@@ -8,6 +8,7 @@ tags:
   - JavaScript
   - Reference
 translation_of: Web/JavaScript/Reference/Functions/Arrow_functions
+original_slug: Web/JavaScript/Reference/Functions_and_function_scope/Arrow_functions
 ---
 <div>{{jsSidebar("Functions")}}</div>
 
diff --git a/files/it/web/javascript/reference/functions_and_function_scope/get/index.html b/files/it/web/javascript/reference/functions/get/index.html
index 0ed76cf469..439255284c 100644
--- a/files/it/web/javascript/reference/functions_and_function_scope/get/index.html
+++ b/files/it/web/javascript/reference/functions/get/index.html
@@ -1,7 +1,8 @@
 ---
 title: getter
-slug: Web/JavaScript/Reference/Functions_and_function_scope/get
+slug: Web/JavaScript/Reference/Functions/get
 translation_of: Web/JavaScript/Reference/Functions/get
+original_slug: Web/JavaScript/Reference/Functions_and_function_scope/get
 ---
 <div>{{jsSidebar("Functions")}}</div>
 
diff --git a/files/it/web/javascript/reference/functions_and_function_scope/index.html b/files/it/web/javascript/reference/functions/index.html
index 8a5255282c..935190e355 100644
--- a/files/it/web/javascript/reference/functions_and_function_scope/index.html
+++ b/files/it/web/javascript/reference/functions/index.html
@@ -1,7 +1,8 @@
 ---
 title: Funzioni
-slug: Web/JavaScript/Reference/Functions_and_function_scope
+slug: Web/JavaScript/Reference/Functions
 translation_of: Web/JavaScript/Reference/Functions
+original_slug: Web/JavaScript/Reference/Functions_and_function_scope
 ---
 <div>{{jsSidebar("Functions")}}</div>
 
diff --git a/files/it/web/javascript/reference/functions_and_function_scope/set/index.html b/files/it/web/javascript/reference/functions/set/index.html
index 1af0f1c79d..c9f7e6f3fa 100644
--- a/files/it/web/javascript/reference/functions_and_function_scope/set/index.html
+++ b/files/it/web/javascript/reference/functions/set/index.html
@@ -1,11 +1,12 @@
 ---
 title: setter
-slug: Web/JavaScript/Reference/Functions_and_function_scope/set
+slug: Web/JavaScript/Reference/Functions/set
 tags:
   - Funzioni
   - JavaScript
   - setter
 translation_of: Web/JavaScript/Reference/Functions/set
+original_slug: Web/JavaScript/Reference/Functions_and_function_scope/set
 ---
 <div>{{jsSidebar("Functions")}}</div>
 
diff --git a/files/it/web/javascript/reference/global_objects/array/prototype/index.html b/files/it/web/javascript/reference/global_objects/array/prototype/index.html
deleted file mode 100644
index d4989792a8..0000000000
--- a/files/it/web/javascript/reference/global_objects/array/prototype/index.html
+++ /dev/null
@@ -1,203 +0,0 @@
----
-title: Array.prototype
-slug: Web/JavaScript/Reference/Global_Objects/Array/prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype
----
-<div>{{JSRef}}</div>
-
-<p>La proprietà <strong><code>Array.prototype</code></strong> rappresenta il prototipo per il costruttore {{jsxref("Array")}} .</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Description" name="Description">Descrizione</h2>
-
-<p>Le istanze {{jsxref("Array")}} ereditano da <code>Array.prototype</code>. Come con gli altri costruttori, si può cambiare il prototipo propagando i cambiamenti su tutte le sue istanze.</p>
-
-<p>Piccola curiosità: <code>Array.prototype</code> è un {{jsxref("Array")}}:</p>
-
-<pre class="brush: js">Array.isArray(Array.prototype); // true
-</pre>
-
-<h2 id="Properties" name="Properties">Proprietà</h2>
-
-<dl>
- <dt><code>Array.prototype.constructor</code></dt>
- <dd>Restituisce il costruttore.</dd>
- <dt>{{jsxref("Array.prototype.length")}}</dt>
- <dd>Restituisce il numero di elementi in un array.</dd>
-</dl>
-
-<h2 id="Methods" name="Methods">Metodi</h2>
-
-<h3 id="Mutator_methods" name="Mutator_methods">Metodi mutator</h3>
-
-<p>Questi metodi modificano l'array:</p>
-
-<dl>
- <dt>{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}</dt>
- <dd>Copia una sequenza di elementi dell'array all'interno dello stesso.</dd>
- <dt>{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}</dt>
- <dd>Riempie le posizioni dell'array contenute tra 2 indici con un valore fisso.</dd>
- <dt>{{jsxref("Array.prototype.pop()")}}</dt>
- <dd>Rimuove e restituisce l'ultimo elemento dell'array.</dd>
- <dt>{{jsxref("Array.prototype.push()")}}</dt>
- <dd>Accoda uno o più elementi all'array e restituisce la lunghezza aggiornata dello stesso.</dd>
- <dt>{{jsxref("Array.prototype.reverse()")}}</dt>
- <dd>Inverte l'ordine delle posizioni degli elementi all'interno dell'array.</dd>
- <dt>{{jsxref("Array.prototype.shift()")}}</dt>
- <dd>Rimuove e resistuisce il primo elemento di un array.</dd>
- <dt>{{jsxref("Array.prototype.sort()")}}</dt>
- <dd>Ordina gli elementi di un array all'interno di esso e restituisce l'array.</dd>
- <dt>{{jsxref("Array.prototype.splice()")}}</dt>
- <dd>Aggiunge e/o rimuove elementi da un array.</dd>
- <dt>{{jsxref("Array.prototype.unshift()")}}</dt>
- <dd>Aggiunge uno o più elementi all'inizio di un array e restituisce la lunghezza aggiornata dello stesso.</dd>
-</dl>
-
-<h3 id="Accessor_methods" name="Accessor_methods">Metodi accessor</h3>
-
-<p>Questi metodi non modificano l'array e ne restituiscono una sua rappresentazione.</p>
-
-<dl>
- <dt>{{jsxref("Array.prototype.concat()")}}</dt>
- <dd>Restituisce un nuovo array costituito dall'array stesso insieme ad altri array/valori.</dd>
- <dt>{{jsxref("Array.prototype.includes()")}} {{experimental_inline}}</dt>
- <dd>Restituisce <code>true</code> se l'array contiene un certo elemento, <code>false</code> altrimenti.</dd>
- <dt>{{jsxref("Array.prototype.join()")}}</dt>
- <dd>Resituisce i valori dell'array come stringa.</dd>
- <dt>{{jsxref("Array.prototype.slice()")}}</dt>
- <dd>Restituisce un nuovo array cosituito da elementi dell'array originale.</dd>
- <dt>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Returns an array literal representing the specified array; you can use this value to create a new array. Overrides the {{jsxref("Object.prototype.toSource()")}} method.</dd>
- <dt>{{jsxref("Array.prototype.toString()")}}</dt>
- <dd>Returns a string representing the array and its elements. Overrides the {{jsxref("Object.prototype.toString()")}} method.</dd>
- <dt>{{jsxref("Array.prototype.toLocaleString()")}}</dt>
- <dd>Returns a localized string representing the array and its elements. Overrides the {{jsxref("Object.prototype.toLocaleString()")}} method.</dd>
- <dt>{{jsxref("Array.prototype.indexOf()")}}</dt>
- <dd>Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found.</dd>
- <dt>{{jsxref("Array.prototype.lastIndexOf()")}}</dt>
- <dd>Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found.</dd>
-</dl>
-
-<h3 id="Iteration_methods" name="Iteration_methods">Iteration methods</h3>
-
-<p>Several methods take as arguments functions to be called back while processing the array. When these methods are called, the <code>length</code> of the array is sampled, and any element added beyond this length from within the callback is not visited. Other changes to the array (setting the value of or deleting an element) may affect the results of the operation if the method visits the changed element afterwards. While the specific behavior of these methods in such cases is well-defined, you should not rely upon it so as not to confuse others who might read your code. If you must mutate the array, copy into a new array instead.</p>
-
-<dl>
- <dt>{{jsxref("Array.prototype.forEach()")}}</dt>
- <dd>Calls a function for each element in the array.</dd>
- <dt>{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}</dt>
- <dd>Returns a new <code>Array Iterator</code> object that contains the key/value pairs for each index in the array.</dd>
- <dt>{{jsxref("Array.prototype.every()")}}</dt>
- <dd>Returns true if every element in this array satisfies the provided testing function.</dd>
- <dt>{{jsxref("Array.prototype.some()")}}</dt>
- <dd>Returns true if at least one element in this array satisfies the provided testing function.</dd>
- <dt>{{jsxref("Array.prototype.filter()")}}</dt>
- <dd>Creates a new array with all of the elements of this array for which the provided filtering function returns true.</dd>
- <dt>{{jsxref("Array.prototype.find()")}} {{experimental_inline}}</dt>
- <dd>Returns the found value in the array, if an element in the array satisfies the provided testing function or <code>undefined</code> if not found.</dd>
- <dt>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</dt>
- <dd>Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found.</dd>
- <dt>{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}</dt>
- <dd>Returns a new <code>Array Iterator</code> that contains the keys for each index in the array.</dd>
- <dt>{{jsxref("Array.prototype.map()")}}</dt>
- <dd>Creates a new array with the results of calling a provided function on every element in this array.</dd>
- <dt>{{jsxref("Array.prototype.reduce()")}}</dt>
- <dd>Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value.</dd>
- <dt>{{jsxref("Array.prototype.reduceRight()")}}</dt>
- <dd>Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value.</dd>
- <dt>{{jsxref("Array.prototype.values()")}} {{experimental_inline}}</dt>
- <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array.</dd>
- <dt>{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}</dt>
- <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array.</dd>
-</dl>
-
-<h3 id="Generic_methods" name="Generic_methods">Generic methods</h3>
-
-<p>Many methods on the JavaScript Array object are designed to be generally applied to all objects which “look like” Arrays. That is, they can be used on any object which has a <code>length</code> property, and which can usefully be accessed using numeric property names (as with <code>array[5]</code> indexing). <span class="comment">TODO: give examples with Array.prototype.forEach.call, and adding the method to an object like {{jsxref("Global_Objects/JavaArray", "JavaArray")}} or {{jsxref("Global_Objects/String", "String")}}.</span> Some methods, such as {{jsxref("Array.join", "join")}}, only read the <code>length</code> and numeric properties of the object they are called on. Others, like {{jsxref("Array.reverse", "reverse")}}, require that the object's numeric properties and <code>length</code> be mutable; these methods can therefore not be called on objects like {{jsxref("String")}}, which does not permit its <code>length</code> property or synthesized numeric properties to be set.</p>
-
-<h2 id="Specifications" name="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility" name="Browser_compatibility">Browser compatibility</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also" name="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Array")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/it/web/javascript/reference/global_objects/object/prototype/index.html b/files/it/web/javascript/reference/global_objects/object/prototype/index.html
deleted file mode 100644
index 568165d0be..0000000000
--- a/files/it/web/javascript/reference/global_objects/object/prototype/index.html
+++ /dev/null
@@ -1,215 +0,0 @@
----
-title: Object.prototype
-slug: Web/JavaScript/Reference/Global_Objects/Object/prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/Object
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype
----
-<div>{{JSRef("Global_Objects", "Object")}}</div>
-
-<h2 id="Summary" name="Summary">Sommario</h2>
-
-<p>La proprietà <strong><code>Object.prototype</code></strong> rappresenta l'oggetto prototipo di {{jsxref("Global_Objects/Object", "Object")}}.</p>
-
-<p>{{js_property_attributes(0, 0, 0)}}</p>
-
-<h2 id="Description" name="Description">Descrizione</h2>
-
-<p>In JavaScript, tutti gli oggetti sono discendenti di {{jsxref("Global_Objects/Object", "Object")}}; tutti gli oggetti ereditano metodi e proprietà di <code>Object.prototype</code> (tranne nel caso l'oggetto abbia il prototipo uguale a {{jsxref("Global_Objects/null", "null")}}, quindi creati con il metodo {{jsxref("Object.create", "Object.create(null)")}}), anche se questi possono essere sovrascritti. Per esempio, i prototipi degli altri costruttori sovrascrivono la proprietà <code>constructor</code> e forniscono un loro metodo {{jsxref("Object.prototype.toString", "toString()")}}. I cambiamenti al prototipo di Object vengono estesi a tutti gli oggetti, eccetto quelli che sovrascrivono le proprietà e i metodi cambiati.</p>
-
-<h2 id="Properties" name="Properties">Proprietà</h2>
-
-<dl>
- <dt>{{jsxref("Object.prototype.constructor")}}</dt>
- <dd>Specifica la funzione che ha creato l'oggetto a partire dal prototipo.</dd>
- <dt>{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}</dt>
- <dd>È un riferimento all'oggetto usato come prototipo quando l'oggetto è stato istanziato.</dd>
- <dt>{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}</dt>
- <dd>Permette di definire una funzione che venga chiamata quando viene chiamato un metodo non definito.</dd>
- <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Rappresenta il numero di proprietà persenti in un oggetto, ma è stato rimosso.</s></dd>
- <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Rappresenta il contesto di un oggetto, ma è stato rimosso.</s></dd>
-</dl>
-
-<h2 id="Methods" name="Methods">Metodi</h2>
-
-<dl>
- <dt>{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
- <dd>Associa una funzione a una proprietà di un oggetto. Quando si tenta di leggere il valore di tale proprietà, viene eseguita la funzione e restituito il valore che restituisce.</dd>
- <dt>{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
- <dd>Associa una funzione a una proprietà di un oggetto. Quando si tenta di cambiare il valore di tale proprietà, viene eseguita la funzione.</dd>
- <dt>{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
- <dd>Restituisce la funzione definita tramite {{jsxref("Object.prototype.defineGetter", "__defineGetter__()")}}.</dd>
- <dt>{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
- <dd>Restituisce la funzione definita tramite {{jsxref("Object.prototype.defineSetter", "__defineSetter__()")}}.</dd>
- <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt>
- <dd>Determina se l'oggetto contiene direttamente una proprietà (non ereditata tramite il prototipo).</dd>
- <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt>
- <dd>Determina se un oggetto fa parte della catena dei prototipi dell'oggetto sul quale è richiamato questo metodo.</dd>
- <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt>
- <dd>Determina se l'<a href="/it/docs/ECMAScript_DontEnum_attribute" title="ECMAScript_DontEnum_attribute">attributo DontEnum di ECMAScript</a> interno è presente.</dd>
- <dt>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Restituisce una stringa contenente il codice sorgente di un oggetto rappresentante l'oggetto sul quale questo metodo viene richiamato; puoi usare questo valore per creare un nuovo oggetto.</dd>
- <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt>
- <dd>Richiama {{jsxref("Object.prototype.toString", "toString()")}}.</dd>
- <dt>{{jsxref("Object.prototype.toString()")}}</dt>
- <dd>Restituisce la rappresentazione dell'oggetto sotto forma di stringa.</dd>
- <dt>{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}</dt>
- <dd>Termina di osservare i cambiamenti di una proprietà dell'oggetto.</dd>
- <dt>{{jsxref("Object.prototype.valueOf()")}}</dt>
- <dd>Ritorna il valore primitivo dell'oggetto.</dd>
- <dt>{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}</dt>
- <dd>Inizia a osservare i cambiamenti di una proprietà di un oggetto.</dd>
- <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Esegue una stringa di codice JavaScript nel contesto dell'oggetto, ma è stato rimosso.</s></dd>
-</dl>
-
-<h2 id="Examples" name="Examples">Esempi</h2>
-
-<p>Siccome in JavaScript gli oggetti non sono sub-classabili in modo "standard", il prototipo è una soluzione utile per creare un oggetto che funzioni da "classe di base" che contenga dei metodi comuni a più oggetti. Per esempio:</p>
-
-<pre class="brush: js">var Persona = function() {
-  this.saParlare = true;
-};
-
-Persona.prototype.saluta = function() {
-  if (this.saParlare) {
-    console.log('Ciao, mi chiamo ' + this.nome);
-  }
-};
-
-var Dipendente = function(nome, titolo) {
-  Persona.call(this);
-  this.nome = nome;
-  this.titolo = titolo;
-};
-
-Dipendente.prototype = Object.create(Persona.prototype);
-Dipendente.prototype.constructor = Dipendente;
-
-Dipendente.prototype.saluta = function() {
-  if (this.saParlare) {
-    console.log('Ciao mi chiamo ' + this.nome + ' e lavoro come ' + this.titolo);
-  }
-};
-
-var Cliente = function(nome) {
-  Persona.call(this);
-  this.nome = nome;
-};
-
-Cliente.prototype = Object.create(Persona.prototype);
-Cliente.prototype.constructor = Cliente;
-
-var Mimo = function(nome) {
-  Persona.call(this);
-  this.nome = nome;
-  this.saParlare = false;
-};
-
-Mimo.prototype = Object.create(Persona.prototype);
-Mimo.prototype.constructor = Mimo;
-
-var bob = new Dipendente('Bob', 'Architetto');
-var joe = new Cliente('Joe');
-var rg = new Dipendente('Red Green', 'Tuttofare');
-var mike = new Cliente('Mike');
-var mime = new Mimo('Mimo');
-bob.saluta();
-joe.saluta();
-rg.saluta();
-mike.saluta();
-mime.saluta();
-</pre>
-
-<p>Stamperà:</p>
-
-<pre>Ciao, mi chiamo Bob e lavoro come Architetto
-Ciao, mi chiamo Joe
-Ciao, mi chiamo Red Green, e lavoro come Tuttofare
-Ciao, mi chiamo Mike</pre>
-
-<h2 id="Specifications" name="Specifications">Specifiche</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commenti</th>
-  </tr>
-  <tr>
-   <td>ECMAScript 1st Edition. Implemented in JavaScript 1.0.</td>
-   <td>Standard</td>
-   <td>Definizione iniziale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilità con i browser</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funzionalità</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Supporto di base</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th><span style="font-family: open sans light,sans-serif; font-size: 16px; line-height: 16px;">Funzionalità</span></th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td><span style="font-size: 12px; line-height: 18px;">Supporto di base</span></td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/it/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introduzione alla programmazione JavaScript orientata agli oggetti</a></li>
-</ul>
diff --git a/files/it/web/javascript/reference/global_objects/proxy/handler/apply/index.html b/files/it/web/javascript/reference/global_objects/proxy/proxy/apply/index.html
index f803b41255..16c5a8dcb2 100644
--- a/files/it/web/javascript/reference/global_objects/proxy/handler/apply/index.html
+++ b/files/it/web/javascript/reference/global_objects/proxy/proxy/apply/index.html
@@ -1,12 +1,13 @@
 ---
 title: handler.apply()
-slug: Web/JavaScript/Reference/Global_Objects/Proxy/handler/apply
+slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply
 tags:
   - ECMAScript 2015
   - JavaScript
   - Proxy
   - metodo
 translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply
+original_slug: Web/JavaScript/Reference/Global_Objects/Proxy/handler/apply
 ---
 <div>{{JSRef}}</div>
 
diff --git a/files/it/web/javascript/reference/global_objects/proxy/handler/index.html b/files/it/web/javascript/reference/global_objects/proxy/proxy/index.html
index 2be6abb116..695cf4ce22 100644
--- a/files/it/web/javascript/reference/global_objects/proxy/handler/index.html
+++ b/files/it/web/javascript/reference/global_objects/proxy/proxy/index.html
@@ -1,6 +1,6 @@
 ---
 title: Proxy handler
-slug: Web/JavaScript/Reference/Global_Objects/Proxy/handler
+slug: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy
 tags:
   - ECMAScript 2015
   - JavaScript
@@ -9,6 +9,7 @@ tags:
   - TopicStub
 translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/Proxy
 translation_of_original: Web/JavaScript/Reference/Global_Objects/Proxy/handler
+original_slug: Web/JavaScript/Reference/Global_Objects/Proxy/handler
 ---
 <div>{{JSRef}}</div>
 
diff --git a/files/it/web/javascript/reference/global_objects/proxy/revocabile/index.html b/files/it/web/javascript/reference/global_objects/proxy/revocable/index.html
index bf87d7e3e7..5039f6fa07 100644
--- a/files/it/web/javascript/reference/global_objects/proxy/revocabile/index.html
+++ b/files/it/web/javascript/reference/global_objects/proxy/revocable/index.html
@@ -1,7 +1,8 @@
 ---
 title: Proxy.revocable()
-slug: Web/JavaScript/Reference/Global_Objects/Proxy/revocabile
+slug: Web/JavaScript/Reference/Global_Objects/Proxy/revocable
 translation_of: Web/JavaScript/Reference/Global_Objects/Proxy/revocable
+original_slug: Web/JavaScript/Reference/Global_Objects/Proxy/revocabile
 ---
 <div>{{JSRef}}</div>
 
diff --git a/files/it/web/javascript/reference/global_objects/string/prototype/index.html b/files/it/web/javascript/reference/global_objects/string/prototype/index.html
deleted file mode 100644
index c83cec2a54..0000000000
--- a/files/it/web/javascript/reference/global_objects/string/prototype/index.html
+++ /dev/null
@@ -1,179 +0,0 @@
----
-title: String.prototype
-slug: Web/JavaScript/Reference/Global_Objects/String/prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/String
-translation_of_original: Web/JavaScript/Reference/Global_Objects/String/prototype
----
-<div>{{JSRef}}</div>
-
-<p>La proprietà <strong><code>String.prototype</code></strong>rappresenta l'oggetto prototipo {{jsxref("String")}}.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Description">Description</h2>
-
-<p>Tutte le istanze {{jsxref("String")}} ereditano da <code>String.prototype</code> . Le modifiche all'oggetto prototipo <code>String</code> vengono propagate a tutte le istanze {{jsxref("String")}}.</p>
-
-<h2 id="Properties">Properties</h2>
-
-<dl>
- <dt><code>String.prototype.constructor</code></dt>
- <dd>Specifica la funzione che crea il prototipo di un oggetto.</dd>
- <dt>{{jsxref("String.prototype.length")}}</dt>
- <dd>Riflette la lunghezza della stringa.</dd>
- <dt><code><em>N</em></code></dt>
- <dd>Utilizzato per accedere al carattere in <em>N</em> posizione in cui <em>N</em> è un numero intero positivo compreso tra 0 e uno inferiore al valore della {{jsxref("String.length", "length")}}. Queste proprietà sono di sola lettura.</dd>
-</dl>
-
-<h2 id="Metodi">Metodi</h2>
-
-<h3 id="Metodi_non_correlati_HTML">Metodi non correlati HTML</h3>
-
-<dl>
- <dt>{{jsxref("String.prototype.charAt()")}}</dt>
- <dd>Restituisce il carattere (esattamente un'unità di codice UTF-16) all'indice specificato</dd>
- <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt>
- <dd>Restituisce un numero che corrisponde al valore dell'unità di codice UTF-16 nell'indice specificato.</dd>
- <dt>{{jsxref("String.prototype.codePointAt()")}}</dt>
- <dd>Restituisce un numero intero non negativo <strong>Numero</strong> che è il valore del punto di codice codificato UTF-16 che inizia con l'indice specificato.</dd>
- <dt>{{jsxref("String.prototype.concat()")}}</dt>
- <dd>Combina il testo di due stringhe e restituisce una nuova stringa.</dd>
- <dt>{{jsxref("String.prototype.includes()")}}</dt>
- <dd>Determina se una stringa può essere trovata all'interno di un'altra stringa.</dd>
- <dt>{{jsxref("String.prototype.endsWith()")}}</dt>
- <dd>Determina se una stringa termina con i caratteri di un'altra stringa.</dd>
- <dt>{{jsxref("String.prototype.indexOf()")}}</dt>
- <dd>Restituisce l'indice all'interno dell'oggetto {{jsxref("String")}} chiamante della prima occorrenza del valore specificato o -1 se non trovato.</dd>
- <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt>
- <dd>Restituisce l'indice all'interno dell'oggetto {{jsxref("String")}} chiamante della prima occorrenza del valore specificato o -1 se non trovato.</dd>
- <dt>{{jsxref("String.prototype.localeCompare()")}}</dt>
- <dd>Restituisce un numero che indica se una stringa di riferimento viene prima o dopo o è uguale alla stringa specificata in ordine di ordinamento.</dd>
- <dt>{{jsxref("String.prototype.match()")}}</dt>
- <dd>Utilizzato per abbinare un'espressione regolare a una stringa.</dd>
- <dt>{{jsxref("String.prototype.normalize()")}}</dt>
- <dd>Restituisce il modulo di normalizzazione Unicode del valore della stringa chiamante.</dd>
- <dt>{{jsxref("String.prototype.padEnd()")}}</dt>
- <dd>Riempie la stringa corrente dalla fine con una determinata stringa per creare una nuova stringa di una determinata lunghezza.</dd>
- <dt>{{jsxref("String.prototype.padStart()")}}</dt>
- <dd>Riempie la stringa corrente dall'inizio con una determinata stringa per creare una nuova stringa da una determinata lunghezza.</dd>
- <dt><s class="obsoleteElement">{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Avvolge la stringa tra virgolette ("<code>"</code>").</s></dd>
- <dt>{{jsxref("String.prototype.repeat()")}}</dt>
- <dd>Restituisce una stringa composta da elementi dell'oggetto ripetuti i tempi indicati.</dd>
- <dt>{{jsxref("String.prototype.replace()")}}</dt>
- <dd>Utilizzato per trovare una corrispondenza tra un'espressione regolare e una stringa e per sostituire la sottostringa con corrispondenza con una nuova sottostringa.</dd>
- <dt>{{jsxref("String.prototype.search()")}}</dt>
- <dd>Esegue la ricerca di una corrispondenza tra un'espressione regolare e una stringa specificata.</dd>
- <dt>{{jsxref("String.prototype.slice()")}}</dt>
- <dd>Estrae una sezione di una stringa e restituisce una nuova stringa.</dd>
- <dt>{{jsxref("String.prototype.split()")}}</dt>
- <dd>Divide un oggetto  {{jsxref("Global_Objects/String", "String")}} in una matrice di stringhe separando la stringa in sottostringhe.</dd>
- <dt>{{jsxref("String.prototype.startsWith()")}}</dt>
- <dd>Determina se una stringa inizia con i caratteri di un'altra stringa.</dd>
- <dt>{{jsxref("String.prototype.substr()")}} {{deprecated_inline}}</dt>
- <dd>Restituisce i caratteri in una stringa che inizia nella posizione specificata attraverso il numero specificato di caratteri.</dd>
- <dt>{{jsxref("String.prototype.substring()")}}</dt>
- <dd>Restituisce i caratteri in una stringa tra due indici nella stringa.</dd>
- <dt>{{jsxref("String.prototype.toLocaleLowerCase()")}}</dt>
- <dd>I caratteri all'interno di una stringa vengono convertiti in minuscolo rispettando le impostazioni locali correnti. Per la maggior parte delle lingue, questo restituirà lo stesso di {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.</dd>
- <dt>{{jsxref("String.prototype.toLocaleUpperCase()")}}</dt>
- <dd>I caratteri all'interno di una stringa vengono convertiti in maiuscolo rispettando le impostazioni locali correnti. Per la maggior parte delle lingue, ciò restituirà lo stesso di {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.</dd>
- <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt>
- <dd>Restituisce il valore della stringa chiamante convertito in minuscolo.</dd>
- <dt>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Restituisce un oggetto letterale che rappresenta l'oggetto specificato; puoi usare questo valore per creare un nuovo oggetto. Sostituisce il metodo {{jsxref("Object.prototype.toSource()")}} method.</dd>
- <dt>{{jsxref("String.prototype.toString()")}}</dt>
- <dd>Restituisce una stringa che rappresenta l'oggetto specificato. Sostituisce il metodo {{jsxref("Object.prototype.toString()")}} .</dd>
- <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt>
- <dd>Restituisce il valore della stringa chiamante convertito in maiuscolo.</dd>
- <dt>{{jsxref("String.prototype.trim()")}}</dt>
- <dd>Taglia gli spazi bianchi all'inizio e alla fine della stringa. Parte dello standard ECMAScript 5.</dd>
- <dt>{{jsxref("String.prototype.trimStart()")}}<br>
- {{jsxref("String.prototype.trimLeft()")}}</dt>
- <dd>Taglia gli spazi bianchi dall'inizio della stringa.</dd>
- <dt>{{jsxref("String.prototype.trimEnd()")}}<br>
- {{jsxref("String.prototype.trimRight()")}}</dt>
- <dd>Taglia gli spazi bianchi dalla fine della stringa.</dd>
- <dt>{{jsxref("String.prototype.valueOf()")}}</dt>
- <dd>Restituisce il valore primitivo dell'oggetto specificato. Sostituisce il metodo {{jsxref("Object.prototype.valueOf()")}}.</dd>
- <dt>{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}}</dt>
- <dd>Restituisce un nuovo oggetto <code>Iterator</code> che itera sopra i punti di codice di un valore String, restituendo ogni punto di codice come valore String.</dd>
-</dl>
-
-<h3 id="HTML_metodi_wrapper_(involucro)">HTML metodi wrapper (involucro)</h3>
-
-<p>Questi metodi sono di uso limitato, in quanto forniscono solo un sottoinsieme dei tag e degli attributi HTML disponibili.</p>
-
-<dl>
- <dt>{{jsxref("String.prototype.anchor()")}} {{deprecated_inline}}</dt>
- <dd>{{htmlattrxref("name", "a", "&lt;a name=\"name\"&gt;")}} (hypertext target)</dd>
- <dt>{{jsxref("String.prototype.big()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("big")}}</dd>
- <dt>{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("blink")}}</dd>
- <dt>{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("b")}}</dd>
- <dt>{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("tt")}}</dd>
- <dt>{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}</dt>
- <dd>{{htmlattrxref("color", "font", "&lt;font color=\"color\"&gt;")}}</dd>
- <dt>{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}</dt>
- <dd>{{htmlattrxref("size", "font", "&lt;font size=\"size\"&gt;")}}</dd>
- <dt>{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("i")}}</dd>
- <dt>{{jsxref("String.prototype.link()")}} {{deprecated_inline}}</dt>
- <dd>{{htmlattrxref("href", "a", "&lt;a href=\"url\"&gt;")}} (link to URL)</dd>
- <dt>{{jsxref("String.prototype.small()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("small")}}</dd>
- <dt>{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("strike")}}</dd>
- <dt>{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("sub")}}</dd>
- <dt>{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("sup")}}</dd>
-</dl>
-
-<h2 id="Specificazioni">Specificazioni</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specificazioni</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Definizione iniziale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_il_browser">Compatibilità con il browser</h2>
-
-<p class="hidden"> tabella di compatibilità in questa pagina è generata da dati strutturati. Se desideri contribuire ai dati, consulta <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e inviaci una richiesta di pull.</p>
-
-<p>{{Compat("javascript.builtins.String.prototype")}}</p>
-
-<h2 id="Guarda_anche">Guarda anche</h2>
-
-<ul>
- <li>{{jsxref("String")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/it/web/javascript/reference/operators/operatore_virgola/index.html b/files/it/web/javascript/reference/operators/comma_operator/index.html
index e4027930a1..f4cf7b3fd6 100644
--- a/files/it/web/javascript/reference/operators/operatore_virgola/index.html
+++ b/files/it/web/javascript/reference/operators/comma_operator/index.html
@@ -1,7 +1,8 @@
 ---
 title: Operatore virgola
-slug: Web/JavaScript/Reference/Operators/Operatore_virgola
+slug: Web/JavaScript/Reference/Operators/Comma_Operator
 translation_of: Web/JavaScript/Reference/Operators/Comma_Operator
+original_slug: Web/JavaScript/Reference/Operators/Operatore_virgola
 ---
 <div>{{jsSidebar("Operators")}}</div>
 
diff --git a/files/it/web/javascript/reference/operators/operator_condizionale/index.html b/files/it/web/javascript/reference/operators/conditional_operator/index.html
index 1ade61b085..1d0bc7f79a 100644
--- a/files/it/web/javascript/reference/operators/operator_condizionale/index.html
+++ b/files/it/web/javascript/reference/operators/conditional_operator/index.html
@@ -1,9 +1,10 @@
 ---
 title: Operatore condizionale (ternary)
-slug: Web/JavaScript/Reference/Operators/Operator_Condizionale
+slug: Web/JavaScript/Reference/Operators/Conditional_Operator
 tags:
   - JavaScript Operatore operatore
 translation_of: Web/JavaScript/Reference/Operators/Conditional_Operator
+original_slug: Web/JavaScript/Reference/Operators/Operator_Condizionale
 ---
 <p>L'<strong>operator</strong><strong>e</strong><strong> condizionale (ternary) </strong>è  l'unico operatore JavaScript che necessità di tre operandi. Questo operatore è frequentemente usato al posto del comando <a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if</code></a> per la sua sintassi concisa e perché fornisce direttamente un espressione valutabile.</p>
 
diff --git a/files/it/web/javascript/reference/operators/operatori_aritmetici/index.html b/files/it/web/javascript/reference/operators/operatori_aritmetici/index.html
deleted file mode 100644
index e49fe045ae..0000000000
--- a/files/it/web/javascript/reference/operators/operatori_aritmetici/index.html
+++ /dev/null
@@ -1,292 +0,0 @@
----
-title: Operatori Aritmetici
-slug: Web/JavaScript/Reference/Operators/Operatori_Aritmetici
-tags:
-  - JavaScript
-  - Operatori
-  - Operatori Aritmetici
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<div>Gli <strong>operatori aritmetici</strong> lavorano su operandi numerici (sia letterali che variabili) e ritornano un singolo valore numerico. Gli operatori aritmetici standard sono l'addizione (+), la sottrazione (-), la moltiplicazione (*) e la divisione (/).</div>
-
-<h2 id="Addizione_()"><a name="Addition">Addizione (+)</a></h2>
-
-<p>L'operazione di addizione produce la somma di operandi numerici o la concatenzione di stringhe.</p>
-
-<h3 id="Sintassi">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> x + y
-</pre>
-
-<h3 id="Esempi">Esempi</h3>
-
-<pre class="brush: js">// Numero + Numero -&gt; addizione
-1 + 2 // 3
-
-// Booleano + Numero -&gt; addizione
-true + 1 // 2
-
-// Booleano + Booleano -&gt; additione
-false + false // 0
-
-// Numero + Stringa -&gt; concatenazione
-5 + "foo" // "5foo"
-
-// Stringa + Booleano -&gt; concatenazione
-"foo" + false // "foofalse"
-
-// Stringa + Stringa -&gt; concatenazione
-"foo" + "bar" // "foobar"
-</pre>
-
-<h2 id="Sottrazione_(-)"><a name="Subtraction">Sottrazione (-)</a></h2>
-
-<p>L'operatore di sottrazione fa la sottrazione dei due operandi e produce la loro differenza.</p>
-
-<h3 id="Sintassi_2">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> x - y
-</pre>
-
-<h3 id="Esempi_2">Esempi</h3>
-
-<pre class="brush: js">5 - 3 // 2
-3 - 5 // -2
-"foo" - 3 // NaN</pre>
-
-<h2 id="Divisione_()"><a name="Division">Divisione (/)</a></h2>
-
-<p>L'operatore di divisione produce il quoziente dei suoi operandi dove l'operando di sinistra è il dividendo e l'operando di destra è il divisore.</p>
-
-<h3 id="Sintassi_3">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> x / y
-</pre>
-
-<h3 id="Esempi_3">Esempi</h3>
-
-<pre class="brush: js">1 / 2      // restituisce 0.5 in JavaScript
-1 / 2      // restituisce 0 in Java
-// (nessuno degli operandi è un numero in virgola mobile esplicito)
-
-1.0 / 2.0  // restituisce 0.5 in both JavaScript and Java
-
-2.0 / 0    // restituisce Infinity in JavaScript
-2.0 / 0.0  // restituisce Infinity too
-2.0 / -0.0 // restituisce -Infinity in JavaScript</pre>
-
-<h2 id="Moltiplicazione_(*)"><a name="Multiplication">Moltiplicazione (*)</a></h2>
-
-<p>The multiplication operator produces the product of the operands.</p>
-
-<h3 id="Sintassi_4">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> x * y
-</pre>
-
-<h3 id="Esempi_4">Esempi</h3>
-
-<pre class="brush: js">2 * 2 // 4
--2 * 2 // -4
-Infinity * 0 // NaN
-Infinity * Infinity // Infinity
-"foo" * 2 // NaN
-</pre>
-
-<h2 id="Resto_()"><a name="Remainder">Resto (%)</a></h2>
-
-<p>L'operatore Resto o Modulo restituisce il “resto“ rimasto quando un operando viene diviso per un secondo operando. Calcola il resto della divisione fra il primo e il secondo operando. Porta sempre il segno del dividendo.</p>
-
-<h3 id="Sintassi_5">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> var1 % var2
-</pre>
-
-<h3 id="Esempi_5">Esempi</h3>
-
-<pre class="brush: js">12 % 5 // 2
--1 % 2 // -1
-NaN % 2 // NaN
-1 % 2 // 1
-2 % 3 // 2
--4 % 2 // -0
-</pre>
-
-<h2 id="Esponente_(**)"><a name="Exponentiation">Esponente (**)</a></h2>
-
-<p><strong>L'operatore Esponente o esponenziale in JavaScript. </strong>Una delle funzionalità di questa versione è l'operatore di esponenziazione. Esponente restituisce il risultato dell'elevamento a potenza dal primo operando al secondo. Cioè <code>var1</code> <code>var2</code> , <code>var2.</code> <code>var1</code>e <code>var2</code> sono variabili. L'operatore Esponente ha ragione associativa. <code>a ** b ** c</code> equivale a <code>a ** (b ** c)</code>.</p>
-
-<h3 id="Sintassi_6">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> var1 ** var2
-</pre>
-
-<h3 id="Note">Note</h3>
-
-<p>Nella maggior parte dei linguaggi come PHP e Python e altri che usano l'operatore Esponente (**), ha precedenza rispetto agli altri operatori unari come + e -, salvo in alcune eccezioni. Ad esempio, in Bash l'operatore ** ha una minor importanza rispetto agli operatori unari. In JavaScript, è impossibile scrivere un'espressione Esponente ambigua, ovvero non è possibile inserire un operatore unario ( <code>+/-/~/!/delete/void/typeof</code> ) immediatamente prima del numero di base. Il calcolo della potenza può essere espresso più sinteticamente usando la notazione infissa. Simile ad altri linguaggi come Python o F#, <code>**</code> è usato per indicare l'operatore. </p>
-
-<pre class="brush: js">-2 ** 2 // equals 4 in ES2016 or in Bash, equals -4 in other languages.</pre>
-
-<p>Accetta base sul lato sinistro ed esponente sul lato destro, rispettivamente.</p>
-
-<pre class="brush: js">let value = 5; value **= 2; // value: 25
-</pre>
-
-<h3 id="Esempi_6">Esempi</h3>
-
-<pre class="brush: js">2 ** 3 // 8
-3 ** 2 // 9
-3 ** 2.5 // 15.588457268119896
-10 ** -1 // 0.1
-NaN ** 2 // NaN
-
-2 ** 3 ** 2 // 512
-2 ** (3 ** 2) // 512
-(2 ** 3) ** 2 // 64
-
-var a = 3;
-var b = a ** 3;
-alert("3x3x3 is = " + b); // 27
-</pre>
-
-<p>Per invertire il segno del risultato di un'espressione di Esponente:</p>
-
-<pre><code>-(2 ** 2) // -4</code>
-</pre>
-
-<p>Per forzare la base di un'espressione di Esponente ad essere un numero negativo:</p>
-
-<pre><code>(-2) ** 2 // 4 </code></pre>
-
-<h2 id="Incremento_()"><a name="Increment">Incremento (++)</a></h2>
-
-<p>L'operatore di incremento incrementa (aggiunge uno a) il suo operando e restituisce un valore.</p>
-
-<ul>
- <li>Se usato in post posizione, con operatore dopo operando (ad esempio, x ++), restituisce il valore prima di incrementare.</li>
- <li>Se usato come prefisso quindi prima dell'operando (ad esempio, ++ x), restituisce il valore dopo l'incremento.</li>
-</ul>
-
-<h3 id="Sintassi_7">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> x++ or ++x
-</pre>
-
-<h3 id="Esempi_7">Esempi</h3>
-
-<pre class="brush: js">// Postfix // post posizione
-var x = 3;
-y = x++; // y = 3, x = 4
-
-// Prefix // Prefisso
-var a = 2;
-b = ++a; // a = 3, b = 3
-</pre>
-
-<h2 id="Decremento_(--)"><a name="Decrement">Decremento (--)</a></h2>
-
-<p>L'operatore decrementa decrementa (sottrae uno da) il suo operando e restituisce un valore.</p>
-
-<ul>
- <li>Se usato in post posizione (ad esempio x--), restituisce il valore prima di decrementare.</li>
- <li>Se usato come prefisso (ad esempio, --x), restituisce il valore dopo la decrementazione.</li>
-</ul>
-
-<h3 id="Sintassi_8">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> x-- or --x
-</pre>
-
-<h3 id="Esempi_8">Esempi</h3>
-
-<pre class="brush: js">// Postfix // post posizione
-var x = 3;
-y = x--; // y = 3, x = 2
-
-// Prefix // Prefisso
-var a = 2;
-b = --a; // a = 1, b = 1
-</pre>
-
-<h2 id="Negazione_unaria_(-)"><a name="Unary_negation">Negazione unaria (-)</a></h2>
-
-<p>L'operatore di negazione unario precede il suo operando e lo nega.</p>
-
-<h3 id="Sintassi_9">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> -x
-</pre>
-
-<h3 id="Esempi_9">Esempi</h3>
-
-<pre><code>var x = 3;
-y = -x; // y = -3, x = 3
-
-//</code>L'operatore di negazione unario può convertire numeri diversi in un numero<code>
-var x = "4";
-y = -x; // y = -4</code></pre>
-
-<h2 id="Unario_più_()"><a name="Unary_plus">Unario più</a> (+)</h2>
-
-<p>L'operatore unario più precede il suo operando e valuta il suo operando, ma tenta di convertirlo in un numero, se non lo è già. Anche se la negazione unaria (-) può anche convertire non numeri, unario è il modo più veloce e preferito per convertire qualcosa in un numero, perché non esegue altre operazioni sul numero. È in grado di convertire rappresentazioni di stringa di numeri interi e float, oltre ai valori non stringa <code>true</code> , <code>false</code> e <code>null</code> . Sono supportati i numeri interi decimali ed esadecimali ("0x" -prefixed). I numeri negativi sono supportati (sebbene non per hex). Se non può analizzare un valore particolare, valuterà in <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a>.</p>
-
-<h3 id="Sintassi_10">Sintassi</h3>
-
-<pre class="syntaxbox"><strong>Operatore:</strong> +x
-</pre>
-
-<h3 id="Esempi_10">Esempi</h3>
-
-<pre><code>+3     // 3
-+'3'   // 3
-+true  // 1
-+false // 0
-+null  // 0
-+function(val){  return val } // NaN</code></pre>
-
-<h2 id="Specificazioni">Specificazioni</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specificazioni</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
-  <tr>
-   <td>ECMAScript 1st Edition.</td>
-   <td>Standard</td>
-   <td>Definizione iniziale.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.3')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Definito in diverse sezioni della specifica: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Additive operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">Multiplicative operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">Postfix expressions</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Unary operators</a>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-postfix-expressions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Definito in diverse sezioni della specifica: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-additive-operators">Additive operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-multiplicative-operators">Multiplicative operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-postfix-expressions">Postfix expressions</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-unary-operators">Unary operators</a>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2016', '#sec-postfix-expressions')}}</td>
-   <td>{{Spec2('ES2016')}}</td>
-   <td>Aggiunto <a href="https://github.com/rwaldron/exponentiation-operator">Exponentiation operator</a>.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilità_con_i_browser">Compatibilità con i browser</h2>
-
-
-
-<p>{{Compat("javascript.operators.arithmetic")}}</p>
-
-<h2 id="Guarda_anche">Guarda anche</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Assignment operators</a></li>
-</ul>
diff --git a/files/it/web/javascript/reference/template_strings/index.html b/files/it/web/javascript/reference/template_literals/index.html
index 5bb4890ad8..52ca5a1802 100644
--- a/files/it/web/javascript/reference/template_strings/index.html
+++ b/files/it/web/javascript/reference/template_literals/index.html
@@ -1,7 +1,8 @@
 ---
 title: Stringhe template
-slug: Web/JavaScript/Reference/template_strings
+slug: Web/JavaScript/Reference/Template_literals
 translation_of: Web/JavaScript/Reference/Template_literals
+original_slug: Web/JavaScript/Reference/template_strings
 ---
 <div>{{JsSidebar("More")}}</div>