Comment lire des fichiers en langage Go ? Une brève analyse de diverses méthodes

Cet article expliquera comment lire des fichiers dans Golang. Nous utiliserons les packages suivants pour traiter ces fichiers. Le package

• os fournit une interface indépendante de la plate-forme pour effectuer des opérations au niveau opérationnel. Le package
• IUtil fournit des fonctions utilitaires faciles à utiliser pour travailler avec des fichiers sans trop en savoir sur l'implémentation interne. Le package
• bufio implémente des E/S tamponnées, ce qui nous aide à améliorer les performances et le débit des opérations d'entrée et de sortie. Le package
• log implémente un package de journalisation simple. Nous l'utiliserons tout au long du programme. Nous utiliserons la fonction Fatal() du package de journalisation dans notre programme. 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

Lecture du fichier entier

Nous pouvons facilement lire le fichier entier en une seule fois et le stocker dans une variable. Mais rappelez-vous que nous ne devrions pas faire cela avec des fichiers volumineux. Nous utiliserons la fonction ioutil.ReadFile() pour lire un fichier et stocker le contenu du fichier dans une variable. 🎜🎜Tout d’abord, stockons un fichier dans le même répertoire que notre programme. Par conséquent, notre structure de dossiers ressemblera à ceci. 🎜

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))
	}
}

🎜Nous écrivons ce qui suit dans la fonction main.go : 🎜rrreee🎜Mais d'abord, discutons du cas de la fonction ReadFile() : 🎜🎜🎜 Définition : Déclaration de méthode func ReadFile(filename string) ([]byte, error)🎜🎜Fonction : Lit le fichier dont le chemin est passé dans le paramètre de fonction et renvoie le contenu du fichier. Méthode os.ReadFile(fileName) utilisée en interne 🎜🎜Returns : renvoie le contenu du fichier et les erreurs dans un tableau d'octets. Un appel réussi renverra err == nil🎜🎜La fonction interne ReadFile est implémentée comme suit :🎜rrreee🎜Maintenant, revenons à notre programme :🎜🎜🎜ioutil.ReadFile("readthisfile.txt" ) Renvoie un byteArray et une erreur. Nous stockons le byteArray dans la variable "content" et l'erreur dans la variable "err". 🎜🎜Ensuite, nous mettons une condition if, si la valeur de l'erreur n'est pas nulle, nous imprimerons l'erreur d'erreur en utilisant la fonction log.Fatal(). N'oubliez pas que la fonction Fatal() est équivalente à la fonction Print(), qui appelle ensuite os.Exit(1) . 🎜🎜Enfin, nous utiliserons la fonction fmt.Println() pour imprimer le contenu du fichier. Nous ne pouvons pas simplement imprimer la variable content car c'est un tableau d'octets, nous devons la convertir en chaîne : string(content)🎜🎜Ensuite Créez un nouveau fichier ilovego.txt et écrivez le contenu suivant : 🎜rrreee🎜Enfin, exécutez le code ci-dessus et vous pourrez voir le résultat suivant : 🎜rrreee

Lire ligne par ligne< /strong>

🎜Scanner Scanner fournit une interface pratique pour lire des données, telles qu'un fichier composé de lignes de texte délimitées par des nouvelles lignes. Il lit les données via des marqueurs ; la fonction Split définit des marqueurs. Par défaut, cette fonction divise les données en lignes et supprime les extrémités des lignes. 🎜rrreee🎜🎜os.Open() Ouvre le fichier passé en paramètre. Si une erreur survient lors de l’ouverture du fichier, la même erreur sera renvoyée. Sinon, l'erreur sera nulle. 🎜🎜Ensuite, nous utilisons un scanner pour lire le fichier et le scanner ligne par ligne jusqu'à la fin du contenu du fichier. 🎜🎜Enfin, nous souhaitons clôturer le dossier. 🎜🎜Exécutez le programme et les résultats sont les suivants : 🎜🎜🎜

Lire mot à mot

🎜On peut aussi lire le fichier mot à mot : 🎜rrreee🎜Exécuter le code : 🎜rrreee

Lire des fichiers sous forme de blocs de données

🎜Lire l'intégralité du fichier en une seule fois semble être un moyen simple, mais nous devons parfois optimiser notre programme. Golang fournit un moyen de lire un fichier en morceaux au lieu de le lire en entier ou même ligne par ligne. Car si la taille d’une ligne est trop grande, la lecture ligne par ligne peut également s’avérer inefficace. 🎜rrreee

Lecture binaire

🎜Le package hex implémente l'encodage et le décodage hexadécimaux. 🎜

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教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!