Golang menulis fail bercelaru

Menulis data ke fail dalam golang ialah operasi asas, tetapi dalam sesetengah kes, anda akan menghadapi masalah aksara bercelaru selepas menulis fail. Beberapa aksara yang salah akan muncul dalam fail, yang bermaksud ia akan menyebabkan ralat semasa membaca fail. Oleh itu, artikel ini akan membincangkan masalah fail kacau yang ditulis oleh golang dan cara menyelesaikannya.

Sebab kod bercelaru

Sebab kod bercelaru ialah format pengekodan fail tidak sepadan dengan format pengekodan data yang ditulis oleh atur cara. Golang menggunakan format pengekodan UTF-8 secara lalai. Jika fail menggunakan format pengekodan yang berbeza, aksara bercelaru akan terhasil. Situasi khusus termasuk yang berikut:

Format pengekodan fail itu sendiri adalah salah

Apabila format pengekodan fail salah, golang akan menghasilkan aksara bercelaru semasa menulis fail. Contohnya, jika format pengekodan fail ialah GBK dan data bertulis menggunakan pengekodan UTF-8, anda akan mendapat aksara yang salah dalam fail.

Tetapan bahasa yang berbeza bagi sistem pengendalian

Perbezaan dalam tetapan bahasa sistem pengendalian juga boleh menyebabkan aksara bercelaru. Jika program golang berjalan pada sistem pengendalian yang menggunakan bahasa yang berbeza, fail bertulis mungkin mengandungi set aksara lalai sistem pengendalian dan output program golang akan dipengaruhi oleh pengekodan UTF-8.

Penyelesaian

Pilihan 1: Paksa penggunaan pengekodan UTF-8

Penyelesaian paling mudah ialah memaksa penggunaan pengekodan UTF-8 semasa menulis fail. Untuk tujuan ini, anda boleh menggunakan pakej "unicode/utf8" daripada pustaka standard Go.

Dalam pakej ini, gunakan fungsi BytesRune() untuk menukar rentetan utf8 kepada kepingan bait. Seterusnya, gunakan "os.File" untuk membuka fail dan gunakan fungsi Write() atau WriteString() untuk menulis kepingan bait ini pada fail. Kod sampel adalah seperti berikut:

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)
    }
}

Dalam kod di atas, fungsi ValidRune() digunakan untuk menentukan sama ada elemen dalam kepingan bait ialah aksara rune yang sah. Jika tidak, fungsi EncodeRune() akan digunakan untuk menukar aksara rune yang diberikan kepada aksara utf8 dan menyimpannya dalam bait yang diberikan.

Walau bagaimanapun, kaedah ini hanya boleh memaksa fail ditulis dalam format pengekodan UTF-8 Jika format pengekodan fail ialah GBK, kaedah ini tidak dapat menyelesaikan masalah.

Pilihan 2: Gunakan tulisan buffered daripada pakej "io"

Penyelesaian lain ialah menggunakan tulisan buffered daripada pakej "io". Kelebihan penimbal ialah ia boleh mengurangkan bilangan panggilan sistem dan meningkatkan prestasi semasa menulis fail, dan mengelakkan menulis aksara yang bercelaru.

Untuk menggunakan penulisan penimbal bagi pakej io, hanya buat penulis penimbal dan gunakan fungsi Write() atau WriteString() untuk menulis data ke penimbal. Apabila penimbal penuh, fungsi Flush() dipanggil secara automatik untuk menulis data dalam penimbal ke fail.

Berikut ialah kod sampel:

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)
    }
}

Dalam kod di atas, fungsi NewWriter() pakej bufio digunakan untuk mencipta penulis buffer. Kemudian gunakan fungsi WriteString() untuk menulis data ke penimbal. Akhir sekali, gunakan fungsi Flush() untuk menulis data daripada penimbal ke fail.

Dalam kes ini, penimbal akan dipadamkan secara automatik sebelum penimbal penuh untuk mengelak daripada menulis aksara bercelaru.

Ringkasan

Masalah fail bercelaru yang ditulis oleh golang disebabkan oleh ketidakpadanan antara format pengekodan fail dan format pengekodan program golang. Untuk menyelesaikan masalah ini, anda boleh memaksa penggunaan format pengekodan UTF-8, atau gunakan operasi tulis penimbal pakej io. Tidak kira kaedah yang digunakan, anda perlu memahami format pengekodan fail dan memprosesnya mengikut situasi sebenar.

Atas ialah kandungan terperinci Golang menulis fail bercelaru. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!