一、 结构体
结构体 (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))
}四、参考
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
