Comment lire un fichier binaire en Aller

Je suis complètement nouveau pour Aller, et je suis en train de lire un fichier binaire, soit octet par octet ou plusieurs octets à la fois. La documentation ne l'aide pas beaucoup et je ne trouve aucun tutoriel ou un simple exemple (d'ailleurs, comment pourrait-Google donner leur langue une telle onu-googlable nom?). En gros, comment puis-je ouvrir un fichier, puis de lire certains des octets dans le buffer? Toute suggestion?

Il permet d'utiliser le terme golang de recherche google.
stackoverflow.com/questions/1821811/...
Vous trouverez peut-être ce lien utile. stackoverflow.com/questions/1821811/...

OriginalL'auteur this.lau_ | 2013-01-25

  1. 17

    Pour la manipulation des fichiers, la os paquet est votre ami:

    f, err := os.Open("myfile")
if err != nil {
   panic(err)
}
defer f.Close()

    Pour plus de contrôle sur la façon dont le fichier est ouvert, voir os.OpenFile() au lieu (doc).

    Pour la lecture de fichiers, il existe de nombreuses façons. Le os.File type retourné par os.Open (le f dans l'exemple ci-dessus) met en œuvre le io.Reader interface (il a un Read() méthode avec la signature à droite), il peut être utilisé directement pour lire des données dans une mémoire tampon (un []byte) ou il peut être enveloppé dans un tampon lecteur (type bufio.Reader).

    Spécifiquement pour des données binaires, le encoding/binary package peut être utile, pour lire une séquence d'octets dans certains tapé structure de données. Vous pouvez voir un exemple dans le Allez doc ici. Le binary.Read() fonction peut être utilisée avec la lecture de fichier à l'aide de la os.Open() fonction, car comme je l'ai mentionné, c'est un io.Reader.

    Et il y a aussi le simple à utiliser io/ioutil paquet, qui vous permet de lire l'ensemble du dossier à la fois dans un octet tranche (ioutil.ReadFile(), qui prend un nom de fichier, de sorte que vous n'avez même pas à ouvrir/fermer le fichier vous-même), ou ioutil.ReadAll() qui prend un io.Reader et renvoie une tranche d'octets contenant le fichier en entier. Voici la doc sur ioutil.

    Enfin, comme d'autres l'ont mentionné, vous pouvez google à propos de l'Aller de la langue à l'aide de "golang" et vous devriez trouver tout ce que vous devez. Le golang-noix de liste de diffusion est également un excellent endroit pour chercher des réponses (assurez-vous de rechercher d'abord avant de poster, beaucoup de choses ont déjà été répondues). Pour chercher des paquets de tierce partie, cochez la godoc.org site web.

    HTH

    OriginalL'auteur mna

  2. 7

    Par exemple, pour compter le nombre de zéro octets dans un fichier:

    package main

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

func main() {
    f, err := os.Open("filename")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()
    data := make([]byte, 4096)
    zeroes := 0
    for {
        data = data[:cap(data)]
        n, err := f.Read(data)
        if err != nil {
            if err == io.EOF {
                break
            }
            fmt.Println(err)
            return
        }
        data = data[:n]
        for _, b := range data {
            if b == 0 {
                zeroes++
            }
        }
    }
    fmt.Println("zeroes:", zeroes)
}

    OriginalL'auteur peterSO

  3. 7

    C'est ce que j'utilise pour lire l'intégralité d'un fichier binaire en mémoire

    func RetrieveROM(filename string) ([]byte, error) {
    file, err := os.Open(filename)

    if err != nil {
        return nil, err
    }
    defer file.Close()

    stats, statsErr := file.Stat()
    if statsErr != nil {
        return nil, statsErr
    }

    var size int64 = stats.Size()
    bytes := make([]byte, size)

    bufr := bufio.NewReader(file)
    _,err = bufr.Read(bytes)

    return bytes, err
}
    Pourquoi ne pas simplement utiliser func ReadFile(filename string) ([]byte, error) de l'Aller io/ioutil paquet?
    c'est drôle, je suis en train d'écrire un émulateur dans le moment et je suis tombé sur votre réponse après avoir googler sur des fichiers binaires 😉

    OriginalL'auteur djhworld

  4. 0

    Vous ne pouvez pas saugrenue fonte types primitifs (char*) comme en C, donc pour toute sorte de (dé)sérialisation de données binaires à utiliser l'encodage/paquet binaire.
    http://golang.org/pkg/encoding/binary .
    Je ne peux pas l'améliorer exemples là.

    OriginalL'auteur kramer