Fix typos and update translation

Author: Marco Trulla

doc/it/array/general.md

@@ -42,13 +42,13 @@ Mentre il *getter* della proprietà `length` ritorna semplicemente il numero di
 elementi che sono contenuti nell'array, il *setter* può essere usato per
 **troncare** l'array.
 
-    var foo = [1, 2, 3, 4, 5, 6];
-    foo.length = 3;
-    foo; // [1, 2, 3]
+    var arr = [1, 2, 3, 4, 5, 6];
+    arr.length = 3;
+    arr; // [1, 2, 3]
 
-    foo.length = 6;
-    foo.push(4);
-    foo; // [1, 2, 3, undefined, undefined, undefined, 4]
+    arr.length = 6;
+    arr.push(4);
+    arr; // [1, 2, 3, undefined, undefined, undefined, 4]
 
 Assegnando una lunghezza più piccola si tronca l'array. Incrementandola si
 crea un array frammentato.
@@ -59,4 +59,3 @@ Per la miglior performance, si raccomanda di usare sempre il ciclo `for`
 classico e fare il caching della proprietà `length`. L'uso di `for in` su di
 un array è segno di un codice scritto male che è suscettibile a bug e pessima
 performance.
-

doc/it/core/eval.md

@@ -2,27 +2,27 @@
 
 La funzione `eval` eseguirà una stringa di codice JavaScript nello scope locale.
 
-    var foo = 1;
+    var number = 1;
     function test() {
-        var foo = 2;
-        eval('foo = 3');
-        return foo;
+        var number = 2;
+        eval('number = 3');
+        return number;
     }
     test(); // 3
-    foo; // 1
+    number; // 1
 
 Comunque, `eval` esegue solo nello scope locale quando viene chiamata
 direttamente *e* quando il nome della funzione chiamata è `eval`.
 
-    var foo = 1;
+    var number = 1;
     function test() {
-        var foo = 2;
-        var bar = eval;
-        bar('foo = 3');
-        return foo;
+        var number = 2;
+        var copyOfEval = eval;
+        copyOfEval('number = 3');
+        return number;
     }
     test(); // 2
-    foo; // 3
+    number; // 3
 
 L'uso di `eval` dovrebbe essere evitato. Il 99.9% dei suoi "utilizzi" può
 essere ottenuto **senza** di essa.
@@ -47,4 +47,3 @@ essere messo in discussione sotto l'aspetto della funzionalità, della performan
 e della sicurezza. Se qualcosa richiede `eval` per poter funzionare, allora **non**
 dovrebbe essere usato in primo luogo, ma si dovrebbe prevedere una
 *miglior progettazione* che non richieda l'uso di `eval`.
-

doc/it/function/constructors.md

@@ -12,44 +12,44 @@ come costruttore.
 Se la funzione che è stata chiamata non ha un'istruzione `return` esplicita,
 allora essa ritorna implicitamente il valore di `this` (il nuovo oggetto).
 
-    function Foo() {
-        this.bla = 1;
+    function Person(name) {
+        this.name = name;
     }
 
-    Foo.prototype.test = function() {
-        console.log(this.bla);
+    Person.prototype.logName = function() {
+        console.log(this.name);
     };
 
-    var test = new Foo();
+    var sean = new Person();
 
-Questo esempio chiama `Foo` come costruttore ed imposta il `prototype` del
-nuovo oggetto creato a `Foo.prototype`.
+Questo esempio chiama `Person` come costruttore ed imposta il `prototype` del
+nuovo oggetto creato a `Person.prototype`.
 
 In caso di istruzione `return` esplicita, la funzione ritorna il valore
 specificato da quell'istruzione, ma **solo** se il valore di ritorno è un
 `Object`.
 
-    function Bar() {
-        return 2;
+    function Car() {
+        return 'ford';
     }
-    new Bar(); // un nuovo oggetto
+    new Car(); // un nuovo oggetto, non 'ford'
 
-    function Test() {
-        this.value = 2;
+    function Person() {
+        this.someValue = 2;
 
         return {
-            foo: 1
+            name: 'Charles'
         };
     }
-    new Test(); // l'oggetto ritornato
+    new Test(); // l'oggetto ritornato ({name: 'Charles'}), escluso someValue
 
 Quando la parola chiave `new` viene omessa, la funzione **non** ritornerà un
 nuovo oggetto.
 
-    function Foo() {
-        this.bla = 1; // imposta la proprietà dell'oggetto globale
+    function Pirate() {
+        this.hasEyePatch = true; // imposta la proprietà nell'oggetto globale!
     }
-    Foo(); // undefined
+    var somePirate = Pirate(); // somePirate è undefined
 
 Mentre l'esempio precedente potrebbe sembrare essere funzionante in alcuni
 casi, a causa del modo in cui lavora [`this`](#function.this) in JavaScript,
@@ -60,27 +60,27 @@ esso userà l'*oggetto globale* come valore di `this`.
 Per poter omettere la parola chiave `new`, la funzione costruttore deve
 esplicitamente ritornare un valore.
 
-    function Bar() {
-        var value = 1;
+    function Robot() {
+        var color = 'gray';
         return {
-            method: function() {
-                return value;
+            getColor: function() {
+                return color;
             }
         }
     }
-    Bar.prototype = {
-        foo: function() {}
+    Robot.prototype = {
+        someFunction: function() {}
     };
 
-    new Bar();
-    Bar();
+    new Robot();
+    Robot();
 
-Entrambe le chiamate a `Bar` ritornano lo stesso risultato, un nuovo oggetto
+Entrambe le chiamate a `Robot` ritornano lo stesso risultato, un nuovo oggetto
 creato con una proprietà chiamata `method`, che è una [Closure](#function.closures).
 
-Bisogna anche notare che la chiamata `new Bar()` **non** influisce sul prototipo
+Bisogna anche notare che la chiamata `new Robot()` **non** influisce sul prototipo
 dell'oggetto ritornato. Mentre il prototipo sarà impostato con il nuovo oggetto
-creato, `Bar` non ritornerà mai quel nuovo oggetto.
+creato, `Robot` non ritornerà mai quel nuovo oggetto.
 
 Nell'esempio sopra, non c'è differenza funzionale nell'usare o meno la parola
 chiave `new`.
@@ -93,19 +93,20 @@ può portare a bug potenzialmente insidiosi da risolvere.
 Per poter creare un nuovo oggetto, si dovrebbe invece usare una factory e
 costruire un nuovo oggetto all'interno di quella factory.
 
-    function Foo() {
-        var obj = {};
-        obj.value = 'blub';
+    function CarFactory() {
+        var car = {};
+        car.owner = 'nobody';
 
-        var private = 2;
-        obj.someMethod = function(value) {
-            this.value = value;
+        var milesPerGallon = 2;
+
+        car.setOwner = function(newOwner) {
+            this.owner = newOwner;
         }
 
-        obj.getPrivate = function() {
-            return private;
+        car.getMPG = function() {
+            return milesPerGallon;
         }
-        return obj;
+        return car;
     }
 
 Sebbene questo esempio sia a prova di omissione della parola chiave `new` e
@@ -126,4 +127,3 @@ bug, **non** è certo un motivo per privarsi completamente dell'uso dei prototip
 Alla fine si tratta di decidere quale sia la soluzione più adatta per
 l'applicazione. È specialmente importante scegliere uno specifico stile
 di creazione degli oggetti ed usarlo in maniera **consistente**.
-

doc/it/function/this.md

@@ -71,21 +71,31 @@ uso pratico.
 Una comune credenza è che `this` all'interno di `test` faccia riferimento a
 `Foo` mentre, invece, **non** è così.
 
-Per poter ottenere l'accesso a `Foo` dall'interno di `test`, è necessario creare
+Per poter ottenere l'accesso a `Foo` dall'interno di `test`, si può creare
 una variabile locale all'interno di `method` che faccia riferimento a `Foo`.
 
     Foo.method = function() {
-        var that = this;
+        var self = this;
         function test() {
-            // Qui viene usato that invece di this
+            // Qui viene usato self invece di this
         }
         test();
     }
 
-`that` è solo un normale nome di variabile, ma viene comunemente usato come
+`self` è solo un normale nome di variabile, ma viene comunemente usato come
 riferimento ad un `this` più esterno. Abbinato alle [closures](#function.closures)
 può anche essere usato per passare il valore di `this`.
 
+Con l'introduzione di ECMAScript 5 è possibile usare il metodo `bind` combinato
+con una funziona anonima
+
+    Foo.method = function() {
+        var test = function() {
+            // this ora fa riferimento a Foo
+        }.bind(this);
+        test();
+    }
+
 ### Metodi di asseganzione
 
 Un'altra cosa che **non** funziona in JavaScript è la creazione di un alias ad
@@ -112,4 +122,3 @@ l'[ereditarietà prototipale](#object.prototype).
 
 Quando `method` viene chiamato da un'istanza di `Bar`, `this` farà riferimento
 a quell'istanza.
-

doc/it/object/forinloop.md

@@ -17,8 +17,19 @@ prototipi quando itera tra le proprietà di un oggetto.
 
 Dato che non è possibile modificare il comportamento del ciclo `for in`,
 è necessario filtrare le proprietà indesiderate all'interno del ciclo stesso.
-Questo può essere fatto usando il metodo [`hasOwnProperty`](#object.hasownproperty)
-di `Object.prototype`.
+In ECMAScript 3 o precedente, questo può essere fatto usando il metodo
+[`hasOwnProperty`](#object.hasownproperty) di `Object.prototype`.
+
+A partire da ECMAScript 5, `Object.defineProperty` può essere utilizzato con
+`enumerbale` impostato a `false` per aggiungere proprietà agli oggetti (incluso
+`Object`) senza che queste proprietà vengano enumerate. In questo caso è
+ragionevole assumere che, nel codice di un'applicazione, ogni proprietà
+enumerabile sia stata aggiunta per un motivo, ed quindi omettere `hasOwnProperty`
+in quanto rende il codice più prolisso e meno leggibile. Nel codice delle
+librerie `hasOwnProperty` dovrebbe essere ancora utilizzato, dato che non è
+possibile presumere quali proprietà enumerabili siano presenti nella catena dei
+prototipi.
+
 
 > **Nota:** dato che `for in` attraversa sempre tutta la catena di prototipi,
 > esso rallenterà per ogni strato aggiuntivo di ereditarietà aggiunto ad un
@@ -33,20 +44,25 @@ di `Object.prototype`.
         }
     }
 
-Questa è la sola versione corretta da usare. Proprio a causa dell'utilizzo di
-`hasOwnProperty`, **soltanto** `moo` verrà stampato; mentre omettendone l'uso,
-il codice sarà soggetto ad errori nei casi dove i prototipi nativi (ad esempio
-`Object.prototype`) sono stati estesi.
+Questa è la sola versione corretta da usare con le vecchie versioni di ECMAScript.
+Proprio a causa dell'utilizzo di `hasOwnProperty`, **soltanto** `moo` verrà
+stampato; mentre omettendone l'uso, il codice sarà soggetto ad errori nei casi
+dove i prototipi nativi (ad esempio `Object.prototype`) sono stati estesi.
 
-Un framework ampiamente usato che estende `Object.prototype` è [Prototype][1].
+Nelle nuove versioni di ECMAScript, le proprietà non enumerabili possono essere
+definite con `Object.defineProperty`, riducendo il rischio di iterare sulle
+proprietà non usando `hasOwnProperty`. È altresì importante stare attenti
+quando si usano librerie come [Prototype][1], che ancora non sfruttano le nuove
+funzionalità di ECMAScript.
 Quando questo framework viene incluso, è sicuro che i cicli `for in` che non
 utilizzano `hasOwnProperty` non funzioneranno.
 
 ### In conclusione
 
-Si raccomanda di usare **sempre** `hasOwnProperty`. Non si dovrebbe mai dare
-per scontato l'ambiente in cui il codice sta girando, o se i prototipi
-nativi sono stati estesi o meno.
+Si raccomanda di usare **sempre** `hasOwnProperty` in ECMAScript 3 o precedenti,
+e nel codice delle librerie. Non si dovrebbe mai dare per scontato nell'ambiente
+in cui il codice sta girando, se i prototipi nativi sono stati estesi o meno. A
+partire da ECMAScript 5 `Object.defineProperty` rende possibile definire proprietà
+non enumerabili ed omettere `hasOwnProperty` nel codice dell'applicazione.
 
 [1]: http://www.prototypejs.org/
-

doc/it/object/hasownproperty.md

@@ -22,10 +22,9 @@ Per verificare se un oggetto ha (possiede) una proprietà definita dentro
     foo.hasOwnProperty('bar'); // false
     foo.hasOwnProperty('goo'); // true
 
-Solo `hasOwnProperty` darà il risultato atteso e corretto. Questo è essenziale
-quando si itera tra le proprietà di un qualsiasi oggetto. **Non** c'è altro
-modo per escludere proprietà che non sono definite all'interno dell'oggetto
-stesso, ma da qualche altra parte nella sua catena di prototipi.
+Solo `hasOwnProperty` darà il risultato atteso e corretto. Guarda la sezione
+[cicli `for in`][#object.forinloop] per maggiori dettagli riguardo a quando
+usare `hasOwnProperty` per iterare le proprietà di un oggetto.
 
 ### `hasOwnProperty` come proprietà
 
@@ -54,7 +53,6 @@ risultato corretto.
 ### In conclusione
 
 Usare `hasOwnProperty` è l'**unico** metodo affidabile per verificare
-l'esistenza di una proprietà in un oggetto. È raccomandabile usare
-`hasOwnProperty` in **ogni** [ciclo `for in`](#object.forinloop) per
-evitare errori con i [prototipi](#object.prototype) nativi estesi.
-
+l'esistenza di una proprietà in un oggetto. È raccomandabile che
+`hasOwnProperty` venga usata in molti casi in cui è necessario iterare le
+proprietà di un oggetto, come descritto nella sezione [cicli `for in`](#object.forinloop).

doc/it/other/timeouts.md

@@ -3,8 +3,12 @@
 Dato che JavaScript è asincrono, è possibile programmare l'esecuzione di una
 funzione usando le funzioni `setTimeout` e `setInterval`.
 
-> **Nota:** i timeout **non** sono parte dello standard ECMAScript. Essi
-> vengono implementati come parte del [DOM][1].
+> **Nota:** i timeout **non** sono parte dello standard ECMAScript. Erano stati
+> implementati in [BOM, o DOM Level 0][1], i quali non sono mai stati definiti
+> o documentati formalmente. Nessuna specifica raccomandazione è mai stata
+> pubblicata, tuttavia, la loro standardizzazione è in via di ultimazione con
+> [HTML5][2]. Per loro stessa natura, quindi, l'implementazione può essere
+> differente nei vari browser e motori di rendering.
 
     function foo() {}
     var id = setTimeout(foo, 1000); // ritorna un Number > 0
@@ -52,7 +56,7 @@ con intervalli molto brevi, tradursi in chiamate a funzione che si sovrappongono
     function foo(){
         // qualcosa che blocca per 1 secondo
     }
-    setInterval(foo, 100);
+    setInterval(foo, 1000);
 
 Nel codice precedente, `foo` verrà chiamato una volta e quindi bloccherà per
 un secondo.
@@ -68,7 +72,7 @@ La soluzione più semplice, come anche la più controllabile, è quella di usare
 
     function foo(){
         // qualcosa che blocca per 1 secondo
-        setTimeout(foo, 100);
+        setTimeout(foo, 1000);
     }
     foo();
 
@@ -119,8 +123,7 @@ gli ID dei timeout, così che possano essere puliti in modo specifico.
 primo parametro. Questa caratteristica non dovrebbe essere **mai** usata
 perché internamente fa uso di `eval`.
 
-> **Nota:** dato che le funzioni di timeout **non** sono specificate dallo
-> standard ECMAScript, l'esatto funzionamento quando viene passata una stringa
+> **Nota:** L'esatto funzionamento quando viene passata una stringa
 > potrebbe differire nelle varie implementazioni di JavaScript. Per esempio,
 > JScript di Microsoft usa il costruttore `Function` al posto di `eval`.
 
@@ -157,6 +160,9 @@ funzione che verrà chiamata da una delle funzioni di timeout.
 > `setTimeout(foo, 1000, 1, 2, 3)`, non la si raccomanda, dato che il suo
 > utilizzo potrebbe portare ad errori subdoli quando usata con i
 > [metodi](#function.this).
+> Inoltre, la sintassi potrebbe non funzionare in alcune implementazioni di
+> JavaScript.
+> Ad esempio, Internet Explorer di Microsoft [**non** passa direttamente gli argomenti al callback](3).
 
 ### In conclusione
 
@@ -169,5 +175,6 @@ di gestire l'effettiva chiamata.
 Inoltre, l'uso di `setInterval` dovrebbe essere evitato perché il suo schedulatore
 non viene bloccato dall'esecuzione di JavaScript.
 
-[1]: http://en.wikipedia.org/wiki/Document_Object_Model "Document Object Model"
-
+[1]: http://www.nczonline.net/blog/2009/09/29/web-definitions-dom-ajax-and-more/ "Web definitions: DOM, Ajax, and more"
+[2]: http://www.w3.org/TR/2014/WD-html5-20140617/webappapis.html#timers "6 Web application APIs - HTML5"
+[3]: http://msdn.microsoft.com/en-us/library/ie/ms536753(v=vs.85).aspx "setTimeout method (Internet Explorer)"