summaryrefslogtreecommitdiffhomepage
path: root/it-it
diff options
context:
space:
mode:
Diffstat (limited to 'it-it')
-rw-r--r--it-it/asciidoc-it.html.markdown135
-rw-r--r--it-it/c++-it.html.markdown7
-rw-r--r--it-it/dynamic-programming-it.html.markdown55
-rw-r--r--it-it/go-it.html.markdown7
-rw-r--r--it-it/html-it.html.markdown4
-rw-r--r--it-it/java-it.html.markdown70
-rw-r--r--it-it/jquery-it.html.markdown131
-rw-r--r--it-it/markdown.html.markdown60
-rw-r--r--it-it/matlab-it.html.markdown3
-rw-r--r--it-it/pcre-it.html.markdown80
-rw-r--r--it-it/pyqt-it.html.markdown85
-rw-r--r--it-it/python3-it.html.markdown6
-rw-r--r--it-it/qt-it.html.markdown161
-rw-r--r--it-it/ruby-it.html.markdown653
-rw-r--r--it-it/toml-it.html.markdown276
-rw-r--r--it-it/typescript-it.html.markdown227
16 files changed, 1881 insertions, 79 deletions
diff --git a/it-it/asciidoc-it.html.markdown b/it-it/asciidoc-it.html.markdown
new file mode 100644
index 00000000..47a57349
--- /dev/null
+++ b/it-it/asciidoc-it.html.markdown
@@ -0,0 +1,135 @@
+---
+language: asciidoc
+contributors:
+ - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+ - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
+translators:
+ - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+filename: asciidoc-it.md
+---
+
+AsciiDoc è un linguaggio di markup simile a Markdown e può essere usato per qualsiasi cosa, dai libri ai blog. Creato nel 2002 da Stuart Rackman, questo linguaggio è semplice ma permette un buon numero di personalizzazioni.
+
+Intestazione Documento
+
+Le intestazioni sono opzionali e possono contenere linee vuote. Deve avere almeno una linea vuota rispetto al contenuto.
+
+Solo titolo
+
+```
+= Titolo documento
+
+Prima frase del documento.
+```
+
+Titolo ed Autore
+
+```
+= Titolo documento
+Primo Ultimo <first.last@learnxinyminutes.com>
+
+Inizio del documento
+```
+
+Autori multipli
+
+```
+= Titolo Documento
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Inizio di un documento con autori multipli.
+```
+
+Linea di revisione (richiede una linea autore)
+
+```
+= Titolo documento V1
+Potato Man <chip@crunchy.com>
+v1.0, 2016-01-13
+
+Questo articolo sulle patatine sarà divertente.
+```
+
+Paragrafi
+
+```
+Non hai bisogno di nulla di speciale per i paragrafi.
+
+Aggiungi una riga vuota tra i paragrafi per separarli.
+
+Per creare una riga vuota aggiungi un +
+e riceverai una interruzione di linea!
+```
+
+Formattazione Testo
+
+```
+_underscore crea corsivo_
+*asterischi per il grassetto*
+*_combinali per maggiore divertimento_*
+`usa i ticks per indicare il monospazio`
+`*spaziatura fissa in grassetto*`
+```
+
+Titoli di sezione
+
+```
+= Livello 0 (può essere utilizzato solo nell'intestazione del documento)
+
+== Livello 1 <h2>
+
+=== Livello 2 <h3>
+
+==== Livello 3 <h4>
+
+===== Livello 4 <h5>
+
+```
+
+Liste
+
+Per creare un elenco puntato, utilizzare gli asterischi.
+
+```
+* foo
+* bar
+* baz
+```
+
+Per creare un elenco numerato usa i periodi.
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+È possibile nidificare elenchi aggiungendo asterischi o periodi aggiuntivi fino a cinque volte.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
+
+## Ulteriori letture
+
+Esistono due strumenti per elaborare i documenti AsciiDoc:
+
+1. [AsciiDoc](http://asciidoc.org/): implementazione Python originale, disponibile nelle principali distribuzioni Linux. Stabile e attualmente in modalità di manutenzione.
+2. [Asciidoctor](http://asciidoctor.org/): implementazione alternativa di Ruby, utilizzabile anche da Java e JavaScript. In fase di sviluppo attivo, mira ad estendere la sintassi AsciiDoc con nuove funzionalità e formati di output.
+
+I seguenti collegamenti sono relativi all'implementazione di `Asciidoctor`:
+
+* [Markdown - AsciiDoc comparazione sintassi](http://asciidoctor.org/docs/user-manual/#comparison-by-example): confronto affiancato di elementi di Markdown e AsciiDoc comuni.
+* [Per iniziare](http://asciidoctor.org/docs/#get-started-with-asciidoctor): installazione e guide rapide per il rendering di documenti semplici.
+* [Asciidoctor Manuale Utente](http://asciidoctor.org/docs/user-manual/): manuale completo con riferimento alla sintassi, esempi, strumenti di rendering, tra gli altri.
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index b4f9c50e..449aebfb 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -1130,7 +1130,6 @@ compl 4 // Effettua il NOT bit-a-bit
```
Letture consigliate:
-Un riferimento aggiornato del linguaggio può essere trovato qui
-<http://cppreference.com/w/cpp>
-
-Risorse addizionali possono essere trovate qui <http://cplusplus.com>
+* Un riferimento aggiornato del linguaggio può essere trovato qui [CPP Reference](http://cppreference.com/w/cpp).
+* Risorse addizionali possono essere trovate qui [CPlusPlus](http://cplusplus.com).
+* Un tutorial che copre le basi del linguaggio e l'impostazione dell'ambiente di codifica è disponibile su [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/it-it/dynamic-programming-it.html.markdown b/it-it/dynamic-programming-it.html.markdown
new file mode 100644
index 00000000..9c7bd9b6
--- /dev/null
+++ b/it-it/dynamic-programming-it.html.markdown
@@ -0,0 +1,55 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+ - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+ - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+# Programmazione dinamica
+
+## Introduzione
+
+La programmazione dinamica è una tecnica potente utilizzata per risolvere una particolare classe di problemi, come vedremo. L'idea è molto semplice, se hai risolto un problema con l'input dato, salva il risultato come riferimento futuro, in modo da evitare di risolvere nuovamente lo stesso problema.
+
+Ricordate sempre!
+"Chi non ricorda il passato è condannato a ripeterlo"
+
+## Modi per risolvere questi problemi
+
+1. *Top-Down* : Inizia a risolvere il problema specifico suddividendolo. Se vedi che il problema è già stato risolto, rispondi semplicemente con la risposta già salvata. Se non è stato risolto, risolvilo e salva la risposta. Di solito è facile da pensare e molto intuitivo. Questo è indicato come Memoization.
+
+2. *Bottom-Up* : Analizza il problema e vedi l'ordine in cui i sotto-problemi sono risolti e inizia a risolvere dal sottoproblema banale, verso il problema dato. In questo processo, è garantito che i sottoproblemi vengono risolti prima di risolvere il problema. Si parla di programmazione dinamica.
+
+## Esempio di programmazione dinamica
+
+Il problema di "Longest Increasing Subsequence" consiste nel trovare la sottosequenza crescente più lunga di una determinata sequenza. Data una sequenza `S= {a1 , a2 , a3, a4, ............., an-1, an }` dobbiamo trovare il sottoinsieme più lungo tale che per tutti gli `j` e gli `i`, `j<i` nel sotto-insieme `aj<ai`.
+Prima di tutto dobbiamo trovare il valore delle sottosequenze più lunghe (LSi) ad ogni indice i con l'ultimo elemento della sequenza che è ai. Quindi il più grande LSi sarebbe la sottosequenza più lunga nella sequenza data. Per iniziare LSi viene inizializzato ad 1, dato che ai è un element della sequenza (Ultimo elemento). Quindi per tutti gli `j` tale che `j<i` e `aj<ai`, troviamo il più grande LSj e lo aggiungiamo a LSi. Quindi l'algoritmo richiede un tempo di *O(n2)*.
+
+Pseudo-codice per trovare la lunghezza della sottosequenza crescente più lunga:
+Questa complessità degli algoritmi potrebbe essere ridotta usando una migliore struttura dei dati piuttosto che una matrice. La memorizzazione dell'array predecessore e della variabile come `largest_sequences_so_far` e il suo indice farebbero risparmiare molto tempo.
+
+Un concetto simile potrebbe essere applicato nel trovare il percorso più lungo nel grafico aciclico diretto.
+
+```python
+for i=0 to n-1
+ LS[i]=1
+ for j=0 to i-1
+ if (a[i] > a[j] and LS[i]<LS[j])
+ LS[i] = LS[j]+1
+for i=0 to n-1
+ if (largest < LS[i])
+```
+
+### Alcuni famosi problemi DP
+
+- Floyd Warshall Algorithm - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+
+
+## Risorse online
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/it-it/go-it.html.markdown b/it-it/go-it.html.markdown
index e49ccd79..797f6b0b 100644
--- a/it-it/go-it.html.markdown
+++ b/it-it/go-it.html.markdown
@@ -270,12 +270,13 @@ func fabbricaDiFrasi(miaStringa string) func(prima, dopo string) string {
}
func imparaDefer() (ok bool) {
- // Le istruzioni dette "deferred" (rinviate) sono eseguite
- // appena prima che la funzione abbia termine.
+ // La parola chiave "defer" inserisce una funzione in una lista.
+ // La lista contenente tutte le chiamate a funzione viene eseguita DOPO
+ // il return finale della funzione che le circonda.
defer fmt.Println("le istruzioni 'deferred' sono eseguite in ordine inverso (LIFO).")
defer fmt.Println("\nQuesta riga viene stampata per prima perché")
// defer viene usato di solito per chiudere un file, così la funzione che
- // chiude il file viene messa vicino a quella che lo apre.
+ // chiude il file, preceduta da "defer", viene messa vicino a quella che lo apre.
return true
}
diff --git a/it-it/html-it.html.markdown b/it-it/html-it.html.markdown
index 471019a1..8f7391a2 100644
--- a/it-it/html-it.html.markdown
+++ b/it-it/html-it.html.markdown
@@ -1,6 +1,6 @@
---
language: html
-filename: learnhtml-it.html
+filename: learnhtml-it.txt
contributors:
- ["Christophe THOMAS", "https://github.com/WinChris"]
translators:
@@ -112,7 +112,7 @@ Questo articolo riguarda principalmente la sintassi HTML ed alcuni suggerimenti
## Uso
-HTML è scritto in files che finiscono con `.html`.
+HTML è scritto in files che finiscono con `.html` o `.htm`. Il "MIME type" è `text/html`.
## Per saperne di più
diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown
index 54602cff..1669816e 100644
--- a/it-it/java-it.html.markdown
+++ b/it-it/java-it.html.markdown
@@ -17,14 +17,14 @@ concorrente, basato su classi e adatto a svariati scopi.
```java
// I commenti su singola linea incominciano con //
/*
-I commenti su piu' linee invece sono cosi'
+I commenti su più linee invece sono così
*/
/**
-I commenti per la documentazione JavaDoc si fanno cosi'.
+I commenti per la documentazione JavaDoc si fanno così.
Vengono usati per descrivere una classe o alcuni suoi attributi.
*/
-// Per importare la classe ArrayList conenuta nel package java.util
+// Per importare la classe ArrayList contenuta nel package java.util
import java.util.ArrayList;
// Per importare tutte le classi contenute nel package java.security
import java.security.*;
@@ -48,7 +48,7 @@ public class LearnJava {
System.out.print("Ciao ");
System.out.print("Mondo ");
- // Per stampare del testo formattato, si puo' usare System.out.printf
+ // Per stampare del testo formattato, si può usare System.out.printf
System.out.printf("pi greco = %.5f", Math.PI); // => pi greco = 3.14159
///////////////////////////////////////
@@ -60,7 +60,7 @@ public class LearnJava {
*/
// Per dichiarare una variabile basta fare <tipoDato> <nomeVariabile>
int fooInt;
- // Per dichiarare piu' di una variabile dello lo stesso tipo si usa:
+ // Per dichiarare più di una variabile dello lo stesso tipo si usa:
// <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3>
int fooInt1, fooInt2, fooInt3;
@@ -71,7 +71,7 @@ public class LearnJava {
// Per inizializzare una variabile si usa
// <tipoDato> <nomeVariabile> = <valore>
int fooInt = 1;
- // Per inizializzare piu' di una variabile dello lo stesso tipo
+ // Per inizializzare più di una variabile dello lo stesso tipo
// si usa <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3> = <valore>
int fooInt1, fooInt2, fooInt3;
fooInt1 = fooInt2 = fooInt3 = 1;
@@ -94,7 +94,7 @@ public class LearnJava {
// Long - intero con segno a 64 bit (in complemento a 2)
// (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
long fooLong = 100000L;
- // L viene usato per indicare che il valore e' di tipo Long;
+ // L viene usato per indicare che il valore è di tipo Long;
// altrimenti il valore viene considerato come intero.
// Nota: Java non dispone di interi senza segno.
@@ -102,14 +102,14 @@ public class LearnJava {
// Float - Numero in virgola mobile a 32 bit con precisione singola (IEEE 754)
// 2^-149 <= float <= (2-2^-23) * 2^127
float fooFloat = 234.5f;
- // f o F indicano the la variabile e' di tipo float;
+ // f o F indicano the la variabile è di tipo float;
// altrimenti il valore viene considerato come double.
// Double - Numero in virgola mobile a 64 bit con precisione doppia (IEEE 754)
// 2^-1074 <= x <= (2-2^-52) * 2^1023
double fooDouble = 123.4;
- // Boolean - Puo' assumere il valore vero (true) o falso (false)
+ // Boolean - Può assumere il valore vero (true) o falso (false)
boolean fooBoolean = true;
boolean barBoolean = false;
@@ -118,26 +118,26 @@ public class LearnJava {
// Le variabili precedute da final possono essere inizializzate una volta sola,
final int HOURS_I_WORK_PER_WEEK = 9001;
- // pero' e' possibile dichiararle e poi inizializzarle in un secondo momento.
+ // però è possibile dichiararle e poi inizializzarle in un secondo momento.
final double E;
E = 2.71828;
// BigInteger - Interi a precisione arbitraria
//
- // BigInteger e' un tipo di dato che permette ai programmatori di
- // gestire interi piu' grandi di 64 bit. Internamente, le variabili
+ // BigInteger è un tipo di dato che permette ai programmatori di
+ // gestire interi più grandi di 64 bit. Internamente, le variabili
// di tipo BigInteger vengono memorizzate come un vettore di byte e
// vengono manipolate usando funzioni dentro la classe BigInteger.
//
- // Una variabile di tipo BigInteger puo' essere inizializzata usando
+ // Una variabile di tipo BigInteger può essere inizializzata usando
// un array di byte oppure una stringa.
BigInteger fooBigInteger = new BigDecimal(fooByteArray);
// BigDecimal - Numero con segno, immutabile, a precisione arbitraria
//
- // Una variabile di tipo BigDecimal e' composta da due parti: un intero
+ // Una variabile di tipo BigDecimal è composta da due parti: un intero
// a precisione arbitraria detto 'non scalato', e un intero a 32 bit
// che rappresenta la 'scala', ovvero la potenza di 10 con cui
// moltiplicare l'intero non scalato.
@@ -158,9 +158,9 @@ public class LearnJava {
// Stringhe
String fooString = "Questa e' la mia stringa!";
- // \n e' un carattere di escape che rappresenta l'andare a capo
+ // \n è un carattere di escape che rappresenta l'andare a capo
String barString = "Stampare su una nuova riga?\nNessun problema!";
- // \t e' un carattere di escape che aggiunge un tab
+ // \t è un carattere di escape che aggiunge un tab
String bazString = "Vuoi aggiungere un tab?\tNessun problema!";
System.out.println(fooString);
System.out.println(barString);
@@ -168,7 +168,7 @@ public class LearnJava {
// Vettori
// La dimensione di un array deve essere decisa in fase di
- // istanziazione. Per dichiarare un array si puo' fare in due modi:
+ // istanziazione. Per dichiarare un array si può fare in due modi:
// <tipoDato>[] <nomeVariabile> = new <tipoDato>[<dimensioneArray>];
// <tipoDato> <nomeVariabile>[] = new <tipoDato>[<dimensioneArray>];
int[] intArray = new int[10];
@@ -189,8 +189,8 @@ public class LearnJava {
System.out.println("intArray @ 1: " + intArray[1]); // => 1
// Ci sono altri tipo di dato interessanti.
- // ArrayList - Simili ai vettori, pero' offrono altre funzionalita',
- // e la loro dimensione puo' essere modificata.
+ // ArrayList - Simili ai vettori, però offrono altre funzionalità,
+ // e la loro dimensione può essere modificata.
// LinkedList - Si tratta di una lista linkata doppia, e come tale
// implementa tutte le operazioni del caso.
// Map - Un insieme di oggetti che fa corrispondere delle chiavi
@@ -207,7 +207,7 @@ public class LearnJava {
int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea
- // L'aritmetica e' lineare.
+ // L'aritmetica è lineare.
System.out.println("1+2 = " + (i1 + i2)); // => 3
System.out.println("2-1 = " + (i2 - i1)); // => 1
System.out.println("2*1 = " + (i2 * i1)); // => 2
@@ -253,7 +253,7 @@ public class LearnJava {
///////////////////////////////////////
System.out.println("\n->Strutture di controllo");
- // La dichiarazione dell'If e'' C-like.
+ // La dichiarazione dell'If è C-like.
int j = 10;
if (j == 10){
System.out.println("Io vengo stampato");
@@ -328,18 +328,18 @@ public class LearnJava {
System.out.println("Risultato del costrutto switch: " + stringaMese);
// Condizioni brevi
- // Si puo' usare l'operatore '?' per un rapido assegnamento
+ // Si può usare l'operatore '?' per un rapido assegnamento
// o per operazioni logiche.
// Si legge:
- // Se (condizione) e' vera, usa <primo valore>, altrimenti usa <secondo valore>
+ // Se (condizione) è vera, usa <primo valore>, altrimenti usa <secondo valore>
int foo = 5;
String bar = (foo < 10) ? "A" : "B";
System.out.println("Se la condizione e' vera stampa A: "+bar);
- // Stampa A, perche' la condizione e' vera.
+ // Stampa A, perché la condizione è vera.
/////////////////////////////////////////
- // Convertire i tipi di tati e Typcasting
+ // Convertire i tipi di dati e Typecasting
/////////////////////////////////////////
// Convertire tipi di dati
@@ -397,16 +397,16 @@ class Bicicletta {
// Variabili della bicicletta
public int cadenza;
- // Public: Puo' essere richiamato da qualsiasi classe
+ // Public: Può essere richiamato da qualsiasi classe
private int velocita;
- // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato
+ // Private: è accessibile solo dalla classe dove è stato inizializzato
protected int ingranaggi;
- // Protected: e'' visto sia dalla classe che dalle sottoclassi
+ // Protected: è visto sia dalla classe che dalle sottoclassi
String nome;
- // default: e'' accessibile sono all'interno dello stesso package
+ // default: è accessibile sono all'interno dello stesso package
// I costruttori vengono usati per creare variabili
- // Questo e'' un costruttore
+ // Questo è un costruttore
public Bicicletta() {
ingranaggi = 1;
cadenza = 50;
@@ -414,7 +414,7 @@ class Bicicletta {
nome = "Bontrager";
}
- // Questo e'' un costruttore che richiede parametri
+ // Questo è un costruttore che richiede parametri
public Bicicletta(int cadenza, int velocita, int ingranaggi, String nome) {
this.ingranaggi = ingranaggi;
this.cadenza = cadenza;
@@ -469,7 +469,7 @@ class Bicicletta {
}
} // Fine classe bicicletta
-// PennyFarthing e'' una sottoclasse della bicicletta
+// PennyFarthing è una sottoclasse della bicicletta
class PennyFarthing extends Bicicletta {
// (Sono quelle biciclette con un unica ruota enorme
// Non hanno ingranaggi.)
@@ -481,7 +481,7 @@ class PennyFarthing extends Bicicletta {
// Bisogna contrassegnre un medodo che si sta riscrivendo
// con una @annotazione
- // Per saperne di piu' sulle annotazioni
+ // Per saperne di più sulle annotazioni
// Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/
@Override
public void setIngranaggi(int ingranaggi) {
@@ -518,8 +518,8 @@ class Frutta implements Commestibile, Digestibile {
}
}
-//In Java si puo' estendere solo una classe, ma si possono implementare
-//piu' interfaccie, per esempio:
+//In Java si può estendere solo una classe, ma si possono implementare
+//più interfaccie, per esempio:
class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia {
public void MetodoPrimaInterfaccia() {
diff --git a/it-it/jquery-it.html.markdown b/it-it/jquery-it.html.markdown
new file mode 100644
index 00000000..811c5c3a
--- /dev/null
+++ b/it-it/jquery-it.html.markdown
@@ -0,0 +1,131 @@
+---
+category: tool
+tool: jquery
+contributors:
+ - ["Sawyer Charles", "https://github.com/xssc"]
+filename: jquery-it.js
+translators:
+ - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+jQuery è una libreria JavaScript che ti aiuta a "fare di più, scrivendo meno". Rende molte attività comuni di JavaScript più facili da scrivere. jQuery è utilizzato da molte grandi aziende e sviluppatori in tutto il mondo. Rende AJAX, gestione degli eventi, manipolazione dei documenti e molto altro, più facile e veloce.
+
+Visto che jQuery è una libreria JavaScript dovresti prima [imparare JavaScript](https://learnxinyminutes.com/docs/javascript/)
+
+```js
+
+
+///////////////////////////////////
+// 1. Selettori
+
+// I selettori in jQuery vengono utilizzati per selezionare un elemento
+var page = $(window); // Seleziona l'intera finestra
+
+// I selettori possono anche essere selettori CSS
+var paragraph = $('p'); // Seleziona tutti gli elementi del paragrafo
+var table1 = $('#table1'); // Seleziona elemento con id 'table1'
+var squares = $('.square'); // Seleziona tutti gli elementi con la classe 'square'
+var square_p = $('p.square') // Seleziona i paragrafi con la classe 'square'
+
+
+///////////////////////////////////
+// 2. Eventi ed effetti
+// jQuery è molto bravo a gestire ciò che accade quando un evento viene attivato
+// Un evento molto comune è l'evento "pronto" sul documento
+// Puoi usare il metodo 'ready' per aspettare che l'elemento abbia finito di caricare
+$(document).ready(function(){
+ // Il codice non verrà eseguito fino a quando il documento non verrà caricato
+});
+// Puoi anche usare funzioni definite
+function onAction() {
+ // Questo viene eseguito quando l'evento viene attivato
+}
+$('#btn').click(onAction); // Invoca onAction al click
+
+// Alcuni altri eventi comuni sono:
+$('#btn').dblclick(onAction); // Doppio click
+$('#btn').hover(onAction); // Al passaggio del mouse
+$('#btn').focus(onAction); // Al focus
+$('#btn').blur(onAction); // Focus perso
+$('#btn').submit(onAction); // Al submit
+$('#btn').select(onAction); // Quando un elemento è selezionato
+$('#btn').keydown(onAction); // Quando un tasto è premuto (ma non rilasciato)
+$('#btn').keyup(onAction); // Quando viene rilasciato un tasto
+$('#btn').keypress(onAction); // Quando viene premuto un tasto
+$('#btn').mousemove(onAction); // Quando il mouse viene spostato
+$('#btn').mouseenter(onAction); // Il mouse entra nell'elemento
+$('#btn').mouseleave(onAction); // Il mouse lascia l'elemento
+
+
+// Questi possono anche innescare l'evento invece di gestirlo
+// semplicemente non passando alcun parametro
+$('#btn').dblclick(); // Innesca il doppio click sull'elemento
+
+// Puoi gestire più eventi mentre usi il selettore solo una volta
+$('#btn').on(
+ {dblclick: myFunction1} // Attivato con doppio clic
+ {blur: myFunction1} // Attivato al blur
+);
+
+// Puoi spostare e nascondere elementi con alcuni metodi di effetto
+$('.table').hide(); // Nascondi gli elementi
+
+// Nota: chiamare una funzione in questi metodi nasconderà comunque l'elemento
+$('.table').hide(function(){
+ // Elemento nascosto quindi funzione eseguita
+});
+
+// È possibile memorizzare selettori in variabili
+var tables = $('.table');
+
+// Alcuni metodi di manipolazione dei documenti di base sono:
+tables.hide(); // Nascondi elementi
+tables.show(); // Mostra elementi
+tables.toggle(); // Cambia lo stato nascondi/mostra
+tables.fadeOut(); // Fades out
+tables.fadeIn(); // Fades in
+tables.fadeToggle(); // Fades in o out
+tables.fadeTo(0.5); // Dissolve in opacità (tra 0 e 1)
+tables.slideUp(); // Scorre verso l'alto
+tables.slideDown(); // Scorre verso il basso
+tables.slideToggle(); // Scorre su o giù
+
+// Tutti i precedenti prendono una velocità (millisecondi) e la funzione di callback
+tables.hide(1000, myFunction); // nasconde l'animazione per 1 secondo quindi esegue la funzione
+
+// fadeTo ha un'opacità richiesta come secondo parametro
+tables.fadeTo(2000, 0.1, myFunction); // esegue in 2 sec. il fade sino ad una opacità di 0.1 opacity e poi la funzione
+
+// Puoi ottenere un effetti più avanzati con il metodo animate
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// Il metodo animate accetta un oggetto di css e valori con cui terminare,
+// parametri opzionali per affinare l'animazione,
+// e naturalmente la funzione di callback
+
+///////////////////////////////////
+// 3. Manipolazione
+
+// Questi sono simili agli effetti ma possono fare di più
+$('div').addClass('taming-slim-20'); // Aggiunge la classe taming-slim-20 a tutti i div
+
+// Metodi di manipolazione comuni
+$('p').append('Hello world'); // Aggiunge alla fine dell'elemento
+$('p').attr('class'); // Ottiene l'attributo
+$('p').attr('class', 'content'); // Imposta l'attributo
+$('p').hasClass('taming-slim-20'); // Restituisce vero se ha la classe
+$('p').height(); // Ottiene l'altezza dell'elemento o imposta l'altezza
+
+
+// Per molti metodi di manipolazione, ottenere informazioni su un elemento
+// restituirà SOLO il primo elemento corrispondente
+$('p').height(); // Ottiene solo la prima altezza del tag 'p'
+
+// È possibile utilizzare each per scorrere tutti gli elementi
+var heights = [];
+$('p').each(function() {
+ heights.push($(this).height()); // Aggiunge tutte le altezze del tag 'p' all'array
+});
+
+
+```
diff --git a/it-it/markdown.html.markdown b/it-it/markdown.html.markdown
index 44801747..b0a123f1 100644
--- a/it-it/markdown.html.markdown
+++ b/it-it/markdown.html.markdown
@@ -28,7 +28,7 @@ Markdown varia nelle sue implementazioni da un parser all'altro. Questa guida ce
## Elementi HTML
Markdown è un superset di HTML, quindi ogni file HTML è a sua volta un file Markdown valido.
-```markdown
+```md
<!-- Questo significa che possiamo usare elementi di HTML in Markdown, come per esempio i commenti,
e questi non saranno modificati dal parser di Markdown. State attenti però,
se inserite un elemento HTML nel vostro file Markdown, non potrete usare la sua sintassi
@@ -39,7 +39,7 @@ all'interno del contenuto dell'elemento. -->
Potete creare gli elementi HTML da `<h1>` a `<h6>` facilmente, basta che inseriate un egual numero di caratteri cancelletto (#) prima del testo che volete all'interno dell'elemento
-```markdown
+```md
# Questo è un <h1>
## Questo è un <h2>
### Questo è un <h3>
@@ -49,7 +49,7 @@ Potete creare gli elementi HTML da `<h1>` a `<h6>` facilmente, basta che inseria
```
Markdown inoltre fornisce due alternative per indicare gli elementi h1 e h2
-```markdown
+```md
Questo è un h1
==============
@@ -60,7 +60,7 @@ Questo è un h2
## Stili di testo semplici
Il testo può essere stilizzato in corsivo o grassetto usando markdown
-```markdown
+```md
*Questo testo è in corsivo.*
_Come pure questo._
@@ -74,12 +74,12 @@ __Come pure questo.__
In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su Github, è presente anche lo stile barrato:
-```markdown
+```md
~~Questo testo è barrato.~~
```
## Paragrafi
-```markdown
+```md
I paragrafi sono una o più linee di testo adiacenti separate da una o più righe vuote.
Questo è un paragrafo. Sto scrivendo in un paragrafo, non è divertente?
@@ -93,7 +93,7 @@ Qui siamo nel paragrafo 3!
Se volete inserire l'elemento HTML `<br />`, potete terminare la linea con due o più spazi e poi iniziare un nuovo paragrafo.
-```markdown
+```md
Questa frase finisce con due spazi (evidenziatemi per vederli).
C'è un <br /> sopra di me!
@@ -101,7 +101,7 @@ C'è un <br /> sopra di me!
Le citazioni sono semplici da inserire, basta usare il carattere >.
-```markdown
+```md
> Questa è una citazione. Potete
> mandare a capo manualmente le linee e inserire un `>` prima di ognuna, oppure potete usare una sola linea e lasciare che vada a capo automaticamente.
> Non c'è alcuna differenza, basta che iniziate ogni riga con `>`.
@@ -115,7 +115,7 @@ Le citazioni sono semplici da inserire, basta usare il carattere >.
## Liste
Le liste non ordinate possono essere inserite usando gli asterischi, il simbolo più o dei trattini
-```markdown
+```md
* Oggetto
* Oggetto
* Altro oggetto
@@ -135,7 +135,7 @@ oppure
Le liste ordinate invece, sono inserite con un numero seguito da un punto.
-```markdown
+```md
1. Primo oggetto
2. Secondo oggetto
3. Terzo oggetto
@@ -143,7 +143,7 @@ Le liste ordinate invece, sono inserite con un numero seguito da un punto.
Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerà comunque nell'ordine corretto, anche se potrebbe non essere una buona idea.
-```markdown
+```md
1. Primo oggetto
1. Secondo oggetto
1. Terzo oggetto
@@ -152,7 +152,7 @@ Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerÃ
Potete inserire anche sotto liste
-```markdown
+```md
1. Primo oggetto
2. Secondo oggetto
3. Terzo oggetto
@@ -163,7 +163,7 @@ Potete inserire anche sotto liste
Sono presenti anche le task list. In questo modo è possibile creare checkbox in HTML.
-```markdown
+```md
I box senza la 'x' sono checkbox HTML ancora da completare.
- [ ] Primo task da completare.
- [ ] Secondo task che deve essere completato.
@@ -174,14 +174,14 @@ Il box subito sotto è una checkbox HTML spuntata.
Potete inserire un estratto di codice (che utilizza l'elemento `<code>`) indentando una linea con quattro spazi oppure con un carattere tab.
-```markdown
+```md
Questa è una linea di codice
Come questa
```
Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vostro codice
-```markdown
+```md
my_array.each do |item|
puts item
end
@@ -189,7 +189,7 @@ Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vo
Codice inline può essere inserito usando il carattere backtick `
-```markdown
+```md
Giovanni non sapeva neppure a cosa servisse la funzione `go_to()`!
```
@@ -205,7 +205,7 @@ Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre
## Linea orizzontale
Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asterischi o trattini, con o senza spazi.
-```markdown
+```md
***
---
- - -
@@ -215,24 +215,24 @@ Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asteri
## Links
Una delle funzionalità migliori di markdown è la facilità con cui si possono inserire i link. Mettete il testo da visualizzare fra parentesi quadre [] seguite dall'url messo fra parentesi tonde ()
-```markdown
+```md
[Cliccami!](http://test.com/)
```
Potete inoltre aggiungere al link un titolo mettendolo fra doppi apici dopo il link
-```markdown
+```md
[Cliccami!](http://test.com/ "Link a Test.com")
```
La sintassi funziona anche con i path relativi.
-```markdown
+```md
[Vai a musica](/music/).
```
Markdown supporta inoltre anche la possibilità di aggiungere i link facendo riferimento ad altri punti del testo.
-```markdown
+```md
[Apri questo link][link1] per più informazioni!
[Guarda anche questo link][foobar] se ti va.
@@ -242,7 +242,7 @@ Markdown supporta inoltre anche la possibilità di aggiungere i link facendo rif
l titolo può anche essere inserito in apici singoli o in parentesi, oppure omesso interamente. Il riferimento può essere inserito in un punto qualsiasi del vostro documento e l'identificativo del riferimento può essere lungo a piacere a patto che sia univoco.
Esiste anche un "identificativo implicito" che vi permette di usare il testo del link come id.
-```markdown
+```md
[Questo][] è un link.
[Questo]: http://thisisalink.com/
@@ -252,13 +252,13 @@ Ma non è comunemente usato.
## Immagini
Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre!
-```markdown
+```md
![Qeusto è il testo alternativo per l'immagine](http://imgur.com/myimage.jpg "Il titolo opzionale")
```
E la modalità a riferimento funziona esattamente come ci si aspetta
-```markdown
+```md
![Questo è il testo alternativo.][myimage]
[myimage]: relative/urls/cool/image.jpg "Se vi serve un titolo, lo mettete qui"
@@ -266,25 +266,25 @@ E la modalità a riferimento funziona esattamente come ci si aspetta
## Miscellanea
### Auto link
-```markdown
+```md
<http://testwebsite.com/> è equivalente ad
[http://testwebsite.com/](http://testwebsite.com/)
```
### Auto link per le email
-```markdown
+```md
<foo@bar.com>
```
### Caratteri di escaping
-```markdown
+```md
Voglio inserire *questo testo circondato da asterischi* ma non voglio che venga renderizzato in corsivo, quindi lo inserirò così: \*questo testo è circondato da asterischi\*.
```
### Combinazioni di tasti
In Github Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
-```markdown
+```md
Il tuo computer è crashato? Prova a premere
<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Canc</kbd>
```
@@ -292,7 +292,7 @@ Il tuo computer è crashato? Prova a premere
### Tabelle
Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
-```markdown
+```md
| Col1 | Col2 | Col3 |
| :------------------- | :------: | -----------------: |
| Allineato a sinistra | Centrato | Allineato a destra |
@@ -300,7 +300,7 @@ Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente
```
oppure, per lo stesso risultato
-```markdown
+```md
Col 1 | Col2 | Col3
:-- | :-: | --:
È una cosa orrenda | fatela | finire in fretta
diff --git a/it-it/matlab-it.html.markdown b/it-it/matlab-it.html.markdown
index 8d6d4385..38be8848 100644
--- a/it-it/matlab-it.html.markdown
+++ b/it-it/matlab-it.html.markdown
@@ -199,8 +199,7 @@ size(A) % ans = 3 3
A(1, :) =[] % Rimuove la prima riga della matrice
A(:, 1) =[] % Rimuove la prima colonna della matrice
-transpose(A) % Traspone la matrice, equivale a:
-A one
+transpose(A) % Traspone la matrice, equivale a: A.'
ctranspose(A) % Trasposizione hermitiana della matrice
% (ovvero il complesso coniugato di ogni elemento della matrice trasposta)
diff --git a/it-it/pcre-it.html.markdown b/it-it/pcre-it.html.markdown
new file mode 100644
index 00000000..68233858
--- /dev/null
+++ b/it-it/pcre-it.html.markdown
@@ -0,0 +1,80 @@
+---
+language: PCRE
+filename: pcre-it.txt
+contributors:
+ - ["Sachin Divekar", "http://github.com/ssd532"]
+translators:
+ - ["Christian Grasso", "https://grasso.io"]
+lang: it-it
+---
+
+Un'espressione regolare (regex o regexp in breve) è una speciale stringa
+utilizzata per definire un pattern, ad esempio per cercare una sequenza di
+caratteri; ad esempio, `/^[a-z]+:/` può essere usato per estrarre `http:`
+dall'URL `http://github.com/`.
+
+PCRE (Perl Compatible Regular Expressions) è una libreria per i regex in C.
+La sintassi utilizzata per le espressioni è molto simile a quella di Perl, da
+cui il nome. Si tratta di una delle sintassi più diffuse per la scrittura di
+regex.
+
+Esistono due tipi di metacaratteri (caratteri con una funzione speciale):
+* Caratteri riconosciuti ovunque tranne che nelle parentesi quadre
+```
+ \ carattere di escape
+ ^ cerca all'inizio della stringa (o della riga, in modalità multiline)
+ $ cerca alla fine della stringa (o della riga, in modalità multiline)
+ . qualsiasi carattere eccetto le newline
+ [ inizio classe di caratteri
+ | separatore condizioni alternative
+ ( inizio subpattern
+ ) fine subpattern
+ ? quantificatore "0 o 1"
+ * quantificatore "0 o più"
+ + quantificatore "1 o più"
+ { inizio quantificatore numerico
+```
+
+* Caratteri riconosciuti nelle parentesi quadre
+```
+ \ carattere di escape
+ ^ nega la classe se è il primo carattere
+ - indica una serie di caratteri
+ [ classe caratteri POSIX (se seguita dalla sintassi POSIX)
+ ] termina la classe caratteri
+
+```
+
+PCRE fornisce inoltre delle classi di caratteri predefinite:
+```
+ \d cifra decimale
+ \D NON cifra decimale
+ \h spazio vuoto orizzontale
+ \H NON spazio vuoto orizzontale
+ \s spazio
+ \S NON spazio
+ \v spazio vuoto verticale
+ \V NON spazio vuoto verticale
+ \w parola
+ \W "NON parola"
+```
+
+## Esempi
+
+Utilizzeremo la seguente stringa per i nostri test:
+```
+66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"
+```
+Si tratta di una riga di log del web server Apache.
+
+| Regex | Risultato | Commento |
+| :---- | :-------------- | :------ |
+| `GET` | GET | Cerca esattamente la stringa "GET" (case sensitive) |
+| `\d+.\d+.\d+.\d+` | 66.249.64.13 | `\d+` identifica uno o più (quantificatore `+`) numeri [0-9], `\.` identifica il carattere `.` |
+| `(\d+\.){3}\d+` | 66.249.64.13 | `(\d+\.){3}` cerca il gruppo (`\d+\.`) esattamente 3 volte. |
+| `\[.+\]` | [18/Sep/2004:11:07:48 +1000] | `.+` identifica qualsiasi carattere, eccetto le newline; `.` indica un carattere qualsiasi |
+| `^\S+` | 66.249.64.13 | `^` cerca all'inizio della stringa, `\S+` identifica la prima stringa di caratteri diversi dallo spazio |
+| `\+[0-9]+` | +1000 | `\+` identifica il carattere `+`. `[0-9]` indica una cifra da 0 a 9. L'espressione è equivalente a `\+\d+` |
+
+## Altre risorse
+[Regex101](https://regex101.com/) - tester per le espressioni regolari
diff --git a/it-it/pyqt-it.html.markdown b/it-it/pyqt-it.html.markdown
new file mode 100644
index 00000000..855a0c75
--- /dev/null
+++ b/it-it/pyqt-it.html.markdown
@@ -0,0 +1,85 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt.py
+contributors:
+ - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+ - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+**Qt** è un framework ampiamente conosciuto per lo sviluppo di software multipiattaforma che può essere eseguito su varie piattaforme software e hardware con modifiche minime o nulle nel codice, pur avendo la potenza e la velocità delle applicazioni native. Sebbene **Qt** sia stato originariamente scritto in *C++*.
+
+
+Questo è un adattamento sull'introduzione di C ++ a QT di [Aleksey Kholovchuk] (https://github.com/vortexxx192
+), alcuni degli esempi di codice dovrebbero avere la stessa funzionalità
+che avrebbero se fossero fatte usando pyqt!
+
+```python
+import sys
+from PyQt4 import QtGui
+
+def window():
+ # Crea un oggetto applicazione
+ app = QtGui.QApplication(sys.argv)
+ # Crea un widget in cui verrà inserita la nostra etichetta
+ w = QtGui.QWidget()
+ # Aggiungi un'etichetta al widget
+ b = QtGui.QLabel(w)
+ # Imposta del testo per l'etichetta
+ b.setText("Ciao Mondo!")
+ # Fornisce informazioni su dimensioni e posizionamento
+ w.setGeometry(100, 100, 200, 50)
+ b.move(50, 20)
+ # Dai alla nostra finestra un bel titolo
+ w.setWindowTitle("PyQt")
+ # Visualizza tutto
+ w.show()
+ # Esegui ciò che abbiamo chiesto, una volta che tutto è stato configurato
+ sys.exit(app.exec_())
+
+if __name__ == '__main__':
+ window()
+
+```
+
+Per ottenere alcune delle funzionalità più avanzate in **pyqt**, dobbiamo iniziare a cercare di creare elementi aggiuntivi.
+Qui mostriamo come creare una finestra popup di dialogo, utile per chiedere all'utente di confermare una decisione o fornire informazioni
+
+```Python
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+ app = QApplication(sys.argv)
+ w = QWidget()
+ # Crea un pulsante e allegalo al widget w
+ b = QPushButton(w)
+ b.setText("Premimi")
+ b.move(50, 50)
+ # Indica a b di chiamare questa funzione quando si fa clic
+    # notare la mancanza di "()" sulla chiamata di funzione
+ b.clicked.connect(showdialog)
+ w.setWindowTitle("PyQt Dialog")
+ w.show()
+ sys.exit(app.exec_())
+
+# Questa funzione dovrebbe creare una finestra di dialogo con un pulsante
+# che aspetta di essere cliccato e quindi esce dal programma
+def showdialog():
+ d = QDialog()
+ b1 = QPushButton("ok", d)
+ b1.move(50, 50)
+ d.setWindowTitle("Dialog")
+ # Questa modalità dice al popup di bloccare il genitore, mentre è attivo
+ d.setWindowModality(Qt.ApplicationModal)
+ # Al click vorrei che l'intero processo finisse
+ b1.clicked.connect(sys.exit)
+ d.exec_()
+
+if __name__ == '__main__':
+ window()
+```
diff --git a/it-it/python3-it.html.markdown b/it-it/python3-it.html.markdown
index 06ef9a5e..04f78cff 100644
--- a/it-it/python3-it.html.markdown
+++ b/it-it/python3-it.html.markdown
@@ -400,8 +400,8 @@ else: # Anche else è opzionale
print("some_var è 10.")
"""
-I cicli for iterano sulle liste, cioé ripetono un codice per ogni elemento
-# di una lista.
+I cicli for iterano sulle liste, cioè ripetono un codice per ogni elemento
+di una lista.
Il seguente codice scriverà:
cane è un mammifero
gatto è un mammifero
@@ -409,7 +409,7 @@ Il seguente codice scriverà:
"""
for animale in ["cane", "gatto", "topo"]:
# Puoi usare format() per interpolare le stringhe formattate.
- print("{} is a mammal".format(animal))
+ print("{} è un mammifero".format(animale))
"""
"range(numero)" restituisce una lista di numeri da zero al numero dato
diff --git a/it-it/qt-it.html.markdown b/it-it/qt-it.html.markdown
new file mode 100644
index 00000000..4543818f
--- /dev/null
+++ b/it-it/qt-it.html.markdown
@@ -0,0 +1,161 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt.cpp
+contributors:
+ - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+ - ["Ale46", "https://gihub.com/ale46"]
+lang: it-it
+---
+
+**Qt** è un framework ampiamente conosciuto per lo sviluppo di software multipiattaforma che può essere eseguito su varie piattaforme software e hardware con modifiche minime o nulle nel codice, pur avendo la potenza e la velocità delle applicazioni native. Sebbene **Qt** sia stato originariamente scritto in *C++*, ci sono diversi porting in altri linguaggi: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
+
+**Qt** è ottimo per la creazione di applicazioni con interfaccia utente grafica (GUI). Questo tutorial descrive come farlo in *C++*.
+
+```c++
+/*
+ * Iniziamo classicamente
+ */
+
+// tutte le intestazioni dal framework Qt iniziano con la lettera maiuscola 'Q'
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+ // crea un oggetto per gestire le risorse a livello di applicazione
+ QApplication app(argc, argv);
+
+ // crea un widget di campo di testo e lo mostra sullo schermo
+ QLineEdit lineEdit("Hello world!");
+ lineEdit.show();
+
+ // avvia il ciclo degli eventi dell'applicazione
+ return app.exec();
+}
+```
+
+La parte relativa alla GUI di **Qt** riguarda esclusivamente *widget* e le loro *connessioni*.
+
+[LEGGI DI PIÙ SUI WIDGET](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * Creiamo un'etichetta e un pulsante.
+ * Un'etichetta dovrebbe apparire quando si preme un pulsante.
+ *
+ * Il codice Qt parla da solo.
+ */
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+ QApplication app(argc, argv);
+
+ QDialog dialogWindow;
+ dialogWindow.show();
+
+ // add vertical layout
+ QVBoxLayout layout;
+ dialogWindow.setLayout(&layout);
+
+ QLabel textLabel("Grazie per aver premuto quel pulsante");
+ layout.addWidget(&textLabel);
+ textLabel.hide();
+
+ QPushButton button("Premimi");
+ layout.addWidget(&button);
+
+ // mostra l'etichetta nascosta quando viene premuto il pulsante
+ QObject::connect(&button, &QPushButton::pressed,
+ &textLabel, &QLabel::show);
+
+ return app.exec();
+}
+```
+
+Si noti la parte relativa a *QObject::connect*. Questo metodo viene utilizzato per connettere *SEGNALI* di un oggetto agli *SLOTS* di un altro.
+
+**I SEGNALI** vengono emessi quando certe cose accadono agli oggetti, come il segnale *premuto* che viene emesso quando l'utente preme sull'oggetto QPushButton.
+
+**Gli slot** sono *azioni* che potrebbero essere eseguite in risposta ai segnali ricevuti.
+
+[LEGGI DI PIÙ SU SLOT E SEGNALI](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+Successivamente, impariamo che non possiamo solo usare i widget standard, ma estendere il loro comportamento usando l'ereditarietà. Creiamo un pulsante e contiamo quante volte è stato premuto. A tale scopo definiamo la nostra classe *CounterLabel*. Deve essere dichiarato in un file separato a causa dell'architettura Qt specifica.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+ Q_OBJECT // Macro definite da Qt che devono essere presenti in ogni widget personalizzato
+
+public:
+ CounterLabel() : counter(0) {
+ setText("Il contatore non è stato ancora aumentato"); // metodo di QLabel
+ }
+
+public slots:
+ // azione che verrà chiamata in risposta alla pressione del pulsante
+ void increaseCounter() {
+ setText(QString("Valore contatore: %1").arg(QString::number(++counter)));
+ }
+
+private:
+ int counter;
+};
+
+#endif // COUNTERLABEL
+```
+
+```c++
+// main.cpp
+// Quasi uguale all'esempio precedente
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+ QApplication app(argc, argv);
+
+ QDialog dialogWindow;
+ dialogWindow.show();
+
+ QVBoxLayout layout;
+ dialogWindow.setLayout(&layout);
+
+ CounterLabel counterLabel;
+ layout.addWidget(&counterLabel);
+
+ QPushButton button("Premimi ancora una volta");
+ layout.addWidget(&button);
+ QObject::connect(&button, &QPushButton::pressed,
+ &counterLabel, &CounterLabel::increaseCounter);
+
+ return app.exec();
+}
+```
+
+Questo è tutto! Ovviamente, il framework Qt è molto più grande della parte che è stata trattata in questo tutorial, quindi preparatevi a leggere e fare pratica.
+
+## Ulteriori letture
+
+- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+Buona fortuna e buon divertimento!
diff --git a/it-it/ruby-it.html.markdown b/it-it/ruby-it.html.markdown
new file mode 100644
index 00000000..295bf28a
--- /dev/null
+++ b/it-it/ruby-it.html.markdown
@@ -0,0 +1,653 @@
+---
+language: ruby
+filename: learnruby-it.rb
+contributors:
+ - ["David Underwood", "http://theflyingdeveloper.com"]
+ - ["Joel Walden", "http://joelwalden.net"]
+ - ["Luke Holder", "http://twitter.com/lukeholder"]
+ - ["Tristan Hume", "http://thume.ca/"]
+ - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+ - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+ - ["Ariel Krakowski", "http://www.learneroo.com"]
+ - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+ - ["Levi Bostian", "https://github.com/levibostian"]
+ - ["Rahil Momin", "https://github.com/iamrahil"]
+ - ["Gabriel Halley", "https://github.com/ghalley"]
+ - ["Persa Zula", "http://persazula.com"]
+ - ["Jake Faris", "https://github.com/farisj"]
+ - ["Corey Ward", "https://github.com/coreyward"]
+translators:
+ - ["abonte", "https://github.com/abonte"]
+lang: it-it
+---
+
+```ruby
+# Questo è un commento
+
+# In Ruby, (quasi) tutto è un oggetto.
+# Questo include i numeri...
+3.class #=> Integer
+
+# ...stringhe...
+"Hello".class #=> String
+
+# ...e anche i metodi!
+"Hello".method(:class).class #=> Method
+
+# Qualche operazione aritmetica di base
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2 ** 5 #=> 32
+5 % 3 #=> 2
+
+# Bitwise operators
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# L'aritmetica è solo zucchero sintattico
+# per chiamare il metodo di un oggetto
+1.+(3) #=> 4
+10.* 5 #=> 50
+100.methods.include?(:/) #=> true
+
+# I valori speciali sono oggetti
+nil # equivalente a null in altri linguaggi
+true # vero
+false # falso
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Uguaglianza
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Disuguaglianza
+1 != 1 #=> false
+2 != 1 #=> true
+
+# nil è l'unico valore, oltre a false, che è considerato 'falso'
+!!nil #=> false
+!!false #=> false
+!!0 #=> true
+!!"" #=> true
+
+# Altri confronti
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Operatori di confronto combinati (ritorna '1' quando il primo argomento è più
+# grande, '-1' quando il secondo argomento è più grande, altrimenti '0')
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# Operatori logici
+true && false #=> false
+true || false #=> true
+
+# Ci sono versioni alternative degli operatori logici con meno precedenza.
+# Sono usati come costrutti per il controllo di flusso per concatenare
+# insieme statement finché uno di essi ritorna true o false.
+
+# `do_something_else` chiamato solo se `do_something` ha successo.
+do_something() and do_something_else()
+# `log_error` è chiamato solo se `do_something` fallisce.
+do_something() or log_error()
+
+# Interpolazione di stringhe
+
+placeholder = 'usare l\'interpolazione di stringhe'
+"Per #{placeholder} si usano stringhe con i doppi apici"
+#=> "Per usare l'interpolazione di stringhe si usano stringhe con i doppi apici"
+
+# E' possibile combinare le stringhe usando `+`, ma non con gli altri tipi
+'hello ' + 'world' #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+"hello #{3}" #=> "hello 3"
+
+# ...oppure combinare stringhe e operatori
+'ciao ' * 3 #=> "ciao ciao ciao "
+
+# ...oppure aggiungere alla stringa
+'ciao' << ' mondo' #=> "ciao mondo"
+
+# Per stampare a schermo e andare a capo
+puts "Sto stampando!"
+#=> Sto stampando!
+#=> nil
+
+# Per stampare a schermo senza andare a capo
+print "Sto stampando!"
+#=> Sto stampando! => nil
+
+# Variabili
+x = 25 #=> 25
+x #=> 25
+
+# Notare che l'assegnamento ritorna il valore assegnato.
+# Questo significa che è possibile effettuare assegnamenti multipli:
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Per convenzione si usa lo snake_case per i nomi delle variabili
+snake_case = true
+
+# Usare nomi delle variabili descrittivi
+path_to_project_root = '/buon/nome/'
+m = '/nome/scadente/'
+
+# I simboli sono immutabili, costanti riusabili rappresentati internamente da
+# un valore intero. Sono spesso usati al posto delle stringhe per comunicare
+# specifici e significativi valori.
+
+:pendente.class #=> Symbol
+
+stato = :pendente
+
+stato == :pendente #=> true
+
+stato == 'pendente' #=> false
+
+stato == :approvato #=> false
+
+# Le stringhe possono essere convertite in simboli e viceversa:
+status.to_s #=> "pendente"
+"argon".to_sym #=> :argon
+
+# Arrays
+
+# Questo è un array
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Gli array possono contenere diversi tipi di elementi
+[1, 'hello', false] #=> [1, "hello", false]
+
+# Gli array possono essere indicizzati
+# Dall'inizio...
+array[0] #=> 1
+array.first #=> 1
+array[12] #=> nil
+
+
+# ...o dalla fine...
+array[-1] #=> 5
+array.last #=> 5
+
+# With a start index and length
+# ...o con un indice di inzio e la lunghezza...
+array[2, 3] #=> [3, 4, 5]
+
+# ...oppure con un intervallo.
+array[1..3] #=> [2, 3, 4]
+
+# Invertire l'ordine degli elementi di un array
+a = [1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Come per l'aritmetica, l'accesso tramite [var]
+# è solo zucchero sintattico
+# per chiamare il metodo '[]'' di un oggetto
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Si può aggiungere un elemento all'array così
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+# oppure così
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Controllare se un elemento esiste in un array
+array.include?(1) #=> true
+
+# Hash è un dizionario con coppie di chiave e valore
+# Un hash è denotato da parentesi graffe:
+hash = { 'colore' => 'verde', 'numero' => 5 }
+
+hash.keys #=> ['colore', 'numero']
+
+# E' possibile accedere all'hash tramite chiave:
+hash['colore'] #=> 'verde'
+hash['numero'] #=> 5
+
+# Accedere all'hash con una chiave che non esiste ritorna nil:
+hash['nothing here'] #=> nil
+
+# Quando si usano simboli come chiavi di un hash, si possono utilizzare
+# queste sintassi:
+
+hash = { :defcon => 3, :action => true }
+hash.keys #=> [:defcon, :action]
+# oppure
+hash = { defcon: 3, action: true }
+hash.keys #=> [:defcon, :action]
+
+# Controllare l'esistenza di una chiave o di un valore in un hash
+new_hash.key?(:defcon) #=> true
+new_hash.value?(3) #=> true
+
+# Suggerimento: sia gli array che gli hash sono enumerabili!
+# Entrambi possiedono metodi utili come each, map, count e altri.
+
+# Strutture di controllo
+
+#Condizionali
+if true
+ 'if statement'
+elsif false
+ 'else if, opzionale'
+else
+ 'else, opzionale'
+end
+
+#Cicli
+# In Ruby, i tradizionali cicli `for` non sono molto comuni. Questi semplici
+# cicli, invece, sono implementati con un enumerable, usando `each`:
+(1..5).each do |contatore|
+ puts "iterazione #{contatore}"
+end
+
+# Esso è equivalente a questo ciclo, il quale è inusuale da vedere in Ruby:
+for contatore in 1..5
+ puts "iterazione #{contatore}"
+end
+
+# Il costrutto `do |variable| ... end` è chiamato 'blocco'. I blocchi
+# sono simili alle lambda, funzioni anonime o closure che si trovano in altri
+# linguaggi di programmazione. Essi possono essere passati come oggetti,
+# chiamati o allegati come metodi.
+#
+# Il metodo 'each' di un intervallo (range) esegue il blocco una volta
+# per ogni elemento dell'intervallo.
+# Al blocco è passato un contatore come parametro.
+
+# E' possibile inglobare il blocco fra le parentesi graffe
+(1..5).each { |contatore| puts "iterazione #{contatore}" }
+
+# Il contenuto delle strutture dati può essere iterato usando "each".
+array.each do |elemento|
+ puts "#{elemento} è parte dell'array"
+end
+hash.each do |chiave, valore|
+ puts "#{chiave} è #{valore}"
+end
+
+# If you still need an index you can use 'each_with_index' and define an index
+# variable
+# Se comunque si vuole un indice, si può usare "each_with_index" e definire
+# una variabile che contiene l'indice
+array.each_with_index do |elemento, indice|
+ puts "#{elemento} è il numero #{index} nell'array"
+end
+
+contatore = 1
+while contatore <= 5 do
+ puts "iterazione #{contatore}"
+ contatore += 1
+end
+#=> iterazione 1
+#=> iterazione 2
+#=> iterazione 3
+#=> iterazione 4
+#=> iterazione 5
+
+# Esistono in Ruby ulteriori funzioni per fare i cicli,
+# come per esempio 'map', 'reduce', 'inject' e altri.
+# Nel caso di 'map', esso prende l'array sul quale si sta iterando, esegue
+# le istruzioni definite nel blocco, e ritorna un array completamente nuovo.
+array = [1,2,3,4,5]
+doubled = array.map do |elemento|
+ elemento * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
+# Costrutto "case"
+grade = 'B'
+
+case grade
+when 'A'
+ puts 'Way to go kiddo'
+when 'B'
+ puts 'Better luck next time'
+when 'C'
+ puts 'You can do better'
+when 'D'
+ puts 'Scraping through'
+when 'F'
+ puts 'You failed!'
+else
+ puts 'Alternative grading system, eh?'
+end
+#=> "Better luck next time"
+
+# 'case' può usare anche gli intervalli
+grade = 82
+case grade
+when 90..100
+ puts 'Hooray!'
+when 80...90
+ puts 'OK job'
+else
+ puts 'You failed!'
+end
+#=> "OK job"
+
+# Gestione delle eccezioni
+begin
+ # codice che può sollevare un eccezione
+ raise NoMemoryError, 'Esaurita la memoria.'
+rescue NoMemoryError => exception_variable
+ puts 'NoMemoryError è stato sollevato.', exception_variable
+rescue RuntimeError => other_exception_variable
+ puts 'RuntimeError è stato sollvato.'
+else
+ puts 'Questo viene eseguito se nessuna eccezione è stata sollevata.'
+ensure
+ puts 'Questo codice viene sempre eseguito a prescindere.'
+end
+
+# Metodi
+
+def double(x)
+ x * 2
+end
+
+# Metodi (e blocchi) ritornano implicitamente il valore dell'ultima istruzione
+double(2) #=> 4
+
+# Le parentesi sono opzionali dove l'interpolazione è inequivocabile
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+ x + y
+end
+
+# Gli argomenit dei metodi sono separati dalla virgola
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Tutti i metodi hanno un implicito e opzionale parametro del blocco.
+# Esso può essere chiamato con la parola chiave 'yield'.
+
+def surround
+ puts '{'
+ yield
+ puts '}'
+end
+
+surround { puts 'hello world' }
+
+# {
+# hello world
+# }
+
+# I blocchi possono essere convertiti in 'proc', il quale racchiude il blocco
+# e gli permette di essere passato ad un altro metodo, legato ad uno scope
+# differente o modificato. Questo è molto comune nella lista parametri del
+# metodo, dove è frequente vedere il parametro '&block' in coda. Esso accetta
+# il blocco, se ne è stato passato uno, e lo converte in un 'Proc'.
+# Qui la denominazione è una convenzione; funzionerebbe anche con '&ananas'.
+def guests(&block)
+ block.class #=> Proc
+ block.call(4)
+end
+
+# Il metodo 'call' del Proc è simile allo 'yield' quando è presente un blocco.
+# Gli argomenti passati a 'call' sono inoltrati al blocco come argomenti:
+
+guests { |n| "You have #{n} guests." }
+# => "You have 4 guests."
+
+# L'operatore splat ("*") converte una lista di argomenti in un array
+def guests(*array)
+ array.each { |guest| puts guest }
+end
+
+# Destrutturazione
+
+# Ruby destruttura automaticamente gli array in assegnamento
+# a variabili multiple:
+a, b, c = [1, 2, 3]
+a #=> 1
+b #=> 2
+c #=> 3
+
+# In alcuni casi si usa l'operatore splat ("*") per destrutturare
+# un array in una lista.
+classifica_concorrenti = ["John", "Sally", "Dingus", "Moe", "Marcy"]
+
+def migliore(primo, secondo, terzo)
+ puts "I vincitori sono #{primo}, #{secondo}, e #{terzo}."
+end
+
+migliore *classifica_concorrenti.first(3)
+#=> I vincitori sono John, Sally, e Dingus.
+
+# The splat operator can also be used in parameters:
+def migliore(primo, secondo, terzo, *altri)
+ puts "I vincitori sono #{primo}, #{secondo}, e #{terzo}."
+ puts "C'erano altri #{altri.count} partecipanti."
+end
+
+migliore *classifica_concorrenti
+#=> I vincitori sono John, Sally, e Dingus.
+#=> C'erano altri 2 partecipanti.
+
+# Per convenzione, tutti i metodi che ritornano un booleano terminano
+# con un punto interrogativo
+5.even? #=> false
+5.odd? #=> true
+
+# Per convenzione, se il nome di un metodo termina con un punto esclamativo,
+# esso esegue qualcosa di distruttivo. Molti metodi hanno una versione con '!'
+# per effettuare una modifiche, e una versione senza '!' che ritorna
+# una versione modificata.
+nome_azienda = "Dunder Mifflin"
+nome_azienda.upcase #=> "DUNDER MIFFLIN"
+nome_azienda #=> "Dunder Mifflin"
+# Questa volta modifichiamo nome_azienda
+nome_azienda.upcase! #=> "DUNDER MIFFLIN"
+nome_azienda #=> "DUNDER MIFFLIN"
+
+# Classi
+
+# Definire una classe con la parola chiave class
+class Umano
+
+ # Una variabile di classe. E' condivisa da tutte le istance di questa classe.
+ @@specie = 'H. sapiens'
+
+ # Inizializzatore di base
+ def initialize(nome, eta = 0)
+ # Assegna il valore dell'argomento alla variabile dell'istanza "nome"
+ @nome = nome
+ # Se l'età non è fornita, verrà assegnato il valore di default indicato
+ # nella lista degli argomenti
+ @eta = eta
+ end
+
+ # Metodo setter di base
+ def nome=(nome)
+ @nome = nome
+ end
+
+ # Metodo getter di base
+ def nome
+ @nome
+ end
+
+ # Le funzionalità di cui sopra posso essere incapsulate usando
+ # il metodo attr_accessor come segue
+ attr_accessor :nome
+
+ # Getter/setter possono anche essere creati individualmente
+ attr_reader :nome
+ attr_writer :nome
+
+ # Un metodo della classe usa 'self' per distinguersi dai metodi dell'istanza.
+ # Può essere richimato solo dalla classe, non dall'istanza.
+ def self.say(msg)
+ puts msg
+ end
+
+ def specie
+ @@specie
+ end
+end
+
+
+# Instanziare una classe
+jim = Umano.new('Jim Halpert')
+
+dwight = Umano.new('Dwight K. Schrute')
+
+# Chiamiamo qualche metodo
+jim.specie #=> "H. sapiens"
+jim.nome #=> "Jim Halpert"
+jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nome #=> "Jim Halpert II"
+dwight.specie #=> "H. sapiens"
+dwight.nome #=> "Dwight K. Schrute"
+
+# Chiamare un metodo della classe
+Umano.say('Ciao') #=> "Ciao"
+
+# La visibilità della variabile (variable's scope) è determinata dal modo
+# in cui le viene assegnato il nome.
+# Variabili che iniziano con $ hanno uno scope globale
+$var = "Sono una variabile globale"
+defined? $var #=> "global-variable"
+
+# Variabili che inziano con @ hanno a livello dell'istanza
+@var = "Sono una variabile dell'istanza"
+defined? @var #=> "instance-variable"
+
+# Variabili che iniziano con @@ hanno una visibilità a livello della classe
+@@var = "Sono una variabile della classe"
+defined? @@var #=> "class variable"
+
+# Variabili che iniziano con una lettera maiuscola sono costanti
+Var = "Sono una costante"
+defined? Var #=> "constant"
+
+# Anche una classe è un oggetto in ruby. Quindi la classe può avere
+# una variabile dell'istanza. Le variabili della classe sono condivise
+# fra la classe e tutti i suoi discendenti.
+
+# Classe base
+class Umano
+ @@foo = 0
+
+ def self.foo
+ @@foo
+ end
+
+ def self.foo=(value)
+ @@foo = value
+ end
+end
+
+# Classe derivata
+class Lavoratore < Umano
+end
+
+Umano.foo #=> 0
+Lavoratore.foo #=> 0
+
+Umano.foo = 2 #=> 2
+Lavoratore.foo #=> 2
+
+# La variabile dell'istanza della classe non è condivisa dai discendenti.
+
+class Umano
+ @bar = 0
+
+ def self.bar
+ @bar
+ end
+
+ def self.bar=(value)
+ @bar = value
+ end
+end
+
+class Dottore < Umano
+end
+
+Umano.bar #=> 0
+Dottore.bar #=> nil
+
+module EsempioModulo
+ def foo
+ 'foo'
+ end
+end
+
+# Includere moduli vincola i suoi metodi all'istanza della classe.
+# Estendere moduli vincola i suoi metodi alla classe stessa.
+class Persona
+ include EsempioModulo
+end
+
+class Libro
+ extend EsempioModulo
+end
+
+Persona.foo #=> NoMethodError: undefined method `foo' for Person:Class
+Persona.new.foo #=> 'foo'
+Libro.foo #=> 'foo'
+Libro.new.foo #=> NoMethodError: undefined method `foo'
+
+# Callbacks sono eseguiti quand si include o estende un modulo
+module ConcernExample
+ def self.included(base)
+ base.extend(ClassMethods)
+ base.send(:include, InstanceMethods)
+ end
+
+ module ClassMethods
+ def bar
+ 'bar'
+ end
+ end
+
+ module InstanceMethods
+ def qux
+ 'qux'
+ end
+ end
+end
+
+class Something
+ include ConcernExample
+end
+
+Something.bar #=> 'bar'
+Something.qux #=> NoMethodError: undefined method `qux'
+Something.new.bar #=> NoMethodError: undefined method `bar'
+Something.new.qux #=> 'qux'
+```
+
+## Ulteriori risorse
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Una variante di questa guida con esercizi nel browser.
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Imparare Ruby attraverso una serie di tutorial interattivi.
+- [Official Documentation](http://ruby-doc.org/core)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Una passata [edizione libera](http://ruby-doc.com/docs/ProgrammingRuby/) è disponibile online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
+- [Try Ruby](http://tryruby.org) - Imparare le basi del linguaggio di programmazion Ruby, interattivamente nel browser.
diff --git a/it-it/toml-it.html.markdown b/it-it/toml-it.html.markdown
new file mode 100644
index 00000000..99082048
--- /dev/null
+++ b/it-it/toml-it.html.markdown
@@ -0,0 +1,276 @@
+---
+language: toml
+filename: learntoml-it.toml
+contributors:
+ - ["Alois de Gouvello", "https://github.com/aloisdg"]
+translators:
+ - ["Christian Grasso", "https://grasso.io"]
+lang: it-it
+---
+
+TOML è l'acronimo di _Tom's Obvious, Minimal Language_. È un linguaggio per la
+serializzazione di dati, progettato per i file di configurazione.
+
+È un'alternativa a linguaggi come YAML e JSON, che punta ad essere più leggibile
+per le persone. Allo stesso tempo, TOML può essere utilizzato in modo abbastanza
+semplice nella maggior parte dei linguaggi di programmazione, in quanto è
+progettato per essere tradotto senza ambiguità in una hash table.
+
+Tieni presente che TOML è ancora in fase di sviluppo, e la sua specifica non è
+ancora stabile. Questo documento utilizza TOML 0.4.0.
+
+```toml
+# I commenti in TOML sono fatti così.
+
+################
+# TIPI SCALARI #
+################
+
+# Il nostro oggetto root (corrispondente all'intero documento) sarà una mappa,
+# anche chiamata dizionario, hash o oggetto in altri linguaggi.
+
+# La key, il simbolo di uguale e il valore devono trovarsi sulla stessa riga,
+# eccetto per alcuni tipi di valori.
+key = "value"
+stringa = "ciao"
+numero = 42
+float = 3.14
+boolean = true
+data = 1979-05-27T07:32:00-08:00
+notazScientifica = 1e+12
+"puoi utilizzare le virgolette per la key" = true # Puoi usare " oppure '
+"la key può contenere" = "lettere, numeri, underscore e trattini"
+
+############
+# Stringhe #
+############
+
+# Le stringhe possono contenere solo caratteri UTF-8 validi.
+# Possiamo effettuare l'escape dei caratteri, e alcuni hanno delle sequenze
+# di escape compatte. Ad esempio, \t corrisponde al TAB.
+stringaSemplice = "Racchiusa tra virgolette. \"Usa il backslash per l'escape\"."
+
+stringaMultiriga = """
+Racchiusa da tre virgolette doppie all'inizio e
+alla fine - consente di andare a capo."""
+
+stringaLiteral = 'Virgolette singole. Non consente di effettuare escape.'
+
+stringaMultirigaLiteral = '''
+Racchiusa da tre virgolette singole all'inizio e
+alla fine - consente di andare a capo.
+Anche in questo caso non si può fare escape.
+Il primo ritorno a capo viene eliminato.
+ Tutti gli altri spazi aggiuntivi
+ vengono mantenuti.
+'''
+
+# Per i dati binari è consigliabile utilizzare Base64 e
+# gestirli manualmente dall'applicazione.
+
+##########
+# Interi #
+##########
+
+## Gli interi possono avere o meno un segno (+, -).
+## Non si possono inserire zero superflui all'inizio.
+## Non è possibile inoltre utilizzare valori numerici
+## non rappresentabili con una sequenza di cifre.
+int1 = +42
+int2 = 0
+int3 = -21
+
+## Puoi utilizzare gli underscore per migliorare la leggibilità.
+## Fai attenzione a non inserirne due di seguito.
+int4 = 5_349_221
+int5 = 1_2_3_4_5 # VALIDO, ma da evitare
+
+#########
+# Float #
+#########
+
+# I float permettono di rappresentare numeri decimali.
+flt1 = 3.1415
+flt2 = -5e6
+flt3 = 6.626E-34
+
+###########
+# Boolean #
+###########
+
+# I valori boolean (true/false) devono essere scritti in minuscolo.
+bool1 = true
+bool2 = false
+
+############
+# Data/ora #
+############
+
+data1 = 1979-05-27T07:32:00Z # Specifica RFC 3339/ISO 8601 (UTC)
+data2 = 1979-05-26T15:32:00+08:00 # RFC 3339/ISO 8601 con offset
+
+######################
+# TIPI DI COLLECTION #
+######################
+
+#########
+# Array #
+#########
+
+array1 = [ 1, 2, 3 ]
+array2 = [ "Le", "virgole", "sono", "delimitatori" ]
+array3 = [ "Non", "unire", "tipi", "diversi" ]
+array4 = [ "tutte", 'le stringhe', """hanno lo stesso""", '''tipo''' ]
+array5 = [
+ "Gli spazi vuoti", "sono", "ignorati"
+]
+
+###########
+# Tabelle #
+###########
+
+# Le tabelle (o hash table o dizionari) sono collection di coppie key/value.
+# Iniziano con un nome tra parentesi quadre su una linea separata.
+# Le tabelle vuote (senza alcun valore) sono valide.
+[tabella]
+
+# Tutti i valori che si trovano sotto il nome della tabella
+# appartengono alla tabella stessa (finchè non ne viene creata un'altra).
+# L'ordine di questi valori non è garantito.
+[tabella-1]
+key1 = "una stringa"
+key2 = 123
+
+[tabella-2]
+key1 = "un'altra stringa"
+key2 = 456
+
+# Utilizzando i punti è possibile creare delle sottotabelle.
+# Ogni parte suddivisa dai punti segue le regole delle key per il nome.
+[tabella-3."sotto.tabella"]
+key1 = "prova"
+
+# Ecco l'equivalente JSON della tabella precedente:
+# { "tabella-3": { "sotto.tabella": { "key1": "prova" } } }
+
+# Gli spazi non vengono considerati, ma è consigliabile
+# evitare di usare spazi superflui.
+[a.b.c] # consigliato
+[ d.e.f ] # identico a [d.e.f]
+
+# Non c'è bisogno di creare le tabelle superiori per creare una sottotabella.
+# [x] queste
+# [x.y] non
+# [x.y.z] servono
+[x.y.z.w] # per creare questa tabella
+
+# Se non è stata già creata prima, puoi anche creare
+# una tabella superiore più avanti.
+[a.b]
+c = 1
+
+[a]
+d = 2
+
+# Non puoi definire una key o una tabella più di una volta.
+
+# ERRORE
+[a]
+b = 1
+
+[a]
+c = 2
+
+# ERRORE
+[a]
+b = 1
+
+[a.b]
+c = 2
+
+# I nomi delle tabelle non possono essere vuoti.
+[] # NON VALIDO
+[a.] # NON VALIDO
+[a..b] # NON VALIDO
+[.b] # NON VALIDO
+[.] # NON VALIDO
+
+##################
+# Tabelle inline #
+##################
+
+tabelleInline = { racchiuseData = "{ e }", rigaSingola = true }
+punto = { x = 1, y = 2 }
+
+####################
+# Array di tabelle #
+####################
+
+# Un array di tabelle può essere creato utilizzando due parentesi quadre.
+# Tutte le tabelle con questo nome saranno elementi dell'array.
+# Gli elementi vengono inseriti nell'ordine in cui si trovano.
+
+[[prodotti]]
+nome = "array di tabelle"
+sku = 738594937
+tabelleVuoteValide = true
+
+[[prodotti]]
+
+[[prodotti]]
+nome = "un altro item"
+sku = 284758393
+colore = "grigio"
+
+# Puoi anche creare array di tabelle nested. Le sottotabelle con doppie
+# parentesi quadre apparterranno alla tabella più vicina sopra di esse.
+
+[[frutta]]
+ nome = "mela"
+
+ [frutto.geometria]
+ forma = "sferica"
+ nota = "Sono una proprietà del frutto"
+
+ [[frutto.colore]]
+ nome = "rosso"
+ nota = "Sono un oggetto di un array dentro mela"
+
+ [[frutto.colore]]
+ nome = "verde"
+ nota = "Sono nello stesso array di rosso"
+
+[[frutta]]
+ nome = "banana"
+
+ [[frutto.colore]]
+ nome = "giallo"
+ nota = "Anche io sono un oggetto di un array, ma dentro banana"
+```
+
+Ecco l'equivalente JSON dell'ultima tabella:
+
+```json
+{
+ "frutta": [
+ {
+ "nome": "mela",
+ "geometria": { "forma": "sferica", "nota": "..."},
+ "colore": [
+ { "nome": "rosso", "nota": "..." },
+ { "nome": "verde", "nota": "..." }
+ ]
+ },
+ {
+ "nome": "banana",
+ "colore": [
+ { "nome": "giallo", "nota": "..." }
+ ]
+ }
+ ]
+}
+```
+
+### Altre risorse
+
++ [Repository ufficiale di TOML](https://github.com/toml-lang/toml)
diff --git a/it-it/typescript-it.html.markdown b/it-it/typescript-it.html.markdown
new file mode 100644
index 00000000..b78705c5
--- /dev/null
+++ b/it-it/typescript-it.html.markdown
@@ -0,0 +1,227 @@
+---
+language: TypeScript
+contributors:
+ - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+ - ["Christian Grasso", "https://grasso.io"]
+filename: learntypescript-it.ts
+lang: it-it
+---
+
+TypeScript è un linguaggio basato su JavaScript che punta a rendere il codice
+più scalabile introducendo concetti quali le classi, i moduli, le interface,
+e i generics.
+Poichè TypeScript è un superset di JavaScript, è possibile sfruttare le sue
+funzionalità anche in progetti esistenti: il codice JavaScript valido è anche
+valido in TypeScript. Il compilatore di TypeScript genera codice JavaScript.
+
+Questo articolo si concentrerà solo sulle funzionalità aggiuntive di TypeScript.
+
+Per testare il compilatore, puoi utilizzare il
+[Playground](http://www.typescriptlang.org/Playground), dove potrai scrivere
+codice TypeScript e visualizzare l'output in JavaScript.
+
+```ts
+// TypeScript ha tre tipi di base
+let completato: boolean = false;
+let righe: number = 42;
+let nome: string = "Andrea";
+
+// Il tipo può essere omesso se è presente un assegnamento a scalari/literal
+let completato = false;
+let righe = 42;
+let nome = "Andrea";
+
+// Il tipo "any" indica che la variabile può essere di qualsiasi tipo
+let qualsiasi: any = 4;
+qualsiasi = "oppure una stringa";
+qualsiasi = false; // o magari un boolean
+
+// Usa la keyword "const" per le costanti
+const numeroViteGatti = 9;
+numeroViteGatti = 1; // Errore
+
+// Per gli array, puoi usare l'apposito tipo o la versione con i generics
+let lista: number[] = [1, 2, 3];
+let lista: Array<number> = [1, 2, 3];
+
+// Per le enumerazioni:
+enum Colore { Rosso, Verde, Blu };
+let c: Colore = Colore.Verde;
+
+// Infine, "void" viene utilizzato per le funzioni che non restituiscono valori
+function avviso(): void {
+ alert("Sono un piccolo avviso fastidioso!");
+}
+
+// Le funzioni supportano la sintassi "a freccia" (lambda) e supportano la type
+// inference, cioè per scalari/literal non c'è bisogno di specificare il tipo
+
+// Tutte le seguenti funzioni sono equivalenti, e il compilatore genererà
+// lo stesso codice JavaScript per ognuna di esse
+let f1 = function (i: number): number { return i * i; }
+// Type inference
+let f2 = function (i: number) { return i * i; }
+// Sintassi lambda
+let f3 = (i: number): number => { return i * i; }
+// Sintassi lambda + type inference
+let f4 = (i: number) => { return i * i; }
+// Sintassi lambda + type inference + sintassi abbreviata (senza return)
+let f5 = (i: number) => i * i;
+
+// Le interfacce sono strutturali, e qualunque oggetto con le stesse proprietà
+// di un'interfaccia è compatibile con essa
+interface Persona {
+ nome: string;
+ // Proprietà opzionale, indicata con "?"
+ anni?: number;
+ // Funzioni
+ saluta(): void;
+}
+
+// Oggetto che implementa l'interfaccia Persona
+// È una Persona valida poichè implementa tutta le proprietà non opzionali
+let p: Persona = { nome: "Bobby", saluta: () => { } };
+// Naturalmente può avere anche le proprietà opzionali:
+let pValida: Persona = { nome: "Bobby", anni: 42, saluta: () => { } };
+// Questa invece NON è una Persona, poichè il tipo di "anni" è sbagliato
+let pNonValida: Persona = { nome: "Bobby", anni: true };
+
+// Le interfacce possono anche descrivere una funzione
+interface SearchFunc {
+ (source: string, subString: string): boolean;
+}
+// I nomi dei parametri non sono rilevanti: vengono controllati solo i tipi
+let ricerca: SearchFunc;
+ricerca = function (src: string, sub: string) {
+ return src.search(sub) != -1;
+}
+
+// Classi - i membri sono pubblici di default
+class Punto {
+ // Proprietà
+ x: number;
+
+ // Costruttore - in questo caso la keyword "public" può generare in automatico
+ // il codice per l'inizializzazione di una variabile.
+ // In questo esempio, verrà creata la variabile y in modo identico alla x, ma
+ // con meno codice. Sono supportati anche i valori di default.
+ constructor(x: number, public y: number = 0) {
+ this.x = x;
+ }
+
+ // Funzioni
+ dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+ // Membri statici
+ static origine = new Point(0, 0);
+}
+
+// Le classi possono anche implementare esplicitamente delle interfacce.
+// Il compilatore restituirà un errore nel caso in cui manchino delle proprietà.
+class PersonaDiRiferimento implements Persona {
+ nome: string
+ saluta() {}
+}
+
+let p1 = new Punto(10, 20);
+let p2 = new Punto(25); // y = 0
+
+// Inheritance
+class Punto3D extends Punto {
+ constructor(x: number, y: number, public z: number = 0) {
+ super(x, y); // La chiamata esplicita a super è obbligatoria
+ }
+
+ // Sovrascrittura
+ dist() {
+ let d = super.dist();
+ return Math.sqrt(d * d + this.z * this.z);
+ }
+}
+
+// Moduli - "." può essere usato come separatore per i sottomoduli
+module Geometria {
+ export class Quadrato {
+ constructor(public lato: number = 0) { }
+
+ area() {
+ return Math.pow(this.lato, 2);
+ }
+ }
+}
+
+let s1 = new Geometria.Quadrato(5);
+
+// Alias locale per un modulo
+import G = Geometria;
+
+let s2 = new G.Quadrato(10);
+
+// Generics
+// Classi
+class Tuple<T1, T2> {
+ constructor(public item1: T1, public item2: T2) {
+ }
+}
+
+// Interfacce
+interface Pair<T> {
+ item1: T;
+ item2: T;
+}
+
+// E funzioni
+let pairToTuple = function <T>(p: Pair<T>) {
+ return new Tuple(p.item1, p.item2);
+};
+
+let tuple = pairToTuple({ item1: "hello", item2: "world" });
+
+// Interpolazione con le template string (definite con i backtick)
+let nome = 'Tyrone';
+let saluto = `Ciao ${name}, come stai?`
+// Possono anche estendersi su più righe
+let multiriga = `Questo è un esempio
+di stringa multiriga.`;
+
+// La keyword "readonly" rende un membro di sola lettura
+interface Persona {
+ readonly nome: string;
+ readonly anni: number;
+}
+
+var p1: Persona = { nome: "Tyrone", anni: 42 };
+p1.anni = 25; // Errore, p1.anni è readonly
+
+var p2 = { nome: "John", anni: 60 };
+var p3: Person = p2; // Ok, abbiamo creato una versione readonly di p2
+p3.anni = 35; // Errore, p3.anni è readonly
+p2.anni = 45; // Compila, ma cambia anche p3.anni per via dell'aliasing!
+
+class Macchina {
+ readonly marca: string;
+ readonly modello: string;
+ readonly anno = 2018;
+
+ constructor() {
+ // Possiamo anche assegnare nel constructor
+ this.marca = "Marca sconosciuta";
+ this.modello = "Modello sconosciuto";
+ }
+}
+
+let numeri: Array<number> = [0, 1, 2, 3, 4];
+let altriNumeri: ReadonlyArray<number> = numbers;
+altriNumeri[5] = 5; // Errore, gli elementi sono readonly
+altriNumeri.push(5); // Errore, il metodo push non esiste (modifica l'array)
+altriNumeri.length = 3; // Errore, length è readonly
+numeri = altriNumeri; // Errore, i metodi di modifica non esistono
+```
+
+## Altre risorse
+ * [Sito ufficiale di TypeScript](http://www.typescriptlang.org/)
+ * [Specifica di TypeScript](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)
+ * [Anders Hejlsberg - Introducing TypeScript su Channel 9](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [TypeScript su GitHub](https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - definizioni per le librerie](http://definitelytyped.org/)