Go语言—函数

Go函数--defer语句 1 defer语句 该语句用于延迟调用指定的函数,它只能出现在函数或方法的内部,由defer 关键字以及针对某个函数的调用表达式组成。这里被调用的函数称为延迟函数。简单的示例如下: func outerFunc() { defer fmt.Println("函数执行结束前一刻才会被打印") fmt.Println("第一个被打印") } 《代码说明》defer关键字后面是针对fmt.Println()函数的调用表达式。这里的outerFunc()称为外围函数。 defer语句经常用 阅读详情

函数

Go不是一门纯函数式的编程语言,但是函数在Go中是“第一公民”,表现在:

  1. 函数是一种类型,函数类型变量可以像其他类型变量一样使用,可以作为其他函数的参数或返回值,也可以直接调用执行。
  2. 函数支持多值返回。
  3. 支持闭包。
  4. 函数支持可变参数。

Go是通过编译成本地代码且基于“堆栈”式执行的,Go的错误处理和函数也有千丝万缕的联系。

函数定义

函数是Go程序源代码的基本构造单位,一个函数的定义包括如下几个部分:
1.函数声明关键字func
2.函数名
3.参数列表
4.返回列表
5.函数体。
函数名遵循标识符的命名规则,首字母的大小写决定该函数在其他包的可见性:大写时其他包可见,小写时只有相同的包可以访问;
函数的参数和返回值需要使用“()”包裹,如果只有一个返回值,而且使用的是非命名的参数,则返回参数的“()”可以省略。
函数体使用“{}”包裹,并且“{”必须位于函数返回值同行的行尾。

func funcName(param-list) (result-list) {
	function-body
}

函数的特点

  • 函数可以没有输入参数,也可以没有返回值(默认返回0)。
func A() {
	//do something 
	//...
}

func A() int {
	//do something 
	//...
	return 1
)
  • 多个相邻的相同类型的参数可以使用简写模式。
func add(a, b int) int {    //a int, b int简写为a, b int 
	return a+b
}
  • 支持有名的返回值,参数名就相当于函数体内最外层的局部变量,命名返回值变量会被初始化为类型零值,最后的return可以不带参数名直接返回。
//sum 相当于函数内的局部变量,被初始化为0
func add(a, b int) (sum int) {	//sum 是命名返回值变量
	sum = a + b
	return 	//return sum 简写
	//sum := a + b 	//如果是sum := a + b,则相当于新声明一个sum变量命名返回变量sum覆盖
	//return sum	//需要显式的调用return sum
}
  • 不支持默认值参数。
  • 不支持函数重载。
  • 不支持命名函数的嵌套定义,但支持嵌套匿名函数。
func add(a, b int) (sum int) {
	anonymous := fumc(x, y int) int {
		return x + y
	}
	return anonymous(a, b)
}

多值返回

Go函数支持多值返回,定义多值返回的返回参数列表时要使用“()”包裹,支持命名参数的返回。

fune swap(a,b int) (int, int){
	return b, a
}

注意:
如果多值返回值有错误类型,则一般将错误类型作为最后一个返回值。

实参 & 形参

Go函数实参到形参的传递永远是值拷贝,有时函数调用后实参指向的值发生了变化,那是因为参数传递的是指针值的拷贝,实参是一个指针变量,传递给形参的是这个指针变量的副本,二者指向同一地址,本质上参数传递仍然是值拷贝。

func chvalue(a int) int {
	a = a + 1
	return a
}

func chpointer(a *int) {
	*a = *a + 1
}

func main() {
	a := 10
	chvalue(a)
	fmt.Println(a) //10 ,实参传递给形参是值拷贝
	chpointer(&a)
	fmt.Println(a) //11,仍然是值拷贝,但是复制的是地址值
}

不定参数

Go函数支持不定数目的形式参数,不定参数声明使用param ...type的语法格式。
函数的不定参数有如下几个特点:

  • 所有的不定参数类型必须是相同的。
  • 不定参数必须是函数的最后一个参数。
  • 不定参数名在函数体内相当于切片,对切片的操作同样适合对不定参数的操作。
func sum(arr ...int) (sum int) {
	for _, v := range arr { //此时 arr 就相当于切片,可以使用 range 访问
		sum += v
	}
	return
}
  • 切片可以作为参数传递给不定参数,切片名后要加上“…”。
func sum(arr ...int) (sum int) {
	for _, v := range arr { //此时 arr 就相当于切片,可以使用 range 访问
		sum += v
	}
	return
}

func main() {
	slice := []int{1, 2, 3, 4}    //切片
	array := [...]int{1, 2, 3, 4} //数组
	//数组不可以作为实参传递给不定参数的函数
	sum(slice...)
}
  • 形参为不定参数的函数和形参为切片的函数类型不相同。
func suma(arr ...int) (sum int) {
	for _, v := range arr { //此时 arr 就相当于切片,可以使用 range 访问
		sum += v
	}
	return
}

func sumb(arr []int) (sum int) {
	for v := range arr {
		sum += v
	}
	return
}

func main() {
	fmt.Printf("%T", suma) //func(...int) int
	fmt.Printf("%T", sumb) //func([]int) int
}

函数签名

函数类型又叫函数签名,一个函数的类型就是函数定义首行去掉函数名、参数名和"{",可以使用fimt.Printf的“%T“格式化参数打印函数的类型。如上程序。
两个函数类型相同的条件是:拥有相同的形参列表和返回值列表(列表元素的次序、个数和类型都相同),形参名可以不同。以下2个函数的函数类型完全一样。

func add(a,b int) int { return a+b }
func sub(x int, y int)(c int) { c = x-y; return c }

可以使用type定义函数类型,函数类型变量可以作为函数的参数或返回值

package main

import "fmt"

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

func sub(a, b int) int {
	return a - b
}

type Op func(int, int) int //定义一个函数类型,输入的是两个int类型,返回值是一个int类型

func do(f Op, a, b int) int {
	return f(a, b) //函数类型变量可以直接用来进行函数调用
}

func main() {

	a := do(add, 1, 2) //函数名add可以当作相同函数类型形参
	fmt.Println(a)     //3
	s := do(sub, 1, 2)
	fmt.Println(s) //-1
}

函数类型和map、slice、chan一样,实际函数类型变量和函数名都可以当作指针变量,该指针指向函数代码的开始位置。
通常说函数类型变量是一种引用类型,未初始化的函数类型的变量的默认值是nil。
Go中有名函数的函数名可以看作函数类型的常量,可以直接使用函数名调用函数,也可以直接赋值给函数类型变量,后续通过该变量来调用该函数。

package main

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

func main() {
	sum(3, 4)	//1.直接调用
	f := sum	//2.有名函数可以直接赋值给变量
	f(1, 2)
}

匿名函数

匿名函数可以看作函数字面量,所有直接使用函数类型变量的地方都可以由匿名函数代替。匿名函数可以直接赋值给函数变量,可以当作实参,也可以作为返回值,还可以直接被调用。

package main

import "fmt"

//匿名函数被直接赋值函数变量
var sum = func(a, b int) int {
	return a + b
}

func doinput(f func(int, int) int, a, b int) int {
	return f(a, b)
}

func wrap(op string) func(int, int) int {
	switch op {
	case "add":
		return func(a, b int) int {
			return a + b
		}
	case "sub":
		return func(a, b int) int {
			return a - b
		}
	default:
		return nil
	}

}

func main() {
	//匿名函数直接被调用
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	sum(1, 2)

	//匿名函数作为实参
	doinput(func(x, y int) int {
		return x + y
	}, 1, 2)

	opFunc := wrap("add")
	re := opFunc(2, 3) //5
	fmt.Printf("%d\n", re)
}

defer

  • Go函数里提供了defer关键字,可以注册多个延迟调用,这些调用以先进后出(FILO)的顺序在函数返回前被执行。这有点类似于Java语言中异常处理中的finally子句。defer常用于保证一些资源最终一定能够得到回收和释放。
package main

func main() {
	//先进后出
	defer func() {
		println("first")
	}()
	defer func() {
		println("second")
	}()
	println("function bldy")
}

//结果(先注册,后执行)
//function bldy
//second
//first
  • defer 后面必须是函数或方法的调用,不能是语句,否则会报expression in defer must be function call错误。
  • defer 函数的实参在注册时通过值拷贝传递进去。下面示例代码中,实参a的值在defer注册时通过值拷贝传递进去,后续语句a++并不会影响defer语句最后的输出结果。
func f() int {
	a := 0
	defer func(i int) {
		println("defer i=", i) //defer i= 0
	}(a)	//a注册时是以值拷贝传递,所以先执行a++也不会影响注册时的a值
	a++
	return a
}

func main() {
	a := f()
	fmt.Println(a) //1
}
  • defer语句必须先注册后才能执行,如果defer位于return之后,则defer因为没有注册,不会执行。
  • 主动调用os.Exit(int)退出进程时,defer将不再被执行(即使defer已经提前注册)。
func main() {
	defer func() {
		println("defer")
	}()
	println("func body")
	os.Exit(1)
}
//运行结果
//func body

defer的好处是可以在一定程度上避免资源泄漏,特别是在有很多return语句,有多个资源需要关闭的场景中,很容易漏掉资源的关闭操作。例如:

func CopyFile(dst, src string) (w int64, err error) {
	src, err := os.Open(src)
	if err != nil {
		return
	}
	dst, err := os.Create(dst)
	if err != nil {
		src.Close()	//src 很容易忘记关闭
		return
	}
	w, err = io.Copy(dst, src)
	dst.Close()
	src.Close()
	return
}

使用defer改写后,在打开资源无报错后直接调用defer关闭资源,一旦养成这样的编程习惯,则很难会忘记资源的释放。

func CopyFile(dst, src string) (w int64, err error) {
	src, err := os.Open(src)
	if err != nil {
		return
	}
	defer src.Close
	dst, err := os.Create(dst)
	if err != nil {
		return
	}
	defer dst.Close()
	w, err = io.Copy(dst, src)
	return
}

defer语句的位置不当,有可能导致panic,一般 defer 语句放在错误检查语句之后。
defer也有明显的副作用:defer会推迟资源的释放,defer尽量不要放到循环语句里面,将大函数内部的defer语句单独拆分成一个小函数是一种很好的实践方式。
defer相对于普通的函数调用需要间接的数据结构的支持,相对于普通函数调用有一定的性能损耗。
defer中最好不要对有名返回值参数进行操作,否则会引发匪夷所思的结果。

闭包

闭包是由函数及其相关引用环境组合而成的实体,一般通过在匿名函数中引用外部函数的局部变量或包全局变量构成。
闭包=函数+引用环境
闭包对闭包外的环境引入是直接引用,编译器检测到闭包,会将闭包引用的外部变量分配到堆上。
如果函数返回的闭包引用了该函数的局部变量(参数或函数内部变量):
(1)多次调用该函数,返回的多个闭包所引用的外部变量是多个副本,原因是每次调用函数都会为局部变量分配内存。
(2)用一个闭包函数多次,如果该闭包修改了其引用的外部变量,则每一次调用该闭包对该外部变量都有影响,因为闭包函数共享外部引用。
示例如下:

func fa(a int) func(i int) int {
	return func(i int) int {
		println(&a, a)
		a = a + i
		return a
	}
}

func main() {
	f := fa(1) //f引用的外部的闭包环境包括本次函数调用的形参a的值1
	g := fa(1) //g引用的外部的闭包环境包括本次函数调用的形参a的值1

	println(f(1))
	println(f(1))

	println(g(1))
	println(g(1))
}
/*
运行结果:
0xc00004a000 1
2
0xc00004a000 2
3
0xc00004a008 1
2
0xc00004a008 2
3
*/

f和g引用的是不同的a。
如果一个函数调用返回的闭包引用修改了全局变量,则每次调用都会影响全局变量。
如果函数返回的闭包引用的是全局变量a,则多次调用该函数返回的多个闭包引用的都是同一个a。同理,调用一个闭包多次引用的也是同一个a。此时如果闭包中修改了a值的逻辑,则每次闭包调用都会影响全局变量a的值。使用闭包是为了减少全局变量,所以闭包引用全局变量不是好的编程方式。

var (
	a = 0
)

func fa() func(i int) int {
	return func(i int) int {
		println(&a, a)
		a = a + 1
		return a
	}
}

func main() {
	f := fa()     //f引用外部的闭包环境包括全局变量a
	g := fa()     //g引用的外部环境闭包环境包括全局变量a
	println(f(1)) //1
	println(g(1)) //2
	println(f(1)) //3
	println(g(1)) //4
}

/*
运行结果:
0x4e49f8 0
1
0x4e49f8 1
2
0x4e49f8 2
3
0x4e49f8 3
4
*/

用一个函数返回的多个闭包共享该函数的局部变量。

func fa(base int) (func(int) int, func(int) int) {
	println(&base, base)

	add := func(i int) int {
		base += i
		println(&base, base)
		return base
	}

	sub := func(i int) int {
		base -= i
		println(&base, base)
		return base
	}

	return add, sub
}

func main() {
	f, g := fa(0)	//f、g 闭包引用的 base 是同一个,是 fa 函数调用传递过来的实参值
	s, k := fa(0)	//s、k 闭包引用的 base 是同一个,是 fa 函数调用传递过来的实参值
	println(f(1), g(2))
	println(s(1), k(2))
}

闭包最初的目的是减少全局变量,在函数调用的过程中隐式地传递共享变量,有其有用的一面;但是这种隐秘的共享变量的方式带来的坏处是不够直接,不够清晰,除非是非常有价值的地方,一般不建议使用闭包。
对象是附有行为的数据,而闭包是附有数据的行为,类在定义时已经显式地集中定义了行为,但是闭包中的数据没有显式地集中声明的地方,这种数据和行为耦合的模型不是一种推荐的编程模型,闭包仅仅是锦上添花的东西,不是不可缺少的。

panic & recover

但在有些情况,当程序发生异常时,无法继续运行。在这种情况下,我们会使用 panic 来终止程序。当函数发生 panic 时,它会终止运行,在执行完所有的延迟函数后,程序控制返回到该函数的调用方。这样的过程会一直持续下去,直到当前协程的所有函数都返回退出,然后程序会打印出 panic 信息,接着打印出堆栈跟踪(Stack Trace),最后程序终止。当程序发生 panic 时,使用 recover 可以重新获得对该程序的控制。

可以认为 panic 和 recover 与其他语言中的 try-catch-finally 语句类似,只不过一般我们很少使用 panic 和 recover。而当我们使用了 panic 和 recover 时,也会比 try-catch-finally 更加优雅,代码更加整洁。

什么时候应该使用 panic?
(需要注意的是:你应该尽可能地使用错误,而不是使用 panic 和 recover。只有当程序不能继续运行的时候,才应该使用 panic 和 recover 机制)

panic 有两个使用情况:

  1. 发生了一个不能恢复的错误,此时程序不能继续运行。 主动调用panic函数结束程序运行。
    例如: web 服务器无法绑定所要求的端口。在这种情况下,就应该使用 panic,因为如果不能绑定端口,啥也做不了。

  2. 发生了一个编程上的错误。 在调试程序中,通过主动调用panic来实现快速推出,painc打印出的堆栈能更快的定位错误。
    例如:我们有一个接收指针参数的方法,而其他人使用 nil 作为参数调用了它。在这种情况下,我们可以使用 panic,因为这是一个编程错误:用 nil 参数调用了一个只能接收合法指针的方法。

为了保证程序的健壮性,需要主动在程序的分支流程上使用recover()拦截运行时错误。

panic和recover的函数签名如下:

panic(i interface{})
recover()interface{}

panic用法挺简单的, 其实就是throw exception。panic是golang的内建函数,panic会中断函数F的正常执行流程, 从F函数中跳出来, 跳回到F函数的调用者。 对于调用者来说, F看起来就是一个panic, 所以调用者会继续向上跳出, 直到当前goroutine返回。在跳出的过程中, 进程会保持这个函数栈。 当goroutine退出时, 程序会crash。

要注意的是, F函数中的defer定义的函数会正常执行, 按照defer的规则。

同时引起panic除了我们主动调用panic之外, 其他的任何运行时错误, 例如数组越界都会造成panic
调用panic的方法非常简单:panic(xxx)。

package main

import (
	"fmt"
)

func main() {
	test()
}

func test() {
	defer func() { fmt.Println("打印前") }()
	defer func() { fmt.Println("打印中") }()
	defer func() { fmt.Println("打印后") }()
	panic("触发异常")
	fmt.Println("test")
}
/* 
运行结果:
打印后
打印中
打印前
panic: 触发异常

goroutine 1 [running]:
main.test()
	C:/Users/WINDSUN/Desktop/Golang/CloseFunc.go:15 +0xd1
main.main()
	C:/Users/WINDSUN/Desktop/Golang/CloseFunc.go:8 +0x27

Process finished with exit code 2
 */

panic与defer
panic 其实是一个终止函数栈执行的过程,但是在函数退出前都会执行defer里面的函数,直到所有的函数都退出后,才会执行panic。发生panic后,程序会从调用panic的函数位置或发生panic的地方立即返回,逐层向上执行函数的defer 语句,然后逐层打印函数调用堆栈,直到被recover 捕获或运行到最外层函数而退出。

func fullName(firstName *string, lastName *string) {
	defer fmt.Println("deferred call in fullName")

	if firstName == nil {
		panic("runtime error: first name cannot be nil")
	}
	if lastName == nil {
		panic("runtime error: last name cannot be nil")
	}
	fmt.Printf("%s %s\n", *firstName, *lastName)
	fmt.Println("returned normally from fullName")
}

func main() {
	defer fmt.Println("deferred call in main")
	firstName := "Elon"
	fullName(&firstName, nil)
	fmt.Println("returned normally from main")
}
/*
运行结果:
deferred call in fullName
deferred call in main
panic: runtime error: last name cannot be nil

goroutine 1 [running]:
main.fullName(0xc00007df20, 0x0)
	C:/Users/WINDSUN/Desktop/Golang/CloseFunc.go:14 +0x255
main.main()
	C:/Users/WINDSUN/Desktop/Golang/CloseFunc.go:23 +0xe0

Process finished with exit code 2
*/

panic不但可以在函数正常流程中抛出,在defer逻辑里也可以再次调用panic或抛出panic。如果defer中也有panic 那么会依次按照发生panic的顺序执行。

recover也是golang的一个内建函数, 其实就是try catch。
不过需要注意的是:
  1. recover如果想起作用的话, 必须在defer函数中使用。
  2. 在正常函数执行过程中,调用recover没有任何作用, 他会返回nil。如这样:fmt.Println(recover()) 。
  3. 如果当前的goroutine panic了,那么recover将会捕获这个panic的值,并且让程序正常执行下去。不会让程序crash。

package main

import "fmt"

func main() {
	fmt.Println("c")
	defer func() { // 必须要先声明defer,否则不能捕获到panic异常
		fmt.Println("d")
		if err := recover(); err != nil {
			fmt.Println(err) // 这里的err其实就是panic传入的内容
		}
		fmt.Println("e")
	}()
	f()              //开始调用f
	fmt.Println("f") //这里开始下面代码不会再执行
}

func f() {
	fmt.Println("a")
	panic("异常信息")
	fmt.Println("b") //这里开始下面代码不会再执行
}

/*
运行结果:
c
a
d
异常信息
e

Process finished with exit code 0
 */

可以有连续多个panic被抛出,连续多个panic的场景只能出现在延迟调用里面,否则不会出现多个panic被抛出的场景。但只有最后一次panic能被捕获。

package main

import "fmt"

func main() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	//只有最后一次panic调用能够被捕获
	defer func() {
		panic("first defer panic")
	}()

	defer func() {
		panic("second defer panic")
	}()

	panic("main body panic")
}

/*
运行结果:
first defer panic
*/

错误处理

Go的错误处理涉及接口的相关知识。
error
Go 语言内置错误接口类型error。任何类型只要实现Error() string方法,都可以传递error接口类型变量。Go语言典型的错误处理方式是将error作为函数最后一个返回值。在调用函数时,通过检测其返回的error值是否为nil来进行错误处理。

type error interface {
	Error() string
}

Go语言标准库提供的两个函数返回实现了error接口的具体类型实例,一般的错误可以使用这两个函数进行封装。遇到复杂的错误,用户也可以自定义错误类型,只要其实现error接口即可。例如:

//http://golang. org/src/pkg/fmt/print. go
//ErrOFf formats according to a format specifier and returns the string
//as a value that satisfies error.
func Errorf(format string, a... interface{}) errort {
	return errors.New(Sprintf(format,a...))
}
//http://golang. org/src/pkg/errors/errors. go
//New returns an error that formats as the given text.
func New(text string) error {
return &errorString{ text }
}

错误处理的最佳实践:

  • 在多个返回值的函数中,error通常作为函数最后一个返回值。
  • 如果一个函数返回error类型变量,则先用if语句处理error!=nil的异常场景,正常逻辑放到if语句块的后面,保持代码平坦。
  • defer 语句应该放到err判断的后面,不然有可能产生panic。
  • 在错误逐级向上传递的过程中,错误信息应该不断地丰富和完善,而不是简单地抛出下层调用的错误。这在错误日志分析时非常有用和友好。

错误和异常
广义上的错误:发生非期望的行为
狭义的错误:发生非期望的已知行为,这里的已知是指错误的类型是预料并定义好的。
异常:发生非期望的未知行为,未知是指错误的类型不在预先定义的错误。异常又被称为未捕获的错误。未捕获由操作系统进行异常处理,如C语言中的段错误。
错误关系如图:
在这里插入图片描述
Go是一门类型安全的语言,其运行时不会出现这种编译器和运行时都无法捕获的错误,也就是说,不会出现untrapped error,所以从这个角度来说,Go语言不存在所谓的异常,出现的“异常”全是错误。
Go程序需要处理的这些错误可以分为两类:

  • 一类是运行时错误(runtime errors),此类错误语言的运行时能够捕获,并采取措施—隐式或显式地抛出panic。
  • 一类是程序逻辑错误:程序执行结果不符合预期,但不会引发运行时错误。
    对于运行时错误,程序员无法完全避免其发生,只能尽量减少其发生的概率,并在不影响程序主功能的分支流程上“recover”这些panic,避免其因为一个panic引发整个程序的崩溃。

Go对于错误提供了两种处理机制:
(1)通过函数返回错误类型的值来处理错误。
(2)通过panic打印程序调用栈,终止程序执行来处理错误。

error和panic使用遵循如下规则:
(1)程序发生的错误导致程序不能容错继续执行,此时程序应该主动调用panic或由运行时抛出panic。
(2)程序虽然发生错误,但是程序能够容错继续执行,此时应该使用错误返回值的方式处理错误,或者在可能发生运行时错误的非关键分支上使用recover 捕获panic。

go的整个错误处理过程如图:
在这里插入图片描述
Go程序的有些错误是在运行时进行检测的,运行期的错误检测包括空指针、数组越界等。
如果运行时发生错误,则程序出于安全设计会自动产生panic。另外,程序在编码阶段通过主动调用panic来进行快速报错,这也是一种有效的调试手段。

Go 学习笔记(17)— 函数(03)[defer 定义、defer 特点、defer 释放资源] 1. defer 定义 Go 函数的关键字 defer 可以提供注册多个延迟调用,在 defer 归属的函数即将返回时,将延迟处理的语句按 defer 的逆序进行执行,这些调用遵循先进后出的顺序在函数返回前被执行。也就是说,先被 defer 的语句最后被执行,最后被 defer 的语句,最先被执行。 defer 常用于保证一些资源最终一定能够得到释放或者回收。 2. defer 示例 ... 阅读详情

相关推荐

go-expression:解析器,表达式

去表达 解析器,表达式

Go语言学习-函数

函数 Go不是一门纯函数式的编程语言,但是函数在Go中是“第一公民”,表现在: 函数是一种类型,函数类型变量可以像其他类型变量一样使用,可以作为其他函数的参数或返回值,也可以直接调用执行。 函数支持多值返回。 支持闭包。 函数支持可变参数。 Go是通过编译成本地代码且基于“堆栈”式执行的,Go的错误处理和函数也有千丝万缕的联系。 函数定义 函数是Go程序源代码的基本构造单位,一个函数的定义包括...

WindSun's Blog 530

嵌入式常见英文2500词总结

嵌入式常见英文总结

qq_28576837的博客 1万+

Go匿名函数

1、GO语言的匿名函数就是闭包 基本概念   闭包是可以包含自由(未绑定到特定对象)变量的代码块,这些变量不在这个代码块内或者任何全局上下文中定义,而是在定义代码块的环境中定义。要执行的代码块(由于自由变量包含 在代码块中,所以这些自由变量以及它们引用的对象没有被释放)为自由变量提供绑定的计算环境(作用域)。 闭包的价值   闭包的价值在于可以作为函数对象或者匿名函数,对于类型系

芸复山人 2483

Win11下Edge浏览器CPU占用飙升?试试这5个隐藏设置(附实测对比图)

本文详细解析了Win11下Edge浏览器CPU占用飙升的原因,并提供了5个关键设置优化方案,包括禁用硬件加速、管理扩展程序等,有效降低资源消耗。实测数据显示优化后CPU占用显著下降,适合Win11用户提升浏览器性能。

weixin_29266679的博客 1527

H3C交换机S-MLAG实战:如何用bond4模式实现服务器高可用(附避坑指南)

本文详细介绍了H3C交换机S-MLAG技术与服务器bond4模式的实战配置,帮助实现跨设备链路聚合的服务器高可用方案。通过解析S-MLAG技术优势、bond4模式选择、关键配置步骤及常见问题排查,提供了一套完整的避坑指南和优化建议,适用于企业级网络架构的高可用需求。

weixin_30790841的博客 466

golang:go语句函数调用引起的死锁问题

在 Go 语言规范中,关于 go 语句有这么一句描述:这里说明,go 语句后面的函数调用,其参数会先求值,这和普通的函数调用求值一样。在规范中调用部分是这样描述的:大意思是说,函数调用之前,实参就被求值好了。因此 语句中的 是在 main goroutine 中求值的。这相当于一个无缓冲的 chan,发送和接收操作都在一个 goroutine 中(main goroutine)进行,因此造成死锁。...

kingu_crimson的博客 564

基于ensp大学网络规划与设计(完整文档+ensp拓扑图)

大家好,我是小华学长,一名计算机领域的博主。经过多年的学习和实践,我积累了丰富的计算机知识和经验,在这里我想与大家分享我的学习心得和技巧,帮助你成为更好的程序员。 作为一名计算机博主,我一直专注于编程、算法、软件开发等领域,在这些方面积累了大量的经验。我相信分享是一种双赢的方式,通过分享,我可以帮助他人提升技术水平,同时也能够得到学习交流的机会。 在我的文章中,你将会看到我对于各种编程语言、开发工具以及常见问题的解析和分析。我会结合自己的实际项目经验,为你提供实用的解决方案和优化技巧。我相信这些经验不仅能够

qq1325513482的博客 5万+

go语言func后面括号_Golang语言基础教程:函数初识

1.1 什么是函数函数是执行特定任务的代码块。1.2 函数的声明go语言至少有一个main函数语法格式:func funcName(parametername type1, parametername type2) (output1 type1, output2 type2) { //这里是处理逻辑代码 //返回多个值 return value1, value2 } func:函数由 func 开...

weixin_28953819的博客 3341

嵌入式:简单的service框架

在嵌入式中,我们获取一个资源、设置一个变量、更新数据的话最直接的方式就是直接调用一个函数。这样的写法也可以满足基本的功能,前提是这个系统是只要一个任务,只有一个while(1)如图1.1。图1.1当有两个或者两个以上的任务的时候,同时调用一个函数(设置一个状态值、操作同一个资源、操作指针等行为)的流程如图1.2。图1.2当两个任务同时操作一个资源的时候,就会有重入的问题,会导致想不到的异常问题(数据不对、指针异常等)。

stupid的博客 987

每日算法讲解(十):使用BP神经网络进行回归任务

BP神经网络是由输入层、隐藏层和输出层组成的多层前馈神经网络,通过反向传播算法(Backpropagation)来调整网络权重和偏置,以最小化预测误差。前向传播:将输入数据通过网络,计算每层的激活值和输出。计算误差:根据预测值和真实值之间的差异计算损失函数值。反向传播:从输出层开始,逐层向后计算梯度,并更新每层的权重和偏置。重复迭代:通过多次迭代,逐步减小预测误差,优化模型参数。接下来,我们定义一个包含一个输入层、两个隐藏层和一个输出层的BP神经网络模型。# 定义模型# 编译模型。

rhtee的博客 1732

【Golang 基础系列十四】Go 语言函数

概述 函数是基本的代码块,用于执行一个任务 语法 函数定义 func 函数名称( 参数列表] ) (返回值列表]){ 执行语句 } 一.函数参数 无参数无返回 func add() 有参数有返回 func add(a, b int) int 函数值传递 func swap(x,y int) int { var temp int temp = x x = y y ...

郭枫的博客 647

Apache Hop集成Spring Boot实战:从配置到执行HPL文件

本文详细介绍了将Apache Hop集成到Spring Boot应用中的完整实战方案。通过配置核心依赖、初始化Hop环境、编写服务层逻辑,实现了在Java应用中程序化执行HPL管道文件,从而将可视化ETL能力无缝嵌入微服务架构,提升数据处理的自动化与可维护性。

blue42的博客 478

13 go语言(golang) - 函数

一个简单的函数定义包括关键字func、函数名、参数列表、返回值列表(可选)以及函数体。func 函数名(参数列表) 返回值类型 {函数体func:用于声明一个新函数。函数名:这是函数的名称。参数列表:表示该函数接的参数。返回值类型:表示该函数返回的结果类型,没有返回时可以省略。函数体:包含了实际执行操作的代码块。

瑞瑞的博客 918

Win10 系统下VisualStudio2022 配置Open3D-0.18.0(C++)

Win10 系统下VisualStudio2022 配置Open3D-0.18.0

点云侠的博客 2658

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Go语言自学系列 | golang 函数

视频来源:B站《golang入门到项目实战 [2021最新Go语言教程,没有废话,纯干货!持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记,并与大家分享,侵权即删,谢谢支持! 附上汇总贴:Go语言自学系列 | 汇总_COCOgsta的博客-优快云博客 golang函数简介 函数的go语言中的一级公民,我们把所有的功能单元都定义在函数中,可以重复使用。函数包含函数的名称、参数列表和返回值类型,这些构成了函数的签名(signature)。 go语言中函数特性 go语言中有3种函数:普

团爸讲算法 773

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

【Golang】Go语言函数

Go语言函数特点包括:无需声明原型、支持不定变参、多返回值、匿名函数和闭包,函数可作为类型赋值给变量,但不支持嵌套、重载和默认参数。文章介绍了基本函数定义格式、匿名函数、自执行函数(只执行一次)、闭包函数(返回函数的函数)以及延迟调用(defer)机制。通过示例代码展示了各种函数的使用方式,包括参数传递、返回值处理、函数赋值等特性。

weixin_73059729的博客 459

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Go语言自学系列 | golang函数的返回值

视频来源:B站《golang入门到项目实战 [2021最新Go语言教程,没有废话,纯干货!持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记,并与大家分享,侵权即删,谢谢支持! 附上汇总贴:Go语言自学系列 | 汇总_COCOgsta的博客-优快云博客 函数可以有0或多个返回值,返回值需要指定数据类型,返回值通过return关键字来指定。 return可以有参数,也可以没有参数,这些返回值可以有名称,也可以没有名称。go中的函数可以有多个返回值。 return关键字中指定了参数时,返

团爸讲算法 8146

Go语言自学系列 | golang高阶函数

视频来源:B站《golang入门到项目实战 [2021最新Go语言教程,没有废话,纯干货!持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记,并与大家分享,侵权即删,谢谢支持! 附上汇总贴:Go语言自学系列 | 汇总_COCOgsta的博客-优快云博客 go语言的函数,可以作为函数的参数,传递给另外一个函数,作为另外一个函数的返回值返回。 go语言函数作为参数 package main import "fmt" func sayHello(name string) {

团爸讲算法 920

【go语言】函数

在 go 语言中,函数是代码块的集合,用于执行特定任务或者计算。函数接受输入(成为参数),执行操作并返回输出(称为返回值)。go 语言中的函数定义非常简单且灵活。在 go 语言中,函数通过 func 关键字定义。func:用于声明函数。:函数的名字,通常首字母大写表示公开(exported)函数,首字母小写表示私有(unexported)函数。:参数列表(可选),参数使用name type的格式。多个参数之间用逗号分隔。returnType:返回值类型(可选)。如果函数没有返回值,则省略。

加油,考上985的研究生 1541

Golang基础语法(go语言函数、闭包)

/ 函数体func:函数关键字,任何一个函数都有func关键字开始声明。function_name:函数名称,参数列表和返回值类型构成了函数签名。parameter list:参数列表,参数列表指定的是参数类型、顺序、及参数个数。参数是可选的,也就是说函数也可以不包含参数。return_types:返回类型,函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值,这种情况下 return_types 不是必须的。函数体:函数定义的代码集合。

Atticus的博客 798

C语言竟可以调用Go语言函数,这是如何实现的?

大家好,我是飞哥!今天和大家聊一个问题,一门语言是否可以在同一个进程内调用另外一门语言实现的函数?例如 C 语言是否可以调用 Golang 实现的函数?注意我说的是同进程内调用,跨进程的 IPC、PRC 之类的技术不算。直接抛出这个问题的答案,同进程跨语言调用是可行的。在各种语言设计时,为了复用其它语言生态中积累下来的大量的代码资产,都会实现跨语言调用的机制。例如在 Golang 中,实现了 cg...

zhangyanfei01的专栏 974

Go语言学习笔记—golang函数

golang 函数

qq_39280718的博客 592

Go语言自学系列 | golang函数的参数

视频来源:B站《golang入门到项目实战 [2021最新Go语言教程,没有废话,纯干货!持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记,并与大家分享,侵权即删,谢谢支持! 附上汇总贴:Go语言自学系列 | 汇总_COCOgsta的博客-优快云博客 go语言函数可以有0或多个参数,参数需要指定数据类型。 声明函数时的参数列表叫做形参,调用时传递的参数叫做实参。 go语言是通过传值的方式传参的,意味着传递给函数的是拷贝后的副本,所以函数内部访问、修改的也是这个副本。 go语言可以

团爸讲算法 2392

【Golang 基础】 Go 语言 函数式编程

Go 语言函数式编程   在 Go 语言中函数是一等公民,它作为一个变量、类型、参数、返回值,甚至可以去实现一个接口,但是 Go 语言中函数不支持重载、嵌套和默认参数。 通过使用 func关键字来定义函数 package main func main(){ } 函数支持的特性 作为变量; func test(){ // 函数体 } funcTest := test fm...

hvkCoder的博客 534

golang延时_关于go 语言中的延迟执行函数

许多内置的带有返回值的函数无法进行延迟调用在go语言中,调用自定义函数的结果值可以全部不存在(丢弃)。但是,对于具有非空白返回结果列表的内置函数,他们的调用的结果不可以抛弃,copy和recover例外。 换句话说,延迟执行函数的结果必须被抛弃,所以许多内置函数无法被延迟。幸运的是,在实践中,很有偶需要延迟执行内置函数的地方。据我所知,只有append函数可能需要被延迟执行。这种情况下,我们可以把...

weixin_33205735的博客 4397
上一篇: Go语言—变量、数据类型、控制结构
下一篇: C++继承
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

code_peak

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值