Go编程基础5-基础模板用法

最新推荐文章于 2024-05-20 13:36:47 发布
最新推荐文章于 2024-05-20 13:36:47 发布
阅读量275 收藏
点赞数
原文链接：http://blog.51cto.com/daixuan/2139701
版权

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编程基础5-基础模板用法

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-基础模板用法

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编程基础5-基础模板用法

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

浏览器访问：http://localhost:4000/ 打印出Path: /
Go编程基础5-基础模板用法

打印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编程基础5-基础模板用法

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

vim main.html
<html>
<head>
    <title>Go Web</title>
</head>
    <body>
    <p>Package info:</p>
    <li>Package name: {{.Name}}}</li>
    <li>Number of functions:{{.NumFuncs}}}</li>
    <li>Number of variables: {{.NumVars}}}</li>
    </body>
</html>

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编程基础5-基础模板用法
右键查看网页源代码：view-source:http://localhost:4000/

<html>
<head>
    <title>Go Web</title>
</head>
    <body>
    <p>Package info:</p>
    <li>Package name: go-web}</li>
    <li>Number of functions:14}</li>
    <li>Number of variables: 1200}</li>
    </body>
</html>

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

首先完成从请求参数中获取成绩score的大小
vim main.html
<html>
<head>
    <title>Go Web</title>
</head>
    <body>
        {{.}}
    </body>
</html>

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
<html>
<head>
    <title>Go Web</title>
</head>
    <body>
        {{if .}}
                score is {{.}}
        {{else}}
                no score
        {{end}}
    </body>
</html>

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编程基础5-基础模板用法
访问：http://localhost:4000/
Go编程基础5-基础模板用法

对数值进行比较

vim main.html
<html>
<head>
    <title>Go Web</title>
</head>
    <body>
        {{if gt . 90}}
                A
        {{else if gt . 80}}
                B
        {{else if gt . 70}}
                C
        {{else if gt . 60}}
                D
        {{else}}
                F
        {{end}}
    </body>
</html>
报错：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编程基础5-基础模板用法
http://localhost:4000/?score=80 输出C
http://localhost:4000/?score=60 输出F

8、range改变作用域

vim main.html
<html>
<head>
    <title>Go Web</title>
</head>
    <body>
        {{range $key,$value := .Header}}
        <p>
                    Method: {{$.Method}}
            key: {{$key}}
        </p>
        <p>
            {{range $value}}
            <li>{{.}}</li>
            {{end}}
        </p>
        {{end}}
    </body>
</html>

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编程基础5-基础模板用法

9、with改变作用域

<html>
    <head>
        <title>Go Web</title>
    </head>
    <body>
        {{with .URL}}
            {{.}}
            {{.Scheme}}
            {{.User}}
            {{.Host}}
            {{.Path}}
            {{end}}
    </body>
</html>

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 <nil> /1234

10、with改变作用域

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

<html>
    <head>
        <title>Go Web</title>
    </head>
    <body>
        {{.Request}}
        {{.Score}}
    </body>
</html>

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编程基础5-基础模板用法

转载于:https://blog.51cto.com/daixuan/2139701

weixin_33845881
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Docker（34）- 如何修改 docker 容器的目录映射
qq_33801641的博客
11-17 2595
如果你还想从头学起 Docker，可以看看这个系列的文章哦！ https://www.cnblogs.com/poloyy/category/1870863.html 问题背景 docker run -d -p 9999:8080 -i --name tomcat7 -v /usr/local/webapps:/usr/local/tomcat/webapps tomcat:7 ...
桫哥-GOlang基础-Go语言实战：多人聊天室（下）
06-12
在本课程"桫哥-GOlang基础-Go语言实战：多人聊天室（下）"中，我们将深入探讨如何使用Go语言构建一个支持多人实时交流的聊天室应用。这个项目不仅涵盖了Go语言的基础语法，还涉及到了网络编程、并发处理以及框架封装...
goland+solidty报错锦集
y943711797的博客
05-19 2700
本文已参与「新人创作礼」活动，一起开启掘金创作之路。 1、write tcp 127.0.0.1:8888->127.0.0.1:7861: wsasend: An established connection was aborted by the software in your host machine.(已建立的连接被您的主机中的软件终止。) 原因： 个人判断是以为数据库超时时...
奇妙的 Docker Inspect
p656456564545的专栏
05-30 7422
奇妙的 Docker Inspect 模版 88250 • 1 年前 • 浏览 1.3K • 评论 0  Translation  Inspect  Template  模版  Docker  golang  概述 很多 Docker 用户都知道 docker inspect 命令，该命令用于获取容器/镜像的元数据，其中 -f 参数可以用于获取指定的数据，例
golang html/template 模板内置函数FuncMap, 模板里面的比较运算 eq ne gt lt 与其相关的实现代码
最新发布
05-20 793
我们在使用go语言的模板的时候对于内置函数我们是可以直接在模板里面使用的， 如 html 他实际上是绑定的函数 func HTMLEscaper(args ...any) string。另外，如eq等于 ne不等于 gt大于 lt小于等 他们实际上也是一个个对应的。
golang内幕之for-range-value
QQ1130141391的专栏
07-20 271
func ForRangeValue_1() { var mapAges map[string]int mapAges = make(map[string]int) mapAges["name-1"] = 1 mapAges["name-2"] = 2 mapAges["name-3"] = 3 var newAges map[string]*int newAges = make...
桫哥-GOlang-11Linux基础
06-12
总的来说，"桫哥-GOlang-11Linux基础"是一门全面且深入的教程，不仅教授Go语言的基础和高级用法，还融入了Linux系统操作的知识，使学习者能够全面发展，成为既懂编程又熟悉系统操作的全栈工程师。通过该课程的学习，...
免费的编程书籍 free-programming-books.docx
01-31
- 提供了C++语言的进阶学习资源，涵盖了面向对象编程、模板、异常处理等主题。 - **Java**: - Java教程涵盖了从基础语法到高级特性的多个方面。 - **Python**: - Python教程不仅介绍了基本语法，还包括了网络编程...
Go-一个纯的GoLiquid模板引擎
08-13
Go语言，作为一种高效、简洁且具有现代特性的编程语言，被广泛用于开发各种应用程序，包括Web框架、API服务器以及各种工具。在Web开发领域，模板引擎是不可或缺的一部分，它允许开发者将逻辑代码与呈现给用户的HTML...
python基础教程：Django框架创建项目的方法入门教程
12-22
Python基础教程：Django框架创建项目的方法 Django是一个用Python编写的高级Web框架，它鼓励快速开发和干净、实用的设计。本教程将带你入门Django框架，介绍如何使用Django管理工具创建一个新的项目。 首先，确保...
奇妙的 Docker Inspect 模版
dyeee的专栏
09-03 391
docker inspect 简单地说， -f 的实参是个 Go 模版 下面让我们来进一步看看 Go 模版的奇妙之处，例如我们可以通过模版来查找所有退出码为非 0 的容器名： $ docker inspect -f '{{if ne 0.0 .State.ExitCode }}{{.Name}} {{.State.ExitCode}}{{ end }}' $(docker ps -aq) ...
helm upgrade install 提示语法报错问题解决
wanger5354的博客
01-09 2334
为什么需要helm？k8s上的应用对象都有特定的资源描述组成，包括deployment、service等。都保存各自文件中或者集中写到一个配置文件，然后执行kubectl apply -f 进行部署。如果应用只由一个或几个这样的服务组成，上面部署方式足够了。对于一个复杂的应用，会有很多类似上面的资源描述文件，例如微服务架构应用，组成应用的服务可能多达十个，几十个。如果有更新或回滚应用的需求，可能要修改和维护所涉及的大量资源文件，而这种组织和管理应用的方式就显得力不从心了。因此在这里我们线上的资源都是采用he
使用Golang模板拼sql(及校验)
big_cheng的博客
09-05 2536
目录1. 版权2. 基本实现3. push_arg4. v_text 文本校验5. p_status例子、is_nil6. v_int 整数校验7. 其他noprint分页8. 例子9. 讨论 1. 版权 本文为原创，遵循 CC 4.0 BY-SA 版权协议，转载需注明出处: https://blog.csdn.net/big_cheng/article/details/108422867. 2. 基本实现 在一个文件里使用Go模板语法, 一个模板定义一条sql, 如: {{define "list_use
Go的50坑：新Golang开发者要注意的陷阱、技巧和常见错误
print的博客
08-07 1520
Go是一门简单有趣的语言，但与其他语言类似，它会有一些技巧。这些技巧的绝大部分并不是Go的缺陷造成的。如果你以前使用的是其他语言，那么这其中的有些错误就是很自然的陷阱。其它的是由错误的假设和缺少细节造成的。 如果你花时间学习这门语言，阅读官方说明、wiki、邮件列表讨论、大量的优秀博文和Rob Pike的展示，以及源代码，这些技巧中的绝大多数都是显而易见的。尽管不是每个人都是以这种方式开始学习的，但也没关系。如果你是Go语言新人，那么这里的信息将会节约你大量的调试代码的时间。 目录 初级篇 开大括号不能
Go语言编程中文版：基础到高级全览
"《Go语言编程》中文版，这是一本详细介绍Go语言的书籍，包含高清版和书签，适合Go语言初学者和进阶者。" Go语言，由Google公司于2007年末发起，由Robert Griesemer、Rob Pike及Ken Thompson设计，于2009年11月正式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值