golang fermer le fichier

Lors de la programmation avec Golang, nous devons généralement ouvrir, lire et écrire des fichiers. Cependant, en même temps, nous devons également nous assurer de fermer le fichier lorsque nous avons fini de l'utiliser pour libérer des ressources système. Par conséquent, cet article explique comment fermer des fichiers dans Golang.

L'importance de fermer les fichiers

Dans Golang, utilisez la fonction os.Open() pour ouvrir des fichiers et utilisez la fonction os.Create() pour en créer de nouveaux. fichiers. Ces fonctions renvoient des instances du type *File. Lorsque nous avons fini de l'utiliser, nous devons utiliser la fonction file.Close() pour fermer le fichier afin de libérer les ressources système. Sinon, le descripteur de fichier fuira et éventuellement toutes les ressources système seront consommées. os.Open()函数可以打开文件，使用os.Create()函数可以创建新文件。这些函数返回的是 *File 类型的实例。当我们使用完毕后，应该使用 file.Close() 函数关闭文件以释放系统资源，否则会导致文件描述符泄漏，最终耗光整个系统资源。

例如，在以下示例中，我们打开一个文件，并遍历其所有行：

file, err := os.Open("example.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

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

注意到这里使用了一个 defer 语句，它将在函数返回前自动执行 file.Close() 方法。这种方式可以确保即使在函数中出现错误，文件也会被正确关闭。

文件关闭错误

我们可以使用 file.Close() 方法关闭文件。但是，有时候关闭文件可能会出错。例如，在以下代码中，我们故意打开一个不存在的文件：

file, err := os.Open("does_not_exist.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

由于文件不存在，打开文件时会返回一个错误。在这种情况下，file.Close() 将触发另一个错误，导致关闭失败。这种情况下，我们需要确保在关闭文件前先判断是否存在错误。例如：

file, err := os.Open("does_not_exist.txt")
if err != nil {
    log.Fatal(err)
}
defer func() {
    if err := file.Close(); err != nil {
        log.Fatal(err)
    }
}()

在这里，我们使用了一个匿名函数，将文件关闭操作放在这个函数中。在函数执行时，我们再次检查了关闭文件时是否发生错误。如果关闭失败，我们可以调用 log.Fatal() 函数记录错误并退出程序。

os.File.Close() 的底层实现

在底层实现中，关闭文件只是一个操作系统调用，调用 close() 系统函数以关闭文件描述符。在 Golang 中，os.File 类型实现了 io.Closer 接口，这个接口中只有一个方法：

type Closer interface {
    Close() error
}

在 os.File 中，Close() 函数实际上只是简单地调用了 syscall.Close() 函数。

func (file *File) Close() error {
    if file == nil {
        return syscall.EINVAL
    }
    if file == os.Stdin || file == os.Stdout || file == os.Stderr {
        return nil
    }
    return file.file.close()
}

注意到这个 Close() 函数还检查了一些特殊情况，例如 file 可以为 nil，或者特殊的标准输入输出流。在这些情况下，关闭操作实际上不会执行任何实际的操作。

通过 defer 关闭资源

在打开文件时，使用 defer 关键字是一个良好的编程习惯。这样，即使在函数返回前发生错误，我们也可以确保文件被关闭。例如，下面的代码会在读取完文件后自动关闭它：

file, err := os.Open("example.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

// 读取文件

由于 defer 语句的执行顺序是“后进先出”，因此在函数返回前的任何时候，我们都可以确保文件被关闭。

结论

在 Golang 中，使用 os.Open() 函数可以打开文件，使用 file.Close() 方法可以关闭文件以释放资源。在关闭文件时，我们应该确保检查错误并记录日志。另外，使用 defer

Par exemple, dans l'exemple suivant, nous ouvrons un fichier et parcourons toutes ses lignes : 🎜rrreee🎜 Notez qu'une instruction defer est utilisée ici, qui exécutera automatiquement le avant le la fonction renvoie la méthode file.Close(). De cette façon, nous garantissons que même si une erreur se produit dans la fonction, le fichier sera fermé correctement. 🎜🎜Erreur de fermeture de fichier🎜🎜Nous pouvons utiliser la méthode file.Close() pour fermer le fichier. Cependant, la fermeture d'un fichier peut parfois mal tourner. Par exemple, dans le code suivant, nous ouvrons intentionnellement un fichier qui n'existe pas : 🎜rrreee🎜 Puisque le fichier n'existe pas, une erreur est renvoyée lors de l'ouverture du fichier. Dans ce cas, file.Close() déclenchera une autre erreur, provoquant l'échec de la fermeture. Dans ce cas, nous devons nous assurer de vérifier les erreurs avant de fermer le fichier. Par exemple : 🎜rrreee🎜Ici, nous utilisons une fonction anonyme et mettons l'opération de fermeture du fichier dans cette fonction. Pendant l'exécution de la fonction, nous vérifions à nouveau si une erreur s'est produite lors de la fermeture du fichier. Si l'arrêt échoue, nous pouvons appeler la fonction log.Fatal() pour enregistrer l'erreur et quitter le programme. 🎜🎜 Implémentation de bas niveau de os.File.Close() 🎜🎜Dans l'implémentation de bas niveau, la fermeture d'un fichier est simplement un appel du système d'exploitation, appelant la fonction système close() pour fermer le fichier. descripteur de fichier. Dans Golang, le type os.File implémente l'interface io.Closer. Il n'y a qu'une seule méthode dans cette interface : 🎜rrreee🎜in os.Filecode> , la fonction <code>Close() appelle en fait simplement la fonction syscall.Close(). 🎜rrreee🎜 Notez que cette fonction Close() vérifie également certaines conditions spéciales, par exemple, file peut être nil, ou une entrée standard spéciale et flux de sortie. Dans ces cas, l’opération d’arrêt n’effectue aucune action réelle. 🎜🎜Fermeture des ressources via defer🎜🎜C'est une bonne habitude de programmation d'utiliser le mot-clé defer lors de l'ouverture d'un fichier. De cette façon, nous pouvons garantir que le fichier est fermé même si une erreur se produit avant le retour de la fonction. Par exemple, le code suivant fermera automatiquement le fichier après l'avoir lu : 🎜rrreee🎜Étant donné que l'ordre d'exécution de l'instruction defer est "dernier entré, premier sorti", à tout moment avant le retour de la fonction, nous Cela garantit que le fichier est fermé. 🎜🎜Conclusion🎜🎜Dans Golang, utilisez la fonction os.Open() pour ouvrir un fichier, et utilisez la méthode file.Close() pour fermer un fichier à libérer ressources. Nous devons nous assurer de vérifier les erreurs et de les enregistrer lors de la fermeture du fichier. De plus, l'utilisation du mot-clé defer garantit que lorsqu'un fichier est utilisé et manipulé, il est toujours fermé correctement. 🎜

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!