Tutoriel GoLang – Application Web Partie 1

GCP-ICON.png

Bookmark and Share
recherche de site bogotobogo.com :

Introduction

Dans ce post, nous allons apprendre à réaliser une application simple. Celle-ci aura plusieurs parties et elle est basée sur https://golang.org/doc/articles/wiki/.

Ce sera un bon complément à nos tutoriels rapides de base que nous avons pratiqués jusqu’à présent.

Pour commencer

Nous allons créer un nouveau répertoire appelé gowiki quelque part sous $GOTPAH:

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

Créer un fichier wiki.go comme ceci:

initial_import.png

Nous importons les paquets fmt et ioutil de la bibliothèque standard de Go. Plus tard, au fur et à mesure que nous implémenterons des fonctionnalités supplémentaires, nous ajouterons d’autres paquets à cette déclaration d’importation.

Définir les structures de données

Un wiki est constitué d’une série de pages, dont chacune possède un titre et un corps (le contenu de la page). Ici, nous définissons Page comme une struct avec deux champs représentant le titre et le corps.

type Page struct { Title string Body byte}

Le type byte signifie une tranche d’octets.

L’élément Body est un octet plutôt qu’une chaîne de caractères car c’est le type attendu par les bibliothèques io que nous utiliserons.

La struct Page décrit comment les données de la page seront stockées en mémoire. Mais qu’en est-il du stockage persistant ? Nous pouvons aborder cela en créant une méthode save() sur Page:

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

La méthode save() dit « C’est une méthode nommée save qui prend comme récepteur p, un pointeur sur Page. Elle ne prend aucun paramètre et renvoie une valeur de type error. »

Notez que le (p *Page) prend la syntaxe suivante:

receiver_syntax.png

Cette méthode va enregistrer le Corps de la Page dans un fichier texte. Pour simplifier, nous utiliserons le Titre comme nom de fichier.

La méthode save renvoie une valeur d’erreur car c’est le type de retour de WriteFile (une fonction de la bibliothèque standard qui écrit une tranche d’octets dans un fichier). La méthode de sauvegarde renvoie la valeur d’erreur, pour laisser l’application la gérer si quelque chose ne va pas pendant l’écriture du fichier. Si tout va bien, Page.save() renvoie nil (la valeur zéro pour les pointeurs, les interfaces et certains autres types).

Le littéral entier octal 0600, passé comme troisième paramètre à WriteFile, indique que le fichier doit être créé avec des permissions de lecture-écriture pour l’utilisateur actuel uniquement.

En plus de sauvegarder des pages, nous voudrons également charger des pages :

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

La fonction loadPage construit le nom du fichier à partir du paramètre title, lit le contenu du fichier dans une nouvelle variable body, et renvoie un pointeur vers un littéral Page construit avec les valeurs appropriées de title et body.

Les fonctions peuvent renvoyer plusieurs valeurs. La fonction de la bibliothèque standard io.ReadFile renvoie byte et error. Dans loadPage, error n’est pas encore traité ; l' »identificateur vide » représenté par le symbole de soulignement (_) est utilisé pour jeter la valeur de retour d’erreur (en substance, affecter la valeur à rien).

Mais que se passe-t-il si ReadFile rencontre une erreur ? Par exemple, le fichier peut ne pas exister. Nous ne devons pas ignorer de telles erreurs. Modifions la fonction pour qu’elle renvoie *Page et erreur.

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}

Les appelants de cette fonction peuvent maintenant vérifier le second paramètre ; s’il est nul, alors elle a réussi à charger une Page. Si ce n’est pas le cas, ce sera une erreur qui peut être gérée par l’appelant.

À ce stade, nous avons une structure de données simple et la possibilité de sauvegarder et de charger à partir d’un fichier. Écrivons une fonction principale pour tester ce que nous avons écrit :

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

Après avoir compilé et exécuté ce code, un fichier nommé TestPage.txt a été créé, contenant le contenu de p1. Le fichier serait ensuite lu dans la structure p2, et son élément Body serait imprimé à l’écran.

TestPage-text.png

paquetnet/http

Débutons avec un serveur web simple un semblable à celui que nous avons fait avant (Web):

Simple_Web_Code.png

La fonction principale commence par un appel à http.HandleFunc, qui indique au paquet http de traiter toutes les requêtes vers la racine web (« / ») avec handler.

Elle appelle ensuite http.ListenAndServe, en spécifiant qu’elle doit écouter sur le port 8080 sur n’importe quelle interface (« :8080 »). (Ne vous préoccupez pas de son deuxième paramètre, nil, pour le moment.) Cette fonction bloquera jusqu’à ce que le programme soit terminé.

ListenAndServe() renvoie toujours une erreur, puisqu’elle ne renvoie que lorsqu’une erreur inattendue se produit. Afin d’enregistrer cette erreur, nous enveloppons l’appel de fonction avec log.Fatal. La fonction Fatal appelle os.Exit(1) après avoir écrit le message du journal.

Le gestionnaire de fonction est du type http.HandlerFunc. Elle prend un http.ResponseWriter et un http.Request comme arguments.

Une valeur http.ResponseWriter assemble la réponse du serveur HTTP ; en y écrivant, on envoie des données au client HTTP.

Une http.Request est une structure de données qui représente la requête HTTP du client. r.URL.Path est le composant chemin de l’URL de la requête. La queue signifie « créer une sous-partie de Path du 1er caractère à la fin ». Cela laisse tomber le « / » de tête du nom du chemin.

Exécutez ce programme et accédez à l’URL:

HiThereIlove.png

Continue à l’application Web Partie 2 (Utilisation de net/http).

  1. Tutoriel GoLang – HelloWorld
  2. Espaces de travail
  3. Code Visual Studio
  4. Types de données et variables
  5. byte et rune
  6. Paquets
  7. Fonctions
  8. . Tableaux et tranches
  9. Une fonction prenant et retournant une tranche
  10. Conditionnelles
  11. Boucles
  12. Cartes
  13. Plage
  14. Pointeurs
  15. Fermetures. et fonctions anonymes
  16. Struits et méthodes de réception
  17. Récepteurs de valeurs ou de pointeurs
  18. Interfaces
  19. Application Web partie 0 (Introduction)
  20. . Application Web Partie 1 (Basique)
  21. Application Web Partie 2 (Utilisation de net/http)
  22. Application Web Partie 3 (Ajout de la capacité de « modification »)
  23. Application Web Partie 4 (Traitement des pages nonexistantes et enregistrement des pages)
  24. Application Web Partie 5 (Gestion des erreurs et mise en cache des modèles)
  25. Application Web Partie 6 (Validation du titre avec une expression régulière)
  26. Application Web Partie 7 (Littérales et fermetures de fonctions)
  27. Construction d’une image Docker et déploiement de l’application Go sur un cluster Kubernetes (minikube)
  28. Framework Serverless (modèle d’application sans serveur-….SAM)
  29. API Web sans serveur avec AWS Lambda
  30. Tableaux contre tranches avec un échantillon de rotation à gauche du tableau
  31. Fonctions variadiques
  32. . Goroutines
  33. Canaux ( »
  34. Canaux ( »
  35. Canaux ( »
  36. Report
  37. GoLang Panique et Récupération
  38. Chaîne de caractères. Formatage
  39. JSON
  40. SQLite
  41. Modules 1 (Création d’un nouveau module)
  42. Modules 2 (Ajout de dépendances)
  43. AWS. SDK pour Go (listing S3)
  44. Liste chaînée
  45. Arbre de recherche binaire (BST) partie 1 (structures arbre/nœud avec fonctions d’insertion et d’impression)

.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.