Das einbetten von Dateien in Golang binaries?

Habe ich einige text-Datei, die ich Lesen aus meinem Programm Gehen. Ich möchte zum versenden einer einzigen ausführbaren Datei, ohne Lieferung, die text-Datei zusätzlich.
Wie bette ich ihn in die Kompilierung unter Windows und Linux?

InformationsquelleAutor Zvika | 2013-07-22

binaries go

28

Verwenden go-bindata. Aus der README:

Dieses tool konvertiert eine Datei in überschaubare Gehen-source-code. Nützlich für
einbetten von binären Daten in ein go-Programm. Die Daten der Datei ist Optional
gzip komprimiert, bevor Sie konvertiert in einem raw-byte-slice.
- Das ist jetzt irgendwie überflüssig. Das generieren von code nicht weitergeben golint und der Besitzer des Geschäfts ist nicht die Interaktion mit pull-Anforderungen. Ich wäre vorsichtig mit dieser Bibliothek
- Ein neues Projekt namens statik scheint, dies zu tun und wurde aktiv in jüngerer Zeit.
InformationsquelleAutor joshlf
45

Da Gehen 1.4, die Sie verwenden können, gehen generieren wenn Sie mehr Flexibilität benötigen.

Wenn du mehr als eine text-Datei oder text-Datei kann sich ändern, wollen Sie vielleicht gar nicht hart Kodieren die text-Datei, aber gehören Sie zur compile-Zeit.

Wenn Sie die folgenden Dateien:
```
main.go
scripts/includetxt.go
a.txt
b.txt
```
Und möchten Zugriff auf die Inhalte aller .txt-Dateien in main.gehen, können Sie auch einen speziellen Kommentar mit einem go-Befehl erstellen.

main.gehen
```
package main

import "fmt"

//go:generate go run scripts/includetxt.go

func main() {
    fmt.Println(a)
    fmt.Println(b)
}
```
Den go-generate-Befehl wird das Skript ausgeführt, nachdem go:generate. In diesem Fall wird ein go-Skript liest alle text-Dateien und gibt Sie als string-Literale in eine neue Datei. Ich übersprungen die Fehlerbehandlung für kürzeren code.

Skript/includetxt.gehen
```
package main

import (
    "io"
    "io/ioutil"
    "os"
    "strings"
)

//Reads all .txt files in the current folder
//and encodes them as strings literals in textfiles.go
func main() {
    fs, _ := ioutil.ReadDir(".")
    out, _ := os.Create("textfiles.go")
    out.Write([]byte("package main \n\nconst (\n"))
    for _, f := range fs {
        if strings.HasSuffix(f.Name(), ".txt") {
            out.Write([]byte(strings.TrimSuffix(f.Name(), ".txt") + " = `"))
            f, _ := os.Open(f.Name())
            io.Copy(out, f)
            out.Write([]byte("`\n"))
        }
    }
    out.Write([]byte(")\n"))
}
```
Kompilieren alle .txt-Dateien in Ihre exectutable:
```
$ go generate
$ go build -o main
```
Nun Ihre Verzeichnis-Struktur wird wie folgt Aussehen:
```
main.go
main
scripts/includetxt.go
textfiles.go
a.txt
b.txt
```
Wo Textdateien.gehen wurde erzeugt, indem go generieren und Skript/includetxt.gehen

Textdateien.gehen
```
package main 

const (
a = `hello`
b = `world`
)
```
Und läuft main gibt
```
$ ./main
hello
world
```
Dies funktioniert gut, so lange, wie Sie die Kodierung UTF-8 codierte Dateien. Wenn Sie Kodieren möchten anderen Dateien, die Sie die volle macht der Sprache (oder einem anderen tool) zu tun. Ich verwendet diese Technik, um hex codieren png:s in einer einzigen ausführbaren Datei. Das erfordert eine geringfügige änderung includetxt.gehen.
- Schön! Ich hatte keine Ahnung, dass die Funktion existiert. Das ist so viel sauberer als dumping in einem string-literal in den Quellcode.
- Einfach nur neugierig, warum müssen wir schreiben Präprozessor-Befehl in die Kommentare und dann separat laufen go generate? Konnte nicht go build kümmern ausführen-Befehl, wenn es Hinweise //go:generate ... Kommentar?
InformationsquelleAutor Johan Wikström

Können Sie eine Stringliteral definieren den text als eine Konstante oder eine variable. String-Literale definiert werden, indem man den string mit back-quotes. z.B. `string`.

Beispiel:

package main

import "fmt"

func main() {
    const text = `
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit  
amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante 
hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet 
vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. Donec ut 
libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet, 
consectetur adipiscing elit. Aenean ut gravida lorem. Ut turpis felis, pulvinar a 
semper sed, adipiscing id dolor. Pellentesque auctor nisi id magna consequat sagittis. 
Curabitur dapibus enim sit amet elit pharetra tincidunt feugiat nisl imperdiet. Ut 
convallis libero in urna ultrices accumsan. Donec sed odio eros. Donec viverra mi quis 
quam pulvinar at malesuada arcu rhoncus. Cum sociis natoque penatibus et magnis dis 
parturient montes, nascetur ridiculus mus. In rutrum accumsan ultricies. Mauris vitae 
nisi at sem facilisis semper ac in est.
`

    fmt.Println(text)
}

go-bindata sieht cool aus, aber diese Methode ist viel einfacher.
Obwohl einfacher, es funktioniert nicht, wenn Ihr 'file' enthält Zeichen wie %.

InformationsquelleAutor Intermernet

2

Ich habe eine einfache Funktion zum Lesen eine externe Vorlage in einem go generate führen und zu generieren, Gehen Sie code aus. Eine Funktion die Rücksendung der Muster als string generiert. Kann man dann analysieren der zurückgegebenen Zeichenfolge Vorlage mit tpl, err := template.New("myname").Parse(mynameTemplate())

Habe ich diesen code auf github. Vielleicht möchten Sie versuchen, https://github.com/wlbr/templify

Sehr einfach, aber funktioniert für mich ganz gut.

InformationsquelleAutor wlbr

Basierend auf @CoreyOgburn Kommentar und das Github Kommentar, der folgende Codeausschnitt erstellt wurde:

//go:generate statik -src=./html

package main

import (
    _ "./statik"
    "github.com/rakyll/statik/fs"
)

func statikFile() {

    s, _ := fs.New()
    f, _ := s.Open("/tmpl/login.html")
    b, _ := ioutil.ReadAll(f)
    t, _ := template.New("login").Parse(string(b))
    t.Execute(w, nil)
}

und führen

go generate

und anschließend

go build

sollte eine Binärdatei, die die Dateien enthält, die

InformationsquelleAutor 030

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

main.gehen

Skript/includetxt.gehen

Textdateien.gehen