这是我参与「第五届青训营 」伴学笔记创作活动的第 3 天
继续肝语法ing，，，
函数
函数是语句序列的集合，能够将一个大的工作分解为小的任务，对外隐藏了实现细节
- 函数组成
- 函数名
- 参数列表(parameter-list)
- 返回值(result-list)
- 函数体(body)
func name(parameter-list) (result-list){
body
}
- 单返回值函数
func plus(a, b int) (res int){
return a + b
}
- 多返回值函数
func multi()(string, int){
return "name", 18
}
- 命名返回值
// 被命名的返回参数的值为该类型的默认零值
// 该例子中 name 默认初始化为空字符串，height 默认初始化为 0
func namedReturnValue()(name string, height int){
name = "xiaoming"
height = 180
return
}
- 参数可变函数
func sum(nums ...int)int{
fmt.Println("len of nums is : ", len(nums))
res := 0
for _, v := range nums{
res += v
}
return res
}
func main(){
fmt.Println(sum(1))
fmt.Println(sum(1,2))
fmt.Println(sum(1,2,3))
}
- 匿名函数
func main(){
func(name string){
fmt.Println(name)
}("字节跳动")
}
- 闭包
func main() {
addOne := addInt(1)
fmt.Println(addOne())
fmt.Println(addOne())
fmt.Println(addOne())
addTwo := addInt(2)
fmt.Println(addTwo())
fmt.Println(addTwo())
fmt.Println(addTwo())
}
func addInt(n int) func() int {
i := 0
return func() int {
i += n
return i
}
}
- 函数作为参数
func sayHello(name string) {
fmt.Println("Hello ", name)
}
func logger(f func(string), name string) {
fmt.Println("start calling method sayHello")
f(name)
fmt.Println("end calling method sayHellog")
}
func main() {
logger(sayHello, "字节跳动")
}
- 传值和传引用
func sendValue(name string) {
name = "hemuketang"
}
func sendAddress(name *string) {
*name = "hemuketang"
}
func main() {
// 传值和传引用
str := "字节跳动"
fmt.Println("before calling sendValue, str : ", str)
sendValue(str)
fmt.Println("after calling sendValue, str : ", str)
fmt.Println("before calling sendAddress, str : ", str)
sendAddress(&str)
fmt.Println("after calling sendAddress, str: ", str)
}
方法
在传统面向对象语言中 (例如 C++), 我们会用一个“类”来封装属于自己的数据和函数，这些类的函数就叫做方法。
虽然 Go 不是经典意义上的面向对象语言，但是我们可以在一些接收者（自定义类型，结构体）上定义函数，同理这些接收者的函数在 Go 里面也叫做方法。
声明
方法（method）的声明和函数很相似, 只不过它必须指定接收者：
func (t T) F() {}
注意：
- 接收者的类型只能为用关键字
type定义的类型，例如自定义类型，结构体。 - 同一个接收者的方法名不能重复 (没有重载)，如果是结构体，方法名还不能和字段名重复。
- 值作为接收者无法修改其值，如果有更改需求，需要使用指针类型。
简单例子
package main
type T struct{}
func (t T) F() {}
func main() {
t := T{}
t.F()
}
接收者类型不是任意类型
例如：
package main
func (t int64) F() {}
func main() {
t := int64(10)
t.F()
}
当运行以下代码会得到 cannot define new methods on non-local type int64 类似错误信息，我们可以使用自定义类型来解决：
package main
type T int64
func (t T) F() {}
func main() {
t := T(10)
t.F()
}
小结：接收者不是任意类型，它只能为用关键字
type定义的类型（例如自定义类型，结构体）。
命名冲突
a. 接收者定义的方法名不能重复, 例如：
package main
type T struct{}
func (T) F() {}
func (T) F(a string) {}
func main() {
t := T{}
t.F()
}
运行代码我们会得到 method redeclared: T.F 类似错误。
b. 结构体方法名不能和字段重复，例如：
package main
type T struct{
F string
}
func (T) F(){}
func main() {
t := T{}
t.F()
}
运行代码我们会得到 : type T has both field and method named F 类似错误。
小结： 同一个接收者的方法名不能重复 (没有重载)；如果是结构体，方法名不能和字段重复。
接收者可以同时为值和指针
在 Go 语言中，方法的接收者可以同时为值或者指针，例如：
package main
type T struct{}
func (T) F() {}
func (*T) N() {}
func main() {
t := T{}
t.F()
t.N()
t1 := &T{} // 指针类型
t1.F()
t1.N()
}
可以看到无论值类型 T 还是指针类型 &T 都可以同时访问 F 和 N 方法。
值和指针作为接收者的区别
同样我们先看一段代码：
package main
import "fmt"
type T struct {
value int
}
func (m T) StayTheSame() {
m.value = 3
}
func (m *T) Update() {
m.value = 3
}
func main() {
m := T{0}
fmt.Println(m) // {0}
m.StayTheSame()
fmt.Println(m) // {0}
m.Update()
fmt.Println(m) // {3}
}
运行代码输出结果为：
{0}
{0}
{3}
小结：值作为接收者（
T） 不会修改结构体值，而指针*T可以修改。
接口
接口类型是一种抽象类型，是方法的集合，其他类型实现了这些方法就是实现了这个接口。
/* 定义接口 */
type interface_name interface {
method_name1 [return_type]
method_name2 [return_type]
method_name3 [return_type]
...
method_namen [return_type]
}
简单示例：打印不同几何图形的面积和周长
package main
import (
"fmt"
"math"
)
type geometry interface {
area() float32
perim() float32
}
type rect struct {
len, wid float32
}
func (r rect) area() float32 {
return r.len * r.wid
}
func (r rect) perim() float32 {
return 2 * (r.len + r.wid)
}
type circle struct {
radius float32
}
func (c circle) area() float32 {
return math.Pi * c.radius * c.radius
}
func (c circle) perim() float32 {
return 2 * math.Pi * c.radius
}
func show(name string, param interface{}) {
switch param.(type) {
case geometry:
// 类型断言
fmt.Printf("area of %v is %v \n", name, param.(geometry).area())
fmt.Printf("perim of %v is %v \n", name, param.(geometry).perim())
default:
fmt.Println("wrong type!")
}
}
func main() {
rec := rect{
len: 1,
wid: 2,
}
show("rect", rec)
cir := circle{
radius: 1,
}
show("circle", cir)
show("test", "test param")
}
接口中可以内嵌接口
对上述例子做以下修改：
- 首先添加
tmp接口，该接口定义了area()方法 - 将
tmp作为geometry接口中的匿名成员，并且将geometry接口中原本定义的area()方法删除
完成以上两步后，
geometry接口将会拥有tmp接口所定义的所有方法。运行结果和上述例子相同。
type tmp interface{
area() float32
}
type geometry interface {
// area() float32
tmp
perim() float32
}
以上便是我今天学习的语法知识，希望能早日触碰项目。
咕咕咕
