golang中type關鍵字使用

type關鍵字使用

type是go語法里的重要而且常用的關鍵字，type絕不只是對應於C/C++中的typedef。搞清楚type的使用，就容易理解go語言中的核心概念struct、interface、函數等的使用。以下我用例子代碼總結描述，請特別留意代碼中的注釋。

1、定義結構體

//結構體定義
type person struct {
   name string //注意后面不能有逗號
   age  int
}

func main() {
   //結構體初始化
   p := person{
      name: "taozs", //注意后面要加逗號
      age:  18, //或者下面的}提到這兒來可以省略逗號
   }

   fmt.Println(p.name)
}

//初始化字段不一定要全部指定，比如下面也是可以的，name默認取長度為0的空字符串
p := person{
   age: 18,
}

 

2、類型等價定義，相當於類型重命名

type name string
name類型與string等價

例子：
type name string

func main() {
   var myname name = "taozs" //其實就是字符串類型
   l := []byte(myname) //字符串轉字節數組
   fmt.Println(len(l)) //字節長度
}

不過，要注意的是，type絕不只是用於定義一系列的別名。還可以針對新類型定義方法。
上面的name類型可以像下面這樣定義方法：

type name string

func (n name) len() int {
   return len(n)
}

func main() {
   var myname name = "taozs" //其實就是字符串類型
   l := []byte(myname) //字符串轉字節數組
   fmt.Println(len(l)) //字節長度
   fmt.Println(myname.len()) //調用對象的方法
}

 

3、結構體內嵌匿名成員

//結構體內嵌匿名成員定義
type person struct {
   string //直接寫類型，匿名
   age int
}

func main() {
   //結構體匿名成員初始化
   p := person{string: "taozs", age: 18}//可以省略部分字段，如：person{string: "taozs"}。也可以這樣省略字段名：person{“taozs”, 18}，但必須寫全了，不可以省略部分字段
   //結構體匿名成員訪問
   fmt.Println(p.string) //注意不能用強制類型轉換（類型斷言）：p.(string)
}

以下是只有單個匿名成員的例子。
//結構體內嵌匿名成員定義
type person struct {
   string
}

func main() {
   //結構體匿名成員初始化
   p := person{string: "taozs"} //也可這樣：person{"taozs"}
   //結構體匿名成員訪問
   fmt.Println(p.string) //注意不能用強制類型轉換（類型斷言）：p.(string)
}

 

4、定義接口類型

package main

import (
   "fmt"
)

//接口定義
type Personer interface {
   Run()
   Name() string
}

//實現接口，注意實現接口的不一定只是結構體，也可以是函數對象，參見下面第5條
type person struct {
   name string
   age  int
}

func (person) Run() {
   fmt.Println("running...")
}

//接收參數person不可以是指針類型，否則不認為是實現了接口
func (p person) Name() string {
   return p.name
}

func main() {
//接口類型的變量定義
var p Personer
   fmt.Println(p) //值<nil>
   
   //實例化結構體，並賦值給interface
   p = person{"taozs", 18} //或者：&person{"taozs", 18}
   p.Run()
   fmt.Println(p.Name())
   
   var p2 person = p.(person) //類型斷言，接口類型斷言到具體類型
   fmt.Println(p2.age)
}

//另外，類型斷言返回值也可以有第二個bool值，表示斷言是否成功，如下：
if p2, ok := p.(person); ok {//斷言成功ok值為true
   fmt.Println(ok)
   fmt.Println(p2.age)
}

 

 

5、定義函數類型

 

//以下是定義一個函數類型handler
type handler func (name string) int

//針對這個函數類型可以再定義方法，如：
func (h handler) add(name string) int {
   return h(name) + 10
}

 

 

 

//下面讓我們詳細看一下例子，其中涉及了函數、函數的方法、結構體方法、接口的使用。

package main

import (
    "fmt"
)

//定義接口
type adder interface {
    add(string) int
}

//定義函數類型
type handler func (name string) int

//實現函數類型方法
func (h handler) add(name string) int {
    return h(name) + 10
}

//函數參數類型接受實現了adder接口的對象（函數或結構體）
func process(a adder) {
    fmt.Println("process:", a.add("taozs"))
}

//另一個函數定義
func doubler(name string) int {
    return len(name) * 2
}

//非函數類型
type myint int

//實現了adder接口
func (i myint) add(name string) int {
    return len(name) + int(i)
}

func main() {
    //注意要成為函數對象必須顯式定義handler類型
    var my handler = func (name string) int {
        return len(name)
    }

    //以下是函數或函數方法的調用
    fmt.Println(my("taozs"))                   //調用函數

    fmt.Println(my.add("taozs")) //調用函數對象的方法

    fmt.Println(handler(doubler).add("taozs")) //doubler函數顯式轉換成handler函數對象然后調用對象的add方法
    //
    ////以下是針對接口adder的調用
    process(my) //process函數需要adder接口類型參數
    //
    process(handler(doubler)) //因為process接受的參數類型是handler，所以這兒要強制轉換
    //
    process(myint(8)) //實現adder接口不僅可以是函數也可以是結構體
}

 

 

熟悉了上面type的各種用法，現在來一起分析下http包里面的HandleFunc    type func() 用法分析

在看golang 的http服務部分代碼時，被golang 中的 type func()寫法難住了，一時沒看懂代碼。后來查資料后，有了一點理解。
在golang中可以通過這樣簡單實現一個http服務

package main

import "net/http"

func mHttp() {
    http.HandleFunc("/", h)
    http.ListenAndServe("0.0.0.0:8888",nil)
}
func h(w http.ResponseWriter, r *http.Request) {

}

 

http.HandleFunc()是一個注冊函數，傳一個string類型的路由，和一個函數，函數的參數為(http.ResponseWriter, *http.Request)。跟蹤進入函數，在golang 源碼net/http/server.go文件中

func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

 

在HandleFunc調用了DefaultServeMux.HandleFunc(pattern, handler)
至於這些函數是干啥的先不做探討，這不是本文的重點。
再次跟進函數

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    if handler == nil {
        panic("http: nil handler")
    }
    mux.Handle(pattern, HandlerFunc(handler))
}

 

在mux.Handle(pattern, HandlerFunc(handler)) 的第二個參數HandlerFunc(handler)是什么鬼。
跟進看一下

type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

 

原來HandlerFunc 是用 type 定義的函數，而函數的類型就是最開始傳入的類型func(ResponseWriter, *Request)
ServeHTTP是HandlerFunc的一個方法（注意一下，golang中方法和函數不是一回事）。並且HandlerFunc實現了 Handler接口
Handler接口定義:

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

 

回到HandleFunc方法中，mux.Handle(pattern, HandlerFunc(handler))的第二個參數是把傳入的函數 handler 強轉成 HandlerFunc類型，這樣handler就實現了Handler接口。
到這我們明白HandlerFunc(handler) 是把普通函數強轉成type定義的函數。
現在寫一個簡單的demo驗證一下：

package main

import "fmt"

func main() {
   one(2, callback)
}

//需要傳遞函數
func callback(i int) {
   fmt.Println("i am callBack")
   fmt.Println(i)
}

//main中調用的函數
func one(i int, f func(int)) {
   two(i, fun(f))
}

//one()中調用的函數
func two(i int, c Call) {
   c.call(i)
}

//定義的type函數
type fun func(int)

//fun實現的Call接口的call()函數
func (f fun) call(i int) {
   f(i)
}

//接口
type Call interface {
   call(int)
}

 

先看一下程序的運行結果:

 

 

我們在main()函數中調用了one()函數，並傳入了callback()函數，最終調用了我們傳入的callback()函數。

 

理一下思路：

使用type定義函數 func(int)
定義 Call 接口，Call中有一個函數 call(int)
在main()中調用one(2, callback)，在one()中調用two()，傳入two()函數前，對callback函數實現了類型轉換，從普通函數轉換成type定義的函數。
在 two() 中調用傳入的 c 因為 c 實現了 Call 接口，所以可以調用 call() 函數，最終調用了我們傳入的 callback() 函數。