Un moyen multiplateforme de vérifier si un répertoire est accessible en écriture dans Golang ?

Dans Golang, pour vérifier si un répertoire est accessible en écriture de manière multiplateforme, vous pouvez utiliser `os.FileMode` pour y parvenir. Tout d'abord, obtenez les informations de fichier du répertoire via la fonction `os.Stat`. Ensuite, utilisez la méthode `file.Mode().Perm()` pour obtenir les autorisations du fichier. Enfin, utilisez la méthode `file.Mode().IsDir()` pour déterminer s'il s'agit d'un répertoire. Si les autorisations du répertoire sont « 0777 », cela signifie qu'il est accessible en écriture ; si les autorisations sont « 0444 » ou « 0555 », cela signifie qu'il est en lecture seule ; si les autorisations sont d'autres valeurs, cela signifie qu'il n'est pas accessible en écriture ; . Cette méthode convient à la vérification de l’écriture des répertoires multiplateformes.

Contenu de la question

J'ai un programme qui essaie d'écrire un fichier dans un répertoire en utilisant Golang. J'en ai besoin pour fonctionner sous MacOS, Linux et Windows (au moins).

golang propose les tests suivants - mais ils semblent être limités à Linux (d'après la question liée ci-dessous) :

func IsWritable(path string) (isWritable bool, err error) {
    isWritable = false
    info, err := os.Stat(path)
    if err != nil {
        fmt.Println("Path doesn't exist")
        return
    }

    err = nil
    if !info.IsDir() {
        fmt.Println("Path isn't a directory")
        return
    }

    // Check if the user bit is enabled in file permission
    if info.Mode().Perm() & (1 << (uint(7))) == 0 {
        fmt.Println("Write permission bit is not set on this file for user")
        return
    }

    var stat syscall.Stat_t
    if err = syscall.Stat(path, &stat); err != nil {
        fmt.Println("Unable to get stat")
        return
    }

    err = nil
    if uint32(os.Geteuid()) != stat.Uid {
        isWritable = false
        fmt.Println("User doesn't have permission to write to this directory")
        return
    }

    isWritable = true
    return
}

J'ai vu cette réponse [1], mais cette question date de 10 ans, existe-t-il un meilleur moyen d'y parvenir que la compilation conditionnelle ?

Résumé : je veux juste que le processus go sache s'il peut écrire dans un répertoire donné.

[1] Comment déterminer si un dossier existe et est accessible en écriture ?

Solution de contournement

C'est ainsi que j'ai atteint mon objectif sans compilation conditionnelle, car les autorisations et privilèges peuvent différer selon les systèmes d'exploitation.

• J'ai essayé d'utiliser os.createtemp pour créer un fichier temporaire dans ce répertoire. Si la fonction ne renvoie pas d'erreur, alors il n'y a aucun problème avec le chemin ou les autorisations et nous pouvons créer le fichier dans ce répertoire.

Voici le code

func IsWritable(path string) (bool, error) {
    tmpFile := "tmpfile"

    file, err := os.CreateTemp(path, tmpFile)
    if err != nil {
        return false, err
    }

    defer os.Remove(file.Name())
    defer file.Close()

    return true, nil
}


func main() {
     path := "absolute-directory-path"

    isWritable, err := IsWritable(path)
    if err != nil {
       panic(err)
    }

    if isWritable {
      // statements
    }

}

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!