Wie lese ich Dateien in der Go-Sprache? Eine kurze Analyse verschiedener Methoden

In diesem Artikel wird erläutert, wie Dateien in Golang gelesen werden. Wir werden die folgenden Pakete verwenden, um diese Dateien zu verarbeiten.

• os Das Paket bietet eine plattformunabhängige Schnittstelle zur Durchführung von Vorgängen auf Betriebsebene.
• IOutil Das Paket bietet benutzerfreundliche Hilfsfunktionen zum Verarbeiten von Dateien, ohne viel über die interne Implementierung zu wissen.
• bufio Das Paket implementiert gepufferte E/A, was uns hilft, die Leistung und den Durchsatz von Eingabe- und Ausgabevorgängen zu verbessern.
• log Paket implementiert ein einfaches Protokollierungspaket. Wir werden dies im gesamten Programm verwenden. Wir werden die Funktion Fatal() des Protokollierungspakets in unserem Programm verwenden. Fatal() 函数。

整个文件读取

我们可以很容易地一次性读取整个文件并将其存储在一个变量中。但请记住，我们不应该对大文件这样做。我们将使用ioutil.ReadFile() 函数来读取文件并将文件的内容存储在一个变量中。

首先，让我们在我们程序所在的同一目录下存储一个文件。因此，我们的文件夹结构将是下面这样的。

___ 
| 
|_ _ _ _ ilovego.txt | 
|_ _ _ _ main.go

我们在 main.go 函数中写入如下的内容：

package main

import (
	"fmt"
	"io/ioutil"
	"log"
)

func main() {

	content, err := ioutil.ReadFile("ilovego.txt")

	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(string(content))
}

但首先，让我们讨论一下 ReadFile() 函数的情况：

• 定义：方法声明 func ReadFile(filename string) ([]byte, error)
• 功能：读取路径被传入函数参数的文件，并返回文件的内容。在内部使用 os.ReadFile(fileName) 方法
• 返回：在一个字节数组中返回文件的内容和错误。一个成功的调用将返回 err == nil

内部 ReadFile 函数实现如下:

func ReadFile(filename string) ([]byte, error) {
    return os.ReadFile(filename)
}

现在，让我们回到我们的程序:

• ioutil.ReadFile("readthisfile.txt") 返回一个 byteArray 和一个 err。我们将byteArray 存储在 "content "变量中，错误存储在 " err "变量中。
• 然后我们放置了一个 if 条件，如果 err 值不为 nil，我们将使用 log.Fatal() 函数打印错误 err 。记住，Fatal() 函数等同于 Print() 函数，然后调用 os.Exit(1) 。
• 最后，我们将使用 fmt.Println() 函数打印文件的内容。 我们不能简单地打印 content 变量，因为它是一个字节数组，我们需要将它转换为字符串: string(content)

然后新建一个 ilovego.txt 文件，写入如下内容：

I Love Golang,
This is One of the Best Languages on the World!

最后，执行上述代码，可以看到如下输出：

$ go run main.go
I Love Golang, 
This is One of the Best Languages on the World!

按行读取

Scanner 扫描器提供了一个方便的接口来读取数据，比如一个由新行分隔的文本行组成的文件。它通过标记来读取数据；Split 函数定义了标记。默认情况下，该函数将数据分成几行，并剥离了行端。

package main

import (
	"fmt"
	// "io/ioutil"
	"bufio"
	"log"
	"os"
)

func main() {

	// opening the file using Open function
	f, err := os.Open("ilovego.txt")

	if err != nil {
		log.Fatal(err)
	}

	defer f.Close()

	// create a scanner for the file
	scanner := bufio.NewScanner(f)

	// loop through the scanner until it return fasle
	for scanner.Scan() {

		fmt.Println(scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		log.Fatal(err)
	}
}

• os.Open() 打开参数中传递的文件。如果在打开文件时遇到任何错误，它将返回同样的错误。否则，错误将是 nil。
• 然后，我们使用扫描器来读取文件，并逐行扫描，直到文件内容结束。
• 最后，我们要关闭该文件。

执行程序，结果如下：

逐个单词读取

我们还可以通过逐个单词来读取文件：

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {

	f, err := os.Open("ilovego.txt")

	if err != nil {
		fmt.Println(err)
	}

	defer f.Close()

	scanner := bufio.NewScanner(f)
	scanner.Split(bufio.ScanWords)

	for scanner.Scan() {

		fmt.Println(scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		fmt.Println(err)
	}
}

运行代码：

$ go run main.go
I
Love
Golang,
This
is
One
of
the
Best
Languages
on
the
World!

以数据块的形式读取文件

一次性读取整个文件似乎是一种简单的方法，但有时我们需要从内存管理的角度使我们的程序得到一些优化。Golang 提供了一种分块读取文件的方法，而不是整个或甚至逐行读取。因为如果一行的大小太大，逐行读取也可能是低效的。

package main

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

func main() {

	f, err := os.Open("ilovego.txt")

	if err != nil {
		log.Fatal(err)
	}

	defer f.Close()

	reader := bufio.NewReader(f)
	buf := make([]byte, 16)

	for {
                // reading a file upto buffer
		n, err := reader.Read(buf)

		if err != nil {

			if err != io.EOF {

				log.Fatal(err)
			}

			break
		}

		fmt.Print(string(buf[0:n]))
	}

	fmt.Println()
}

二进制读取

hex

Lesen der gesamten Datei

Wir können die gesamte Datei problemlos auf einmal lesen und in einer Variablen speichern. Aber denken Sie daran, dass wir dies nicht bei großen Dateien tun sollten. Wir werden die Funktion ioutil.ReadFile() verwenden, um eine Datei zu lesen und den Inhalt der Datei in einer Variablen zu speichern. #🎜🎜##🎜🎜#Lassen Sie uns zunächst eine Datei im selben Verzeichnis wie unser Programm speichern. Daher wird unsere Ordnerstruktur so aussehen. #🎜🎜#

package main

import (
	"bufio"
	"encoding/hex"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {

	f, err := os.Open("sid.jpg")

	if err != nil {
		log.Fatal(err)
	}

	defer f.Close()

	reader := bufio.NewReader(f)
	buf := make([]byte, 256)

	for {
		_, err := reader.Read(buf)

		if err != nil {
			if err != io.EOF {
				fmt.Println(err)
			}
			break
		}

		fmt.Printf("%s", hex.Dump(buf))
	}
}

#🎜🎜#Wir schreiben den folgenden Inhalt in die Funktion main.go: #🎜🎜#rrreee#🎜🎜#Aber zuerst besprechen wir ReadFile( ) Code> Funktionssituation: #🎜🎜##🎜🎜##🎜🎜#Definition: Methodendeklaration func <code>ReadFile(filename string) ([]byte, error)#🎜🎜## 🎜🎜#Funktion : Liest die Datei, deren Pfad an den Funktionsparameter übergeben wird, und gibt den Inhalt der Datei zurück. Intern verwendete os.ReadFile(fileName)-Methode #🎜🎜##🎜🎜#Returns: Gibt den Inhalt der Datei und Fehler in einem Byte-Array zurück. Ein erfolgreicher Aufruf gibt err == nil#🎜🎜##🎜🎜#Die interne ReadFile-Funktion wird wie folgt implementiert: #🎜🎜#rrreee#🎜🎜#Kehren wir nun zu unserem Programm zurück: #🎜 🎜 ##🎜🎜##🎜🎜#ioutil.ReadFile("readthisfile.txt") Gibt ein ByteArray und einen Fehler zurück. Wir speichern das ByteArray in der Variablen „content“ und den Fehler in der Variablen „err“. #🎜🎜##🎜🎜#Dann platzieren wir eine if-Bedingung. Wenn der Fehlerwert nicht Null ist, verwenden wir die Funktion log.Fatal(), um den Fehlerfehler auszugeben. Denken Sie daran, dass die Funktion Fatal() der Funktion Print() entspricht, die dann os.Exit(1) aufruft. #🎜🎜##🎜🎜#Abschließend verwenden wir die Funktion fmt.Println(), um den Inhalt der Datei zu drucken. Wir können die Variable content nicht einfach drucken, da es sich um ein Byte-Array handelt und wir sie in einen String konvertieren müssen: string(content)#🎜🎜## 🎜🎜#Erstellen Sie dann eine neue ilovego.txt-Datei und schreiben Sie den folgenden Inhalt: #🎜🎜#rrreee#🎜🎜#Führen Sie abschließend den obigen Code aus und Sie können die folgende Ausgabe sehen: #🎜🎜 # rrreee

Zeilenweise lesen

#🎜🎜#Scanner Der Scanner bietet eine praktische Schnittstelle zum Lesen von Daten, beispielsweise einer Datei, die aus durch Zeilenumbrüche getrennten Textzeilen besteht. Es liest Daten über Marker; die Funktion Split definiert Marker. Standardmäßig unterteilt diese Funktion die Daten in Zeilen und entfernt die Zeilenenden. #🎜🎜#rrreee#🎜🎜##🎜🎜#os.Open() Öffnet die im Parameter übergebene Datei. Wenn beim Öffnen der Datei ein Fehler auftritt, wird derselbe Fehler zurückgegeben. Andernfalls ist der Fehler gleich Null. #🎜🎜##🎜🎜# Anschließend lesen wir die Datei mit einem Scanner und scannen sie Zeile für Zeile bis zum Ende des Dateiinhalts. #🎜🎜##🎜🎜#Zuletzt wollen wir die Datei schließen. #🎜🎜##🎜🎜#Führen Sie das Programm aus und die Ergebnisse sind wie folgt: #🎜🎜##🎜🎜##🎜🎜#

Wort für Wort lesen

#🎜🎜 #Wir können die Datei immer noch Wort für Wort lesen: #🎜🎜#rrreee#🎜🎜#Führen Sie den Code aus: #🎜🎜#rrreee

Lesen Sie die Datei in Abschnitten

#🎜 🎜 #Die gesamte Datei auf einmal zu lesen scheint eine einfache Methode zu sein, aber manchmal müssen wir unser Programm im Hinblick auf die Speicherverwaltung optimieren. Golang bietet eine Möglichkeit, eine Datei in Blöcken zu lesen, anstatt sie als Ganzes oder sogar Zeile für Zeile zu lesen. Denn wenn die Größe einer Zeile zu groß ist, kann das zeilenweise Lesen auch ineffizient sein. #🎜🎜#rrreee

Binäres Lesen

#🎜🎜#hex-Paket implementiert hexadezimale Kodierung und Dekodierung. #🎜🎜#

package main

import (
	"bufio"
	"encoding/hex"
	"fmt"
	"io"
	"log"
	"os"
)

func main() {

	f, err := os.Open("sid.jpg")

	if err != nil {
		log.Fatal(err)
	}

	defer f.Close()

	reader := bufio.NewReader(f)
	buf := make([]byte, 256)

	for {
		_, err := reader.Read(buf)

		if err != nil {
			if err != io.EOF {
				fmt.Println(err)
			}
			break
		}

		fmt.Printf("%s", hex.Dump(buf))
	}
}

总结

本文介绍了 Go 语言读取文件的几种方式，ioutil.ReadFile 函数将整个文件读成一个字符串。这个函数很方便，但不应该用于非常大的文件。希望能对你有所帮助！

推荐学习：Golang教程

Das obige ist der detaillierte Inhalt vonWie lese ich Dateien in der Go-Sprache? Eine kurze Analyse verschiedener Methoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!