Go語言的內建包使您能夠在應用程式中執行各種檔案操作，從寫入、讀取和建立檔案到建立和刪除目錄。當執行檔案操作時遇到錯誤時，它還會提供有用的錯誤訊息。
在 Go 中讀取檔案
os包提供了一個ReadFile使 Go 中讀取檔案變得簡單的函式。例如，我的專案資料夾中有一個data.txt檔案，我可以使用以下程式碼讀取並列印它：
package main
import (
<font>"fmt"
"os"
)
func main() {
filepath := "data.txt"
data, err := os.ReadFile(filepath)
if err != nil {
fmt.Println("File reading error", err)
return
}
fmt.Println(string(data))
}
|
- 上面的程式碼定義了一個 filepath 變數，該變數的字串值是我要讀取的檔案 data.txt。
- 然後使用 ReadFile 函式讀取檔案，並將結果和錯誤儲存在 data 和 err 變數中。
- 最後，在使用字串輔助函式將結果以字串格式列印出來之前，它會檢查是否有錯誤。
用 Go 逐行讀取日誌檔案
在本節中，我們將探討在 Go 中讀取檔案的一個實際用例。假設您正在構建一個幫助使用者部署 Go 應用程式的應用程式。您需要為使用者提供一種檢視部署錯誤的方法，以便他們在嘗試重新部署應用程式之前瞭解需要解決哪些問題。
我們將編寫一段程式碼，逐行讀取日誌檔案，並只列印使用者要求的行數。這樣，使用者就可以選擇只檢視最後五條日誌，而不必翻閱所有日誌來查詢部署中的問題。
我有一個 log.txt 檔案示例，看起來是這樣的：
2023-07-11 10:00:00 - Successful: operation completed.
2023-07-11 10:05:12 - Error: Failed to connect to the database.
2023-07-11 10:10:32 - Successful: data retrieval from API.
2023-07-11 10:15:45 - Error: Invalid input received.
2023-07-11 10:20:58 - Successful: file upload.
2023-07-11 10:25:01 - Error: Authorization failed.
2023-07-11 10:30:22 - Successful: record update.
2023-07-11 10:35:37 - Error: Internal server error.
2023-07-11 12:45:59 - Error: Server overloaded.
2023-07-11 12:50:06 - Successful: session created.
2023-07-11 12:55:17 - Error: Invalid input parameters.
2023-07-11 13:00:30 - Successful: software update installed.
2023-07-11 13:05:46 - Error: Access denied.
2023-07-11 13:10:53 - Successful: report generated.
2023-07-11 13:16:01 - Error: Unexpected exception occurred.
2023-07-11 13:20:13 - Successful: user registration.
2023-07-11 13:25:28 - Error: Disk read/write failure.
|
程式碼如下：
package main
import (
<font>"bufio"
"fmt"
"os"
)
func printLastNLines(lines []string, num int) []string {
var printLastNLines []string
for i := len(lines) - num; i < len(lines); i++ {
printLastNLines = append(printLastNLines, lines[i])
}
return printLastNLines
}
func main() {
filepath := "log.txt"
file, err := os.Open(filepath)
if err != nil {
fmt.Println("Error opening file:", err)
}
defer file.Close()
var lines []string
scanner := bufio.NewScanner(file)
for scanner.Scan() {
lines = append(lines, scanner.Text())
}
if err := scanner.Err(); err != nil {
fmt.Println("Error reading file:", err)
}
// print the last 10 lines of the file<i>
printLastNLines := printLastNLines(lines, 3)
for _, line := range printLastNLines {
fmt.Println(line)
fmt.Println("________")
}
}
|
上面的程式碼：
- 使用 os 的包 Open 函式開啟檔案，
- 用 defer 關鍵字延遲關閉函式，
- 定義一個空的 lines slice，並使用 bufio 的 NewScanner 函式逐行讀取檔案，
- 同時使用 Text 函式將每一行以文字格式追加到 lines 陣列中。
- 最後，使用 printLastNLines 函式獲取行陣列的最後 N 行。N 是使用者選擇的任意數字，在本例中是 3，
- 程式碼使用 for 迴圈列印每一行，每一行之間用橫線隔開。
使用示例 log.txt 檔案，上述程式碼應返回以下內容：
2023-07-11 13:16:01 - Error: Unexpected exception occurred.
________
2023-07-11 13:20:13 - Successful: user registration.
________
2023-07-11 13:25:28 - Error: Disk read/write failure.
________
|
在 Go 中讀取 .json 檔案
讀取和使用 .json 檔案中的資料也是程式設計中的一種常用情況，讓我們來學習一下如何做到這一點。例如，你有一個如下所示的 .json 配置檔案：
{
<font>"database_host": "localhost",
"database_port": 5432,
"database_username": "myuser",
"database_password": "mypassword",
"server_port": 8080,
"server_debug": true,
"server_timeout": 30
}
|
您還需要透過讀取和解碼 .json 檔案來讀取資訊，以便應用程式正常執行：
package main
import (
<font>"encoding/json"
"fmt"
"os"
)
type Config struct {
DBHost string `json:"database_host"`
DBPort int `json:"database_port"`
DBUsername string `json:"database_username"`
DBPassword string `json:"database_password"`
ServerPort int `json:"server_port"`
ServerDebug bool `json:"server_debug"`
ServerTimeout int `json:"server_timeout"`
}
func main() {
filepath := "config.json"
var config Config
file, err := os.Open(filepath)
if err != nil {
fmt.Println(err)
}
defer file.Close()
decoder := json.NewDecoder(file)
err = decoder.Decode(&config)
if err != nil {
fmt.Println(err)
}
fmt.Println(config)
}
|
上面的程式碼使用 os 的包 Open 函式開啟檔案，用 defer 關鍵字延遲關閉函式，並使用 json 的 NewDecoder 函式讀取檔案。然後，它使用 Decoder 函式將檔案解碼為物件，並在終端列印配置詳細資訊之前檢查錯誤：
{localhost 5432 myuser mypassword 8080 true 30}
在 Go 中讀取 .csv 檔案
逗號分隔值（CSV）是最流行的檔案格式之一。讓我們在本節中探討如何讀取以下 .csv 檔案：
Name,Email,Phone,Address
John Doe,johndoe@example.com,555-1234,123 Main St
Jane Smith,janesmith@example.com,555-5678,456 Elm St
Bob Johnson,bobjohnson@example.com,555-9876,789 Oak St
|
程式碼：
package main
import (
<font>"encoding/csv"
"fmt"
"os"
)
func main() {
filepath := "data.csv"
file, err := os.Open(filepath)
if err != nil {
fmt.Println(err)
}
defer file.Close()
reader := csv.NewReader(file)
records, err := reader.ReadAll()
if err != nil {
fmt.Println(err)
}
fmt.Println(records)
}
|
上面的程式碼使用 os 的包 Open 函式開啟檔案，使用 defer 關鍵字延遲關閉函式，並建立一個閱讀器變數來儲存 NewReader 函式的結果。然後使用 ReadAll 函式讀取檔案、檢查錯誤並將結果列印到終端。輸出結果應該是這樣的
[[Name Email Phone Address] [John Doe johndoe@example.com 555-1234 123 Main St] [Jane Smith janesmith@example.com 555-5678 456 Elm St] [Bob Johnson bobjohnson@example.com 555-9876 789 Oak St]]
|
用 Go 從檔案中讀取位元組數
在某些情況下，您可能希望用 Go 從檔案中讀取特定數量的位元組：
package main
import (
<font>"fmt"
"os"
)
func main() {
filepath := "data.txt"
file, err := os.Open(filepath)
if err != nil {
fmt.Println(err)
}
defer file.Close()
data := make([]byte, 10)
_, err = file.Read(data)
if err != nil {
fmt.Println(err)
}
fmt.Println(data)
fmt.Println(string(data))
}
|
上面的程式碼使用 os 軟體包的 Open 函式開啟檔案，用 defer 關鍵字延遲關閉函式，並使用 make 函式建立一個值為 10 位元組的資料變數。然後在以位元組和字串格式列印資料前檢查是否有錯誤：
[49 46 32 102 109 116 10 50 46 32]
1. fmt
2.
|
用 Go 寫操作檔案
在 Go 中讀寫檔案相對簡單，因為它為開發人員提供了大量執行此類任務的函式，而無需下載第三方庫。在本節中，我們將探討不同的 Go 編寫任務以及如何正確處理它們。
在 Go 中建立檔案
Go 的 os 包提供了一個 Create 函式，可以建立任意副檔名的檔案。例如，假設您有一個幫助使用者部署應用程式的應用程式。在這種情況下，您可能希望在使用者建立新專案後立即建立一個包含應用程式日誌的 log.txt 空檔案：
package main
import (
<font>"fmt"
"log"
"os"
)
func main() {
file, err := os.Create("log.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
fmt.Print("File created successfully")
}
|
上面的程式碼使用作業系統的 Create 函式建立一個空的 log.txt 檔案，檢查是否有任何錯誤，然後向使用者列印一條成功資訊。
Go 中的檔案開啟標誌
Go 提供的檔案開啟標誌由 os 包中定義的常量表示。這些標誌決定了檔案操作的行為，例如開啟、建立和截斷檔案。下面列出了這些標誌及其作用。
- os.O_RDONLY：以只讀方式開啟檔案。檔案必須存在。
- os.O_WRONLY：以只寫方式開啟檔案。如果檔案存在，其內容將被截斷。如果檔案不存在，則建立一個新檔案。
- os.O_RDWR: 開啟檔案供讀寫。如果檔案存在，其內容將被截斷。如果不存在，則建立一個新檔案。
- os.O_APPEND：寫入時向檔案新增資料。寫入發生在檔案末尾。
- os.O_CREATE：如果檔案不存在，則建立一個新檔案。
- os.O_EXCL：與 O_CREATE 一起使用，確保只建立檔案，防止在檔案已存在的情況下建立檔案。
- os.O_SYNC：為同步 I/O 操作開啟檔案。寫操作在呼叫返回前完成。
- os.O_TRUNC：如果檔案存在並被成功開啟，其內容將被截斷為零長度。
- os.O_NONBLOCK: 以非阻塞模式開啟檔案。如果沒有可用資料或操作會阻塞，讀取或寫入等操作可能會立即返回錯誤。
這些標誌可以用位運算子 OR（|）組合起來。例如，os.O_WRONLY|os.O_CREATE 將開啟檔案供寫入，如果檔案不存在，則建立檔案。
使用這些標誌時，重要的是要檢查檔案操作返回的錯誤，以處理無法按預期開啟或建立檔案的情況。
讓我們在下一節看看如何向檔案寫入文字。
在 Go 中將文字寫入檔案
os 軟體包還提供了一個 WriteString 函式，可以幫助你將字串寫入檔案。例如，你想用一條日誌資訊更新 log.txt 檔案：
package main
import (
<font>"log"
"os"
)
func main() {
file, err := os.OpenFile("log.txt", os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
data := "2023-07-11 10:05:12 - Error: Failed to connect to the database. _________________"
_, err = file.WriteString(data)
if err != nil {
log.Fatal(err)
}
}
|
上面的程式碼使用 OpenFile 函式以只寫模式開啟 log.txt 檔案，如果該檔案不存在，則建立該檔案。然後建立一個包含字串的資料變數，並使用 WriteString 函式將字串資料寫入檔案。
在 Go 中追加檔案
上一節中的程式碼在每次執行程式碼寫入新資料之前都會刪除檔案中的資料，這在某些情況下是可以接受的。但是，對於日誌檔案，您希望它保留所有以前的日誌，這樣使用者就可以根據需要多次引用它們，例如執行分析。
package main
import (
<font>"log"
"os"
)
func main() {
file, err := os.OpenFile("log.txt", os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
data := "\n 2023-07-11 10:05:12 - Error: Failed to connect to the database.\n __________________ \n"
_, err = file.WriteString(data)
if err != nil {
log.Fatal(err)
}
}
|
上述程式碼使用 os.O_APPEND 以追加模式開啟檔案，並在向 log.txt 檔案新增新資料之前保留所有現有資料。每次執行程式碼時，你都會得到一個更新的檔案，而不是一個新檔案。
用 Go 將位元組寫入檔案
Go 允許使用 Write 函式將位元組以字串形式寫入檔案。例如，如果您從伺服器流式傳輸資料，而伺服器返回的是位元組，您可以將位元組寫入檔案以便讀取：
package main
import (
<font>"log"
"os"
)
func main() {
file, err := os.OpenFile("data.bin", os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
data := []byte{0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x20, 0x57, 0x6F, 0x72, 0x6C, 0x64, 0x21, 0x0A}
_, err = file.Write(data)
if err != nil {
log.Fatal(err)
}
}
|
上述程式碼以只寫和追加模式開啟 data.bin 檔案，並在該檔案不存在的情況下建立它。上面的程式碼應返回一個包含以下內容的 data.bin 檔案：Hello, World!
用 Go 將格式化資料寫入檔案
這是構建軟體應用程式時最常見的檔案編寫任務之一。例如，如果您正在建立一個電子商務網站，您需要為每個買家建立訂單確認收據，其中將包含使用者訂單的詳細資訊。下面介紹如何在 Go 中實現這一功能：
package main
import (
<font>"fmt"
"log"
"os"
)
func main() {
username, orderNumber := "Adams_adebayo", "ORD6543234"
file, err := os.Create(username + orderNumber + ".pdf")
if err != nil {
log.Fatal(err)
}
defer file.Close()
item1, item2, item3 := "shoe", "bag", "shirt"
price1, price2, price3 := 1000, 2000, 3000
_, err = fmt.Fprintf(file, "Username: %s\nOrder Number: %s\nItem 1: %s\nPrice 1: %d\nItem 2: %s\nPrice 2: %d\nItem 3: %s\nPrice 3: %d\n", username, orderNumber, item1, price1, item2, price2, item3, price3)
if err != nil {
log.Fatal(err)
}
}
|
上面的程式碼定義了兩個變數 username 和 orderNumber，根據變數建立了一個 .pdf，檢查是否有錯誤，並用 defer 關鍵字延遲 Close 函式。然後定義 item1、item2 和 item3 三個變數，用 fmt 的 Fprintf 格式化所有變數的資訊，並將其寫入 .pdf 檔案。
上述程式碼建立了一個 Adams_adebayoORD6543234.pdf 檔案，內容如下：
Username: Adams_adebayo
Order Number: ORD6543234
Item 1: shoe
Price 1: 1000
Item 2: bag
Price 2: 2000
Item 3: shirt
Price 3: 3000
|
用 Go 寫入 .csv 檔案
在編碼/csv 軟體包的幫助下，您可以用 Go 輕鬆地將資料寫入 .csv 檔案。例如，您想在新使用者註冊後將其個人資料資訊儲存到 .csv 檔案中：
package main
import (
<font>"encoding/csv"
"log"
"os"
)
func main() {
file, err := os.OpenFile("users.csv", os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
writer := csv.NewWriter(file)
defer writer.Flush()
data := []string{"Adams Adebayo", "30", "Lagos"}
err = writer.Write(data)
if err != nil {
log.Fatal(err)
}
}
|
上面的程式碼以只寫和追加模式開啟 users.csv 檔案，並在檔案不存在的情況下建立該檔案。然後，它將使用 NewWriter 函式建立一個寫入器變數，推遲執行 Flush 函式，使用字串片段建立一個資料變數，並使用 Write 函式將資料寫入檔案。
用 Go 將 JSON 資料寫入檔案
將 JSON 資料寫入 .json 檔案是軟體開發中的常見用例。例如，您正在構建一個小型應用程式，並希望使用一個簡單的 .json 檔案來儲存應用程式資料：
package main
import (
<font>"encoding/json"
"log"
"os"
)
func main() {
file, err := os.OpenFile("users.json", os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
data := map[string]interface{}{
"username": "jdon",
"twitter": "@jdon",
"email": "hello@jdon.com",
"website": "https://jdon,com/",
"location": "Lagos, Nigeria",
}
encoder := json.NewEncoder(file)
err = encoder.Encode(data)
if err != nil {
log.Fatal(err)
}
}
|
上面的程式碼以只寫和追加模式開啟 users.csv 檔案，並在檔案不存在的情況下建立該檔案，延遲關閉函式，並定義一個包含使用者資料的資料變數。然後使用 NewEncoder 函式建立一個編碼器變數，並使用 Encoder 函式對其進行編碼。
在 Go 中將 XML 資料寫入檔案
您還可以使用 encoding/xml 軟體包在 Go 中將 XML 資料寫入檔案：
package main
import (
<font>"encoding/xml"
"log"
"os"
)
func main() {
type Person struct {
Name string `xml:"name"`
Age int `xml:"age"`
City string `xml:"city"`
}
file, err := os.OpenFile("users.xml", os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
data := Person{
Name: "John Doe",
Age: 30,
City: "New York",
}
encoder := xml.NewEncoder(file)
err = encoder.Encode(data)
if err != nil {
log.Fatal(err)
}
}
|
上面的程式碼定義了一個包含三個欄位的 Person 結構，以只寫和追加模式開啟 users.xml 檔案，並在檔案不存在的情況下建立該檔案，延遲關閉函式，並定義了一個包含使用者資料的資料變數。然後使用 NewEncoder 函式建立一個編碼器變數，並使用 Encoder 函式對其進行編碼。<Person><name>John Doe</name><age>30</age><city>New York</city></Person>
|
在 Go 中重新命名檔案
Go 支援使用重新命名功能從程式碼中重新命名檔案：
package main
import (
<font>"fmt"
"os"
)
func main() {
err := os.Rename("users.xml", "data.xml")
if err != nil {
fmt.Println(err)
}
}
|
上面的程式碼將上一節建立的 users.xml 檔案重新命名為 data.xml。
在 Go 中刪除檔案
Go 支援使用 Remove 功能刪除檔案：
package main
import (
<font>"fmt"
"os"
)
func main() {
err := os.Remove("data.bin")
if err != nil {
fmt.Println(err)
}
fmt.Println("File deleted")
}
|
在 Go 中使用目錄
除了檔案之外，Go 還提供了可用於在應用程式中執行不同任務的函式。我們將在以下部分中探討其中一些任務。
建立目錄
Go 提供了一個Mkdir可以用來建立空目錄的函式：
package main
import (
<font>"fmt"
"os"
)
func main() {
err := os.Mkdir("users", 0755)
if err != nil {
fmt.Println(err)
}
fmt.Println("Directory Created Successfully")
}
|
上面的程式碼users在當前工作目錄中建立一個資料夾。
在 Go 中建立多個目錄
您可以使用以下MkdirAll函式在 Go 中建立多個目錄：
package main
import (
<font>"fmt"
"os"
)
func main() {
err := os.MkdirAll("data/json_data", 0755)
if err != nil {
fmt.Println(err)
}
fmt.Println("Directory Created Successfully")
}
|
上面的程式碼將建立一個data目錄以及json_data其中的一個目錄。
注意：如果data目錄已經存在，程式碼只會json_data在其中新增一個目錄。
檢查 Go 中是否存在目錄
為了避免錯誤，在建立檔案或目錄之前檢查目錄是否存在是一個很好的做法。您可以使用Stat函式和IsNotExist函式進行快速檢查：
package main
import (
<font>"fmt"
"os"
)
func main() {
if _, err := os.Stat("data/csv_data"); os.IsNotExist(err) {
fmt.Println("Directory does not exist")
} else {
fmt.Println("Directory exists")
}
}
|
上面的程式碼根據檢查結果返回一條訊息。就我而言，它將返回以下內容：
Directory exists
在 Go 中重新命名目錄
您還可以使用該Rename函式重新命名目錄：
package main
import (
<font>"fmt"
"os"
)
func main() {
err := os.Rename("data/csv_data", "data/xml_data")
if err != nil {
fmt.Println(err)
}
}
|
上面的程式碼將目錄重新命名data/csv_data為data/xml_data.
Go 中刪除空目錄
您可以使用該Remove功能刪除應用程式中的資料夾：
package main
import (
<font>"fmt"
"os"
)
func main() {
err := os.Remove("data/json_data")
if err != nil {
fmt.Println(err)
}
}
|
上面的程式碼json_data從data目錄中刪除該目錄。在 Go 中刪除目錄及其所有內容
Go 提供了一個RemoveAll功能，允許您刪除所有目錄及其內部的所有內容，包括檔案和資料夾：
package main
import (
<font>"fmt"
"os"
)
func main() {
err := os.RemoveAll("users")
if err != nil {
fmt.Println(err)
}
fmt.Println("users directory and all it's content has been removed")
}
|
上面的程式碼刪除了users目錄及其中的所有內容。
注意：在嘗試刪除該目錄之前，最好先檢查該目錄是否存在。
Go中獲取目錄中的檔案和目錄列表
您可以使用以下函式檢索目錄中所有檔案和目錄的列表ReadDir：
package main
import (
<font>"fmt"
"os"
)
func main() {
dirEntries, err := os.ReadDir("data")
if err != nil {
fmt.Println(err)
}
for _, entry := range dirEntries {
fmt.Println(entry.Name())
}
}
|
上面的程式碼返回資料夾內所有目錄和檔案的列表data。
現在您已經知道如何在 Go 應用程式中使用目錄，讓我們在下一節中探討一些高階檔案操作。
Go 中的高階檔案操作
在本節中，我們將探討您在 Go 應用程式中可能遇到的一些高階檔案操作。
在 Go 中將壓縮資料寫入檔案
使用壓縮檔案並不常見，但以下是如何.txt使用包在壓縮檔案中建立檔案的方法compress/gzip：
package main
import (
<font>"compress/gzip"
"fmt"
"log"
"os"
)
func main() {
file, err := os.OpenFile("data.txt.gz", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
log.Fatal(err)
}
defer file.Close()
gzipWriter := gzip.NewWriter(file)
defer gzipWriter.Close()
data := "Data to compress"
_, err = gzipWriter.Write([]byte(data))
if err != nil {
log.Fatal(err)
}
fmt.Println("File compressed successfully")
}
|
上面的程式碼建立了一個data.txt.gz，其中包含data.txt工作目錄中的一個檔案。
在 Go 中將加密資料寫入檔案
當構建需要安全檔案的應用程式時，您可以使用 Gocrypto/aes和crypto/cipher包建立加密檔案：
package main
import (
<font>"crypto/aes"
"crypto/cipher"
"fmt"
"log"
"os"
)
func main() {
// file, err := os.OpenFile("encrypted.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)<i>
file, err := os.Create("encrypted.txt")
if err != nil {
log.Fatal(err)
fmt.Println("Error")
}
defer file.Close()
key := []byte("cacf2ebb8cf3402964356547f20cced5")
plaintext := []byte("This is a secret! Don't tell anyone!")
block, err := aes.NewCipher(key)
if err != nil {
log.Fatal(err)
fmt.Println("Error")
}
ciphertext := make([]byte, len(plaintext))
stream := cipher.NewCTR(block, make([]byte, aes.BlockSize))
stream.XORKeyStream(ciphertext, plaintext)
_, err = file.Write(ciphertext)
if err != nil {
log.Fatal(err)
fmt.Println("Error")
}
fmt.Println("Encrypted file created successfully")
}
|
上面的程式碼建立一個encrypted.txt包含該字串的加密版本的檔案plaintext：
?Э_g?L_.?^_?,_?_;?S???{?Lؚ?W4r
W?8~?
|
將檔案複製到 Go 中的另一個目錄
將現有檔案複製到不同位置是我們經常做的事情。在 Go 中執行此操作的方法如下：
package main
import (
<font>"fmt"
"io"
"os"
)
func main() {
srcFile, err := os.Open("data/json.go")
if err != nil {
fmt.Println(err)
}
defer srcFile.Close()
destFile, err := os.Create("./json.go")
if err != nil {
fmt.Println(err)
}
defer destFile.Close()
_, err = io.Copy(destFile, srcFile)
if err != nil {
fmt.Println(err)
}
fmt.Println("Copy done!")
}
|
上面的程式碼複製目錄json.go中的檔案data及其內容，然後json.go在根目錄中建立另一個具有相同內容的檔案。
在 Go 中獲取檔案屬性
Go 允許您使用以下函式獲取檔案的屬性Stat：
package main
import (
<font>"fmt"
"os"
)
func main() {
fileInfo, err := os.Stat("config.json")
if err != nil {
fmt.Println(err)
}
fmt.Println("File name:", fileInfo.Name())
fmt.Println("Size in bytes:", fileInfo.Size())
fmt.Println("Permissions:", fileInfo.Mode())
fmt.Println("Last modified:", fileInfo.ModTime())
fmt.Println("File properties retrieved successfully")
}
|
上面的程式碼返回檔案的名稱、大小、許可權和上次修改日期config.json：
File name: config.json
Size in bytes: 237
Permissions: -rw-r--r--
Last modified: 2023-07-11 22:46:59.705875417 +0100 WAT
File properties retrieved successfully
|
獲取Go中當前工作目錄路徑
您可以在 Go 中獲取應用程式的當前工作目錄：
package main
import (
<font>"fmt"
"os"
)
func main() {
wd, err := os.Getwd()
if err != nil {
fmt.Println(err)
}
fmt.Println("Current working directory:", wd)
}
|
上面的程式碼將返回我當前工作目錄的完整路徑：
Current working directory: /Users/user12/Documents/gos/go-files