Copie de fichiers efficace et simple dans Go

Copier efficacement un fichier dans Go, sans recourir à des bibliothèques complexes ou à du code dépendant du système d'exploitation, peut être réalisé en utilisant une implémentation robuste qui gère divers cas extrêmes.

Utiliser des liens physiques pour une duplication rapide

Un moyen rapide de dupliquer un fichier existant consiste à utiliser le système d'exploitation Fonction .Link(). Cela crée un lien physique entre le fichier d'origine et le fichier de destination, ce qui en fait essentiellement le même fichier plutôt que de créer une copie. Cette approche permet d'économiser du temps et de l'espace disque, en particulier pour les fichiers volumineux.

Gestion des différentes restrictions du système

Cependant, les liens physiques sont soumis à des restrictions en fonction du système d'exploitation et du système de fichiers. configurations. Par exemple, certains systèmes n'autorisent pas les liens physiques entre des fichiers sur différents systèmes de fichiers ou partitions.

Fonction de copie robuste et générique

Pour créer une fonction de copie générique et robuste , procédez comme suit :

1. Vérifiez les autorisations, l'existence du répertoire et d'autres problèmes potentiels avant de tenter une copie.
2. Vérifiez si les deux fichiers existent et sont identiques à l'aide de os.SameFile. Si tel est le cas, renvoyez le succès.
3. Tentez un lien physique avec os.Link. Renvoie en cas de succès.
4. Si tout le reste échoue, copiez le fichier octet par octet.

Optimisation et simplicité

Pour améliorer les performances, la copie d'octets peut être effectuée dans une routine go distincte pour éviter de bloquer le thread appelant. Cependant, cela ajoute de la complexité à la responsabilité de l'appelant de gérer le succès ou l'échec.

Pour une implémentation plus facile, on peut créer deux fonctions de copie distinctes : CopyFile() pour la copie synchrone et CopyFileAsync() pour la copie asynchrone, qui renvoie un canal de signalisation vers l'appelant.

Exemple de code

Le code fourni démontre une fonction CopyFile robuste qui tente d'établir un lien physique avant d'effectuer une copie de repli d'octet :

package main

import (
    "fmt"
    "io"
    "os"
)

func CopyFile(src, dst string) (err error) {
    // Validate input
    // ...

    if err = os.Link(src, dst); err == nil {
        return
    }
    err = copyFileContents(src, dst)
    return
}

func copyFileContents(src, dst string) (err error) {
    // Copy file contents
    // ...
    return
}

func main() {
    // ...
    err := CopyFile(os.Args[1], os.Args[2])
    if err != nil {
        // ...
    }
}