1.朴素方法

在函数起始位置计算当前时间，在函数结束位置算出耗时。

package main

import (
    "fmt"
    "time"
)

func sum(n int) int {
	startT := time.Now()		//计算当前时间
	
    total := 0
    for i:=1; i <= n; i++ {
        total += i
    }
	
	tc := time.Since(startT)	//计算耗时
	fmt.Printf("time cost = %v\n", tc)
    return total
}

func main() {
    count := sum(100)
	fmt.Printf("count = %v\n", count)
}

编译运行输出：

time cost = 350ns
count = 5050
2.简洁方法

计算当前时间与计算耗时放在两处，难免显得丑陋，且不易阅读。如果有多个函数需要统计耗时，那么多处书写重复的两行代码会造成代码冗余。由于 Golang 提供了函数延时执行的功能，借助 defer ，我们可以通过函数封装的方式来避免代码冗余。

package main

import (
    "fmt"
    "time"
)

//@brief：耗时统计函数
func timeCost(start time.Time){
	tc:=time.Since(start)
	fmt.Printf("time cost = %v\n", tc)
}

func sum(n int) int {
	defer timeCost(time.Now())
    total := 0
    for i:=1; i <= n; i++ {
        total += i
    }
	
    return total
}

func main() {
    count := sum(100)
	fmt.Printf("count = %v\n", count)
}

编译运行输出：

time cost = 1.574µs
count = 5050

通过输出可以看到sum()耗时增加了，因为增加了一次timeCost()函数调用。不过相比于函数封装带来的便利与代码美观，新增的耗时是微不足道可以接受的。

3.优雅方法

每次调用耗时统计函数timeCost()都需要传入time.Now()，重复书写time.Now()无疑造成了代码冗余。我们在上面的基础上，进行进一步的封装，实现如下。

package main

import (
    "fmt"
    "time"
)

//@brief：耗时统计函数
func timeCost() func() {
	start := time.Now()
	return func() {
		tc:=time.Since(start)
		fmt.Printf("time cost = %v\n", tc)
	}
}

func sum(n int) int {
	defer timeCost()()		//注意，是对 timeCost()返回的函数进行调用，因此需要加两对小括号
    total := 0
    for i:=1; i <= n; i++ {
        total += i
    }
	
    return total
}

func main() {
    count := sum(100)
	fmt.Printf("count = %v\n", count)
}

编译运行输出：

time cost = 1.204µs
count = 5050