golang常用文本处理总结

本文主要对一些常用文本处理方法汇总总结，后期持续更新。

一、JSON解析到结构体

在介绍这部分之前先简要介绍一下Json语法

JSON 语法是 JavaScript 语法的子集。JSON 语法是 JavaScript 对象表示法语法的子集。

数据在名称/值对中

数据由逗号分隔

大括号保存对象

中括号保存数组

1.JSON名称/值对

"name" : "value"

2.JSON值
可以是：

数字（整数或浮点数）

字符串（在双引号中）

逻辑值（true 或 false）

数组（在中括号中）

对象（在大括号中）

null

3. JSON数据
JSON 数字可以是整型或者浮点型

{ "age":30 }

4. JSON对象
JSON 对象在大括号（{}）中书写：
对象可以包含多个名称/值对：

{
    "name": "runoob",
    "alexa": 10000,
    "sites": {
        "site1": "www.runoob.com",
        "site2": "m.runoob.com",
        "site3": "c.runoob.com"
    }
}

5. JSON数组
JSON 数组在中括号中书写：

数组可包含多个对象：

{
    "sites": [
        {
            "name": "菜鸟教程",
            "url": "www.runoob.com"
        },
        {
            "name": "google",
            "url": "www.google.com"
        },
        {
            "name": "微博",
            "url": "www.weibo.com"
        }
    ]
}

6. JSON布尔值

{ "flag":true }

7. JSON null

{ "runoob":null }

Json解析到结构体

//JSON解析到结构体
package main
import (
	"encoding/json"
	"fmt"
	"os"
)
type Server struct {
	ServerName string
	ServerIP   string
}
type Serverslice struct {
	Servers []Server
}
func main() {
	var s Serverslice
	str := `{"servers":
   [{"serverName":"Guangzhou_Base","serverIP":"127.0.0.1"},
   {"serverName":"Beijing_Base","serverIP":"127.0.0.2"}]}`
	err:=json.Unmarshal([]byte(str), &s)
	if err!=nil{
		fmt.Println(err)
	}
	fmt.Println(s)
	fmt.Println(s.Servers[0].ServerName)
}

二、Json转map

package main


import (
    "fmt"
    "encoding/json"
)

func main() {

    b := []byte(`{"IP": "127.0.0.1", "name": "SKY"}`)

    m := make(map[string]string)

    err := json.Unmarshal(b, &m)
    if err != nil {

        fmt.Println("Umarshal failed:", err)
        return
    }


    fmt.Println("m:", m)

    for k,v :=range m {
        fmt.Println(k, ":", v)
    }
}

输出结果：

m: map[IP:127.0.0.1 name:SKY]
name : SKY
IP : 127.0.0.1

三、生成JSON

package main
import (
    "encoding/json"
    "fmt"
)
type Server struct {
    ServerName string `json:"serverName,string"`
    ServerIP   string `json:"serverIP,omitempty"`
}
type Serverslice struct {
    Servers []Server `json:"servers"`
}
func main() {
    var s Serverslice
    s.Servers = append(s.Servers, Server{ServerName: "Guangzhou_Base", ServerIP: "127.0.0.1"})
    s.Servers = append(s.Servers, Server{ServerName: "Beijing_Base", ServerIP: "127.0.02"})
    b, err := json.Marshal(s)
    if err != nil {
        fmt.Println("JSON ERR:", err)
    }
    fmt.Println(string(b))
}

四、写文件

//写文件
package main
import (
	"fmt"
	"os"
)
func main() {
	userFile := "test.txt"
	fout, err := os.Create(userFile)
	defer fout.Close()
	if err != nil {
		fmt.Println(userFile, err)
		return
	}
	for i := 0; i < 10; i++ {
		fout.WriteString("Just a test!\r\n")
		fout.Write([]byte("Just a test!\r\n"))
	}
}

五、读文件

//读文件
package main
import (
    "fmt"
    "os"
)
func main() {
    userFile := "text.txt"
    fl, err := os.Open(userFile)
    defer fl.Close()
    if err != nil {
        fmt.Println(userFile, err)
        return
    }
    buf := make([]byte, 1024)
    for {
        n, _ := fl.Read(buf)
        if 0 == n {
            break
        }
        os.Stdout.Write(buf[:n])
    }
}

六、按行读取文件

package main

import (
	"fmt"
	"os"
	"io"
	"bufio"
	"strings"
)

func main() {
	fileName := "test.txt"
	file, err := os.OpenFile(fileName, os.O_RDWR, 0666)
	if err != nil {
		fmt.Println("Open file error!", err)
		return
	}
	defer file.Close()

	stat, err := file.Stat()
	if err != nil {
		panic(err)
	}

	var size = stat.Size()
	fmt.Println("file size=", size)

	buf := bufio.NewReader(file)
	for {
		line, err := buf.ReadString('\n')
		line = strings.TrimSpace(line)
		fmt.Println(line)
		if err != nil {
			if err == io.EOF {
				fmt.Println("File read ok!")
				break
			} else {
				fmt.Println("Read file error!", err)
				return
			}
		}
	}
}

七、去掉字符串中多余空格

删除字符串中多余的空格(含tab)，有多个空格时，仅保留一个空格，同时将字符串中的tab换为空格


func DeleteExtraSpace(s string) string {
	//删除字符串中的多余空格，有多个空格时，仅保留一个空格
	s1 := strings.Replace(s, "	", " ", -1)      //替换tab为空格
	regstr := "\\s{2,}"                          //两个及两个以上空格的正则表达式
	reg, _ := regexp.Compile(regstr)             //编译正则表达式
	s2 := make([]byte, len(s1))                  //定义字符数组切片
	copy(s2, s1)                                 //将字符串复制到切片
	spc_index := reg.FindStringIndex(string(s2)) //在字符串中搜索
	for len(spc_index) > 0 {                     //找到适配项
		s2 = append(s2[:spc_index[0]+1], s2[spc_index[1]:]...) //删除多余空格
		spc_index = reg.FindStringIndex(string(s2))            //继续在字符串中搜索
	}
	return string(s2)
}

更多文本处理方法https://blog.csdn.net/wade3015/article/details/83715492

golang常用文本处理总结

猜你喜欢