go基础10-函数 参数传递，变长参数 多返回值

go函数传递参数 默认是按值传参  //传递参数值的一个副本，生成了一个新的内存地址

func add(a,b int) int{

　　a *=2

　　b *=3

　　return a+b

}

func main(){

　　x,y:=1,2

　　z := add(x,y)

　　fmt.Printf("add($d,$d) = $d\n",x,y,z)    //结果    add(1,2)=8

}

 

//引用传参      内存地址指向同一个

func add(a,b int) int {

　　*a *= 2//声明类型为指针

       *b *= 3

　　return a+b

}

func main(){

　　x,y :=1,2

　　z := add(&x,&y)//变量加&  语法是这样的

　　fmt.Printf("add(%d,$d)=%d",x,y,z)//       add(2,6) = 8

}

 

2 变长参数

变长参数是只参数的数量不确定      比如fmt.Printf   前面就是例子

基本定义和传值

只需要在参数类型前加上   ...  前缀就可以了

func   math(mumbers  ...int){//表示接受任意数量的int参数 

　　for _,number := range numbers{

　　　　fmt.Println(number)

　　}

}

 

这种变长参数 还支持 []int 类型的切片  传递参数时候 在末尾加上  ...  作为标识

例

slice = []int{1,2,3,4,5}

math(slice...)

math(slice[1:3]...)

 

...type参数 必须有是函数的最后一个参数

之所以支持切片 是因为 。。。type 本质就是一个切片  也就是 []type

 

2 任意类型的变长参数（泛型）

interface{}

比如   fmt.Printf的函数原型

func Printf(format string,args ...interface){

　　//

}

 

func myPrint(args ...interface){

　　for _,arg := range args{

　　　　switch reflect.TypeOf(arg).Kind(){

　　　　case reflect.Int:

　　　　　　fmt.Println(arg,“is an int value”)

　　　　case reflect.String:

　　　　　　fmt.Printf("%s is a string value".args)

　　　　case reflect.Array:

　　　　　　fmt.Println(arg,"is an  array type")

　　　　defatlt:

　　　　　　fmt.Println(arg,"is unknow type")

　　　　}　　　

　　}

}

 

func main(){

　　myPrint(1,"1",[1]int{1},true)

}

 

interface{} 是一个空接口 表示任意类型    reflect通过反射对数据进行类型检查   面向对象会介绍

 

多返回值  

go语言支持多返回值

func  add(a,b *int)(int,error){

　　if*a <0 || *b <0 {

　　　　err := errors.New("只支持非负数相加")　　

　　　　return 0，error

　　}

*a  *= 2

*b  *=3

return *a+*b, nil

}

func main(){

　　x,y = -1,2

　　z,err := add(&x,&y)

　　if error != nil{

　　　　fmt.Println(error.Error())

　　　　return 

　　}

　　fmt.Println("add($%d,%d)=%d",x,y,z)

}

 

3命名返回值

例子

func add(a,b *int)(c int ,err error){//c  err 命名了返回值

　　c = *a+*b

}