De io.Reader à chaîne dans Go

J'ai un io.ReadCloserobjet (d'un http.Responseobjet).

Quelle est la manière la plus efficace de convertir l'intégralité du flux en stringobjet?

ÉDITER:

Depuis la 1.10, strings.Builder existe. Exemple:

buf := new(strings.Builder)
n, err := io.Copy(buf, r)
// check errors
fmt.Println(buf.String())

INFORMATIONS DÉPASSÉES CI-DESSOUS

La réponse courte est que cela ne sera pas efficace car la conversion en chaîne nécessite de faire une copie complète du tableau d'octets. Voici la bonne façon (non efficace) de faire ce que vous voulez:

buf := new(bytes.Buffer)
buf.ReadFrom(yourReader)
s := buf.String() // Does a complete copy of the bytes in the buffer.

Cette copie est faite comme un mécanisme de protection. Les chaînes sont immuables. Si vous pouviez convertir un octet [] en chaîne, vous pourriez changer le contenu de la chaîne. Cependant, go vous permet de désactiver les mécanismes de sécurité de type à l'aide du package unsafe. Utilisez l'emballage dangereux à vos propres risques. Espérons que le nom à lui seul est un avertissement suffisant. Voici comment je le ferais en utilisant unsafe:

buf := new(bytes.Buffer)
buf.ReadFrom(yourReader)
b := buf.Bytes()
s := *(*string)(unsafe.Pointer(&b))

Voilà, vous avez maintenant converti efficacement votre tableau d'octets en chaîne. En réalité, tout cela ne fait que tromper le système de types en l'appelant une chaîne. Il y a quelques mises en garde à cette méthode:

1. Il n'y a aucune garantie que cela fonctionnera dans tous les compilateurs go. Bien que cela fonctionne avec le compilateur plan-9 gc, il repose sur des "détails d'implémentation" non mentionnés dans la spécification officielle. Vous ne pouvez même pas garantir que cela fonctionnera sur toutes les architectures ou ne sera pas modifié dans gc. En d'autres termes, c'est une mauvaise idée.
2. Cette chaîne est mutable! Si vous faites des appels sur ce tampon , il va changer la chaîne. Soyez très prudent.

Mon conseil est de s'en tenir à la méthode officielle. Faire une copie n'est pas si cher et cela ne vaut pas les maux de dangereux. Si la chaîne est trop volumineuse pour faire une copie, vous ne devez pas en faire une chaîne.

Les réponses jusqu'à présent n'ont pas abordé la partie "flux entier" de la question. Je pense que la bonne façon de faire est ioutil.ReadAll. Avec ton io.ReaderClosernom rc, j'écrirais,

if b, err := ioutil.ReadAll(rc); err == nil {
    return string(b)
} ...

data, _ := ioutil.ReadAll(response.Body)
fmt.Println(string(data))

Le moyen le plus efficace serait de toujours utiliser à la []byteplace de string.

Au cas où vous auriez besoin d'imprimer les données reçues de io.ReadCloser, le fmtpackage peut gérer []byte, mais ce n'est pas efficace car l' fmtimplémentation sera convertie en interne []byteen string. Afin d'éviter cette conversion, vous pouvez implémenter l' fmt.Formatterinterface pour un type comme type ByteSlice []byte.

func copyToString(r io.Reader) (res string, err error) {
    var sb strings.Builder
    if _, err = io.Copy(&sb, r); err == nil {
        res = sb.String()
    }
    return
}

var b bytes.Buffer
b.ReadFrom(r)

// b.String()

J'aime la structure bytes.Buffer . Je vois qu'il a des méthodes ReadFrom et String . Je l'ai utilisé avec un octet [] mais pas avec un io.Reader.