golang基础教程

1
2

fmt.Print("b", "c")
fmt.Print("a")

1
2
3

a := 10
fmt.Printf("a的值为 %v", a)  // 表示格式化输出，%v相当于占位符，输出a的值
//输出 a的值为 10

1

var a int = 10   //int 可以省略

1

a :=10   

1
2

var username string
fmt.Println(username)    //输出为空

1
2

var age int
fmt.Println(age)   //输出为0

1
2
3
4
5
6
7
8

func getUserinfo() (int, string) {
	return 10, "张三"
}
func main(){
	age, _ := getUserinfo()    // 用_ 忽略返回的 "张三"
	fmt.Println(age)

}

1
2

const pi = math.Pi
fmt.Printf("%v %T", pi, pi)  // 3.141592653589793 float64

1
2
3
4
5

const (
		a = iota //const 第一次出现时iota为0
		b = iota // const 第二次为1 可以理解为const语句的行索引
	)
	fmt.Println(a, b)   // 0 1

1
2
3
4
5
6
7
8
9

const (
		a = iota
		_
		b
		_
		c
	)
	fmt.Println(a, b, c)   //0 2 4
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const (
		b  = 1 << (10 * iota)
		kb // 1<<10  0000 0000 0001  0100 0000 0000
		mb
		gb
		tb
		pb
	)
	fmt.Println(b, kb, mb, gb, tb, pb)
//1 1024 1048576 1073741824 1099511627776 1125899906842624

1
2

var num int8 = 150
fmt.Println(num)     //报错 因为num是int8，取值只能在-128和127之间

1
2
3

f1 := 3.1415
fmt.Printf("%v 类型是%T", f1, f1)
// 3.1415 类型是float64

1
2
3

f1 := 3.14e2   // 3.14*10的2次方  f1 := 3.14e-2  3.14/10的2次方
fmt.Printf("%v 类型是%T", f1, f1)    
// 314 类型是float64

1
2
3
4

f1 := 8.2
f2 := 3.8
fmt.Println(f1 - f2)
// 4.3999999999999995

1
2
3
4

  f1 := 8.2
	f2 := 3.8
	f3 := decimal.NewFromFloat(f1).Sub(decimal.NewFromFloat(f2))
	fmt.Println(f3)   // 4.4

1
2

  str := "你好"
	fmt.Println(len(str))    //输出6 因为一个汉字代表3个字节

1
2
3
4
5

//拼接字符串  "+"
  str1 := "你好"
	str2 := "golang"
	str3 := str1 + str2
	fmt.Println(str3)    // 你好golang

1
2
3
4
5

  //使用 fmt.Sprintf 拼接
  str1 := "你好"
	str2 := "golang"
	str3 := fmt.Sprintf("%v %v", str1, str2)
	fmt.Println(str3)

1
2
3

	str := "golang,javascript,c,c++"
	str2 := strings.Split(str, "n")
	fmt.Printf("%v %T", str2, str2)  //[gola g,javascript,c,c++] []string

1
2
3

	sliceA := []string{"c++", "golang", "java", "javascript"}
	str := strings.Join(sliceA, ",")
	fmt.Println(str)     //c++,golang,java,javascript

1
2
3

	str := "hello golang"
	index := strings.Index(str, "go")
	fmt.Println(index)    // 6

1
2
3

	str := "hello go golang"
	index := strings.LastIndex(str, "go")
	fmt.Println(index)   //9

1
2

	a := 'a'
	fmt.Printf("%v %c", a, a)   // 97 a  97是输出的ASCII码 a是字符输出

1
2
3
4

	a := "abc"
	strSlice := []byte(a)
	fmt.Println(strSlice)   // 输出是以字符串abc的byte（int8）切片  
	// [97 98 99]

1
2
3
4
5

	a := "abc"
	strSlice := []byte(a)
	strSlice[0] = 'd'
	fmt.Println(string(strSlice))   //输出 dbc
	fmt.Println(a)    // 输出abc

1
2
3

  f := 25.868686
  str := strconv.FormatFloat(float64(f), 'f', 10, 64)
  fmt.Println(str)   //25.8686860000

1

var city [3]string

1

var city = [...]string{"北京","上海","广东","深圳"}

1
2
3
4
5
6
7

var arry = [...]string{"上海", "北京", "广州", "深圳"}
	for i := 0; i < len(arry); i++ {
		fmt.Println(arry[i])
	}
	for _, v := range arry {
		fmt.Println(v)
	}

1
2
3
4
5
6
7

	a := 10
	b := a // 赋值操作的时候相当于拷贝了一份a给b
	a = 30
	fmt.Println(a)
	fmt.Println(b)
 // 30
 // 10

1
2
3
4
5
6
7

	sliceA := []int{1, 2, 3}
	sliceB := sliceA
	sliceA[0] = 22
	fmt.Println(sliceA)
	fmt.Println(sliceB)
//[22 2 3]
//[22 2 3]

1
2
3
4
5
6
7

	sliceA := []int{1, 2, 3}
	sliceB := sliceA
	sliceB[1] = 66
	fmt.Println(sliceA)
	fmt.Println(sliceB)
//[1 66 3]
 //[1 66 3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

//多维数组
		var arry = [3][2]string{
		{"上海", "北京"},
		{"杭州", "广州"},
		{"深圳", "成都"},
	}
	for _, strings := range arry {
		for _, s := range strings {
			fmt.Println(s)
		}
	}      //上海
					北京
					杭州
					广州
					深圳
					成都

1
2
3

	var sliceA []int
	fmt.Println(sliceA)
	fmt.Println(sliceA == nil)

1
2

[]
true

1
2
3
4

sliceA := []int{1, 5, 121, 33, 53}
	for _, v := range sliceA {
		fmt.Println(v)
	}

1
2
3
4
5
6

	arr := [...]int{22, 52, 6, 78, 92}
	sliceA := arr[1:] //从数组元素索引1开始到最后一个元素
	sliceB := arr[:3] //从数组元素索引3不包括3到第一个元素
	sliceC := arr[:]  // 所有数组元素
	fmt.Println(sliceC, sliceB, sliceA)
 // [22 52 6 78 92] [22 52 6] [52 6 78 92]

1
2
3
4

	arr := [...]int{22, 52, 6, 78, 92}
	sliceA := arr[:2]
	fmt.Printf("%d %d", len(sliceA), cap(sliceA))// 切片sliceA为[22,52] 容量是从22开始到92一共5
	// 2 5

1

var sliceA = make([]T,size,cap)

1
2
3
4
5
6

	sliceA := make([]int, 5, 5)  //切片的长度是5，容量也是5
	fmt.Printf("%v %v %v\n", sliceA, len(sliceA), cap(sliceA))
	sliceA[0] = 20
	fmt.Printf("%v %v %v", sliceA, len(sliceA), cap(sliceA))
//[0 0 0 0 0] 5 5
//[20 0 0 0 0] 5 5

1
2
3
4

	var sliceA []int
	sliceA = append(sliceA, 10)
	fmt.Printf("%v %v %v", sliceA, len(sliceA), cap(sliceA))
	//[10] 1 1

1
2
3
4
5
6

	sliceA := []int{1, 2, 3}
	sliceB := []int{5, 6, 7}
	//把切片sliceB合并到切片A中
	sliceA = append(sliceA, sliceB...)
	fmt.Printf("值：%v 长度：%v 容量：%v", sliceA, len(sliceA), cap(sliceA))
//值：[1 2 3 5 6 7] 长度：6 容量：6

1
2
3
4
5

	sliceA := []int{33, 66, 22, 33, 77, 55} //底层有一个6个元素的数组
	//	删除下标为3的元素
	sliceA = append(sliceA[:3], sliceA[4:]...)
	fmt.Printf("值：%v 长度：%v 容量：%v", sliceA, len(sliceA), cap(sliceA))
	// 值：[33 66 22 77 55] 长度：5 容量：6 容量还是6因为底层数组元素是6个

1
2
3
4
5
6
7
8

	sliceA := []int{2, 5, 6, 8, 9}
	sliceB := make([]int, 5, 8)
	copy(sliceB, sliceA)
	sliceB[0] = 333    // 现在修改sliceB的值不会影响silceA
	fmt.Println(sliceA)
	fmt.Println(sliceB)  
	// [2 5 6 8 9]
	// [333 5 6 8 9]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import "fmt"

func main() {
	S := []int{1, 2, 3, 4, 5, 6}
	ele := CopyDelEle(S, 2)
	fmt.Println(ele) //[1 2 4 5 6]
	fmt.Println(S)   // [1 2 3 4 5 6]
}
func CopyDelEle(slice []int, index int) []int {
	srcSliceA := slice // [1,2,3,4,5]
	distSlice := make([]int, index)
	copy(distSlice, srcSliceA[:index])
	distSlice = append(distSlice, srcSliceA[index+1:]...)
	return distSlice
}

1
2
3

	userinfo := make(map[string]string)
	userinfo["username"] = "张三"
	fmt.Println(userinfo)

1
2
3
4
5
6
7

userinfo := map[string]string{
		"username": "张三",
		"age":      "20",
		"gender":   "男",
	}
	fmt.Printf("%v %v", userinfo, len(userinfo))
// map[age:20 gender:男 username:张三] 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

userinfo := map[string]string{
		"username": "张三",
		"age":      "20",
		"gender":   "female",
	}
	v, ok := userinfo["username"]  // v是username对应的value，如果有ok就是true
	if ok {
		fmt.Println(v, ok)
	}
// 张三 true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

	userinfo := map[string]string{
		"username": "张三",
		"age":      "20",
		"gender":   "female",
	}
	v, ok := userinfo["username"]
	if ok {
		fmt.Println(v, ok)
	}
	for key, value := range userinfo {
		fmt.Printf("%v:%v\n", key, value)
	}
//username:张三
//age:20
//gender:female

1
2
3
4
5
6
7
8

	userinfo := map[string]string{
		"username": "张三",
		"age":      "20",
		"gender":   "female",
	}
	delete(userinfo, "age")
	fmt.Println(userinfo)
// map[gender:female username:张三]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

sliceA := []map[string]string{
		{
			"username": "张三",
			"age":      "20",
		},
		{
			"username": "李四",
			"age":      "30",
		},
	}
	fmt.Println(sliceA)
// [map[age:20 username:张三] map[age:30 username:李四]]

1
2
3
4
5

	mapA := make(map[string]interface{})
	mapA["username"] = "张三"
	mapA["hubby"] = []string{"篮球", "足球", "写代码"}
	fmt.Println(mapA)
// map[hubby:[篮球 足球 写代码] username:张三]

1
2
3
4
5
6

	mapA := map[string]interface{}{
		"username": "张三",
		"hubby":    []string{"篮球", "足球", "写代码"},
	}
	fmt.Println(mapA)
// map[hubby:[篮球 足球 写代码] username:张三]

1
2
3
4
5
6
7
8
9

str := "how do you do"
	strSlice := strings.Split(str, " ")
	mapA := make(map[string]int)
	for _, value := range strSlice {
		mapA[value]++
	}
	fmt.Println(mapA)

// map[do:2 how:1 you:1]

1
2
3
4

func sum(x, y int) int {
	sum := x + y
	return sum
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func sum(x int, y ...int) int {
	sum := x
	for _, v := range y {
		sum += v
	}
	return sum
}
调用
total := sum(10, 1, 2, 3, 4, 5)  //第一个10赋值给x 1，,2，,3，4，5会以切片的形式赋值给y
	fmt.Println(total)
// 25

1
2
3
4
5

func calc(x, y int) (sum, sub int) {
sum = x + y
sub = x - y
return
}

1
2

//函数类型,可以用type关键字定义一个函数类型
type calc func(int, int) int //定义了一个calc的函数类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

//函数类型,可以用type关键字定义一个函数类型
type calc func(int, int) int //定义了一个calc的函数类型

func add(x, y int) int {
	return x + y
}

func main() {
	// 定义一个函数类型calc的变量
	var c calc
	c = add // 把符合calc类型的函数赋值给c
	fmt.Println(c(5, 6))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import "fmt"

//函数类型,可以用type关键字定义一个函数类型
type calc func(int, int) int //定义了一个calc的函数类型

func add(x, y int) int {
	return x + y
}
func sub(x, y int) int {
	return x - y
}
// cb是一个函数，类型是自定义函数类型calc 也就是func(int, int) int
func calculation(x int, y int, cb calc) int {
	//调用传递的函数
	return cb(x, y)
}
func main() {
	sum := calculation(10, 20, add)  //把函数add作为参数传递
	fmt.Println(sum)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

func add(x, y int) int {
	return x + y
}
func sub(x, y int) int {
	return x - y
}
func calc(str string) func(int, int) int {
	switch str {
	case "+":
		return add
	case "-":
		return sub
	case "*":
		return func(x, y int) int { //返回一个匿名函数，如果在函数体内定义函数只能定义成匿名函数
			return x * y
		}

	default:
		return nil
	}
}
func main() {
	a := calc("+")
	fmt.Println(a(5, 9))   //14
	s := calc("-")
	fmt.Println(s(6, 3))   //3
	m := calc("*")
	fmt.Println(m(5, 6))  //30
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func main() {
	//匿名函数赋值给一个变量
	fn := func(x, y int) int {
		return x + y
	}
	fmt.Println(fn(5, 8))
	//	匿名函数立即执行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}

1
2
3
4
5
6
7

//递归实现1-100的和
func fn(x int) int {
	if x == 0 {
		return 0
	}
	return x + fn(x-1) //3+f(2)  //3+2+fn(1)   // 3+2+1 +fn(0)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main

import "fmt"

func main() {

	a := fn2(5)
	fmt.Println(a)  //120
}

func fn2(x int) int {
	if x > 1 {
		return x * fn2(x-1) //5*fn(4)  // 5*4*fn(3) //5*4*3*fn(2) //5*4*3*2*fn(1)
	} else {
		return 1
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package main
import "fmt"
func main() {
	fn2 := fn()
	fmt.Println(fn2(10))   // 输出20
	fmt.Println(fn2(10))   // 输出30 因为此时x=20+10
	fmt.Println(fn2(10))   // 输出40 因为此时x=30+10
	
}
func fn() func(int) int {
	x := 10
	return func(y int) int {
		x += y
		return x
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main
import "fmt"
func main() {
	fmt.Println("开始")
	defer func() {
		fmt.Println("1")
	}()
	defer func() {
		fmt.Println("2")
	}()
	defer func() {
		fmt.Println("3")
	}()
	fmt.Println("结束")
}
//开始
//结束
//3
//2
//1

1
2
3
4
5
6
7
8

func f1() int {
	x := 5
	defer func() {
		x++
	}()
	return x
}
//输出 为5

1
2
3
4
5
6
7

func f2() (x int) { //x为命名返回值，可以在函数中使用x开始是0
	defer func() { 
		x++    //再执行 x++ x变为6 最后返回值为6
	}()
	return 5  // 先执行return 5 x为5
}
// 6

1
2
3
4
5
6
7
8
9

package main
import "fmt"
func main() {
	fmt.Println(div(10, 0))
	fmt.Println("结束程序")
}
func div(x, y int) int {
	return x / y
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

func main() {
	fmt.Println(div(10, 0))
	fmt.Println("结束程序")
}
func div(x, y int) int {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println(err)
		}
	}()
	return x / y
}
// runtime error: integer divide by zero
//0
//结束程序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

  now := time.Now()
	fmt.Println(now)
	//	获取年月日时分秒方法
	year := now.Year()
	month := now.Month()
	day := now.Day()
	hour := now.Hour()
	minute := now.Minute()
	second := now.Second()
	//时间格式化输出字符串 方式一
	time := fmt.Sprintf("%d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second)
	fmt.Println(time)

1
2
3

now := time.Now()
dateStr := now.Format("2006-01-02 15:03:04")   //固定写法
fmt.Println(dateStr)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

	timeStampSecond := time.Now().Unix() //秒时间戳
	fmt.Println(timeStampSecond)
	//毫秒时间错
	timeStampMill := time.Now().UnixMilli()
	fmt.Println(timeStampMill)
	//微秒时间戳
	timeStampMicro := time.Now().UnixMicro()
	fmt.Println(timeStampMicro)
	//纳秒时间戳
	timeStampNano := time.Now().UnixNano()
	fmt.Println(timeStampNano)

1
2
3
4

  //将毫秒时间戳转为时间对象
  var timeStamp int64 = 1713013113882
	timeObj := time.UnixMilli(timeStamp)
	fmt.Println(timeObj)

1
2
3
4

  var str = "2024-04-13"
	var template = "2006-01-02"
	timeObj, _ := time.ParseInLocation(template, str, time.Local)
	fmt.Println(timeObj)

1
2
3
4
5
6
7

 var a = 10
	var b *int
	b = &a        // 取变量a对应的内存地址赋值给指针b
	fmt.Println(&a)    // 打印a的内存地址
	fmt.Printf("%v  ", b)   // 打印指针b的值
 //0xc0000ba058
 //0xc0000ba058

1
2
3
4
5
6
7

var a = 10
	var p *int
	p = &a
	fmt.Println(&a)
	fmt.Printf("%v  ", *p)
  //0xc00001a098
 //10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main
import "fmt"
func main() {
	a := 10
	fn1(a) //打印10
	fmt.Println(a)
	fn2(&a)   //方法fn2的参数是变量a的地址
	fmt.Println(a)   //打印30
}
func fn1(x int) {
	x += 1
}
func fn2(p *int) {
	*p = 30        //通过*p直接修改a变量内存中的值
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main
import "fmt"
func main() {
	a := 100
	b := 200
	swap(&a, &b)
	fmt.Println(a, b)
}

func swap(x, y *int) {
	var temp int
	temp = *x //通过地址取值取到a的值，赋值给temp
	*x = *y   // 将*y取到的值b 赋值给a
	*y = temp // temp赋值给 b
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

//type关键字可以定义自定义类型和类型别名
type myInt int         // 自定义类型
type myFloat = float64 // 类型别名 myFloat是float64的别名
var a myInt = 12
var b myFloat = 12.21
fmt.Printf("%v %T \n", a, a)
fmt.Printf("%v %T \n", b, b)

12 main.myInt 
12.21 float64   //别名打印的还是原来的类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main
import "fmt"
type Person struct {
	Name   string
	Age    int
	Gender string
}
func main() {
	//实例化结构体
	var p Person
	p.Gender = "男"
	p.Name = "张三"
	p.Age = 28
	fmt.Printf("%#v 类型是%T", p, p)

}
//main.Person{Name:"张三", Age:28, Gender:"男"} 类型是main.Person

1
2
3
4
5
6

	p2 := new(Person)   // 通过new关键字得到的p2是一个结构体指针，存储的Person结构体的地址
	p2.Gender = "女"
	p2.Name = "小花"
	p2.Age = 30
	fmt.Printf("%#v %T", p2, p2)
// &main.Person{Name:"小花", Age:30, Gender:"女"} *main.Person

1
2
3
4
5
6

	p3 := &Person{}
	p3.Name = "李四"
	p3.Age = 30
	p3.Gender = "男"
	fmt.Printf("%#v %T", p3, p3)
//&main.Person{Name:"李四", Age:30, Gender:"男"} *main.Person

1
2
3
4
5
6
7

p4 := Person{   // 初始化的时候填充字段
		Name:   "王五",
		Age:    40,
		Gender: "男",
	}
	fmt.Printf("%#v %T", p4, p4)
// main.Person{Name:"王五", Age:40, Gender:"男"} main.Person

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

//package main
import "fmt"
type Person struct {
	Name   string
	Age    int
	Gender string
}

//定义结构体方法
func (p Person) GetInfo() {   //这里相当于是哪个实例调用方法会把实例拷贝赋值给p
	p.Age = 20                  //但因为结构体是值类型所以并不会改变实例本身的值
	p.Name = "小花"
	p.Gender = "女"
	fmt.Printf("%#v %T\n ", p, p)
}
func main() {
	//结构体方法和接受者
	p := Person{
		Name:   "张三",
		Age:    30,
		Gender: "男",
	}
	p.GetInfo()
	fmt.Printf("%#v %T\n", p, p)

}
//main.Person{Name:"小花", Age:20, Gender:"女"} main.Person
 //main.Person{Name:"张三", Age:30, Gender:"男"} main.Person

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main
import "fmt"
type Person struct {
	Name   string
	Age    int
	Gender string
}

//定义结构体方法
func (p *Person) GetInfo() {    //接受者类型是结构体指针，p是结构体实例的地址所以在函数中修改
							//会改变实例本身的值
	p.Age = 20
	p.Name = "小花"
	p.Gender = "女"
	fmt.Printf("%#v %T\n ", p, p)
}
func main() {
	//结构体方法和接受者
	p := Person{
		Name:   "张三",
		Age:    30,
		Gender: "男",
	}
	p.GetInfo()
	fmt.Printf("%#v %T\n", p, p)
}
// &main.Person{Name:"小花", Age:20, Gender:"女"} *main.Person
 // main.Person{Name:"小花", Age:20, Gender:"女"} main.Person

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package main
import "fmt"
type Person struct {
	Name   string
	Age    int
	Gender string
}
type Teacher struct {
	Class  string
	Person //在教师结构体中嵌套人的结构体，那么教师结构体就会拥有Person结构体的
	//属性和方法
}
func (p Person) Run() {
	fmt.Println(p.Name + "会奔跑")
}
func (t Teacher) Teach() {
	fmt.Println(t.Name + "教书")
}

//定义结构体方法
func (p *Person) GetInfo() {
	fmt.Printf("%#v %T\n ", p, p)
}
func main() {
	t := Teacher{
		Class: "科学",
		Person: Person{
			Name:   "李老师",
			Age:    25,
			Gender: "女",
		},
	}
	t.Teach()
	t.Run()
	t.GetInfo()
}
//李老师教书
//李老师会奔跑
//&main.Person{Name:"李老师", Age:25, Gender:"女"} *main.Person

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func main() {
	user := &User{
		Username: "张三",
		Password: "123456",
		Gender:   "男",
		Mobile:   "18989898989",
	}
	jsonStrByte, err := json.Marshal(user)  // 这里序列化为byte类型的切片，byte就是uint8类型。输出的是ascii码的值十进制数，一个英文字母占用8位，0-255。
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(jsonStrByte))
}

1

{"Username":"张三","Password":"123456","Gender":"男","Mobile":"18989898989"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

type User struct {
	Username string
	Password string
	Gender   string
	Mobile   string
}

func main() {
	var user User
	jsonStr := `{"Username":"张三","Password":"123456","Gender":"男","Mobile":"18989898989"}`
	err := json.Unmarshal([]byte(jsonStr), &user)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(user)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type User struct {
	Username string "Username information"
	Password int    "user password information"
	Gender   string "user gender information"
	Mobile   string "user mobile information"
}

func main() {
	user := User{
		Username: "张三",
		Password: 123456,
		Gender:   "男",
		Mobile:   "15956569591",
	}
	userType := reflect.TypeOf(user) //返回变量user的类型
	field := userType.Field(1)      // 如果userType是结构体，就可以用Fied()方法索引字段，0为Username，1为Password
	fmt.Println(userType)
	fmt.Printf("%#v\n", field)
	fmt.Printf("%v", field.Tag)
}

1
2
3

 main.User
 reflect.StructField{Name:"Password", PkgPath:"", Type:(*reflect.rtype)(0x4ad8c0), Tag:"user password information", Offset:0x10, Index:[]int{1}, Anonymous:false}
 user password information

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

type User struct {
	Username string "Username information"
	Password int    "user password information"
	Gender   string "user gender information"
	Mobile   string "user mobile information"
	Age      int    `json:"age"`
}

func main() {
	user := User{
		Username: "张三",
		Password: 123456,
		Gender:   "男",
		Mobile:   "15956569591",
		Age:      25,
	}

	strByte, _ := json.Marshal(user)
	fmt.Println(string(strByte))
	fmt.Printf("%#v", reflect.TypeOf(user).Field(4))

}

1
2

{"Username":"张三","Password":123456,"Gender":"男","Mobile":"15956569591","age":25}
reflect.StructField{Name:"Age", PkgPath:"", Type:(*reflect.rtype)(0x4267e0), Tag:"json:\"age\"", Offset:0x38, Index:[]int{4}, Anonymous:false}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import "fmt"

//接口也是一种数据类型，其他类型只要实现了接口的方法就是实现了这个接口
//定义 Phone接口，接口有call方法
type Phone interface {
	call()
}
type NokiaPhone struct {
	Name string
}

func (n NokiaPhone) call() {
	fmt.Println(n.Name + "手机")
}

func main() {
	var phone Phone
	phone = new(NokiaPhone)
	phone.call()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main
import "fmt"
//空接口类型，空接口也是一种类型,任何类型的变量都可以实现空接口，也就是说空接口可以接受任何变量类型
type Phone interface {
}

func main() {
	var p Phone
	var num int
	num = 10
	p = num //int实现空接口
	fmt.Println(p)
	str := "string类型实现空接口"
	p = str
	fmt.Println(str)
	boolean := true
	p = boolean     // bool类型实现空接口
	fmt.Println(p)
	f := 3.1415
	p = f //folat类型实现空接口
	fmt.Println(f)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main
import "fmt"
func main() {
	b := Print("接受一个string类型")
	fmt.Println(b)
	c := Print(5)   // 这里相当于 a=5 int实现空接口，因为 a interface{}
	fmt.Println(c)
	d := 10
	//fmt.Println(c + d)  //如果返回的是空接口类型必须用接口断言后才能和整数相加
	v, ok := c.(int)
	if ok {
		fmt.Println(v + d)
	}
}

//定义一个方法接受任意类型数据并返回
func Print(a interface{}) interface{} {
	return a
}

1
2
3
4
5
6
7

m := make(map[string]interface{})
	m["username"] = "张三"
	m["age"] = 20
	m["gender"] = "男"
	m["married"] = true
	fmt.Printf("%v %T", m, m)
// map[age:20 gender:男 married:true username:张三] map[string]interface {}

1
2
3
4
5

//切片实现空接口，数据类型可以是任意类型
	sliceA := []interface{}{1, "切片实现空接口", true, 3.1515, map[string]interface{}{"username": "张三", "age": 20}}
	fmt.Println(sliceA)
//map[age:20 gender:男 married:true username:张三] map[string]interface {}[1 切片实现空接口 true 3.1515 map[age:20 username:
张三]]