go语言基础（三）

一、 结构体

结构体 (Struct) 指的是一种数据结构, 由一系列具有相同类型或不同类型的数据构成的数据集合. 类似其他语言中的 Class. 

定义

type 类型名 struct {
    字段名 字段类型
    字段名 字段类型
    …
}

类型名：标识自定义结构体的名称，在同一个包内不能重复。
字段名：表示结构体字段名。结构体中的字段名必须唯一。
字段类型：表示结构体字段的具体类型。

实例 

type person struct {
    name string
    city string
    age  int8
}

func main() {
    var p1 person
    p1.name = "沙河娜扎"
    p1.city = "北京"
    p1.age = 18
    fmt.Printf("p1=%v\n", p1)  //p1={沙河娜扎 北京 18}
    fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"沙河娜扎", city:"北京", age:18}
}

 

二、函数

func 函数名( [参数列表] ) [返回值类型] {
    函数体
}

1、func: 函数由 func 开始声明, 类似 python 的 def
2、函数名: 函数的名称, 函数名和参数列表一起构成了函数签名
3、参数列表: 参数就像一个站位符. 参数列表制定的是参数类型, 顺序, 以及参数个数. 
4、返回值类型: 函数返回一列值的数据类型. 不是必须的
 

package main

import (
	"fmt"
	"strconv"
)


//const 来定义枚举类型
const (
	//可以在const() 添加一个关键字 iota， 每行的iota都会累加1, 第一行的iota的默认值是0
	BEIJING = iota	 //iota = 0
	SHANGHAI 		  //iota = 1
	SHENZHEN          //iota = 2
)

const (
	a, b = iota+1, iota+2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2
	c, d				  // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3
	e, f				  // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4

	g, h = iota * 2, iota *3  // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9 
	i, k					   // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)


func fun1(a string, b int) int {
	fmt.Println("a = ", a)
	fmt.Println("b = ", b)
	b,error := strconv.Atoi(a)
	if error != nil{
	fmt.Println("字符串转换成整数失败")
	}
	b = b + 1
	fmt.Println(b)
	return b
}

//返回多个返回值，匿名的
func fun2(a int, b string) (string, int) {
	fmt.Println("a = ", a)
	fmt.Println("b = ", b)
	d := strconv.Itoa(a)   //数字变成字符串
	d = d + "sdfs"
	fmt.Println(d)

	e,error := strconv.Atoi(b)  //字符串转换成整数
	if error != nil{
		fmt.Println("字符串转换成整数失败")
		} else {
		fmt.Println(e)
	}
	return d, e
}

//返回多个返回值， 有形参名称的
func fun3(a string, b int) (r1 string, r2 int) {
	fmt.Println("---- foo3 ----")
	fmt.Println("a = ", a)
	fmt.Println("b = ", b)

	//r1 r2 属于foo3的形参，  初始化默认的值是0
	//r1 r2 作用域空间 是foo3 整个函数体的{}空间
	fmt.Println("r1 = ", r1)
	fmt.Println("r2 = ", r2)

	//给有名称的返回值变量赋值
	r1 = a
	r2 = 2000

	return
}


func main() {
	//常量(只读属性)
	const length int = 10

	fmt.Println("length = ", length)

	//length = 100 //常量是不允许修改的。
	fmt.Println("BEIJIGN = ", BEIJING)
	fmt.Println("SHANGHAI = ", SHANGHAI)
	fmt.Println("SHENZHEN = ", SHENZHEN)

	fmt.Println("a = ", a, "b = ", b)
	fmt.Println("c = ", c, "d = ", d)
	fmt.Println("e = ", e, "f = ", f)
	fmt.Println("g = ", g, "h = ", h)
	fmt.Println("i = ", i, "k = ", k)

	// iota 只能够配合const() 一起使用， iota只有在const进行累加效果。

	c := fun1("666", 555)
	fmt.Println("c = ", c)

	ret1, ret2 := fun2(1000, "999")
	fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)

	ret1, ret2 = fun3("foo3", 333)
	fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)


}

三、函数闭包

• Go 语言支持匿名函数, 可作为闭包. 匿名函数是一 “内嵌” 语句或表达式.
• 匿名函数的优越性在于可以直接使用函数内的变量, 不必声明 

package main

import "fmt"

func main() {

	// 匿名函数
	var add = func(a int, b int) int {
		return a + b
	}
	// 调试输出
	fmt.Println(add(1, 2))
	
}

四、参考

go语言基础之结构体 - 努力乄小白 - 博客园 (cnblogs.com)

Go语言--结构体(struct)