Go編程基礎5-基礎模板用法

時間  2019-11-09
標籤 編程 基礎 模板 用法 简体版
原文   原文鏈接

一、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!

二、輸出動態模板

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

三、模板結果輸出到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-基礎模板用法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.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-基礎模板用法web

五、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-基礎模板用法vim

打印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-基礎模板用法ide

六、建立一個真正的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>

七、簡單應用，根據成績判斷成績等級是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
符合預期code

判斷score是否存在orm

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

對數值進行比較

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

八、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-基礎模板用法

九、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

十、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-基礎模板用法

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程