Go 语言中，函数被称为“一等公民”、 reflect 包支持种类值

喜欢ヅ旅行 2023-10-14 13:31 9阅读 0赞

#### 阅读目录 ####

*  golang中reflect包支持种类值
 *  Go 语言中，函数被称为“一等公民”
 *   *  1 存储在变量中
     *  2 作为参数传递给其他函数
     *  3 可以在函数中创建，并作为返回值
     *  4 函数特性
     *   *  go语言中函数特性
         *  go语言函数的返回值特性
         *  go语言函数的参数特性

## golang中reflect包支持种类值 ##

布尔型（bool）

整型（int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64、uintptr）

浮点型（float32、float64）

复数型（complex64、complex128）

字符串型（string）

字节型（byte、rune）

指针型（pointer）

接口型（interface）

切片型（slice）

数组型（array）

结构体型（struct）

函数型（func）

映射型（map）

通道型（chan）

## Go 语言中，函数被称为“一等公民” ##

“一等公民”的特性是可以存储在变量中，可以作为参数传递给函数，可以在函数中创建并作为返回值从函数返回。

### 1 存储在变量中 ###

Go 语言的函数可以作为变量的值，存储在变量中。

package main
    
    import "fmt"
    
    func main() {
        
    	var hello = func(name string) {
         fmt.Printf("hello %s\n", name) }
    	hello("gopher")
    }

阅读上面这段代码，我们定义一个变量 hello，和一个匿名函数，将匿名函数赋值给变量 hello，我们可以通过变量调用该匿名函数。

### 2 作为参数传递给其他函数 ###

Go 语言的函数可以作为参数，传递给其他函数。

package main
    
    import (
    	"fmt"
    	"strings"
    )
    
    func main() {
        
    	strings := []string{
        "hello", "world", "Go", "programming"}
    
    	upperCaseStrings := ProcessStrings(strings, stringsToUpper) // 转换为大写
    	fmt.Println("Upper case:", upperCaseStrings)
    
    	lowerCaseStrings := ProcessStrings(strings, stringsToLower) // 转换为小写
    	fmt.Println("Lower case:", lowerCaseStrings)
    }
    
    type StringOperation func(string) string
    
    func ProcessStrings(strings []string, op StringOperation) []string {
        
    	result := make([]string, len(strings))
    	for i, str := range strings {
        
    		result[i] = op(str)
    	}
    	return result
    }
    
    func stringsToUpper(str string) string {
        
    	return strings.ToUpper(str)
    }
    
    func stringsToLower(str string) string {
        
    	return strings.ToLower(str)
    }

PS E:\TEXT\test> go run .
    Upper case: [HELLO WORLD GO PROGRAMMING]
    Lower case: [hello world go programming]
    PS E:\TEXT\test>

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func main() {
        
    	fmt.Println(math.Pi)
    	area := Circle(5, areaOfCircle)
    	fmt.Printf("area:%.2f\n", area)
    
    	perimeter := Circle(5, perimeterOfCircle)
    	fmt.Printf("perimeter:%.2f\n", perimeter)
    }
    
    func Circle(r float64, op func(float64) float64) float64 {
        
    	return op(r)
    }
    
    func areaOfCircle(r float64) float64 {
        
    	return math.Pi * r * r
    }
    
    func perimeterOfCircle(r float64) float64 {
        
    	return 2 * math.Pi * r
    }

PS E:\TEXT\test> go run .
    3.141592653589793
    area:78.54     
    perimeter:31.42
    PS E:\TEXT\test>

阅读上面这段代码，我们定义三个函数，分别是 Circle、areaOfCircle 和 perimeterOfCircle，其中 areaOfCircle 和 perimeterOfCircle 作为 Circle 的参数，分别用于计算面积和周长。

### 3 可以在函数中创建，并作为返回值 ###

Go 语言的函数可以在函数体中创建，并作为返回值从函数体中返回。

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    func main() {
        
    	calcArea := CircleCalc("area")
    	fmt.Println(calcArea(5))
    	calcPerimeter := CircleCalc("perimeter")
    	fmt.Println(calcPerimeter(5))
    }
    
    func CircleCalc(s string) func(float64) float64 {
        
    	switch s {
        
    	case "area":
    		return func(r float64) float64 {
        
    			return math.Pi * r * r
    		}
    	case "perimeter":
    		return func(r float64) float64 {
        
    			return 2 * math.Pi * r
    		}
    	default:
    		return nil
    	}
    }

PS E:\TEXT\test> go run .
    78.53981633974483
    31.41592653589793
    PS E:\TEXT\test>

阅读上面这段代码，我们定义一个函数 CircleCalc，在其函数体中定义两个匿名函数，并将匿名函数作为返回值从函数体中返回。

### 4 函数特性 ###

#### go语言中函数特性 ####

*  go语言中有 3 种函数：  
    普通函数、匿名函数(没有名称的函数)、方法(定义在struct上的函数)。receiver
 *  go语言中不允许函数重载(overload)，也就是说不允许函数同名。
 *  go语言中的函数不能嵌套函数，但可以嵌套匿名函数。
 *  函数是一个值，可以将函数赋值给变量，使得这个变量也成为函数。
 *  函数可以作为参数传递给另一个函数。
 *  函数的返回值可以是一个函数。
 *  函数调用的时候，如果有参数传递给函数，则先拷贝参数的副本，再将副本传递给函数。
 *  函数参数可以没有名称。

#### go语言函数的返回值特性 ####

*  return可以有参数，也可以没有参数，这些返回值可以有名称，也可以没有名称。  
    go中的函数可以有多个返回值。
 *  return关键字中指定了参数时，返回值可以不用名称。  
    如果return省略参数，则返回值部分必须带名称。
 *  当返回值有名称时，必须使用括号包围，逗号分隔，即使只有一个返回值。
 *  但即使返回值命名了，return中也可以强制指定其它返回值的名称，也就是说return的优先级更高。
 *  命名的返回值是预先声明好的，在函数内部可以直接使用，无需再次声明。命名返回值的名称不能和函数参数名称相同，否则报错提示变量重复定义。
 *  return中可以有表达式，但不能出现赋值表达式，这和其它语言可能有所不同。例如return a+b是正确的，但return c=a+b是错误的。

#### go语言函数的参数特性 ####

*  go语言函数可以有 0 或多个参数，参数需要指定数据类型。
 *  声明函数时的参数列表叫做形参，调用时传递的参数叫做实参。
 *  go语言是通过传值的方式传参的，意味着传递给函数的是拷贝后的副本，所以函数内部访问、修改的也是这个副本。
 *  go语言可以使用变长参数，有时候并不能确定参数的个数，可以使用变长参数，可以在函数定义语句的参数部分使用ARGS…TYPE的方式。这时会将…代表的参数全部保存到一个名为ARGS的slice中，注意这些参数的数据类型都是TYPE。