Travailler avec des fichiers et des répertoires est une tâche essentielle pour les applications qui doivent stocker et récupérer des données. Go fournit le paquetage filepath pour des opérations sur les chemins de fichiers indépendantes de la plateforme. Le paquetage inclut des fonctions pour manipuler les chemins de fichiers et il est compatible avec Windows, Linux et macOS.
Les fonctions incluses dans filepath peuvent joindre, diviser et nettoyer les chemins de fichiers pour s’assurer qu’ils sont valides. Le paquetage possède également des fonctions pour parcourir les répertoires et rechercher des fichiers.
Parcourir les arbres des répertoires
Le site Marche fonction de la chemin de fichier fournit une fonctionnalité permettant de parcourir une arborescence de répertoires et de parcourir les fichiers et les répertoires dans un ordre préalable. Il visitera récursivement tous les répertoires situés sous la racine donnée. La fonction Walk prend un répertoire racine et une fonction qui prend le chemin, une instance d’information sur le fichier et une instance d’erreur.
package main
import (
"fmt"
"path/filepath"
"os"
)
func main() {
// Defines the root directory to start the walk
root := "."
// Uses the Walk function to walk the directory tree
err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
// Prints the name of each file or directory
fmt.Println(path)
return nil
})
// Checks for errors
if err != nil {
fmt.Printf("Error walking directory tree: %v\n", err)
}
}
Ce programme définit le répertoire racine comme le répertoire de travail actuel. Le site principal parcourt les répertoires du répertoire racine et affiche les noms des fichiers.
Correspondance de fichiers avec le filtrage par motif
Vous pouvez utiliser la fonction Correspondance pour faire correspondre les noms de fichiers à un motif. La syntaxe du motif est basée sur la syntaxe courante des caractères génériques de fichier, qui utilise des métacaractères, connus sous le nom de motifs globaux dans les environnements Unix.
package main
import (
"fmt"
"path/filepath"
)
func main() {
// Defines the pattern to match
pattern := "*.txt"
// Uses the Match function to match the pattern on files
match, err := filepath.Match(pattern, "file.txt")
if err != nil {
fmt.Printf("Error matching pattern: %v\n", err)
return
}
// Prints the result of the match
if match {
fmt.Println("File matches pattern.")
} else {
fmt.Println("File does not match pattern.")
}
}
Le site principal fait correspondre un nom de fichier à la base de données *.txt et imprime une chaîne de caractères en fonction du résultat de l’instruction conditionnelle.
Nettoyage des chemins avec la fonction Clean
Le site Propre prend un chemin d’accès à un fichier et renvoie une version nettoyée du chemin en supprimant les séparateurs inutiles et les changements de répertoire, tels que . (répertoire actuel) et .. (répertoire parent) segments.
Le nettoyage des chemins de fichiers est utile car il permet d’éviter les erreurs si un chemin contient des séparateurs redondants ou des segments invalides, ou construit des chemins indépendants du répertoire de travail actuel.
package main
import (
"fmt"
"path/filepath"
)
func main() {
// Creates a path with redundant separators and invalid segments
path := "/foo/bar//baz/.././qux/"
// Cleans the path
cleanPath := filepath.Clean(path)
// Prints the original and cleaned file paths
fmt.Println("Original path:", path)
fmt.Println("Cleaned path:", cleanPath)
}
Le site chemin est le chemin d’accès initial au fichier, et la variable Nettoyer fonction nettoie le chemin et renvoie le chemin du fichier nettoyé. L’adresse principal imprime les chemins de fichiers initiaux et propres.
Joindre et diviser les chemins d’accès aux fichiers dans Go
Le site Rejoignez et Split Les fonctions fournissent une fonctionnalité pour joindre et diviser les chemins de fichiers.
La fonction Join prend un nombre quelconque d’éléments de chemin. Elle renvoie une chaîne de chemin d’accès unique qui résulte de la concaténation de ces éléments en utilisant le séparateur de chemin approprié au système d’exploitation. L’adresse Join est utile pour construire des chemins de fichiers indépendants du système de fichiers sous-jacent.
package main
import (
"fmt"
"path/filepath"
)
func main() {
// Defines four file paths for the join operation
path1 := "folder1"
path2 := "folder2"
path3 := "subfolder1"
path4 := "example.txt"
// Joins the four file paths together into a single path
joinedPath := filepath.Join(path1, path2, path3, path4)
// Print the unified file path
fmt.Println("Joined Path:", joinedPath)
}
Le site chemin1, chemin2et chemin3 sont des noms de dossiers, et les variables chemin4 variable est un nom de fichier. Le site Rejoindre prend les noms des variables de chemin et renvoie le chemin d’accès au fichier concaténé. Le site main imprime le chemin d’accès au fichier concaténé dans la console avec la fonction fmt paquet.
Le site Split prend une chaîne de chemin et renvoie les composants du nom de répertoire et du nom de fichier du chemin. Le site Split est utile pour extraire les noms de fichiers ou déterminer le répertoire parent d’un fichier.
package main
import (
"fmt"
"path/filepath"
)
func main() {
// Sets the file path for the split operation
filePath := "/home/user/documents/example.txt"
// Use the Split function to split the file path
// into its directory and file components
dir, file := filepath.Split(filePath)
// Print the directory and file components
fmt.Println("Directory:", dir)
fmt.Println("File:", file)
}
Le site filePath est le chemin du fichier original, et la variable Diviser fonction prend dans le filePath et renvoie les noms de répertoire et de fichier sous forme de chaînes de caractères. L’adresse principal affiche les noms des répertoires et des fichiers sur la console.
Vous pouvez manipuler les fichiers texte avec Go
En plus des fonctionnalités du système de fichiers, Go fournit des paquets pour vous aider à travailler avec plusieurs types de fichiers, y compris les fichiers texte.
Vous pouvez utiliser la fonction bufio pour les opérations d’entrée et de sortie en mode tampon sur les fichiers texte et le paquet os paquet pour la création de fichiers, entre autres opérations.