save

Author: jcbhmr

content/it/docs/README.md

@@ -0,0 +1,21 @@
+# Go by Example - IT
+
+[Go](http://golang.org/) è un linguaggio di programmazione open source ideato per la creazione di software semplice, veloce e efficiente.
+
+*Go by Example - IT* è una introduzione pratica a Go che utilizza programmi di esempio commentati con adeguate spiegazioni. Dai un'occhiata al [primo esempio](hello-world.md) o cerca nella lista intera qui di seguito.
+
+Quella che vedi è la traduzione italiana del progetto *Go by Example* ([gobyexample.com](http://gobyexample.jcbhmr.com/)), realizzata dalla community italiana di golang ([golang-it](http://golangit.github.io/)).
+
+<br>
+
+<style>
+/* Make draft links from included SUMMARY.md on README.md non-clickable. */
+#content a[href=""] {
+    color: var(--sidebar-non-existant);;
+    text-decoration: none;
+    cursor: default;
+    pointer-events: none;
+}
+</style>
+
+{{#include SUMMARY.md:7:}}

content/it/docs/SUMMARY.md

@@ -0,0 +1,71 @@
+# Summary
+
+[Go by Example - IT](README.md)
+
+---
+
+- [Hello World](hello-world.md)
+- [Valori](valori.md)
+- [Variabili](variabili.md)
+- [Costanti](costanti.md)
+- [For](for.md)
+- [If/Else](if-else.md)
+- [Switch](switch.md)
+- [Array](array.md)
+- [Slice](slice.md)
+- [Map](map.md)
+- [Range](range.md)
+- [Funzioni](funzioni.md)
+- [Multipli Valori Restituiti](multipli-valori-restituiti.md)
+- [Funzioni Variadiche](funzioni-variadiche.md)
+- [Chiusure](chiusure.md)
+- [Ricorsione](ricorsione.md)
+- [Puntatori](puntatori.md)
+- [Struct](struct.md)
+- [Metodi](metodi.md)
+- [Interfacce](interfacce.md)
+- [Errori](errori.md)
+- [Goroutine](goroutine.md)
+- [Channel](channel.md)
+- [Channel con Buffer](channel-con-buffer.md)
+- [Sincronizzazione Dei Channel](sincronizzazione-dei-channel.md)
+- [Direzioni Dei Channel](direzioni-dei-channel.md)
+- [Select](select.md)
+- [Timeout](timeout.md)
+- [Operazioni Su Channel Non Bloccanti](operazioni-su-channel-non-bloccanti.md)
+- [Chiudere Channel](chiudere-channel.md)
+- [Range sui Channel](range-sui-channel.md)
+- [Timer](timer.md)
+- [Ticker](ticker.md)
+- [Worker Pool](worker-pool.md)
+- [Rate Limiting](rate-limiting.md)
+- [Contatori Atomici](contatori-atomici.md)
+- [Mutex](mutex.md)
+- [Gestione dello Stato con Goroutine](gestione-dello-stato-con-goroutine.md)
+- [Ordinamento](ordinamento.md)
+- [Ordinamento con Funzioni](ordinamento-con-funzioni.md)
+- [Panic](panic.md)
+- [Defer](defer.md)
+- [Funzioni per Collezioni](funzioni-per-collezioni.md)
+- [Funzioni per Stringhe](funzioni-per-stringhe.md)
+- [Formattazione di stringhe](formattazione-di-stringhe.md)
+- [Espressioni Regolari](espressioni-regolari.md)
+- [JSON](json.md)
+- [Tempo](tempo.md)
+- [Epoch](epoch.md)
+- [Formattazione / Parsing del Tempo](formattazione-parsing-del-tempo.md)
+- [Numeri Casuali](numeri-casuali.md)
+- [Parsing di Numeri](parsing-di-numeri.md)
+- [Parsing di URl](parsing-di-url.md)
+- [Hash SHA1](hash-sha1.md)
+- [Codifica Base64](codifica-base64.md)
+- [Leggere File](leggere-file.md)
+- [Scrivere File](scrivere-file.md)
+- [Line Filter](line-filter.md)
+- [Argomenti della Linea di Comando](argomenti-della-linea-di-comando.md)
+- [Command-Line Flag](command-line-flag.md)
+- [Variabili d'Ambiente](variabili-dambiente.md)
+- [Eseguire Sottoprocessi](eseguire-sottoprocessi.md)
+- [Rimpiazzare il Processo](rimpiazzare-il-processo.md)
+- [Segnali](segnali.md)
+- [Exit](exit.md)

content/it/docs/errori.md

@@ -0,0 +1,106 @@
+# Errori
+```go
+// In Go si è soliti comunicare errori attraverso un
+// valore restituito esplicito e separato. Questo
+// diversamente sia da quanto accade con le eccezioni
+// usate in linguaggi come Java e Ruby che dall'overloading
+// di un singolo valore come risultato / errore
+// che è a volte usato in C. L'approccio
+// usato da Go rende facile capire quali funzioni possono
+// generare errori e gestirli attraverso gli stessi
+// costrutti utilizzati per qualsiasi altra attività che
+// non riguardi la gestione degli errori.
+
+package main
+
+import "errors"
+import "fmt"
+
+// Per convenzione, gli errori sono l'ultimo valore
+// restituito, ed il loro tipo è `error`,
+// un'interfaccia built-in.
+func f1(arg int) (int, error) {
+    if arg == 42 {
+
+        // `errors.New` crea un errore base con il
+        // messaggio di errore dato.
+        err := errors.New("impossibile calcolare con 42")
+        return -1, err
+
+    }
+
+    // Un `nil` nella posizione dell'errore indica che non
+    // vi è stato alcun errore.
+    return arg + 3, nil
+}
+
+// È possibile usare altri tipi come `error`
+// implementando il metodo `Error()` su di essi. Di
+// seguito una variante del precedente esempio che
+// usa un tipo a sé per rappresentare esplicitamente un
+// errore di parametri.
+type argError struct {
+    arg  int
+    prob string
+}
+
+func (e *argError) Error() string {
+    return fmt.Sprintf("%d - %s", e.arg, e.prob)
+}
+
+func f2(arg int) (int, error) {
+    if arg == 42 {
+
+        // In questo caso, usiamo la sintassi
+        // `&argError` per costruire una nuova struct ed
+        // inserire i valori dei due campi, `arg` e `prob`.
+        return -1, &argError{arg, "impossibile calcolare"}
+    }
+    return arg + 3, nil
+}
+
+func main() {
+
+    // I due cicli che seguono provano ognuna delle nostre
+    // funzioni che restituiscono un errore. Nota che l'uso di
+    // un controllo di errori sulla stessa linea dell'`if`
+    // è una pratica comune in Go.
+    for _, i := range []int{7, 42} {
+        if r, e := f1(i); e != nil {
+            fmt.Println("f1 ha fallito   :", e)
+        } else {
+            fmt.Println("f1 ha funzionato:", r)
+        }
+    }
+    for _, i := range []int{7, 42} {
+        if r, e := f2(i); e != nil {
+            fmt.Println("f2 ha fallito   :", e)
+        } else {
+            fmt.Println("f2 ha funzionato:", r)
+        }
+    }
+
+    // Se vuoi utilizzare qualche campo specifico di
+    // un errore personalizzato, devi convertire
+    // l'errore in un'istanza dell'errore personalizzato
+    // tramite un type assertion.
+    _, e := f2(42)
+    if ae, ok := e.(*argError); ok {
+        fmt.Println(ae.arg)
+        fmt.Println(ae.prob)
+    }
+}
+```
+```sh
+$ go run errors.go
+f1 ha funzionato: 10
+f1 ha fallito   : impossibile calcolare con 42
+f2 ha funzionato: 10
+f2 ha fallito   : 42 - impossibile calcolare
+42
+impossibile calcolare 
+
+# Dai un'occhiata a questo [ottimo post](http://blog.golang.org/2011/07/error-handling-and-go.html)
+# sul blog di Go per ulteriori informazioni sulla gestione
+# degli errori. 
+```

content/it/docs/eseguire-sottoprocessi.md

@@ -0,0 +1,91 @@
+# Eseguire Sottoprocessi
+```go
+// Talvolta i programmi Go hanno bisogno di far partire
+// altri processi, che possono non essere scritti in Go. Ad esempio
+// l'highlight della sintassi in questo sito è [realizzata](https://github.com/golangit/gobyexample-it/blob/master/tools/generate.go)
+// facendo partire un processo [`pygmentize`](http://pygments.org/)
+// da un programma Go.
+// Vediamo qualche esempio su come poter eseguire processi
+// arbitrari da Go.
+package main
+
+import "fmt"
+import "io/ioutil"
+import "os/exec"
+
+func main() {
+
+    // Inizieremo con un programma semplice, che non ha argomenti
+    // o input ma che stampa solamente sul stdout. La funzione
+    // `exec.Command` è un helper che rappresenta il processo
+    // che andremo ad eseguire
+    dateCmd := exec.Command("date")
+
+    // Tramite la funzione `.Output` è possibile eseguire il
+    // processo, attendere che finisca ed ottenere il output.
+    // Se non ci sono stati errori `dateOut` conterrà i byte
+    // della data.
+    dateOut, err := dateCmd.Output()
+    if err != nil {
+        panic(err)
+    }
+    fmt.Println("> date")
+    fmt.Println(string(dateOut))
+
+    // Adesso vedremo un esempio leggermente più complesso
+    // dove forniremo alcuni dati sullo stdin di un processo,
+    // e raccoglieremo il suo output sullo stdout.
+    grepCmd := exec.Command("grep", "ciao")
+
+    // Qui possiamo vedere come ottenere lo stdin e lo stdout
+    // di un futuro comando, scrivere dei dati sullo stdin,
+    // leggere dei dati dallo stdout e attendere che il processo
+    // termini.
+    grepIn, _ := grepCmd.StdinPipe()
+    grepOut, _ := grepCmd.StdoutPipe()
+    grepCmd.Start()
+    grepIn.Write([]byte("ciao grep\naddio grep"))
+    grepIn.Close()
+    grepBytes, _ := ioutil.ReadAll(grepOut)
+    grepCmd.Wait()
+
+    // Abbiamo tralasciato il controllo degli errori nelle
+    // righe precedenti, ma ricordiamoci che possiamo usare
+    // il classico pattern `if err != nil` per tutti loro.
+    // Ci limitiamo inoltre a leggere dallo `StdoutPipe`,
+    // ma potremmo leggere anche da `StderrPipe` nello stesso
+    // identico modo.
+    fmt.Println("> grep hello")
+    fmt.Println(string(grepBytes))
+
+    // Nota che per eseguire processi con flag e parametri
+    // è necessario passare un array che li contenga, non è
+    // possibile passare semplicemente una stringa.
+    // Se si vuole eseguire un processo passando la sua stringa
+    // è possibile utilizzare il comando `bash` con il
+    // flag `-c` e passare la stringa del processo da eseguire.
+    lsCmd := exec.Command("bash", "-c", "ls -a -l -h")
+    lsOut, err := lsCmd.Output()
+    if err != nil {
+        panic(err)
+    }
+    fmt.Println("> ls -a -l -h")
+    fmt.Println(string(lsOut))
+}
+```
+```sh
+# Il processo eseguito stampa lo stesso output
+# che avrebbe stampato se lo avessimo eseguito
+# direttamente da terminale
+$ go run spawning-processes.go 
+> date
+Wed Oct 10 09:53:11 PDT 2012
+
+> grep ciao
+ciao grep
+
+> ls -a -l -h
+drwxr-xr-x  4 mark 136B Oct 3 16:29 .
+drwxr-xr-x 91 mark 3.0K Oct 3 12:50 ..
+-rw-r--r--  1 mark 1.3K Oct 3 16:28 spawning-processes.go
+```