Compétences en traitement de fichiers et en opérations d'E/S en langage Go

En tant que langage de programmation populaire ces dernières années, le langage Go possède des fonctions puissantes et d'excellentes performances dans le traitement des fichiers et les opérations d'E/S. Le traitement des fichiers et les opérations d'E/S sont des moyens d'interaction importants entre les développeurs et les ordinateurs, et constituent également des compétences de base nécessaires au développement de programmes de haute qualité. Cet article présentera certaines techniques de traitement de fichiers et d'opération d'E/S couramment utilisées dans le langage Go pour aider les lecteurs à maîtriser rapidement les connaissances pertinentes.

1. Traitement des fichiers

1. Ouverture de fichiers

L'ouverture de fichiers en langage Go est implémentée via la fonction Open du package os :

func Open(name string) (*File, error)

Cette fonction renvoie un objet fichier et un objet erreur. L'objet fichier est un type d'interface avec des méthodes de lecture et d'écriture. Il comporte trois méthodes : Lire, Écrire et Fermer. L'objet d'erreur est une interface de type d'erreur qui représente le message d'erreur qui s'est produit.

Exemple de code :

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

Le code ci-dessus peut ouvrir un fichier nommé test.txt et fermer automatiquement le fichier une fois le traitement du fichier terminé.

2. Lecture du contenu du fichier

La lecture du contenu du fichier est obtenue en lisant l'objet fichier. Pour lire le contenu du fichier, vous pouvez utiliser les méthodes Read et ReadAt de l'objet fichier. Read lit le contenu du fichier de manière séquentielle et renvoie le nombre d'octets lus. Lorsque la fin du fichier est lue, une erreur io.EOF est renvoyée. ReadAt commence à lire le contenu du fichier au décalage spécifié. Le fichier peut être lu dans le désordre et le nombre d'octets lus est renvoyé.

Exemple de code :

package main

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

func main() {
    content, err := ioutil.ReadFile("test.txt")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("File contents: %s", content)
}

Avec le code ci-dessus, vous pouvez utiliser le package ioutil pour lire le contenu du fichier.

3. Écriture du contenu du fichier

L'écriture du contenu du fichier est également implémentée via l'objet fichier. Les méthodes Write et WriteAt de l'objet fichier peuvent écrire séquentiellement et écrire respectivement en fonction du décalage. de tronçons.

Exemple de code :

package main

import (
    "log"
    "os"
)

func main() {
    file, err := os.Create("test.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    file.Write([]byte("Hello, world"))
}

Le code ci-dessus peut créer un fichier test.txt et y écrire "Hello, World".

4. Supprimer des fichiers

Vous pouvez supprimer des fichiers via le package os du langage Go. La façon de supprimer des fichiers est d'utiliser la fonction Supprimer et de prendre le nom du fichier comme paramètre.

Exemple de code :

package main

import (
    "log"
    "os"
)

func main() {
    err := os.Remove("test.txt")
    if err != nil {
        log.Fatal(err)
    }
}

Le fichier nommé test.txt peut être supprimé via le code ci-dessus.

2. Compétences en matière d'opération IO

1. Fonctionnement des flux d'entrée et de sortie standard

Le langage Go utilise les flux d'entrée et de sortie standard (stdin, stdout et stderr) dans le package os. du package os pour les faire fonctionner. , la méthode est la suivante :

os.Stdin         // 标准输入
os.Stdout        // 标准输出
os.Stderr        // 标准错误输出

Exemple de code :

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Fprintln(os.Stdout, "Hello, world")
    fmt.Fprintln(os.Stderr, "This is an error")
}

Grâce au code ci-dessus, un morceau de texte peut être affiché respectivement sur la sortie standard et la sortie d'erreur standard.

2. Flux d'entrée et de sortie de chaînes

Dans le langage Go, il existe un type appelé bytes.Buffer, qui peut être utilisé pour enregistrer des chaînes et leur fournir des interfaces d'entrée et de sortie. Grâce au type bytes.Buffer, nous pouvons convertir les flux d'entrée et de sortie en traitement de flux d'octets pour traiter l'entrée et la sortie des chaînes.

Exemple de code :

package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("Hello, world")
    fmt.Println(buf.String())
}

Grâce au code ci-dessus, nous "écrivons" une phrase dans buf, puis utilisons la méthode String() pour la sortir, et le caractère "Hello, world" peut être vu sur la console Enchaînés ensemble .

3. Lire le flux d'entrée dans un tableau d'octets

Le package io/ioutil dans le langage Go peut facilement effectuer des opérations de lecture et d'écriture de données dans le package ioutil peut lire le flux d'entrée dans un tableau d'octets et le renvoyer. il.

Exemple de code :

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    data, err := ioutil.ReadAll(os.Stdin)
    if err != nil {
        fmt.Println("ERROR reading STDIN: ", err)
        return
    }
    fmt.Println("STDIN = ", string(data))
}

Le code ci-dessus peut lire le flux d'entrée standard en données et l'imprimer.

Cet article décrit certaines techniques courantes de traitement de fichiers et d'opérations d'E/S dans le langage Go, telles que l'ouverture, la lecture, l'écriture et la suppression de fichiers, ainsi que l'exploitation de flux d'entrée et de sortie standard, de flux d'entrée et de sortie de chaîne et la lecture de flux d'entrée en octets. Conseils moyens. Ces techniques sont très utiles pour développer des programmes de haute qualité, et les lecteurs peuvent se débarrasser des problèmes et améliorer l'efficacité du travail en fonction de leurs propres besoins.

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!