LOGO

Golang 入门-3.文件处理

Golang
技术
发布日期:   2021-10-18
文章字数:   1.2k
阅读时长:   6 分
阅读次数:  

文件处理

Json

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

type Website struct {
    Name   string `xml:"name,attr"`
    Url    string
    Course []string
}

func write() {
    info := []Website{{"Golang", "http://www.ibug.info/golang/", []string{"http://www.ibug.info/cplus/", "http://www.ibug.info/linux_tutorial/"}}, {"Java", "http://www.ibug.info/java/", []string{"http://www.ibug.info/socket/", "http://www.ibug.info/python/"}}}

    // 创建文件
    filePtr, err := os.Create("info.json")
    if err != nil {
        fmt.Println("文件创建失败", err.Error())
        return
    }
    defer filePtr.Close()

    // 创建Json编码器
    encoder := json.NewEncoder(filePtr)

    err = encoder.Encode(info)
    if err != nil {
        fmt.Println("编码错误", err.Error())

    } else {
        fmt.Println("编码成功")
    }
}

func read() {
	filePtr, err := os.Open("./info.json")
	if err != nil {
		fmt.Println("文件打开失败 [Err:%s]", err.Error())
		return
	}
	defer filePtr.Close()
	var info []Website
	// 创建json解码器
	decoder := json.NewDecoder(filePtr)
	err = decoder.Decode(&info)
	if err != nil {
		fmt.Println("解码失败", err.Error())
	} else {
		fmt.Println("解码成功")
		fmt.Println(info)
	}
}

Xml

package main
import (
    "encoding/xml"
    "fmt"
    "os"
)
type Website struct {
    Name   string `xml:"name,attr"`
    Url    string
    Course []string
}
func write() {
    //实例化对象
    info := Website{"Golang", "http://www.ibug.info/golang/", []string{"Go语言入门教程", "Golang入门教程"}}
    f, err := os.Create("./info.xml")
    if err != nil {
        fmt.Println("文件创建失败", err.Error())
        return
    }
    defer f.Close()
    //序列化到文件中
    encoder := xml.NewEncoder(f)
    err = encoder.Encode(info)
    if err != nil {
        fmt.Println("编码错误：", err.Error())
        return
    } else {
        fmt.Println("编码成功")
    }
}

func read() {
	//打开xml文件
	file, err := os.Open("./info.xml")
	if err != nil {
		fmt.Printf("文件打开失败：%v", err)
		return
	}
	defer file.Close()
	info := Website{}
	//创建 xml 解码器
	decoder := xml.NewDecoder(file)
	err = decoder.Decode(&info)
	if err != nil {
		fmt.Printf("解码失败：%v", err)
		return
	} else {
		fmt.Println("解码成功")
		fmt.Println(info)
	}
}

Gob

package main
import (
    "encoding/gob"
    "fmt"
    "os"
)
func write() {
    info := map[string]string{
        "name":    "Golang",
        "website": "http://www.ibug.info/golang/",
    }
    name := "demo.gob"
    File, _ := os.OpenFile(name, os.O_RDWR|os.O_CREATE, 0777)
    defer File.Close()
    enc := gob.NewEncoder(File)
    if err := enc.Encode(info); err != nil {
        fmt.Println(err)
    }
}
func read() {
	var M map[string]string
	File, _ := os.Open("demo.gob")
	D := gob.NewDecoder(File)
	D.Decode(&M)
	fmt.Println(M)
}

Txt

package main
import (
    "bufio"
    "fmt"
    "os"
)
func write() {
    //创建一个新文件，写入内容
    filePath := "./output.txt"
    file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Printf("打开文件错误= %v \n", err)
        return
    }
    //及时关闭
    defer file.Close()
    //写入内容
    str := "http://www.ibug.info/golang/\n" // \n\r表示换行  txt文件要看到换行效果要用 \r\n
    //写入时，使用带缓存的 *Writer
    writer := bufio.NewWriter(file)
    for i := 0; i < 3; i++ {
        writer.WriteString(str)
    }
    //因为 writer 是带缓存的，因此在调用 WriterString 方法时，内容是先写入缓存的
    //所以要调用 flush方法，将缓存的数据真正写入到文件中。
    writer.Flush()
}

func read() {
	//打开文件
	file, err := os.Open("./output.txt")
	if err != nil {
		fmt.Println("文件打开失败 = ", err)
	}
	//及时关闭 file 句柄，否则会有内存泄漏
	defer file.Close()
	//创建一个 *Reader ， 是带缓冲的
	reader := bufio.NewReader(file)
	for {
		str, err := reader.ReadString('\n') //读到一个换行就结束
		if err == io.EOF {                  //io.EOF 表示文件的末尾
			break
		}
		fmt.Print(str)
	}
	fmt.Println("文件读取结束...")
}

Bin

package main
import (
    "encoding/gob"
    "fmt"
    "os"
)
func write() {
    info := "http://www.ibug.info/golang/"
    file, err := os.Create("./output.gob")
    if err != nil {
        fmt.Println("文件创建失败", err.Error())
        return
    }
    defer file.Close()
    encoder := gob.NewEncoder(file)
    err = encoder.Encode(info)
    if err != nil {
        fmt.Println("编码错误", err.Error())
        return
    } else {
        fmt.Println("编码成功")
    }
}

func read() {
	file, err := os.Open("./output.gob")
	if err != nil {
		fmt.Println("文件打开失败", err.Error())
		return
	}
	defer file.Close()
	decoder := gob.NewDecoder(file)
	info := ""
	err = decoder.Decode(&info)
	if err != nil {
		fmt.Println("解码失败", err.Error())
	} else {
		fmt.Println("解码成功")
		fmt.Println(info)
	}
}

Zip

package main
import (
    "archive/zip"
    "bytes"
    "fmt"
    "os"
)
func write() {
    // 创建一个缓冲区用来保存压缩文件内容
    buf := new(bytes.Buffer)
    // 创建一个压缩文档
    w := zip.NewWriter(buf)
    // 将文件加入压缩文档
    var files = []struct {
        Name, Body string
    }{
        {"Golang.txt", "http://www.ibug.info/golang/"},
    }
    for _, file := range files {
        f, err := w.Create(file.Name)
        if err != nil {
            fmt.Println(err)
        }
        _, err = f.Write([]byte(file.Body))
        if err != nil {
            fmt.Println(err)
        }
    }
    // 关闭压缩文档
    err := w.Close()
    if err != nil {
        fmt.Println(err)
    }
    // 将压缩文档内容写入文件
    f, err := os.OpenFile("file.zip", os.O_CREATE|os.O_WRONLY, 0666)
    if err != nil {
        fmt.Println(err)
    }
    buf.WriteTo(f)
}
func read() {
	// 打开一个zip格式文件
	r, err := zip.OpenReader("file.zip")
	if err != nil {
		fmt.Printf(err.Error())
	}
	defer r.Close()
	// 迭代压缩文件中的文件，打印出文件中的内容
	for _, f := range r.File {
		fmt.Printf("文件名: %s\n", f.Name)
		rc, err := f.Open()
		if err != nil {
			fmt.Printf(err.Error())
		}
		_, err = io.CopyN(os.Stdout, rc, int64(f.UncompressedSize64))
		if err != nil {
			fmt.Printf(err.Error())
		}
		rc.Close()
	}
}

File Lock

package main

import (
    "fmt"
    "os"
    "sync"
    "syscall"
    "time"
)

//文件锁
type FileLock struct {
    dir string
    f   *os.File
}

func New(dir string) *FileLock {
    return &FileLock{
        dir: dir,
    }
}

//加锁
func (l *FileLock) Lock() error {
    f, err := os.Open(l.dir)
    if err != nil {
        return err
    }
    l.f = f
    err = syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
    if err != nil {
        return fmt.Errorf("cannot flock directory %s - %s", l.dir, err)
    }
    return nil
}

//释放锁
func (l *FileLock) Unlock() error {
    defer l.f.Close()
    return syscall.Flock(int(l.f.Fd()), syscall.LOCK_UN)
}

func main() {
    test_file_path, _ := os.Getwd()
    locked_file := test_file_path

    wg := sync.WaitGroup{}

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(num int) {
            flock := New(locked_file)
            err := flock.Lock()
            if err != nil {
                wg.Done()
                fmt.Println(err.Error())
                return
            }
            fmt.Printf("output : %d\n", num)
            wg.Done()
        }(i)
    }
    wg.Wait()
    time.Sleep(2 * time.Second)

}
文章作者: 鲁君树人
文章链接: https://www.ibug.info/p/18d45deb1a2749fdbdd672767346cfa9.html
版权声明: 本篇文章采用 CC BY 4.0 版权协议『必须署名，可共享，可演绎』，转载请注明来源 幺蛾日记 !
Golang
赏
评论
 上一篇
竞品分析怎么做? 竞品分析怎么做?
老板让你做个竞品分析报告，没做过怎么办? 这篇文章教你快速上手。
2021-10-25 商业
竞品分析 产品经理
下一篇 
Golang 入门-0.特性 Golang 入门-0.特性
强类型静态编译型语言。 更丰富的内置类型 函数多返回值 在C中如果想返回多个值，通常会在调用函数中分配返回值的空间，并将返回值的指针传给被调函数。Go的做法是在传入的参数之上留了两个空位，被调者直接将返回值放在这两空位。Go是使用栈空间
2021-10-18 技术
Golang
  目录