Golang écrit des fichiers tronqués

L'écriture de données dans un fichier en golang est une opération de base, mais dans certains cas, vous rencontrerez le problème des caractères tronqués après l'écriture du fichier. Certains caractères erronés apparaîtront dans le fichier, ce qui signifie que cela provoquera des erreurs lors de la lecture du fichier. Par conséquent, cet article abordera le problème des fichiers tronqués écrits par Golang et comment le résoudre.

La raison des caractères tronqués

La raison des caractères tronqués est que le format d'encodage du fichier ne correspond pas au format d'encodage des données écrites par le programme. Golang utilise le format d'encodage UTF-8 par défaut. Si les fichiers utilisent des formats de codage différents, des caractères tronqués en résulteront. Les situations spécifiques incluent les suivantes :

Le format d'encodage du fichier lui-même est incorrect

Lorsque le format d'encodage du fichier est incorrect, Golang produira des caractères tronqués lors de l'écriture du fichier. Par exemple, si le format de codage du fichier est GBK et que les données écrites utilisent le codage UTF-8, vous obtiendrez des caractères erronés dans le fichier.

Différents paramètres de langue du système d'exploitation

Les différences dans les paramètres de langue du système d'exploitation peuvent également entraîner des caractères tronqués. Si le programme golang s'exécute sur un système d'exploitation qui utilise une langue différente, le fichier écrit peut contenir le jeu de caractères par défaut du système d'exploitation et la sortie du programme golang sera affectée par le codage UTF-8.

Solution

Option 1 : Forcer l'utilisation du format d'encodage UTF-8

La solution la plus simple est de forcer l'utilisation du format d'encodage UTF-8 lors de l'écriture de fichiers. Pour cela, vous pouvez utiliser le package "unicode/utf8" de la bibliothèque standard Go.

Dans ce package, utilisez la fonction BytesRune() pour convertir les chaînes utf8 en tranches d'octets. Ensuite, utilisez "os.File" pour ouvrir le fichier et utilisez la fonction Write() ou WriteString() pour écrire cette tranche d'octets dans le fichier. L'exemple de code est le suivant :

import (
    "os"
    "unicode/utf8"
)

func main() {
    file, err := os.Create("test.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    str := "hello world"
    byteArr := []byte(str)

    // 将str强制转换为utf8编码的byte数组
    utf8Byte := make([]byte, len(byteArr))
    count := 0
    for len(byteArr) > 0 {
        size := 0
        c := make([]byte, 4)
        if utf8.ValidRune(rune(byteArr[0])) {
            size = 1
            c[0] = byteArr[0]
        } else {
            size = utf8.EncodeRune(rune(c[0]), rune(byteArr[0]))
        }
        utf8Byte[count] = c[0]
        count++
        byteArr = byteArr[size:]
    }

    // 将utf8编码的byte数组写入文件
    _, err = file.Write(utf8Byte)
    if err != nil {
        panic(err)
    }
}

Dans le code ci-dessus, la fonction ValidRune() est utilisée pour déterminer si l'élément dans la tranche d'octets est un caractère runique légal. Si ce n'est pas le cas, le caractère runique donné sera converti en caractère utf8 à l'aide de la fonction EncodeRune() et stocké dans les octets donnés.

Cependant, cette méthode ne peut forcer que le fichier à être écrit au format d'encodage UTF-8. Si le format d'encodage du fichier est GBK, cette méthode ne peut pas résoudre le problème.

Option 2 : écritures tamponnées à l'aide du package « io »

Une autre solution consiste à utiliser les écritures tamponnées à partir du package « io ». L'avantage du tampon est qu'il peut réduire le nombre d'appels système, améliorer les performances lors de l'écriture de fichiers et éviter d'écrire des caractères tronqués.

Pour utiliser l'écriture tamponnée à partir du package io, créez simplement un écrivain tamponné et utilisez la fonction Write() ou WriteString() pour écrire des données dans le tampon. Lorsque le tampon est plein, la fonction Flush() est automatiquement appelée pour écrire les données du tampon dans le fichier.

Voici un exemple de code :

import (
    "bufio"
    "os"
)

func main() {
    file, err := os.Create("test.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    writer := bufio.NewWriter(file)
    str := "hello world"
    _, err = writer.WriteString(str)
    if err != nil {
        panic(err)
    }
    err = writer.Flush()
    if err != nil {
        panic(err)
    }
}

Dans le code ci-dessus, la fonction NewWriter() du package bufio est utilisée pour créer un écrivain mis en mémoire tampon. Utilisez ensuite la fonction WriteString() pour écrire les données dans le tampon. Enfin, utilisez la fonction Flush() pour écrire les données du tampon dans le fichier.

Dans ce cas, le tampon sera automatiquement vidé avant qu'il ne soit plein pour éviter d'écrire des caractères tronqués.

Résumé

Le problème des fichiers tronqués écrits par Golang est dû à la non-concordance entre le format d'encodage du fichier et le format d'encodage du programme Golang. Pour résoudre ce problème, vous pouvez forcer l'utilisation du format de codage UTF-8 ou utiliser l'opération d'écriture tamponnée du package io. Quelle que soit la méthode utilisée, vous devez comprendre le format d'encodage du fichier et le traiter en fonction de la situation réelle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!