本文是参考多篇 Golang 教程文章而组织出的入门教程，旨在帮助开发者快速上手 Golang。

参考文章：

  1. Go 语言数据类型
  2. Go 语言类型转换
  3. Go 语言变量
  4. Go 语言常量
  5. Go 语言函数
  6. Go 语言数组
  7. Go 系列教程 —— 11. 数组和切片
  8. Go 语言切片(Slice)
  9. Go 语言指针
  10. Go 语言结构体
  11. Go 语言Map(集合)
  12. golang 字符串
  13. golang import基础

数据类型

参考《Go 语言数据类型》、《Go 语言类型转换》等文章。

  1. 借助工具实现一些数据类型转换： ```go package main

import ( “fmt” “strconv” “strings” )

func main() { /**

  1.  * 字符串数组 -> 字符串
  2.  */
  3. ary := []string{"W", "J", "T"}
  4. fmt.Println(strings.Join(ary, ""))
  6. /**
  7.  * 数字 -> 字符串
  8.  */
  9. num := 10
  10. fmt.Println(strconv.Itoa(num) + " am") // 拼接一个字符串，表示数字已转换为字符串

}

  2. <a name="8ZwFW"></a>
  3. ## 语言变量与常量
  5. 参考《[Go 语言变量](http://codingdict.com/article/6750)》、《[Go 语言常量](http://codingdict.com/article/6751)》等文章。
  6. ```go
  7. // 这种不带声明格式的只能在函数体中出现
  8. g, h := 123, "hello"
  10. // 这种只能出现在全局变量中，函数体内不支持
  11. var (
  12.     a int
  13.     b bool
  14. )

函数

参考《Go 语言函数》一文。

数组

参考《Go 语言数组》、《Go 系列教程 —— 11. 数组和切片》、《Go 语言切片(Slice)》等文章。

  1. 基础操作： ```go package main

import “fmt”

func main() { var ary1 [5]int // 声明一个长度为5的int类型数组 var ary2 = []int{1, 2, 3, 4, 5} // 声明并初始化一个int类型数组，不用声明长度

  1. /**
  2.  * 指定长度但未初始化数组，以0填充之
  3.  */
  4. fmt.Println(ary1, ary2) // [0, 0, 0, 0, 0] [1, 2, 3, 4, 5]
  6. /**
  7.  * 使用for range遍历数组，输出:
  8.  * 0: 1
  9.  * 1: 2
  10.  * 2: 3
  11.  * 3: 4
  12.  * 4: 5
  13.  */
  14. for index, item := range ary2 {
  15.     fmt.Printf("%d: %d\n", index, item)
  16. }

}

  2. 2. 切片：
  3. ```go
  4. package main
  6. import "fmt"
  8. func main() {
  9.     var slice1 []string // 定义切片
  11.     /**
  12.      * 切片未初始化前等于nil，长度为0
  13.      */
  14.     fmt.Println(slice1, slice1 == nil) // [] true
  16.     strAry := []string{"A", "B", "C", "D", "E", "F"} // 数组
  17.     slice1 = strAry[1:3]                             // 切片: ["B", "C"]
  19.     /**
  20.      * len()获取切片当前长度;
  21.      * cap()获取切片可达到的最大长度;
  22.      */
  23.     fmt.Println(len(slice1), cap(slice1)) // 2 5
  25.     /**
  26.      * 使用append()往切片追加元素
  27.      */
  28.     slice1 = append(slice1, "G", "H")
  29.     fmt.Println(slice1) // ["B", "C", "G", "H"]
  31.     /**
  32.      * 使用copy()实现切片拷贝
  33.      */
  34.     slice2 := make([]string, len(slice1), cap(slice1)) // 使用make()创建切片
  35.     copy(slice2, slice1)
  36.     fmt.Println(slice2) // ["B", "C", "G", "H"]
  37. }
  1. 二维数组：
    1. ary := [][]string{
    2.  {"name Like", "%ABC%"},
    3. }

指针

参考《Go 语言指针》一文。

结构体

参考《Go 语言结构体》一文。

结构体与指针结合，可实现动态改变一个结构体变量的值。

集合

参考《Go 语言Map(集合)》一文。

  1. package main
  3. import "fmt"
  5. func main() {
  6.     /**
  7.      * 集合的初始化
  8.      */
  9.     map1 := make(map[string]string)
  10.     map1["uuid"] = "aceghopljs1"
  11.     map1["userName"] = "WJT"
  13.     /**
  14.      * 遍历集合，输出:
  15.      * uuid: aceghopljs1
  16.      * userName: WJT
  17.      */
  18.     for key := range map1 {
  19.         fmt.Printf("%s: %s\n", key, map1[key])
  20.     }
  22.     /**
  23.      * 删除map中的一个键值对
  24.      */
  25.     delete(map1, "userName")
  26.     fmt.Println(map1["userName"]) // ""
  27. }

字符串操作

参考《golang 字符串》一文。

包

参考《golang import基础》一文。

Golang 支持通过相对路径、绝对路径的形式导入指定位置的包：

  1. import "./model"  // 当前文件同一目录的model目录，但是不建议这种方式import
  2. import "shorturl/model"  // 加载GOPATH/src/shorturl/model模块

import 的同时，还能对引入的包进行以下操作：

  1. // 点操作，导入该包后，调用其中的api，可以省略前缀的书写
  2. import(. "fmt")
  4. // 别名操作，给引入的包重新定义一个名字，主要避免变量污染问题
  5. import(baseModel "locusts-go-server/model")
  7. // _操作，仅仅执行其中的init()函数，而无视包的内容
  8. import(_ "github.com/jinzhu/gorm/dialects/mysql")