资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划，从策略到执行的一站式服务

网站建设 >

查看其它板块

Go中基础模板怎么用-创新互联

这篇文章将为大家详细讲解有关Go中基础模板怎么用，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。

创新互联公司长期为近千家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为长汀企业提供专业的网站制作、成都做网站，长汀网站改版等技术服务。拥有十年丰富建站经验和众多成功案例,为您定制开发。

1、html/template创建基础静态模板

package main
import(
    "html/template"
    "log"
    "os"
)
func main(){
    tmpl,err := template.New("go-web").Parse(`Hello World!`)//先创建一个template对象
    if err != nil {
        log.Fatalf("Parse:%v",err)//fatalf格式化字符串，打印错误
    }
    err = tmpl.Execute(os.Stdout,nil) //调用方法Execute，两个参数：目的地，data先等于nil
    if err != nil{
        log.Fatal("Execute: %v", err)
    }
}
go run test.go 输出：
Hello World!

2、输出动态模板

package main
import(
    "html/template"
    "log"
    "os"
)
func main(){
    tmpl,err := template.New("go-web").Parse(`Hello World!,{{.}}`)//先创建能够根据输入数据的不同，产生不同的效果的动态模板{{}}, “.”代表跟对象“go web”
    if err != nil {
        log.Fatalf("Parse:%v",err)//fatalf格式化字符串，打印错误
    }
    err = tmpl.Execute(os.Stdout,"go web") //调用方法Execute，两个参数：目的地，data先等于go web,此时跟对象的值是 go web
    if err != nil{
        log.Fatal("Execute: %v", err)
    }
}
go run test.go 输出：
Hello World!,go web

package main
import(
    "html/template"
    "log"
    "os"
)
type Package struct {//自定义的传入类型Package
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    tmpl,err := template.New("go-web").Parse(`Hello World!,{{.}}`)//先创建能够根据输入数据的不同，产生不同的效果的动态模板{{}}, .代表跟对象
    if err != nil {
        log.Fatalf("Parse:%v",err)//fatalf格式化字符串，打印错误
    }
    err = tmpl.Execute(os.Stdout,&Package{ //自定义的传入类型Package
        Name :"go-web",
        NumFuncs:12,
        NumVars:1200,

    }) //调用方法Execute，两个参数：目的地，data先等于go web,此时跟对象的值是 go web
    if err != nil{
        log.Fatal("Execute: %v", err)
    }
}
go run test.go 输出：
Hello World!,{go-web 12 1200}

如何将模板渲染的结果输出到stdout呢？
package main
import(
    "html/template"
    "log"
    "os"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    tmpl,err := template.New("go-web").Parse(` 
        Package name: {{.Name}}  //通过反射寻找方法，字段或者函数，Name必须公开，必须首字母大写，
        Number of functions: {{.NumFuncs}} 
        Number of variables: {{.NumVars}}
        `)//先创建能够根据输入数据的不同，产生不同的效果的动态模板{{}}, .代表跟对象
    if err != nil {
        log.Fatalf("Parse:%v",err)//fatalf格式化字符串，打印错误
    }
    err = tmpl.Execute(os.Stdout,&Package{
        Name :"go-web",
        NumFuncs:12,
        NumVars:1200,

    }) //调用方法Execute，两个参数：目的地，data先等于go web,此时跟对象的值是 go web
    if err != nil{
        log.Fatal("Execute: %v", err)
    }
}
go run test.go 输出：
        Package name: go-web
        Number of functions: 12 
        Number of variables: 1200

3、模板结果输出到http响应流，通过浏览器访问

package main
import(
    "html/template"
    "log"
    "net/http"
    "fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.New("go-web").Parse(`
        Package name: {{.Name}}
        Number of functions: {{.NumFuncs}} 
        Number of variables: {{.NumVars}}
        `)//先创建能够根据输入数据的不同，产生不同的效果的动态模板{{}}, .代表跟对象
        if err != nil {
            fmt.Fprintf(writer,"Parse:%v",err)
            return
        }
        err = tmpl.Execute(writer,&Package{
            Name :"go-web",
            NumFuncs:12,
            NumVars:1200,

        }) //调用方法Execute，两个参数：目的地，data先等于go web,此时跟对象的值是 go web
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 10:38:40 Starting Server....

浏览器访问：http://localhost:4000/
Go中基础模板怎么用

4、从文件中读取模板的方法

package main
import(
    "html/template"
    "log"
    "net/http"
    "fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.tmpl")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        err = tmpl.Execute(writer,&Package{
            Name :"go-web",
            NumFuncs:14,
            NumVars:1200,

        }) //调用方法Execute，两个参数：目的地，data先等于go web,此时跟对象的值是 go web
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
然后编辑本地main.tmpl文件：
➜  test pwd
/Users/daixuan/qbox/test
➜  test vim main.tmpl
Package name: {{.Name}}
Number of functions: {{.NumFuncs}}
Number of variables: {{.NumVars}}
go run test.go 输出：
2018/07/10 10:52:56 Starting Server....

浏览器访问：http://localhost:4000/
Go中基础模板怎么用

5、http.request 如何使用模板打印出结构中我们所需要的内容

➜  test vim main.tmpl
Method: {{.Method}}

package main
import(
    "html/template"
    "log"
    "net/http"
    "fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.tmpl")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        err = tmpl.Execute(writer,request) //调用方法Execute，两个参数：目的地，data先等于go web,此时跟对象的值是 go web
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 11:01:28 Starting Server....

浏览器访问：http://localhost:4000/ 打印出了Method：GET
Go中基础模板怎么用

修改main.tmpl
Method: {{.Method}}
URL: {{.URL.Path}}

浏览器访问：http://localhost:4000/ 打印出Path: /
Go中基础模板怎么用

打印User-Agent

修改main.tmpl
Method: {{.Method}}
Path: {{.URL.Path}}
Header: {{.Header.Get "User-Agent"}}

package main
import(
    "html/template"
    "log"
    "net/http"
    "fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.tmpl")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        err = tmpl.Execute(writer,request) //调用方法Execute，两个参数：目的地，data先等于go web,此时跟对象的值是 go web
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 11:10:01 Starting Server....

浏览器访问：http://localhost:4000/
Go中基础模板怎么用

6、创建一个真正的html页面

vim main.html


    Go Web

    
    
Package info:

    
  • Package name: {{.Name}}}
    • 
    
  • Number of functions:{{.NumFuncs}}}
    • 
    
  • Number of variables: {{.NumVars}}}
    • 
    


package main
import(
    "html/template"
    "log"
    "net/http"
    "fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.html")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        err = tmpl.Execute(writer,&Package{
            Name :"go-web",
            NumFuncs:14,
            NumVars:1200,

        })
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 11:24:51 Starting Server....

    浏览器访问：http://localhost:4000/
    Go中基础模板怎么用
    右键查看网页源代码：view-source:http://localhost:4000/

    

    Go Web

    
    
    Package info:
    
    
  • Package name: go-web}
    • 
    
  • Number of functions:14}
    • 
    
  • Number of variables: 1200}
    • 
    

    7、简单应用，根据成绩判断成绩等级是A，B，C.....

    首先完成从请求参数中获取成绩score的大小
vim main.html


    Go Web

    
        {{.}}
    


package main
import(
    "html/template"
    "log"
    "net/http"
    "fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.html")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        score := request.FormValue("score")
        err = tmpl.Execute(writer,score)
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 11:33:01 Starting Server....

    访问：http://localhost:4000/?score=100
    输出100
    访问：http://localhost:4000/?score=1
    输出1
    符合预期

    判断score是否存在

    vim main.html


    Go Web

    
        {{if .}}
                score is {{.}}
        {{else}}
                no score
        {{end}}
    


vim test.go
package main
import(
"html/template"
"log"
"net/http"
"fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.html")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        score := request.FormValue("score")
        err = tmpl.Execute(writer,score)
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 11:38:10 Starting Server....

    访问：http://localhost:4000/?score=100
    Go中基础模板怎么用
    访问：http://localhost:4000/
    Go中基础模板怎么用

    对数值进行比较

    vim main.html


    Go Web

    
        {{if gt . 90}}
                A
        {{else if gt . 80}}
                B
        {{else if gt . 70}}
                C
        {{else if gt . 60}}
                D
        {{else}}
                F
        {{end}}
    

报错：Execute:template: main.html:6:13: executing "main.html" at : error calling gt: incompatible types for comparison
原因是request.FormValue("score")返回的是string类型，不能与int型90比较
修改返回类型
vim test.go
package main
import(
"html/template"
"log"
"net/http"
"fmt"
"strconv"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.html")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        score := request.FormValue("score")
        num, _ := strconv.Atoi(score)
        err = tmpl.Execute(writer,num)
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 11:53:59 Starting Server....

    访问：http://localhost:4000/?score=100 输出A
    Go中基础模板怎么用
    http://localhost:4000/?score=80 输出C
    http://localhost:4000/?score=60 输出F

    8、range改变作用域

    vim main.html


    Go Web

    
        {{range $key,$value := .Header}}
        
    
                    Method: {{$.Method}}
            key: {{$key}}
        
    
        
    
            {{range $value}}
            
  • {{.}}
    • 
            {{end}}
        
    
        {{end}}
    


vim test.go
package main
import(
"html/template"
"log"
"net/http"
"fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.html")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        err = tmpl.Execute(writer,request)
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 12:14:13 Starting Server....

    http://localhost:4000/
    Go中基础模板怎么用

    9、with改变作用域

    
    
        Go Web
    
    
        {{with .URL}}
            {{.}}
            {{.Scheme}}
            {{.User}}
            {{.Host}}
            {{.Path}}
            {{end}}
    


package main
import(
"html/template"
"log"
"net/http"
"fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.html")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        err = tmpl.Execute(writer,request)
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：

    访问：http://localhost:4000/1234?score=80 输出：
    /1234?score=80 /1234

    10、with改变作用域

    web中想临时输出一些字符串，字段，怎么办？
    维护一个大的结构不方便
    将跟对象变成一个key类型为string，值类型为空接口的map，再在map中放入需要传入的所有对象，除此之外，还有一个好处，就是可以把map申明为一个变量，在不同的 Handler中进行传递，在最后响应的这个Handler之前，不断的将map中添加新的内容，最终模板渲染的时候，就可以使用到所有的内容

    
    
        Go Web
    
    
        {{.Request}}
        {{.Score}}
    


package main
import(
"html/template"
"log"
"net/http"
"fmt"
)
type Package struct {
    Name string
    NumFuncs int
    NumVars int
}
func main(){
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        tmpl,err := template.ParseFiles("main.html")
        if err != nil {
            fmt.Fprintf(writer,"ParseFiles:%v",err)
            return
        }
        err = tmpl.Execute(writer,map[string]interface{}{
            "Request": request,
            "Score": 97,
        })
        if err != nil{
            fmt.Fprintf(writer,"Execute:%v",err)
            return
        }
    })
    log.Println("Starting Server....")
    log.Fatal(http.ListenAndServe(":4000",nil))
}
go run test.go 输出：
2018/07/10 12:29:10 Starting Server....

    http://localhost:4000/ 输出score=97 和GET方法
    Go中基础模板怎么用

    关于“Go中基础模板怎么用”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。

    另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。


    当前题目：Go中基础模板怎么用-创新互联
    新闻来源：http://cdkjz.cn/article/dcdsos.html
    返回首页 了解更多建站资讯

    相关资讯

    多年建站经验

    多一份参考，总有益处

    联系快上网，免费获得专属《策划方案》及报价

    咨询相关问题或预约面谈，可以通过以下方式与我们联系

    业务热线：400-028-6601 / 大客户专线   成都：13518219792   座机：028-86922220

    在线咨询 提交需求
    友情链接 交换友情链接
    发电机组维修保养南充网站制作网站搜索引擎优化江安网站建设SSL证书云主机光华机房服务器托管服务器托管崇州湖霆科技成都网站维护公司

    成都网站建设公司地址：成都市青羊区太升南路288号锦天国际A座10层 建设咨询400-028-6601

    成都快上网科技有限公司-四川网站建设设计公司 | 蜀ICP备19037934号 Copyright 2020,ALL Rights Reserved cdkjz.cn | 成都网站建设 | © Copyright 2020版权所有.

    专家团队为您提供成都网站建设,成都网站设计,成都品牌网站设计,成都营销型网站制作等服务,成都建网站就找快上网！ | 成都网站建设哪家好？ | 网站建设地图