GoLang Tutorial – Applicazione Web Parte 1

GCP-ICON.png

Bookmark and Share
ricerca sito bogotobogo.com:

Introduzione

In questo post, impareremo come fare una semplice applicazione. Questa avrà diverse parti ed è basata su https://golang.org/doc/articles/wiki/.

Questa sarà una buona aggiunta ai nostri rapidi tutorial di base che abbiamo praticato finora.

Inizio

Creiamo una nuova directory chiamata gowiki da qualche parte sotto $GOTPAH:

$ echo $GOPATH~/go$ mkdir -p $GOPATH/src/github.com/einsteinish/go_tutorial/gowiki

Creiamo un file wiki.go come questo:

initial_import.png

Importiamo i pacchetti fmt e ioutil dalla libreria standard Go. Più tardi, quando implementeremo ulteriori funzionalità, aggiungeremo altri pacchetti a questa dichiarazione di importazione.

Definizione delle strutture dati

Un wiki consiste in una serie di pagine, ciascuna delle quali ha un titolo e un corpo (il contenuto della pagina). Qui, definiamo Page come una struct con due campi che rappresentano il titolo e il corpo.

type Page struct { Title string Body byte}

Il tipo byte significa una fetta di byte.

L’elemento Body è un byte piuttosto che una stringa perché questo è il tipo previsto dalle librerie io che useremo.

La struct Page descrive come i dati della pagina saranno memorizzati in memoria. Ma che dire della memorizzazione persistente? Possiamo occuparcene creando un metodo save() su Page:

func (p *Page) save() error { filename := p.Title + ".txt" return ioutil.WriteFile(filename, p.Body, 0600)}

Il metodo save() dice “Questo è un metodo chiamato save che prende come destinatario p, un puntatore a Page. Non prende parametri e restituisce un valore di tipo error.”

Nota che il (p *Page) ha la seguente sintassi:

receiver_syntax.png

Questo metodo salverà il corpo della pagina in un file di testo. Per semplicità, useremo il Titolo come nome del file.

Il metodo save restituisce un valore di errore perché questo è il tipo di ritorno di WriteFile (una funzione della libreria standard che scrive una fetta di byte in un file). Il metodo save restituisce il valore di errore, per permettere all’applicazione di gestirlo nel caso in cui qualcosa vada storto durante la scrittura del file. Se tutto va bene, Page.save() restituirà nil (il valore zero per puntatori, interfacce e alcuni altri tipi).

Il letterale ottale intero 0600, passato come terzo parametro a WriteFile, indica che il file dovrebbe essere creato con permessi di lettura-scrittura solo per l’utente corrente.

Oltre a salvare le pagine, vogliamo anche caricare le pagine:

func loadPage(title string) *Page { filename := title + ".txt" body, _ := ioutil.ReadFile(filename) return &Page{Title: title, Body: body}}

La funzione loadPage costruisce il nome del file dal parametro title, legge il contenuto del file in una nuova variabile body, e restituisce un puntatore a un letterale Page costruito con i valori title e body appropriati.

Le funzioni possono restituire più valori. La funzione di libreria standard io.ReadFile restituisce byte ed errore. In loadPage, l’errore non viene ancora gestito; il “blank identifier” rappresentato dal simbolo underscore (_) viene usato per buttare via il valore di ritorno dell’errore (in sostanza, assegnando il valore a niente).

Ma cosa succede se ReadFile incontra un errore? Per esempio, il file potrebbe non esistere. Non dovremmo ignorare tali errori. Modifichiamo la funzione per restituire *Page e l’errore.

func loadPage(title string) (*Page, error) { filename := title + ".txt" body, err := ioutil.ReadFile(filename) if err != nil { return nil, err } return &Page{Title: title, Body: body}, nil}

I chiamanti di questa funzione possono ora controllare il secondo parametro; se è nil allora ha caricato con successo una pagina. Altrimenti, sarà un errore che può essere gestito dal chiamante.

A questo punto abbiamo una semplice struttura dati e la capacità di salvare e caricare da un file. Scriviamo una funzione principale per testare ciò che abbiamo scritto:

func main() { p1 := &Page{Title: "TestPage", Body: byte("This is a sample Page.")} p1.save() p2, _ := loadPage("TestPage") fmt.Println(string(p2.Body))}

wiki-go-1.png

Dopo aver compilato ed eseguito questo codice, è stato creato un file chiamato TestPage.txt, contenente il contenuto di p1. Il file verrebbe poi letto nella struct p2, e il suo elemento Body stampato sullo schermo.

TestPage-text.png

pacchettonet/http

Iniziamo con un semplice server web simile a quello che abbiamo fatto prima (Web):

Simple_Web_Code.png

La funzione principale inizia con una chiamata a http.HandleFunc, che dice al pacchetto http di gestire tutte le richieste alla radice del web (“/”) con handler.

Poi chiama http.ListenAndServe, specificando che dovrebbe ascoltare sulla porta 8080 su qualsiasi interfaccia (“:8080”). (Non preoccupatevi del suo secondo parametro, nil, per ora.) Questa funzione si bloccherà finché il programma non sarà terminato.

ListenAndServe() restituisce sempre un errore, poiché ritorna solo quando si verifica un errore inaspettato. Per registrare tale errore, avvolgiamo la chiamata alla funzione con log.Fatal. La funzione Fatal chiama os.Exit(1) dopo aver scritto il messaggio di log.

Il gestore della funzione è del tipo http.HandlerFunc. Prende un http.ResponseWriter e un http.Request come argomenti.

Un valore http.ResponseWriter assembla la risposta del server HTTP; scrivendoci, inviamo dati al client HTTP.

Un http.Request è una struttura dati che rappresenta la richiesta HTTP del client. r.URL.Path è il componente path dell’URL della richiesta. Il trailing significa “crea una sotto-fetta di Path dal 1° carattere alla fine”. Questo elimina la “/” iniziale dal nome del percorso.

Esegui questo programma e accedi all’URL:

HiThereIlove.png

Continua a Web Application Part 2 (Using net/http).

  1. Tutorial GoLang – HelloWorld
  2. Spazi di lavoro
  3. Codice Visual Studio
  4. Tipi di dati e variabili
  5. byte e rune
  6. Pacchetti
  7. Funzioni
  8. Array e fette
  9. Una funzione che prende e restituisce una fetta
  10. Condizionali
  11. Loop
  12. Mappe
  13. Range
  14. Puntatori
  15. Chiusure e funzioni anonime
  16. Strutture e metodi riceventi
  17. Ricevitori di valori o puntatori
  18. Interfacce
  19. Applicazione Web Parte 0 (Introduzione)
  20. Applicazione Web Parte 1 (Base)
  21. Applicazione Web Parte 2 (Usare net/http)
  22. Applicazione Web Parte 3 (Aggiungere capacità di “modifica”)
  23. Applicazione Web Parte 4 (Gestire pagine nonpagine esistenti e salvataggio delle pagine)
  24. Applicazione Web Parte 5 (Gestione degli errori e caching dei template)
  25. Applicazione Web Parte 6 (Validazione del titolo con un’espressione regolare)
  26. Applicazione Web Parte 7 (Letterali di funzione e chiusure)
  27. Costruzione dell’immagine Docker e distribuzione dell’applicazione Go in un cluster Kubernetes (minikube)
  28. Framework Serverless (Serverless Application Model-SAM)
  29. Serverless Web API con AWS Lambda
  30. Array vs Slices con un esempio di rotazione sinistra dell’array
  31. Funzioni Variadic
  32. Goroutines
  33. Canali (”
  34. Canali (”
  35. Canali (”
  36. Defer
  37. GoLang Panic e Recover
  38. Stringa Formattazione
  39. JSON
  40. SQLite
  41. Moduli 1 (Creare un nuovo modulo)
  42. Moduli 2 (Aggiungere dipendenze)
  43. AWS SDK per Go (elenco S3)
  44. Lista collegata
  45. Albero di ricerca binario (BST) Parte 1 (Strutture albero/nodo con funzioni di inserimento e stampa)

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.