通过会话变量在Golang layout.tpl中有条件地呈现HTML

There's a few things you need to do to tie this together. I'm not going to show a complete example as it would be both fairly lengthy and may not match your code (which you haven't posted). It will contain the basic building blocks though: if you get stuck, come back with a direct question and a code snippet and you'll get a more direct answer :)

1. Write some middleware or logic in a [login] handler that saves the user data in the session when a user logs in. A userID, email and admin boolean value would be sufficient. e.g.

   // In your login handler, once you've retrieved the user &
   // matched their password hash (scrypt, of course!) from the DB.
   session.Values["user"] = &youruserobject
   err := session.Save(r, w)
   if err != nil {
       // Throw a HTTP 500
   }
   

Note: remember that you need to gob.Register(&youruserobject{}) as per the gorilla/sessions docs if you want to store your own types.

2. Write a helper to type-assert your type when you pull it out of the session, e.g.

   var ErrInvalidUser= errors.New("invalid user stored in session")
   
   func GetUser(session *sessions.Session) (*User, error) {
       // You can make the map key a constant to avoid typos/errors
       user, ok := session.Values["user"].(*User)
       if !ok || user == nil {
           return nil, ErrInvalidUser
       }
       return user, nil
   }
   
   
   // Use it like this in a handler that serves user content
   session, err := store.Get("yoursessionname", r)
   if err != nil {
       // Throw a HTTP 500
   }
   
   user, err := GetUser(session)
      if err != nil {
       // Re-direct back to the login page or
       // show a HTTP 403 Forbidden, etc.
   }
   

3. Write something to check if the returned user is an admin:

   func IsAdmin(user *User) bool {
           if user.Admin == true && user.ID != "" && user.Email != "" {
                   return true
           }
   
           return false
   }
   

4. Pass that to the template:

    err := template.Execute(w, "sometemplate.html", map[string]interface{}{
           "admin": IsAdmin(user),
           "someotherdata": someStructWithData,
       }
   
    // In your template...
    {{ if .admin }}{{ template "admin_menu" }}{{ end }}
   

Also make sure you're setting an authentication key for your session cookies (read the gorilla docs), preferably an encryption key, and that you're serving your site over HTTPS with the Secure: true flag set as well.

Keep in mind that the above method is also simplified: if you de-flag a user as admin in your DB, the application will continue to detect them as an administrator for as long as their session lasts. By default this can be 7 days, so if you're in a risky environment where admin churn is a real problem, it may pay to have really short sessions OR hit the DB inside the IsAdmin function just to be safe. If it's a personal blog and it's just you, not so much.

Added: If you want to pass the User object directly to the template, you can do that too. Note that it's more performant to do it in your handler/middleware than it is in the template logic. You also get the flexibility of more error handling, and the option of "bailing out" earlier - i.e. if the session contains nothing, you can fire up a HTTP 500 error rather than rendering half a template or having to put lots of logic in your template to handle nil data.

You still need to store your User object (or equivalent) in the session, and retrieve it from session.Values before you can pass it to the template.

 func GetUser(r *http.Request) *User {
        session, err := store.Get("yoursessionname", r)
        if err != nil {
            // Throw a HTTP 500
        }
        if user, ok := session.Values["user"].(*User); ok {
            return user
        }

        return nil
 }

 // In the handler itself
 err := template.Execute(w, "sometemplate.html", map[string]interface{}{
        "user": GetUser(r),
        "someotherdata": someStructWithData,
        }


 // In your template...
 {{ if .User.admin }}{{ template "admin_menu" }}{{ end }}

It seems you cannot access the Request context from a template or a template helper function afterall (so I accepted the answer above). My solution was to create a Page struct that I pass as the context for every template. It contains the Content as a generic interface, the User object, as well as other useful parameters:

//Page holds the model to be rendered for every HTTP handler.
type Page struct {
     MetaTitle     string
     User          User
     HeaderStyles  string
     HeaderScripts string
     FooterScripts string
     Content       interface{}
 }

 func (pg *Page) Init(r *http.Request) {

    if pg.MetaTitle == "" {
        pg.MetaTitle = "This is the default <title> content for the page!"
    }

    user, _ := GetUserFromSession(r)
    pg.User = *user

    if user.IsAdmin() {
        pg.HeaderStyles += `<link href="/css/libs/summernote/summernote.css" rel="stylesheet">`
        pg.FooterScripts += `<script src="/js/libs/summernote/summernote.min.js"></script>`
    }

}

The Init method allows me to set defaults and use the Page struct more easily, by specifying only the Content for the page, if that's all I need:

package main

import (
    "html/template"
    "github.com/julienschmidt/httprouter"
)

func HomeHandler(w http.ResponseWriter, r *http.Request, p httprouter.Params) {

    var model = struct {
        CatalogPicks   []PromotionalModelList
        ClearanceItems []Model
    }{
        CatalogPicks:   GetCatalogPicks(),
        ClearanceItems: GetClearanceItems(),
    }

    pg := &Page{Content: model}
    pg.Init(r)
    ren.HTML(w, http.StatusOK, "home", pg)
}