Go一小时入门

第一个Go程序，仍然从hello world开始！

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

也像Java也像C，有package来做包管理，import来导入类库（包），main是入口函数。

• 第一行代码 package main 定义了包名。package main表示一个可独立执行的程序，每个Go应用程序都包含一个名为main的包；
• import "fmt" 告诉Go编译器这个程序需要使用fmt包；
• func main() 是程序开始执行的函数，即入口函数；
• 当标识符（包括常量、变量、类型、函数名、结构字段等）以一个大写字母开头，那么使用这种形式的标识符对象就可以被外部包的代码所使用，这被称为导出（类似OOP中的public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（类似于OOP中的protected ）。
• 一行代表一个语句结束，每个语句不需要以分号;结尾

Go语言标识符、关键字、保留字、注释与C语言类似，不再赘述。

Go使用var来声明变量，变量类型放在后面，例如：

var age int

一次可以声明多个变量，例如：

var a, b int = 1, 2

声明变量可以省略var，使用:=声明符（初始化声明）。但要注意省略 var， := 左侧如果没有声明新的变量，就产生编译错误。例如：

var intValue int
intValue := 1 //这时候会产生编译错误
intValue, intValue1 := 1, 2 //此时不会产生编译错误，因为有新的变量声明， := 是一个声明语句
可以将

var f string = "test"
简写为

 f := "test"

因为Go可以根据值自行判定变量类型，可以在变量初始化时省略变量的类型而由系统自动推断。

与c语言类似，Go也使用指针，&符号返回变量的地址，*符号声明指针变量。

Go的条件判断语句同样有if else和switch，if语句没有什么特别之处，switch语句倒是有很大不同。 Go 编程语言中 if 语句的语法如下：

if 布尔表达式 {
}

if 布尔表达式 {
} else {
}

Go 编程语言中 switch 语句的语法如下：

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

• 变量var1可以是任何类型，而val1和val2则可以是同类型的任意值。
• 类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
• 多个可能符合条件的值，使用逗号分割。不同的case之间不需要使用break分隔。
• switch语句还有一个fallthrough特性。使用fallthrough会强制执行后面的一条case语句，fallthrough不会判断下一条 case的表达式结果是否为true，直接执行。
• Go语言还有一个特殊的控制结构，select语句，与switch语句有些类似。每个case 必须是一个通信操作，要么是发送要么是接收。select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

Go 编程语言中 select 语句的语法如下：

select {
    case 通信操作 :
       执行语句;
    case 通信操作  :
       执行语句;
    ...
    default :
       执行语句;
}

在讲循环语句之前先说一下Range关键字。Go语言中range关键字用于for循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回key-value对的key值。

Go 语言没有while和do…while语法，可以通过for 循环来实现其使用效果。Go语言的For循环有3种形式：

• 和 C 语言的 for 一样：for init; condition; post { }
• 和 C 语言的 while 一样：for condition { }
• 和 C 语言的 for(;;) 一样：for { }

循环控制语句有break, continue, goto。goto语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。但是，在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。 for循环的range格式可以对slice、map、数组、字符串等进行迭代循环。

for key, value := range aMap {
    newMap[key] = value
}

Go语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {
    函数体
}

Go函数可以有多个返回值，这是Go的一大特点。如下例所示：

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}

Go与C一样，参数传递方式有值传递和引用传递。默认情况下，Go语言使用的是值传递，即在调用过程中不会影响到实际参数。 Go的函数定义后可作为另外一个函数的实参数传入，Go语言可以很灵活的创建函数，并作为另外一个函数的实参。函数作为参数传递，实现回调，如下例所示：

package main
import "fmt"

// 声明一个函数类型
type cb func(int) int

func main() {
    testCallBack(1, callBack)
    testCallBack(2, func(x int) int {
        fmt.Printf("call back，x：%d\n", x)
        return x
    })
}

func testCallBack(x int, f cb) {
    f(x)
}

func callBack(x int) int {
    fmt.Printf("call back，x：%d\n", x)
    return x
}

Go语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必声明。 Go语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。语法格式如下：

func (variable_name variable_data_type) function_name() [return_type] {
   /* 方法体 */
}

Go 语言中变量可以在三个地方声明：

• 函数内定义的变量称为局部变量；
• 在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用；
• 函数定义中的变量称为形式参数；

Go 语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑。

Go语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

初始化数组：

var balance = [6]float32{100.0, 2.1, 3.4, 7.6, 30.2, 8.9}

Go语言切片实际上就是动态数组。与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。 你可以声明一个未指定大小的数组来定义切片：

var sliceA []type

切片不需要说明长度。或使用make()函数来创建切片。也可以指定容量，其中capacity为可选参数。

make([]T, length, capacity)

切片提供了计算容量的方法cap()可以测量切片最长可以达到多少。一个切片在未初始化之前默认为nil，长度为0。

Go语言的空值为nil，在概念上和其它语言的null、None、NULL一样。

Go语言的结构体与C语言类似，结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体有中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

如果要访问结构体成员，需要使用点号"."操作符，使用结构体指针访问结构体成员，同样使用 "." 操作符。

Key/value的键值对,可以使用内建函数 make ,也可以使用map关键字来定义Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go语言类型转换基本格式如下：

type_name(expression)

type_name为类型，expression为表达式。

Go语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

type interface_name interface {
   method1 [return_type]
   method2 [return_type]
   method3 [return_type]
   ...
   methodN [return_type]
}

Go语言通过内置的错误接口提供了非常简单的错误处理机制。error类型是一个接口类型，这是它的定义：

type error interface {
    Error() string
}

我们可以在编码中通过实现error接口类型来生成错误信息。函数通常在最后的返回值中返回错误信息，使用errors.New 可返回一个错误信息。 此外，panic与recover是Go的两个内置函数，这两个内置函数用于处理Go运行时的错误，panic用于主动抛出错误，recover用来捕获panic抛出的错误。还有一个defer语句，其目的类似于Java的finally，在当前函数的末尾执行一些清理代码，而不管此函数如何退出。defer的有趣之处在于它跟代码块没有联系，可以随时出现。

Go语言支持并发，我们只需要通过go关键字来开启goroutine即可。goroutine是轻量级线程，goroutine的调度是由Golang运行时进行管理的。goroutine语法格式：

go 函数名( 参数列表 )

同一个程序中的所有goroutine共享同一个地址空间。goroutine是golang中在语言级别实现的轻量级线程，仅仅利用go就能立刻起一个新线程。

通道（channel）是用来传递数据的一个数据结构。通道可用于两个goroutine之间通过传递一个指定类型的值来同步运行和通讯。操作符<- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

ch <- v    // 把v发送到通道ch
v := <-ch  // 从ch接收数据, 并把值赋给v
声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建。

ch := make(chan int)

$ go get -u github.com/gin-gonic/gin</p>

import "github.com/gin-gonic/gin"

使用gin需要Go的版本号为1.6或更高。

下面我们就通过一个简单的例子来快速入门Gin。

package main

import "github.com/gin-gonic/gin"

func main() {
    router := gin.Default()
    router.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    router.Run() // listening on 0.0.0.0:8080
}

运行这段代码并在浏览器中访问 http://localhost:8080。

可以使用 GET, POST, PUT, PATCH, DELETE, OPTIONS等方法。

获取路径中的参数： #+END_SRC router.GET("user:name", func(c *gin.Context) { name := c.Param("name") c.String(http.StatusOK, "Hello %s", name) }) #+END_SRC

获取Get参数：

firstname := c.DefaultQuery("firstname", "Guest")
lastname := c.Query("lastname")

获取Post参数：

message := c.PostForm("message")
nick := c.DefaultPostForm("nick", "anonymous")

使用Group方法进行路由分组：

v1 := router.Group("/v1")
v2 := router.Group("/v2")

可以使用在全局上，也可以使用在分组上。

若要将请求主体绑定到结构体中，请使用模型绑定，目前支持JSON、XML、YAML和标准表单值(foo=bar&boo=baz)的绑定。需要在绑定的字段上设置tag，比如，绑定格式为json，需要这样设置 json:"fieldname" 。当我们使用绑定方法时，Gin会根据Content-Type推断出使用哪种绑定器，如果你确定你绑定的是什么，你可以使用MustBindWith或者BindingWith。下面以绑定JSON类型为例：

// 绑定为json
type Login struct {
    User     string `json:"user" binding:"required"`
    Password string `json:"password" binding:"required"`
}

func main() {
    router := gin.Default()

    // Example for binding JSON ({"user": "test", "password": "123"})
    router.POST("/login", func(c *gin.Context) {
        var json Login
        if err := c.ShouldBindJSON(&json); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        if json.User != "test" || json.Password != "123" {
            c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
            return
        }

        c.JSON(http.StatusOK, gin.H{"status": "Login successfully!"})
    })
}

关于Gin就讲这么多，够用了，想了解更加详细的内容，请访问Gin的官方网站。

查询单条数据使用Get方法，在调用Get方法时需要传入一个对应结构体的指针，同时结构体中的非空field自动成为查询的条件和前面的方法条件组合在一起查询。 根据Id来获得单条数据:

a:=&Account{}
has, err := x.Id(id).Get(a)

根据where获取单条数据：

a := new(Account)
has, err := x.Where("name=?", "admin").Get(a)

返回的结果为两个参数，一个has(bool类型)为该条记录是否存在，第二个参数err为是否有错误。不管err是否为nil，has都有可能为true或者false。

批量获取数据

err = x.Desc("balance").Find(&as)

Find方法的第一个参数为slice的指针或Map指针，即为查询后返回的结果，第二个参数可选，为查询的条件struct的指针。

// 创建 Session 对象
sess := x.NewSession()
defer sess.Close()// 开启事务
if err = sess.Begin(); err != nil {
    return err
}

if _, err = sess.Update(a1); err != nil {    // 发生错误时进行回滚
    sess.Rollback()
    return err
}

// 完成事务
return sess.Commit()