go后端学习开发-go语言入门指南Go 语言入门指南：基础语法和常用特性解析，主要讲述了go语言常见的数据类型，基础语法

1 基础语法学习

1 helloworld

第一步实现go语言的helloworld，需要导入fmt库，定义main()函数，调用println函数即可

package main
import (
	"fmt"
)
func main() {
	fmt.Println("hello world")
}

2 变量定义

变量采取var关键词定义常量采用const关键词定义

package main
import (
	"fmt"
	"math"
)
func main() {

	var a = "initial"

	var b, c int = 1, 2

	var d = true

	var e float64

	f := float32(e)

	g := a + "foo"
	fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
	fmt.Println(g)                // initialapple

	const s string = "constant"
	const h = 500000000
	const i = 3e20 / h
	fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}

3 for if switch语句

for 和if 语句都没有()包裹其余语法结构与java类似，switch语句注意go语言不需要break；

package main
import "fmt"
func main() {
//----------------------for----------------------
for n := 0; n < 5; n++ {
    if n%2 == 0 {
        continue
}
    fmt.Println(n)
}
//----------------------if----------------------
if 7%2 == 0 {
    fmt.Println("7 is even")
} else {
    fmt.Println("7 is odd")
}
//----------------------switch----------------------
a := 2
switch a {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    case 4, 5:
        fmt.Println("four or five")
    default:
        fmt.Println("other")
}
}

4 array slice map

数组（array）：主要从数组的定义和遍历两个角度来学习，定义可以通过var a [5]int 这种方式，或者b := [5]int{1, 2, 3, 4, 5}这种方式来定义，二维数组同理，遍历和其他语言一样，只要通过下标的遍历即可。
切片（slice）：类似于列表list，是可变数组，采用make关键词来定义s := make([]string, 3)，如果要在slice后面新增元素，则采取append， s = append(s, "d")，但是要注意，函数的返回值要继续赋值给s
表（map）：同样map由key和value两部分组成，采用make关键词来定义 m := make(map[string]int)，括号内的类型是键（key）的类型，后面是值（value）的类型，可以通过 r, ok := m["unknow"]表达式来判断map中有没有包含"unknow"这个key，如果有则该值传给r，如果没有ok=false，删除某一个键值对采取delete关键词。

package main
import "fmt"
func main() {
        //----------------------array----------------------
	var a [5]int
	a[4] = 100
	fmt.Println("get:", a[2])
	fmt.Println("len:", len(a))
	b := [5]int{1, 2, 3, 4, 5}
	fmt.Println(b)
	var twoD [2][3]int
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			twoD[i][j] = i + j
		}
	}
	fmt.Println("2d: ", twoD)
        //----------------------slice----------------------
        s := make([]string, 3)
	s[0] = "a"
	s[1] = "b"
	s[2] = "c"
	fmt.Println("get:", s[2])   // c
	fmt.Println("len:", len(s)) // 3

	s = append(s, "d")
	s = append(s, "e", "f")
	fmt.Println(s) // [a b c d e f]
        //----------------------map----------------------
        m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
	m["three"] = 3
	fmt.Println(m)           // map[one:1 two:2]
	fmt.Println(len(m))      // 2
	fmt.Println(m["one"])    // 1
	fmt.Println(m["unknow"]) // 0

	r, ok := m["unknow"]
	fmt.Println(r, ok) // 0 false

	delete(m, "one")

	m2 := map[string]int{"one": 1, "two": 2}
	var m3 = map[string]int{"one": 1, "two": 2}
	fmt.Println(m2, m3)
}

5 函数（func）

函数采用func定义，案例中定义了两个函数，add函数用来简单的计算两个数求和，exists函数用来判断map中是否包含键k，如果包含返回其对应的值和true，否则返回false，基本的函数比较简单，下一小节结合指针后略有难度。

package main

import "fmt"

func add(a int, b int) int {
	return a + b
}


func exists(m map[string]string, k string) (v string, ok bool) {
	v, ok = m[k]
	return v, ok
}

func main() {
	res := add(1, 2)
	fmt.Println(res) // 3
	v, ok := exists(map[string]string{"a": "A"}, "a")
	fmt.Println(v, ok) // A True
}

6 指针（point）

指针是为了保证在函数传参的过程时，传递的是这个变量的地址，而不是将这个变量的值传递给形参，比如add2函数，在参数传递的过程中，就会将参数赋值给形参n，实际参数的值并不会改变，改变的是形参n的值，而形参n在函数结束之后也就不存在了，所以是没有意义的。‘ 因此采取add2ptr这种形式，直接传递n的地址，这样就相当于直接对实参n的值进行改变，对原来的值就产生了影响。

package main
import "fmt"
func add2(n int) {
	n += 2
}
func add2ptr(n *int) {
	*n += 2
}
func main() {
	n := 5
	add2(n)
	fmt.Println(n) // 5
	add2ptr(&n)
	fmt.Println(n) // 7
}

7 结构体（struct）

结构体这个概念相当于java中的类，将多个不同类型的数据打包成一个整体，如案例中定义结构体user，包含两个属性 name和password 。给结构体初始化的方法有：

a := user{name: "wang", password: "1024"}
var d user d.name = "wang" d.password = "1024" 这两种方式都可以实现对结构体的初始化同时可以定义函数 checkpassword，将结构体作为参数传递，如checkPassword

package main

import "fmt"

type user struct {
	name     string
	password string
}

func main() {
	a := user{name: "wang", password: "1024"}
	b := user{"wang", "1024"}
	c := user{name: "wang"}
	c.password = "1024"
	var d user
	d.name = "wang"
	d.password = "1024"

	fmt.Println(a, b, c, d)                 // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
	fmt.Println(checkPassword(a, "haha"))   // false
}

func checkPassword(u user, password string) bool {
	return u.password == password
}

结构体的方法函数：类似于java中类的成员方法：定义方式如下所示，函数前加（u user）,注意如果是查询操作可以采用（u user）因为没有改变结构体的值，所以不会影响，但是如果涉及到修改操作，必须采用指针的形式（u *user），否则你改变的数据都是形参的值，对原来的结构体没有任何改变。

package main

import "fmt"

type user struct {
	name     string
	password string
}

func (u user) checkPassword(password string) bool {
	return u.password == password
}

func (u *user) resetPassword(password string) {
	u.password = password
}

func main() {
	a := user{name: "wang", password: "1024"}
	a.resetPassword("2048")
	a.resetPassword("1234")
	fmt.Println(a.checkPassword("2048")) // true
}

9 string

使用string相关的函数先导入strings库，下面是strings相关函数的分析

strings.Contains(a, "ll")：判断字符串a中是否包含字符串"ll"
strings.Count(a, "l"):计算字符串a中包含字符串"l"的次数
strings.HasPrefix(a, "he")：判断字符串a是否以"he"作为前缀
strings.HasSuffix(a, "llo")：判断字符串a是否以"llo"作为后缀
strings.Index(a, "ll")：判断字符串"ll"在字符串a中开始的索引位置
strings.Join([]string{"he", "llo"}, "-"）：将一个字符串数组拼接成一个字符串中间用"-"连接
strings.Repeat(a, 2)：将字符串a重复两次得到新的字符串
strings.Replace(a, "e", "E", -1)：将字符串a中的"e"替换成"E",参数-1表示替换范围为整个字符串
strings.Split("a-b-c", "-")：将字符串以"-"分开
strings.ToLower(a)：将字符串a中的英文字符都换成小写字母
strings.ToUpper(a)：将字符串a中的英文字符都换成大写字母
len(a):计算字符串的长度

package main

import (
	"fmt"
	"strings"
)

func main() {
	a := "hello"
	fmt.Println(strings.Contains(a, "ll"))                // true
	fmt.Println(strings.Count(a, "l"))                    // 2
	fmt.Println(strings.HasPrefix(a, "he"))               // true
	fmt.Println(strings.HasSuffix(a, "llo"))              // true
	fmt.Println(strings.Index(a, "ll"))                   // 2
	fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
	fmt.Println(strings.Repeat(a, 2))                     // hellohello
	fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
	fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
	fmt.Println(strings.ToLower(a))                       // hello
	fmt.Println(strings.ToUpper(a))                       // HELLO
	fmt.Println(len(a))                                   // 5
	b := "你好"
	fmt.Println(len(b)) // 6
}

10 fmt

主要是介绍fmt.Printf()函数，可以采取“s = %v\n”，利用%v实现占位操作，后面跟上参数即可，在输出结构体的时候有三种方式，按照先后顺序会越来越详细：

fmt.Printf("p=%v\n", p) 输出结果为：p={1 2}
fmt.Printf("p=%+v\n", p) 输出结果为：p={x:1 y:2}
fmt.Printf("p=%#v\n", p) 输出结果为：p=main.point{x:1, y:2}

package main

import "fmt"

type point struct {
	x, y int
}

func main() {
	s := "hello"
	n := 123
	p := point{1, 2}
	fmt.Println(s, n) // hello 123
	fmt.Println(p)    // {1 2}

	fmt.Printf("s=%v\n", s)  // s=hello
	fmt.Printf("n=%v\n", n)  // n=123
	fmt.Printf("p=%v\n", p)  // p={1 2}
	fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
	fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}

	f := 3.141592653
	fmt.Println(f)          // 3.141592653
	fmt.Printf("%.2f\n", f) // 3.14
}

11 json

本小节主要讲述了如何将结构体转换成json格式的数据以及如何将json格式的数据通过结构体来接收。

通过函数json.Marshal(a)，将结构体转换成了一个字节数组buf。（序列化过程）
通过函数json.Unmarshal(buf, &b)，将字节数组buf转换成结构体类型，由b接收。（反序列化过程）

package main

import (
	"encoding/json"
	"fmt"
)

type userInfo struct {
	Name  string
	Age   int `json:"age"`
	Hobby []string
}

func main() {
	a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
	buf, err := json.Marshal(a)
	if err != nil {
		panic(err)
	}
	fmt.Println(buf)         // [123 34 78 97...]
	fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}

	buf, err = json.MarshalIndent(a, "", "\t")
	if err != nil {
		panic(err)
	}
	fmt.Println(string(buf))

	var b userInfo
	err = json.Unmarshal(buf, &b)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
	fmt.Printf("%+v\n", b) 
}

12 strconv

利用strconv库可以将字符串转换为其他类型的数据。

strconv.ParseFloat("1.234", 64)：将字符串转换为float类型
strconv.ParseInt("111", 10, 64)：将字符串按照10进制转换为int类型
strconv.ParseInt("0x1000", 0, 64)：将字符串按照16进制转换为int类型
strconv.Atoi("123"):将字符串转为整数。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	f, _ := strconv.ParseFloat("1.234", 64)
	fmt.Println(f) // 1.234

	n, _ := strconv.ParseInt("111", 10, 64)
	fmt.Println(n) // 111

	n, _ = strconv.ParseInt("0x1000", 0, 64)
	fmt.Println(n) // 4096

	n2, _ := strconv.Atoi("123")
	fmt.Println(n2) // 123

	n2, err := strconv.Atoi("AAA")
	fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}