GO文件創建及讀寫操作的方法

本文小編為大家詳細介紹“GO文件創建及讀寫操作的方法”，內容詳細，步驟清晰，細節處理妥當，希望這篇“GO文件創建及讀寫操作的方法”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學習新知識吧。

三種文件操作比較

ioutil
bufio
os.File

當文件較小(KB 級別)時，ioutil > bufio > os。
當文件大小比較常規(MB 級別)時，三者差別不大，但 bufio 又是已經顯現出來。
當文件較大(GB 級別)時，bufio > os > ioutil。

ioutil

ioutil.ReadFile讀

//讀
func Ioutil_read() {
	file, _ := ioutil.ReadFile("./write.txt")
	fmt.Println(string(file))
}

ioutil.WriteFile 寫

//寫
func Ioutil_write()  {
	ioutil.WriteFile("./write.txt",[]byte("aaaa\nbbb\ncccc\n啦啦啦啦"),0777)
}

ioutil.ReadAll 讀

// 比較浪費內存，解決方法，百度查詢
file,_ := os.Open("./write.txt")
b,_:=ioutil.ReadAll(file)
fmt.Println(string(b))

ioutil.ReadDir 查看路徑下目錄信息

func Ioutil_ReadDir()  {
	dir,_:=ioutil.ReadDir("./")
	for _,file := range dir{
		fmt.Println(file.Name())  //文件名字
		fmt.Println(file.Size())  //文件大小
		fmt.Println(file.IsDir())  //判斷是否為目錄
		fmt.Println(file.Mode())  //查看讀寫權限-rw-r--r--
		fmt.Println(file.ModTime())  //文件創建時間
	}
}

ioutil.TempDir 創建臨時目錄

// 創建臨時目錄，以jeff開頭，eg:jeff0123755
func Ioutil_Tempdir()  {
	path,_ := ioutil.TempDir("./","jeff")
	fmt.Println(path)  //返回臨時目錄路徑
}

ioutil.TempFile 創建臨時文件

// 創建臨時文件，以jeff開頭，eg:jeff067576
func Ioutil_file()  {
	//以讀寫模式打開該文件并返回os.File指針
	path,_:=ioutil.TempFile("./","jeff")
	fmt.Println(path) //返回os.File指針
}

os.file

方法

os.Create() //創建文件，如果有該文件則會清空文件
os.Open()  // 只讀方式打開文件
os.OpenFile(文件名，打開方式，打開權限)
Write() //寫入
Read()  //讀取

os.OpenFile(）

OpenFile( )這個函數有三個參數，第一個參數表示打開文件的路徑，第二個參數表示模式，常見的模式有

O_RDONLY(只讀模式)，O_WRONLY(只寫模式),O_RDWR(可讀可寫模式)，O_APPEND(追加模式)。

第三個參數，表示權限，取值范圍（0-7）
表示如下：

0：沒有任何權限
1：執行權限(如果是可執行文件，是可以運行的)
2：寫權限
3:寫權限與執行權限
4：讀權限
5:讀權限與執行權限
6:讀權限與寫權限
7:讀權限，寫權限，執行權限

fp,err := os.OpenFile("D:/a.txt",os.O_RDWR,6)
if err!=nil {
    fmt.Println("打開文件失敗")
}

fp.WriteString("hello")
fp.WriteAt([]byte("hello"),25)
defer fp.Close()

創建文件

將數據存儲到文件之前，先要創建文件。GO語言中提供了一個Create( )函數專門創建文件.

該函數在創建文件時，首先會判斷要創建的文件是否存在，如果不存在，則創建，如果存在，會先將文件中已有的數據清空。

同時，當文件創建成功后，該文件會默認的打開，所以不用在執行打開操作，可以直接向該文件中寫入數據。

創建文件的步驟：

(1)導入“os”包，創建文件，讀寫文件的函數都在該包

(2)指定創建的文件存放路徑以及文件名。

(3)執行Create( )函數，進行文件創建

(4)關閉文件

具體代碼：

package main

import (
    "fmt"
    "os"
)

func main() {
    //os.Create(文件名) 文件名  可以寫絕對路徑和相對路徑
    //返回值  文件指針 錯誤信息
    fp,err := os.Create("./a.txt")
    if err!=nil{
        //文件創建失敗
        /*
        1.路徑不存在
        2.文件權限
        3.程序打開文件上限
         */
        fmt.Println("文件創建失敗")
        return
    }

    //讀寫文件

    defer fp.Close()

    //關閉文件
    //如果打開文件不關閉 造成內存的浪費  程序打開文件的上限
    //fp.Close()
}

寫入數據三種方式

第一種-WriteString( )函數

WriteString( )方法默認返回兩個參數，第一個參數，指的是寫入文件的數據長度，第二個參數記錄的是錯誤信息
WriteString( )方法默認寫到文件中的數據是不換行的。如果想換行，可以采用如下的方式:

//\n不會換行  原因 在windows文本文件中換行\r\n  回車  在linux中換行\n
fp.WriteString("hello world\r\n")
fp.WriteString("性感荷官在線發牌")

文件打開以后，可以向文件中寫數據，可以使用WriteString( )方法。

//\反斜杠 轉義字符
//在寫路徑時可以使用/正斜杠代替\反斜杠
fp,err := os.Create("D:/a.txt")
if err!=nil{
    //文件創建失敗
    /*
    1.路徑不存在
    2.文件權限
    3.程序打開文件上限
     */
    fmt.Println("文件創建失敗")
    return
}

//寫文件

//\n不會換行  原因 在windows文本文件中換行\r\n  回車  在linux中換行\n
fp.WriteString("hello world\r\n")
fp.WriteString("性感荷官在線發牌")


defer fp.Close()

//關閉文件
//如果打開文件不關閉 造成內存的浪費  程序打開文件的上限
//fp.Close()

第二種-Write( )函數

在這里要注意的是，使用Write( )函數寫數據時，參數為字節切片，所以需要將字符串轉換成字節切片。該方法返回的也是寫入文件數據的長度

fp,err := os.Create("D:/a.txt")
if err!=nil{
    //文件創建失敗
    /*
    1.路徑不存在
    2.文件權限
    3.程序打開文件上限
     */
    fmt.Println("文件創建失敗")
    return
}

//寫操作
//slice := []byte{'h','e','l','l','o'}
//count,err1 := fp.Write(slice)
count,err1 := fp.Write([]byte("性感老王在線授課"))

if err1!=nil {
    fmt.Println("寫入文件失敗")
    return
}else {
    fmt.Println(count)
}

defer fp.Close()

第三種-WriteAt( )函數

在指定的位置寫入數據,以下程序中Seek( )函數返回值存儲到變量n中，值為文件末尾的位置。WriteAt( )也返回的是寫入的數據長度。

fp,err := os.Create("D:/a.txt")
if err!=nil{
    //文件創建失敗
    /*
    1.路徑不存在
    2.文件權限
    3.程序打開文件上限
     */
    fmt.Println("文件創建失敗")
    return
}

//寫操作
//獲取光標流位置'
//獲取文件起始到結尾有多少個字符
//count,_:=fp.Seek(0,os.SEEK_END)
count,_:=fp.Seek(0,io.SeekEnd)
fmt.Println(count)
//指定位置寫入
fp.WriteAt([]byte("hello world"),count)
fp.WriteAt([]byte("hahaha"),0)
fp.WriteAt([]byte("秀兒"),19)

defer fp.Close()

讀取文件

Read 讀取文件

如果文件已經存在，并且也已經有數據了，那么可以直接讀取該文件中的內容。

讀取文件的基本流程如下：

（1）打開要讀取的文件

（2）對文件進行讀取

（3）關閉文件

在向文件中寫數據的時候，使用的是Write,那么讀取文件中的數據，使用的是Read.

關于Read( )函數的使用如下：

package main

import (
    "fmt"
    "io"
    "os"
)
func main() {

    //打開文件
    fp, err := os.Open("D:/a.txt")
    if err != nil {
        fmt.Println("err=", err)
        return
    }

    buf := make([]byte, 1024*2) //2k大小
    //n代表從文件讀取內容的長度
    n, err1 := fp.Read(buf)
    if err1 != nil && err1 != io.EOF {
        fmt.Println("err1=", err1)
        return
    }
    fmt.Println("buf=", string(buf[:n]))

    //關閉文件
    defer fp.Close()

}

Open( )是打開文件，與OpenFile( )的區別是，Open( )只有讀的權限

在使用Read( )函數讀取文件中的內容時，需要一個切片類型，而定義切片時類型為字符數組，將文件中的內容保存在切片中，同時除了對其判斷是否出錯時以外，還要判斷是否到文件末尾(這里需要導入io包)。

Read( )函數返回的是從文件中讀取的數據的長度。最后，輸出切片中存儲的文件數據，注意，讀取的是從最開始到整個數據長度，因為有可能存儲到切片中的數據達不到切片的總長度（也是切片時2k,但是從文件中讀取的數據有可能只有1k）

按行讀取

上面我們是將文件的內容全部讀取出來，然后存放在切片中，我們也可以每次只讀取一行數據。

這需要用到bufio包中的ReadBytes函數。具體如下：

1：打開文件

fp, err := os.Open("D:/a.txt")
if err != nil {
    fmt.Println("打開文件失敗", err)
    return
}

2：創建緩沖區

在使用ReadBytes( )函數讀取數據時，需要用到緩沖區,所謂緩沖區就是存儲數據的區域，也就是先將從文件中讀取的數據存儲在該區域內，然后在將區域中的數據取出來，寫到磁盤上。提供緩沖區的原因是：

為了緩和 CPU 與磁盤設備之間速度不匹配矛盾。文件緩沖區是用以暫時存放讀寫期間的文件數據而在內存區預留的一定空間。

//創建文件緩沖區
r := bufio.NewReader(fp)

3：循環讀取文件中的內容，直到文件末尾位置。

for {
    //遇到'\n'結束讀取，但是'\n'也讀取進入
    buf,err := r.ReadBytes('\n')
    fmt.Println("buf = ",string(buf))
    if err != nil {
        if err == io.EOF {
            break
        }
        fmt.Println("err=",err)
    }
}

在使用ReadBytes( )函數時，傳遞的參數是‘\n’,表示遇到’\n’就結束，所以使用了死循環（每循環一次，讀取一行數據），只有到文件末尾了，才退出整個循環。最后，將讀取的數據打印出來，注意ReadBytes( )返回的是字節切片，所以在打印時要轉換成字符串。

4：最后關閉文件

//關閉文件
defer fp.Close()

現在我們已經完成了文件的創建，讀取，以及將數據保存到文件的操作，在對文件操作時，我們需要指定文件的路徑。

關于路徑，有兩種情況：

第一：相對路徑，所謂相對路徑指的是文件相對于應用程序的路徑。例如：上面我們一只使用的a.txt,這個文件，該文件存放的位置與可執行文件存儲的路徑是一樣的。

第二：絕對路徑：指的是通過給定的這個路徑直接能在我的電腦中找到這個文件。例如：D:\Info.txt,

• 建議我們以后在開發中使用相對路徑

文件操作案例

文件拷貝，將已有的文件復制一份，同時重新命名。

基本的思路：

(1)讓用戶輸入要拷貝的文件的名稱(源文件)以及目的文件的名稱

(2)創建目的文件

(3)打開源文件，并且讀取該文件中的內容

(4)將從源文件中讀取的內容寫到目的文件中。

var srcFileName string
var dstFileName string
fmt.Printf("請輸入源文件名稱:")
fmt.Scan(&srcFileName)
fmt.Println("請輸入目的文件名稱:")
fmt.Scan(&dstFileName)
if srcFileName == dstFileName {
    fmt.Println("源文件和目的文件名字不能相同")
    return
}
//只讀方式打開源文件
sF,err1 := os.Open(srcFileName)
if err1 != nil {
    fmt.Println("err1=",err1)
    return
}
//新建目的文件
dF,err2 := os.Create(dstFileName)
if err2 != nil{
    fmt.Println("err2=",err2)
    return
}
//操作完畢，需要關閉文件
defer sF.Close()
defer dF.Close()
//核心處理，從源文件讀取內容，往目的文件寫，讀多少寫多少
buf := make([]byte,4*1024)//4k大小臨時緩沖區
for{
    n,err := sF.Read(buf)//從源文件讀取內容,每次讀取一部分
    if err != nil{
        fmt.Println("err=",err)
        if err == io.EOF{//文件讀取完畢
            break
        }
    }
    //往目的文件寫，讀多少寫多少
    dF.Write(buf[:n])
}

讀到這里，這篇“GO文件創建及讀寫操作的方法”文章已經介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領會，如果想了解更多相關內容的文章，歡迎關注億速云行業資訊頻道。