https://blog.csdn.net/tianshi418/article/details/105194869/

    1. func isGBK(data []byte) bool {
    2.         length := len(data)
    3.         var i int = 0
    4.         for i < length {
    5.             if data[i] <= 0x7f {
    6.                 //编码0~127,只有一个字节的编码，兼容ASCII码
    7.                 i++
    8.                 continue
    9.             } else {
    10.                 //大于127的使用双字节编码，落在gbk编码范围内的字符
    11.                 if  data[i] >= 0x81 &&
    12.                     data[i] <= 0xfe &&
    13.                     data[i + 1] >= 0x40 &&
    14.                     data[i + 1] <= 0xfe &&
    15.                     data[i + 1] != 0xf7 {
    16.                     i += 2
    17.                     continue
    18.                 } else {
    19.                     return false
    20.                 }
    21.             }
    22.         }
    23.         return true
    24.     }
    26. //UTF-8编码格式的判断
    28. func preNUm(data byte) int {
    29.     var mask byte = 0x80
    30.     var num int = 0
    31.     //8bit中首个0bit前有多少个1bits
    32.     for i:=0; i < 8; i++ {
    33.         if (data & mask) == mask {
    34.             num++
    35.             mask = mask >> 1
    36.         } else {
    37.             break
    38.         }
    39.     }
    40.     return num
    41. }
    42. func isUtf8(data []byte) bool {
    43.     i := 0
    44.     for i < len(data)  {
    45.         if (data[i] & 0x80) == 0x00 {
    46.             // 0XXX_XXXX
    47.             i++
    48.             continue
    49.         } else if num := preNUm(data[i]); num > 2 {
    50.             // 110X_XXXX 10XX_XXXX
    51.             // 1110_XXXX 10XX_XXXX 10XX_XXXX
    52.             // 1111_0XXX 10XX_XXXX 10XX_XXXX 10XX_XXXX
    53.             // 1111_10XX 10XX_XXXX 10XX_XXXX 10XX_XXXX 10XX_XXXX
    54.             // 1111_110X 10XX_XXXX 10XX_XXXX 10XX_XXXX 10XX_XXXX 10XX_XXXX
    55.             // preNUm() 返回首个字节的8个bits中首个0bit前面1bit的个数，该数量也是该字符所使用的字节数
    56.             i++
    57.             for j := 0; j < num - 1; j++ {
    58.                 //判断后面的 num - 1 个字节是不是都是10开头
    59.                 if (data[i] & 0xc0) != 0x80 {
    60.                     return false
    61.                 }
    62.                 i++
    63.             }
    64.         } else  {
    65.             //其他情况说明不是utf-8
    66.             return false
    67.         }
    68.     }
    69.     return true
    70. }
    72. import "golang.org/x/text/encoding/simplifiedchinese"
    73. simplifiedchinese.GBK.NewEncoder().Bytes()   //utf-8 转 gbk
    74. simplifiedchinese.GBK.NewDecoder().Bytes()  
    76. const (
    77.     GBK string  = "GBK"
    78.     UTF8 string = "UTF8"
    79.     UNKNOWN string = "UNKNOWN"
    80. )
    82. //需要说明的是，isGBK()是通过双字节是否落在gbk的编码范围内实现的，
    83. //而utf-8编码格式的每个字节都是落在gbk的编码范围内，
    84. //所以只有先调用isUtf8()先判断不是utf-8编码，再调用isGBK()才有意义
    85. func GetStrCoding(data []byte) string {
    86.     if isUtf8(data) == true {
    87.         return UTF8
    88.     } else if isGBK(data) == true {
    89.         return GBK
    90.     } else {
    91.         return UNKNOWN
    92.     }
    93. }
    95. func main() {
    96.     str := "月色真美，风也温柔，233333333，~！@#"  //go字符串编码为utf-8
    97.     fmt.Println("before convert:", str)   //打印转换前的字符串
    99.     fmt.Println("coding:", GetStrCoding([]byte(str)))   //判断是否是utf-8
    102.     gbkData, _ := simplifiedchinese.GBK.NewEncoder().Bytes([]byte(str))  //使用官方库将utf-8转换为gbk
    103.     fmt.Println("gbk直接打印会出现乱码:", string(gbkData))   //乱码字符串
    104.     fmt.Println("coding:", GetStrCoding(gbkData)) //判断是否是gbk
    106.     utf8Data, _ := simplifiedchinese.GBK.NewDecoder().Bytes(gbkData) //将gbk再转换为utf-8
    107.     fmt.Println("coding:", GetStrCoding(utf8Data))  //判断是否是utf-8
    108.     fmt.Println("after convert:", string(utf8Data))   //打印转换后的字符串
    109. }