texte/template question Parse() vs ParseFiles()

Je suis en train de faire un simple travail avec le texte/package de modèle. L'exemple donné dans le haut de modèle est ce que je suis en train de travailler avec.

Comment puis-je écrire le "analysé" fichier donc template.ParseFiles() correctement lit et exécute?

package main

import (
    "text/template"
    "os"
)

type Inventory struct {
    Material string
    Count    uint
}

func main() {
    sweaters := Inventory{"wool", 17}
    tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}")
    //tmpl, err := template.New("test").ParseFiles("file.txt")

    if err != nil { panic(err) }
    err = tmpl.Execute(os.Stdout, sweaters)
    if err != nil { panic(err) }
}

/*
Contents of file.txt:
{{.Count}} items are made of {{.Material}}

Error thrown:
panic: template: test:1: "test" is an incomplete or empty template

goroutine 1 [running]:
main.main()
    /tmp/templates/t.go:19 +0x21a

goroutine 2 [syscall]:
created by runtime.main
    /var/tmp/portage/dev-lang/go-1.0.1/work/go/src/pkg/runtime/proc.c:221
*/

J'ai une copie de ce code affiché à l'golang aire de jeux ici

Edit #1:
J'ai fait quelques recherches sur cette question... puisque c'est la Execute() méthode qui lève l'exception, et non la ParseFiles() partie, j'ai vérifié la définition de la méthode:

//Execute applies a parsed template to the specified data object,
//and writes the output to wr.
func (t *Template) Execute(wr io.Writer, data interface{}) (err error) {
    defer errRecover(&err)
    value := reflect.ValueOf(data)
    state := &state{
        tmpl: t,
        wr:   wr,
        line: 1,
        vars: []variable{{"$", value}},
    }
    if t.Tree == nil || t.Root == nil {
        state.errorf("%q is an incomplete or empty template", t.name)
    }
    state.walk(value, t.Root)
    return
}

Donc, sur une intuition, j'ai perdu la valeur de t.Arbre pour le inline 'non-fichier de style, tmpl est: &parse.Tree{Name:"test", Root:(*parse.ListNode)(0xf840030700), funcs:[]map[string]interface {}(nil), lex:(*parse.lexer)(nil), token:[2]parse.item{parse.item{typ:6, val:""}, parse.item{typ:9, val:"{{"}}, peekCount:1, vars:[]string(nil)} et
quand a couru avec ParseFiles(), tmpl est: (*parse.Tree)(nil). Je trouve bizarre que l'on est un déréférencement, et une valeur est un pointeur. Cela peut aider à résoudre l'énigme

Remarque, la chose intéressante à propos de cet exemple, et d'autres ParseFiles() des tests que j'ai fait, ils ne sont pas sur l'analyse, ils ne parviennent pas quand ils arrivent à l'Execute() de phase, toujours avec le incomplètes ou modèle vide message
Votre lié golang aire de jeux exemple fonctionne pour moi. Êtes-vous sûr que c'est en fait cassé?
Oui, il fonctionne très bien, parce que vous n'avez pas accès à un système de fichiers sur l'aire de jeux. Toutefois, si vous supprimez le ParseFiles() ligne, commentez les autres Parse() ligne de l'exécuter localement, vous verrez l'erreur que j'ai dans les commentaires dans le code.

OriginalL'auteur Evan Plumlee | 2012-08-04

go go-templates

14
```
sweaters := Inventory{"wool", 17}
tmpl, err := template.ParseFiles("file.txt")
if err != nil {
    panic(err)
}
err = tmpl.ExecuteTemplate(os.Stdout, "file.txt", sweaters)
if err != nil {
    panic(err)
}
```
Si vous avez de nombreux fichiers, vous pouvez utiliser ParseGlob:
```
tmpl, err := template.ParseGlob("*.txt")
if err != nil {
    panic(err)
}
err = tmpl.ExecuteTemplate(os.Stdout, "file.txt", sweaters)
if err != nil {
    panic(err)
}
err = tmpl.ExecuteTemplate(os.Stdout, "file2.txt", sweaters)
if err != nil {
    panic(err)
}
```
Yup, j'ai trouvé la réponse moi-même plus tard, mais stackoverflow ne me laisse pas le poster. Il est source de confusion et malheureux que tout Parse() fonctionne de manière similaire à (t *Template) Parse(), ParseFiles() fonctionne d'une manière différente que (t *Template) ParseFiles() qui a causé tous mes confusion. Merci de répondre.
Point clé: utiliser un modèle.ParseFiles("filename.txt"), NON (t *Modèle) ParseFiles... et je n'obtiendrai jamais la dernière heure de retour.
A couru dans la même question, et votre commentaire est ce que effacés pour moi. Ne pense pas que j'aurais trouvé que c'est le contraire. A regarder le pkg docs de nouveau.
En outre, si votre modèle est dans un sous-répertoire à l'argument de ExecuteTemplate est le nom du fichier partie seulement sans le chemin d'accès au répertoire.
template.ParseFiles("file.txt") retourne un Modèle nommé file.txt. Par conséquent, lorsque vous exécutez template.New("test").ParseFiles("file.txt") vous vous retrouvez avec 2 Modèles: test et file.txt. Ce dernier est associé avec l'ancien.

OriginalL'auteur Eli Revah

Il y a un petit truc en Aller modèle parseFiles.

func parseFiles(t *Template, filenames ...string) (*Template, error) {
    if len(filenames) == 0 {
        //Not really a problem, but be consistent.
        return nil, fmt.Errorf("template: no files named in call to ParseFiles")
    }
    for _, filename := range filenames {
        b, err := ioutil.ReadFile(filename)
        if err != nil {
            return nil, err
        }
        s := string(b)
        name := filepath.Base(filename)
        //First template becomes return value if not already defined,
        //and we use that one for subsequent New calls to associate
        //all the templates together. Also, if this file has the same name
        //as t, this file becomes the contents of t, so
        // t, err := New(name).Funcs(xxx).ParseFiles(name)
        //works. Otherwise we create a new template associated with t.
        var tmpl *Template
        if t == nil {
            t = New(name)
        }
        if name == t.Name() {
            tmpl = t
        } else {
            tmpl = t.New(name)
        }
        _, err = tmpl.Parse(s)
        if err != nil {
            return nil, err
        }
    }
    return t, nil
}

Seul le modèle avec le même nom sera réutilisation, sinon créer un nouveau.
en tant que votre échantillon:

tmpl, err := template.New("test").ParseFiles("file.txt")

tmpl est le modèle nommé "test", et associé à un autre modèle appelé "file.txt", vous appelez Exécuter sur "test" de modèle, ce modèle est un modèle vide, de sorte que génère l'erreur "est un test incomplet ou modèle vide".

Il a travaillé quand vous modifiez le nom du modèle file.txt

tmpl, err := template.New("file.txt").ParseFiles("file.txt")

c'est de ce faire sucer, ignorer le modèle défini par le nom et le nom du fichier à la place

OriginalL'auteur jolestar

Vous devez vous connecter pour publier un commentaire.