普拉多VX

人生一路,不问来时,不知归期

0%

匿名函数

匿名函数就是一个没有名字的函数,只有函数体,函数可以被作为一种类型被赋值给函数类型的变量,匿名函数往往是以变量方式被传递。

匿名函数的定义

1
2
3
4
func (参数列表)(返回值列表) {
函数体

}

调用方式

  • 声明时直接调用
  • 赋值给变量进行调用

实例:匿名函数调用

1.声明时直接调用

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

package main

import "fmt"

//func (参数列表)(返回值列表) {
// 函数体
//
//}

func main(){

func (userId,age int){
fmt.Printf("用户ID:%d,年龄:%d\n",userId,age)
}(1,24) //声明时直接调用

}

2.赋值给变量调用

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

import "fmt"

//func (参数列表)(返回值列表) {
// 函数体
//
//}

func main(){

result :=func (a,b int )int{
return a+b
}

fmt.Println(result(2,6)) //直接赋值给result,然后调用即可

}

全局匿名函数

以上我们的函数调用都是一个局部调用,如何进行全局调用呢,可以将匿名函数赋值给一个全局变量,就可以程序中使用了。

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
40
package main

import "fmt"
//全局匿名函数
var (
getResult = func(a,b int,meth_type string) int {
if meth_type == "+" {
return a + b
}else if meth_type == "-" {

return a -b
}else if meth_type == "*" {
return a *b
}else{
return 1
}
}

)


func funcMethod(a,b int)(int,int,int){

//加法
add := getResult(a,b,"+") //函数中调用全局匿名函数
//减法
sub := getResult(a,b,"-")
//乘法
mul := getResult(a,b,"*")

return add,sub,mul

}

func main(){

fmt.Println(funcMethod(1,23))


}

函数闭包

闭包就是一个函数与其相关的引用环境组成的一个整体。它本质上是一个函数,但是这个函数会用于函数外的变量,它们共同组成的整体称为闭包。

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

package main

import "fmt"

//累积数据,返回值是一个func
func addUpper() func(int) int {
n := 10
n -= 1
c := 20

return func (x int) int {
c -= 2
fmt.Println(c)

n = n +x
return n
}
}

func main(){

t := addUpper() //t变量用于接收返回的函数

fmt.Println(t(5))

}

defer(延迟函数)

defer用来声明一个延迟函数,并把这个函数放到一个栈上,当外部的包含方法return之前,放回参数到调用方法之前调用。通常用于做资源释放,比如关闭io等。

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

import "fmt"

//defer 用于程序释放资源,用于延迟操作。


func f() {
//延迟调用,采用FILO(先进后出原则) 延迟函数执行按后进先出顺序执行,即先出现的defer后执行
i:=0
defer fmt.Println(i)
i++
defer fmt.Println(i)
return

}

func main() {
f() //结果是1 后是0
}

关闭文件io

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func closeFile(){

f, _ := os.Open("Godefer.go")

//将文件名交给带有缓存的IO Reader
r := bufio.NewReader(f)

for {
line, err := r.ReadString('\n') //指定分割符
//判断是否是文件结尾
if err == io.EOF {
break
}
fmt.Print(line)
}

defer f.Close()

}

函数作用域

1.在函数内部声明/定义的变量叫局部变量,作用域仅限于函数内部

1
2
3
4
func change(){  
a := 124 //在change函数体内部声明的变量叫局部变量
fmt.Println(a)
}

2.函数外部声明/定义的变量叫全局变量,作用于在整个包内。如果变量的首字母大写,则可以外部访问调用(作用域为整个程序)

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
package main

import "fmt"

// 外部变量
var (
Name string = "default"
Age int64

)
func change(){
//修改的就是全局变量
Name = "1234"

}

func main() {

Age = 100
fmt.Println(Name,Age)

change()
Age = 100
fmt.Println(Name,Age)

}

函数声明

golang 的函数声明包含func关键字、函数名、形式参数列表(可省略)、返回值列表及函数体

1
2
3
func FuncName(username string,age int){

}

最简单的函数定义如果,以func开头及函数名

1
2
3
func Simple(){
//表示该函数不需要输入参数,以及没有返回值
}

下面通过两个实例来介绍下函数的使用

1.计算两个数相加。定义一下funcAdd 函数,接收两个参数a,b 类型为int 返回值为int。函数调用时,以函数名()的形式进行调用。

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

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

func main(){
fmt.Println(funcAdd(3,5)) //输出结果为8
}

函数返回时还可以直接以变量的形式进行返回

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

import "fmt"

func funcAdd(a int, b int) (result int){
result=a+b
return //直接输入return进行返回即可
}

func main(){
fmt.Println(funcAdd(7,8))
}

2.计算商品价格。定义一个函数名加ShopPrice,接收几个参数,并且返回商品价格。

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

import "fmt"

func ShopPrice(s_price,number,sale float64)(price float64){
//商品原价 * 数量 * 折扣
// 999.88 * 2 * 98/100
price = s_price * number * sale / 100.00
return
}

func main(){


fmt.Println(ShopPrice(999.25,2,98))

}

可以返回多个数据,传入商品名、价格、数量。最后返回商品及计算结果

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

import "fmt"

func ShopDetail(s_price,number,sale float64,name string)(float64, string){
//商品原价 * 数量 * 折扣
// 999.88 * 2 * 98/100
price := s_price * number * sale / 100.00
return price,name
}


func main(){
price,name := ShopDetail(999.25,2,98,"大衣")
fmt.Println("商品:",name,"价格:",price)

}

函数多返回值

在go中,一个函数可以接收多个参数列表,同时也可以返回多个值,便于我们进行处理。

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

import "fmt"

func AbcFunc(a,b,c int)(int,int,int){ //返回值为3个int数值
return c,b,a //将123 转成321输出
}

func main(){
c,b,a := AbcFunc(1,2,3)
fmt.Println(c,b,a)
}

空白符号的使用

如果在接收参数时,有不想使用的变量数值,可以使用_进行代替,程序不作处理。

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

import "fmt"

func nullValue(username string,age int,address string)(string,int,string){

return username,age,address
}


func main(){
//_用于接收任何类型的任何值,如果以“_”表示,那将省略,可以理解为垃圾桶
username,age,_ := nullValue("roddy",27,"sichuan")
fmt.Println(username,age)
}

函数可变参数

向函数传递一个未知数量的参数值时,可以使用…来代替,下面样例就是传递一个数字序列,然后分别打印出来例子。

1
2
3
4
5
6
7
8
9
10
11
func MultipleNumber(args ...int){
for i:=0;i<len(args);i++{
fmt.Println(args[i])
}
}


func main(){

MultipleNumber(1,2,3,5,4,5,6,6,7,8)
}

实例

输入一列数据,返回这组数据的最小值与最大值

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

import "fmt"

func MinMax(input ...int)(min,max int){
min = input[0]
max = input[0]

for i :=0;i<len(input);i++{
if input[i] < min{
min = input[i]
}

if input[i] >max {
max = input[i]
}
}
return
}

func main(){
min,max :=MinMax(1,2,34,5,6,7)
fmt.Println("最小值为:",min,"最大值为:",max)
}

如何使用golang打印一个乘法表

使用模块fmt,语法使用for循环嵌套,然后使用fmt.Printf格式化输出结果。

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

import "fmt"

func main() {
for i:=1;i<=9;i++ {
for c:=1;c<=i;c++{
fmt.Printf("%d * %d = %d ",i,c,i*c)
}
fmt.Println()
}
}

此时输出结果发现,细微发现数字没有对齐

1
2
3
4
5
6
7
8
9
1 * 1 = 1 
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81

改进代码在=%d改成%-2d 2d表示2位数字。-标识缺省

1
fmt.Printf("%d * %d = %-2d ",i,c,i*c)

输出结果

1
2
3
4
5
6
7
8
9
1 * 1 = 1  
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81