Golang -- 函数
函数声明func (p myType ) funcName ( a,b int,c string ) ( r,s int ) {
函数体
return 语句
}
函数调用我们知道C++的类中有 private,public,friend,可以控制类成员可见度。并且通过命名空间来减少命名冲突。Java也是如此。
其中第2中和第4中都是来自外部包,并且函数名称第一个字母都是大写字母,所不同的是标准包有Go提供,而用户自己创建的包由用户自己创建。 import "pcakageName"
packageName.FunctionName(参数)
第三种情况由于被掉函数 和 主调函数在同一个包中,所以直接调用即可,无需导入包名,并且函数首字母可以是小写字母 (这里,哪怕两个两个函数不在同一个文件中,只要在同一个包中即可)。 调用标准函数Golang 提供了 大量的包和实用函数 供用户使用,这些函数被称为标准函数。常见的标准包有
调用自定义函数通常,一个可执行的Go程序一般都有一个 main 包,在 main包中必须声明一个 main 函数。 调用 外部包的函数如果需要调用外部包的函数,那么需要导入这个包,才能调用相关函数(首字母必须大写)。 比如构建 package mymath
func Add(a,b int) int {
return (a + b)
}
func Sub(a,b int) int {
return (a - b)
}
func Mult(a,b int) int {
return (a * b)
}
func Div(a,b int) int {
if b != 0 {
return float32(a) / float32(b)
} else {
return 0
}
}
调用内置函数13个内置函数,这些内置函数,非常有用。 参数传递参数传递主要是为了在函数之间,传递数据。 常规传递指针传递数组元素 作为参数数组名 作为参数 (将会进行数组的整体复制)package main
import (
"fmt"
)
func main() {
var b = [5]int {1, 2, 3, 4, 5}
f4(b)
fmt.Println(b[0])
}
func f4(a [5]int) {
a[0] += 1
fmt.Println(a[0]) //不会影响原先的数组。因为传递数组名是指拷贝
}
在使用 数组名 作为参数的时候,实参类型和形参类型必须一致。 比如实参 b的类型是 [5]int,那么形参的类型也应该是 [5]int。 将形参定义为 []int,[10]int 等类型都是错误的,而C语言往往允许这么做。 Slice 作为函数参数
函数作为参数传递函数也是一种数据类型,可以将一个函数赋值给一个变量。 func main(){
var a,b int = 3, 4
f := sum
f1(a,b,f)
}
func f1(a,sum func(int,int) int) int {
fmt.Println(sum(a,b))
}
func sum(a,b int) int {
return (a+b)
}
返回值返回值: 允许多个返回值,并且允许定义返回值变量,这样return 语句可以更加方便。 func f2(a,b int) (int,float32){ //多个返回值 需要一个括号
return a *b,float32(a) / float32(b)
}
同时在调用函数的时候,也可以忽略返回值。 func main() {
ret,_ := f2(3, 6) //可以忽略返回值
}
func f2(a,float32){
return a *b,float32(a) / float32(b)
}
可以命名返回值参数,这样在return 的时候,就可以不用直接写返回值了。 func main() {
sum,sub = f3(3, 6)
fmt.Println(sum,sub)
}
func f3(a,b int) (sum,sub int) { //直接命名了返回值参数,需要一个括号
sum = a + b
sub = a - b
return
}
变参函数形式参数的 类型 和 个数 都是可以变化的。 变参函数的声明func functionName (variableArgumetName ... dataType) returnValue {...}
(1) 变参的类型是”…类型“,而且变参必须是函数的最后一个参数。如果函数还有其他的参数,比如放在 变参的前面。 package main
import "fmt"
func main() {
f1(1, 3)
f1(4, 5, 6, 7)
}
func f1(args ...int) {
fmt.Println(args)
}
输出为:
[1 2 3]
[4 5 6 7]
变参函数的 传递一个变参函数,如何将这些变参传递给另外一个 变参函数呢? package main
import "fmt"
func main() {
f2(1, 3)
f2(4, 7)
}
func f1(args ...int) {
fmt.Println(args)
}
func f2(args ...int) {
f1(args...)
f1(args[2:]...)
}
不定长的变参在进行参数传递的是偶虽然接受到的是一个 Slice,但是和直接传递一个Slice还是有区别的:不定长参数在传递一个 Slice的时候,它仅仅是获取 Slice的一个副本,对这个副本进行操作,不会改变原先的Slice的值。 任意类型的 变参函数当用户希望传递不同类型的参数的时候,就像 fmt.Printf() 可以接受 int string 等各种类型。 func f1(args... interface{}) //指定变参类型为 interface{}
在Go语言中,interface{} 可以指向任何数据类型,所以可以使用 interface{}定义任意类型的变参。 同时 interface{] 也是类型安全的。 (对所有数据类型的抽象。。。吗?) package main
import (
"fmt"
)
func main() {
f1(2,"go", 8,"language",'a',false,"A", 3.24)
}
// 采用 interface {} 作为类型
func f1(args ...interface{}) {
var num = make([]int, 0, 6)
var str = make([]string, 6)
var ch = make([]int32, 6) //字符类型,是int32的哦!
var other = make([]interface{}, 6) //采用 interface{}作为类型
for _,arg := range args {
switch v := arg.(type) { //这个是什么用法?
case int:
num = append(num,v)
case string:
str = append(str,v)
case int32: //这里 'a' 被统计到了 int32中。
ch = append(ch,v)
default:
other = append(other,v)
}
}
fmt.Println(num)
fmt.Println(str)
fmt.Println(ch)
fmt.Println(other)
}
输出为:
[2 8]
[go language A]
[97]
[false 3.24]
可以看到: Go 语言是类型安全的。 匿名函数声明: func (参数列表)(返回值){函数体} //注意没有函数名,所以称为匿名函数
func (a,b int) int {
return (a + b)
}
package main
import (
"fmt"
)
func main() {
//声明 并且直接将 匿名函数 赋值 给变量f
f := func(a,b int) int {
return a + b
}
// 对函数类型的变量尽心调用
sum := f(2, 3)
fmt.Println(sum)
// 声明 并且 直接执行 匿名函数
sum = func(a,b int) int {
return a + b
}(2, 3)
fmt.Println(sum)
}
注意: 使用 匿名函数,不能将它作为顶级函数使用,也就是说一定要将它放在其他函数的函数体中。 函数闭包closure: defer 语句
Golang 异常恢复机制golang 的 异常恢复机制,是采用 panic() / recover() 的机制。 这些都是 内置函数。 (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |