Quelle est la différence entre ResponseWriter.Écrire et io.WriteString?

io.Writer

Un flux de sortie représente une cible à laquelle vous pouvez écrire des séquence(s) d'octets. Dans cette est capturé par le général io.L'écrivain interface:

type Writer interface {
    Write(p []byte) (n int, err error)
}

Tout ce qui a cette seule Write() méthode peut être utilisée comme une sortie, par exemple un fichier sur votre disque dur (os.Fichier), d'une connexion réseau (net.Conn) ou un tampon en mémoire (octets.Tampon).

La http.ResponseWriter qui est utilisé pour configurer la réponse HTTP et envoie les données vers le client est également une io.Writer, les données que vous voulez envoyer (le corps de la réponse) est monté en appelant (pas nécessairement juste une fois) ResponseWriter.Write() (qui est de mettre en œuvre le général io.Writer). Ceci est la seule garantie que vous avez sur la mise en œuvre de la http.ResponseWriter interface (concernant l'envoi de l'organisme).

WriteString()

Maintenant sur WriteString(). Souvent nous voulons écrire des données textuelles à un io.Writer. Oui, on peut le faire simplement en convertissant le string à un []byte, par exemple

w.Write([]byte("Hello"))

qui fonctionne comme prévu. Cependant c'est une opération très fréquente et il est donc "en général" méthode acceptée pour ce capturé par les io.StringWriter interface (disponible depuis 1.12 Go, avant qu'il a été désexporter):

type StringWriter interface {
    WriteString(s string) (n int, err error)
}

Cette méthode donne la possibilité d'écrire un string de la valeur au lieu d'une []byte. Donc, si quelque chose (qui implémente également io.Writer) met en œuvre cette méthode, vous pouvez tout simplement passer à string valeurs sans []byte de conversion. Cela semble être un mineur de simplification dans le code, mais c'est plus que cela. La conversion d'un string à []byte a faire une copie de la string contenu (parce que string valeurs immuables Allez lire plus à ce sujet ici: golang: []byte(string) vs []byte(*string)), donc il y a certains frais généraux, qui devient perceptible si l' string est plus "grand" et/ou que vous avez à faire à de nombreuses reprises.

Selon la nature et les détails de mise en œuvre d'un io.Writer, il peut être possible d'écrire le contenu d'un string sans convertir []byte et d'éviter ainsi l'mentionnés ci-dessus les frais généraux.

Comme un exemple, si un io.Writer est quelque chose qui écrit dans un tampon en mémoire (bytes.Buffer est un exemple), il peut utiliser le builtin copier() fonction:

La copie intégré dans la fonction de copie des éléments à partir d'une source tranche en une destination de tranche. (Comme un cas spécial, il sera également copier des octets d'une chaîne à une tranche d'octets.)

La copy() peut être utilisé pour copier le contenu (en octets) d'un string dans un []byte sans conversion de la string à []byte, par exemple:

buf := make([]byte, 100)
copy(buf, "Hello")

Maintenant, il y a une "utilité" de la fonction io.WriteString() qui écrit un string dans un io.Writer. Mais il le fait en vérifiant d'abord si l' (type dynamique de l') passé io.Writer a un WriteString() méthode, et si oui, qui sera utilisé (dont la mise en œuvre est probablement plus efficace). Si le passé io.Writer n'a pas cette méthode, alors que le général convertir-à-octet-tranche-et-écrire-que méthode sera utilisée comme un "repli".

Vous pourriez penser que ce WriteString() ne prévalent dans le cas de la mémoire tampon, mais ce n'est pas vrai. Les réponses de requêtes web sont également souvent tamponnée (à l'aide d'un tampon en mémoire), de sorte qu'il peut améliorer les performances en cas de http.ResponseWriter trop. Et si vous regardez à la mise en œuvre de http.ResponseWriter: c'est le désexporter type http.response (server.aller actuellement en ligne n ° 308), qui n'en œuvre WriteString() (actuellement la ligne #1212) de sorte qu'il n'impliquent amélioration.

Dans l'ensemble, chaque fois que vous écrivez string valeurs recommandées pour l'utilisation de io.WriteString() qu'il peut être plus efficace (plus rapide).

fmt.Fprintf()

Vous devriez considérer cela comme un moyen pratique et facile pour ajouter plus de mise en forme les données que vous voulez écrire, en échange d'un peu moins performant.

Donc utiliser de l'esf.Fprintf() si vous voulez formaté string créé dans la voie de la facilité, par exemple:

name := "Bob"
age := 23
fmt.Fprintf(w, "Hi, my name is %s and I'm %d years old.", name, age)

Qui sera string être écrit:

Hi, my name is Bob and I'm 23 years old.

Une chose que vous ne devez pas oublier: fmt.Fprintf() s'attend à un chaîne de format, de sorte qu'il sera analysée et non pas écrite comme à la sortie. Comme un exemple rapide:

fmt.Fprintf(w, "100 %%")

Vous attendons à ce que "100 %%" serait écrit à la sortie (avec 2 % caractères), mais un seul sera envoyée dans la chaîne de format % est un caractère spécial et %% ne fait qu'un % dans la sortie.

Si vous voulez juste écrire un string à l'aide de la fmt package, utilisez de l'esf.Fprint() qui ne nécessite pas un format string:

fmt.Fprint(w, "Hello")

Un autre avantage de l'utilisation de la fmt paquet est que vous pouvez écrire les valeurs des autres types de trop, pas seulement strings, par exemple

fmt.Fprint(w, 23, time.Now())

(Bien sûr, les règles de comment convertir une valeur en une string–et à la série d'octets à la fin–est bien défini, dans la doc de la fmt package.)

Pour de "simples" formaté sorties de la fmt paquet pourrait être OK. Pour des complexes de documents de sortie n'envisager l'utilisation de la text/template (pour le texte) et html/template (lorsque la sortie est en HTML).

Passant /remise http.ResponseWriter

Pour être complet, il convient de mentionner que, souvent, le contenu que vous souhaitez envoyer la réponse web est généré par "quelque chose" qui prend en charge le "streaming" le résultat. Un exemple peut être une réponse JSON, qui est généré à partir d'une structure ou d'une carte.

Dans de tels cas, il est souvent plus efficace de passer la main au-dessus de votre http.ResponseWriter qui est un io.Writer à ce quelque chose si elle prend en charge l'écriture du résultat dans un io.Writer à la volée.

Un bon exemple de cela est de générer des réponses JSON. Bien sûr, vous pourriez ranger un objet en JSON avec json.Maréchal(), qui vous renvoie un octet tranche, qui vous pouvez tout simplement envoyer en appelant ResponseWriter.Write().

Cependant, il est plus efficace de laisser les json package de savoir que vous avez un io.Writer, et, finalement, vous voulez envoyer le résultat à qui. De cette façon, il est inutile de générer d'abord le texte JSON dans un tampon, que vous venez d'écrire dans votre réponse avant de le jeter. Vous pouvez créer un nouveau json.Codeur en appelant json.NewEncoder() à laquelle vous pouvez passer votre http.ResponseWriter comme un io.Writer, et en appelant Codeur.Encode() après qui va écrire directement le résultat JSON dans votre réponse écrivain.

Un inconvénient ici est que si la génération de la réponse JSON échoue, vous pourriez avoir un partiellement envoyé /commis de réponse, que vous ne prenez le dos. Si c'est un problème pour vous, vous n'avez pas vraiment d'autre choix que la génération de la réponse dans un tampon, et si marshaling de succès, alors vous pouvez écrire la réponse complète à la fois.