Translate into it_IT

_posts/it/2015-12-29-inserire-un-elemento-in-un-array.md

@@ -0,0 +1,46 @@
+---
+layout: post
+
+titolo: Inserire un elemento in un Array
+tip-numero: 00
+tip-username: loverajoel 
+tip-username-profile: https://github.com/loverajoel
+tip-tldr: Inserire degli elementi dentro un array é un processo che si ripete giornalmente. Puoi aggiungere elementi alla fine di esso usando la funzione push, all'inizio usando unshift, o sennò nel mezzo usando splice.
+
+
+categoria:
+    - it
+---
+
+Inserire degli elementi dentro un array é un processo che si ripete giornalmente. Puoi aggiungere elementi alla fine di esso usando la funzione push, all'inizio usando unshift altrimenti nel mezzo usando splice.
+
+Questi sono i metodi più conosciuti, ma questo non vuol dire che non esistano alternative più performanti. Vediamo:
+
+Aggiungere un elemento alla fine di un array é facile usando push(), ma esiste un'alternativa più performante.
+
+```javascript
+var arr = [1,2,3,4,5];
+
+arr.push(6);
+arr[arr.length] = 6; // 43% più veloce in Chrome 47.0.2526.106 su Mac OS X 10.11.1
+```
+Entrambi i metodi modificano l'array originale. Non mi credete? Date un occhio a [jsperf](http://jsperf.com/push-item-inside-an-array)
+
+Ora se provassimo ad aggiungere un elemento all'inizio di un array:
+
+```javascript
+var arr = [1,2,3,4,5];
+
+arr.unshift(0);
+[0].concat(arr); // 98% più veloce in Chrome 47.0.2526.106 su Mac OS X 10.11.1
+```
+Vediamo più in dettaglio: unshift modifica l'array originale; concat invece restituisce un nuovo array. [jsperf](http://jsperf.com/unshift-item-inside-an-array)
+
+Aggiungere un elemento nel mezzo ad un array é facile con splice, e questo é il modo più performante per farlo.
+
+```javascript
+var items = ['one', 'two', 'three', 'four'];
+items.splice(items.length / 2, 0, 'hello');
+```
+
+Ho eseguito queste prove in diversi Browsers e OS e i risultati sono stati simili. Spero che questi tips vi resteranno utili e vi incoraggeranno a sperimentarli!

_posts/it/2016-01-01-angularjs-digest-vs-apply.md

@@ -0,0 +1,37 @@
+---
+layout: post
+
+titolo: AngularJs - `$digest` vs `$apply`
+tip-numero: 01
+tip-username: loverajoel 
+tip-username-profile: https://github.com/loverajoel
+tip-tldr: I moduli e i passaggi per compilare in Javascript stanno diventando sempre più numerosi e complicati, ma che dire degli standard nei nuovi frameworks?
+
+categoria:
+    - it
+---
+
+Una delle funzionalità più apprezzate di AngularJs è il data binding bidirezionale (two-way data binding). Per fare ciò, AngularJs calcola i cambiamenti fra model e view attraverso cicli(`$digest`). È necessario conoscere questo concetto per capire come il framework funzioni al suo interno.
+
+Angular calcola ogni watcher ogniqualvolta si verifica un evento. Questo è conosciuto come ciclo `$digest`.
+Talvolta dovete forzare l'esecuzione manuale di un nuovo ciclo e scegliere l'opzione giusta perchè è da questo che dipendono le prestazioni del programma.
+
+### `$apply`
+Questo metodo vi permette di avviare il ciclo `$digest` esplicitamente. Questo significa che tutti i watchers sono verificati; l'intera applicazione fa partire il `$digest loop`. Internamente, dopo aver eseguito un parametro di funzione opzionale, viene richiamato il metodo `$rootScope.$digest();`.
+
+### `$digest`
+In questo caso il metodo `$digest` avvia il ciclo `$digest` per il corrente ambito e suoi figli. Noterete che gli ambiti del metodo padre non verrano verificati e influenzati.
+
+### Raccomandazioni
+- Usate `$apply` o `$digest` solamente quando gli eventi DOM del browser avvengono al di fuori di AngularJS.
+- Passate un espressione a `$apply`, questo metodo supporta l'implementazione di un metodo di gestione degli errori e permette l'integrazione di cambiamenti nel ciclo digest.
+
+```javascript
+$scope.$apply(() => {
+	$scope.tip = 'Javascript Tip';
+});
+```
+
+- Se dovete solo aggiornare il corrente ambito o suoi figli, usate `$digest`, e prevenite un nuovo ciclo digest per l'intera applicazione. Migliori prestazioni saranno fin da subito evidenti.
+- `$apply()` è un processo impegnativo per la macchina e può portare a problemi di prestazione quando vi sono molti legami.
+- Se state usando >AngularJS 1.2.X, usate `$evalAsync`, è un metodo che eseguirà l'espressione durante il ciclo corrente o quello dopo. Questo può migliorare le prestazioni della vostra applicazione.

_posts/it/2016-01-03-migliorare-condizioni-nidificate.md

@@ -0,0 +1,92 @@
+---
+layout: post
+
+titolo: Improve Nested Conditionals
+tip-numero: 03
+tip-username: AlbertoFuente 
+tip-username-profile: https://github.com/AlbertoFuente
+tip-tldr: Come possiamo migliorare e rendere più efficienti istruzioni `if` nidificate in javascript?
+
+categoria:
+    - it
+---
+
+Come possiamo migliorare e rendere più efficienti istruzioni `if` nidificate in javascript?
+
+```javascript
+if (color) {
+  if (color === 'black') {
+    printBlackBackground();
+  } else if (color === 'red') {
+    printRedBackground();
+  } else if (color === 'blue') {
+    printBlueBackground();
+  } else if (color === 'green') {
+    printGreenBackground();
+  } else {
+    printYellowBackground();
+  }
+}
+```
+
+Un metodo per migliorare le istruzioni `if` nidificate sarebbe usare l'istruzione `switch`. Although it is less verbose and is more ordered, it's not recommended to use it because it's so difficult to debug errors. Here's [why](https://toddmotto.com/deprecating-the-switch-statement-for-object-literals/).
+
+```javascript
+switch(color) {
+  case 'black':
+    printBlackBackground();
+    break;
+  case 'red':
+    printRedBackground();
+    break;
+  case 'blue':
+    printBlueBackground();
+    break;
+  case 'green':
+    printGreenBackground();
+    break;
+  default:
+    printYellowBackground();
+}
+```
+
+But what if we have a conditional with several checks in each statement? In this case, if we want it less verbose and more ordered, we can use the conditional `switch`.
+If we pass `true` as a parameter to the `switch` statement, it allows us to put a conditional in each case.
+
+```javascript
+switch(true) {
+  case (typeof color === 'string' && color === 'black'):
+    printBlackBackground();
+    break;
+  case (typeof color === 'string' && color === 'red'):
+    printRedBackground();
+    break;
+  case (typeof color === 'string' && color === 'blue'):
+    printBlueBackground();
+    break;
+  case (typeof color === 'string' && color === 'green'):
+    printGreenBackground();
+    break;
+  case (typeof color === 'string' && color === 'yellow'):
+    printYellowBackground();
+    break;
+}
+```
+
+But we must always avoid having several checks in every condition and avoid using `switch` as much as possible. We also must take into account that the most efficient way to do this is through an `object`.
+
+```javascript
+var colorObj = {
+  'black': printBlackBackground,
+  'red': printRedBackground,
+  'blue': printBlueBackground,
+  'green': printGreenBackground,
+  'yellow': printYellowBackground
+};
+
+if (color in colorObj) {
+  colorObj[color]();
+}
+```
+
+Here you can find more information about [this](http://www.nicoespeon.com/en/2015/01/oop-revisited-switch-in-js/).

_posts/it/2016-01-05-differenze-tra-undefined-e-null.md

@@ -0,0 +1,40 @@
+---
+layout: post
+
+titolo: Differenze tra `undefined` e `null`
+tip-numero: 05
+tip-username: loverajoel 
+tip-username-profile: https://github.com/loverajoel
+tip-tldr: Capire le differenze tra `undefined` e `null`.
+
+categoria:
+    - it
+---
+
+- `undefined` significa che una variabile non è stata dichiarata, o è stata dichiarata ma non gli è stato ancora assegnato un valore
+- `null` è un'assegnazione di valore che significa "nessun valore"
+- Javascript assegna ad un variabile senza valore il valore `undefined`
+- Javascript non assegna mai il valore `null`. È usato dai programmato per indicare che una `variabile` non ha un valore.
+- `undefined` non è valido in JSON mentre `null` lo è
+- Il tipo di `undefined` è `undefined`
+- Il tipo di `null` è `object`. [Perchè?](http://www.2ality.com/2013/10/typeof-null.html)
+- Entrambi sono tipi primitivi
+- Entrambi sono [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy)
+  (`Boolean(undefined) // false`, `Boolean(null) // false`)
+- Puoi sapere se una variabile è [undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)
+
+  ```javascript
+  typeof variable === "undefined"
+```
+- Puoi verificare se una variabile è [null](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null)
+
+  ```javascript
+  variable === null
+```
+- L'operatore di **uguaglianza semplice** (==) li considera uguali, ma l'operatore di **uguaglianza stretta** (===) no
+
+  ```javascript
+  null == undefined // true
+
+  null === undefined // false
+```

_posts/it/2016-01-13-consiglio-per-misurare-le-prestazioni-di-un-blocco-di-codice-javascript.md

@@ -0,0 +1,33 @@
+---
+layout: post
+
+titolo: Consiglio per misurare le prestazioni di un blocco di codice javascript
+tip-numero: 13
+tip-username: manmadareddy
+tip-username-profile: https://twitter.com/manmadareddy
+tip-tldr: Per misurare velocemente le prestazioni di un blocco di codice javascript, possiamo utilizzare le funzioni console come `console.time(label)` e `console.timeEnd(label)`
+
+categoria:
+    - it
+---
+
+Per misurare velocemente le prestazioni di un blocco di codice javascript, possiamo utilizzare le funzioni console come
+[`console.time(label)`](https://developer.chrome.com/devtools/docs/console-api#consoletimelabel) e [`console.timeEnd(label)`](https://developer.chrome.com/devtools/docs/console-api#consoletimeendlabel)
+
+```javascript
+console.time("Array initialize");
+var arr = new Array(100),
+    len = arr.length,
+    i;
+
+for (i = 0; i < len; i++) {
+    arr[i] = new Object();
+};
+console.timeEnd("Array initialize"); // Restituisce: Array initialize: 0.711ms
+```
+
+Per maggiori informazioni:
+[Console object](https://github.com/DeveloperToolsWG/console-object),
+[Javascript benchmarking](https://mathiasbynens.be/notes/javascript-benchmarking)
+
+Demo: [jsfiddle](https://jsfiddle.net/meottb62/) - [codepen](http://codepen.io/anon/pen/JGJPoa) (outputs in browser console)

_posts/it/2016-01-19-concatenazione-stringhe-sicura.md

@@ -0,0 +1,36 @@
+---
+layout: post
+
+titolo: Concatenazione stringhe sicura
+tip-numero: 19
+tip-username: gogainda
+tip-username-profile: https://twitter.com/gogainda
+tip-tldr: Supponete di avere un paio di variabili di tipo non conosciuto e di volerle unire in una stringa. Per essere sicuri che delle operazioni aritmetiche non vengano eseguite, usate concat
+
+categoria:
+    - it
+---
+
+Supponete di avere un paio di variabili di tipo non conosciuto e di volerle unire in una stringa. Per essere sicuri che delle operazioni aritmetiche non vengano eseguite, usate `concat`:
+
+```javascript
+var one = 1;
+var two = 2;
+var three = '3';
+
+var result = ''.concat(one, two, three); //"123"
+```
+
+In questo modo la concatenazione avviene nel modo corretto. Al contrario, la concatenazione usando dei segni aritmetici e senza usare `concat` può portare a risultati inaspettati:
+
+```javascript
+var one = 1;
+var two = 2;
+var three = '3';
+
+var result = one + two + three; //"33" instead of "123"
+```
+
+Parlando di prestazioni, comparando il metodo `join` con concat, la velocità di `concat` è pressochè uguale. [Approfondimento](http://www.sitepoint.com/javascript-fast-string-concatenation/).
+
+Potete approfondire il metodo `concat` su MDN [page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat).

_posts/it/2016-01-20-restituire-oggetti-per-permettere-il-concatenamento-di-funzioni.md

@@ -0,0 +1,33 @@
+---
+layout: post
+
+titolo: Restituire oggetti per permettere il concatenamento di funzioni
+tip-numero: 20
+tip-username: WakeskaterX
+tip-username-profile: https://twitter.com/WakeStudio
+tip-tldr: Quando creiamo una funzione all'interno di un oggetto in Javascript Orientato agli Oggetti, restituire l'oggetto nella funzione vi permette di concatenare insieme le funzioni.
+
+categoria:
+    - it
+---
+
+Quando creiamo una funzione all'interno di un oggetto in Javascript Orientato agli Oggetti, restituire l'oggetto nella funzione vi permette di concatenare insieme le funzioni.
+
+```js
+function Person(name) {
+  this.name = name;
+
+  this.sayName = function() {
+    console.log("Hello my name is: ", this.name);
+    return this;
+  };
+
+  this.changeName = function(name) {
+    this.name = name;
+    return this;
+  };
+}
+
+var person = new Person("John");
+person.sayName().changeName("Timmy").sayName();
+```

_posts/it/2016-01-21-mescolare-un-array.md

@@ -0,0 +1,37 @@
+---
+layout: post
+
+titolo: Mescolare un Array
+tip-numero: 21
+tip-username: 0xmtn
+tip-username-profile: https://github.com/0xmtn/
+tip-tldr: Fisher-Yates Shuffling è un algoritmo per mescolare un array.
+
+categoria:
+    - it
+---
+
+ Questo frammento di codice utilizza l'algoritmo [Fisher-Yates Shuffling](https://www.wikiwand.com/en/Fisher%E2%80%93Yates_shuffle) per mescolare un array.
+
+```javascript
+function shuffle(arr) {
+    var i,
+        j,
+        temp;
+    for (i = arr.length - 1; i > 0; i--) {
+        j = Math.floor(Math.random() * (i + 1));
+        temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    return arr;    
+};
+```
+Un esempio:
+
+```javascript
+var a = [1, 2, 3, 4, 5, 6, 7, 8];
+var b = shuffle(a);
+console.log(b);
+// [2, 7, 8, 6, 5, 3, 1, 4]
+```

_posts/it/2016-01-23-metodo-veloce-per-convertire-stringhe-in-numero.md

@@ -0,0 +1,28 @@
+---
+layout: post
+
+titolo: Metodo veloce per convertire stringhe in numero
+tip-numero: 23
+tip-username: sonnyt
+tip-username-profile: http://twitter.com/sonnyt
+tip-tldr: Convertire delle stringhe in numero è estremamente comune. Il metodo più facile e veloce per fare ciò è usare l'operatore aritmetico `+` (più).
+
+categoria:
+    - it
+---
+
+Convertire delle stringhe in numero è estremamente comune. Il metodo più facile e veloce ([jsPref](https://jsperf.com/number-vs-parseint-vs-plus/29)) per fare ciò è usare l'operatore aritmetico `+` (più).
+
+```javascript
+var one = '1';
+
+var numberOne = +one; // Number 1
+```
+
+Potete anche usare l'operatore aritmetico `-` (meno) che converte il tipo ma lo cambia pure di segno.
+
+```javascript
+var one = '1';
+
+var negativeNumberOne = -one; // Number -1
+```