错误码方式 VS 异常机制

      先来看一段代码,  是不是很眼熟：

package main 

import (
	"fmt"
	"errors"
)

func low(money int) (int, error) {
	if money < 1 {
		return money, errors.New(fmt.Sprintf("invalid 1---> %d", money))
	}

	return money - 1, nil
}


func middle(money int) (int, error) {
	if money < 2 {
		return money, errors.New(fmt.Sprintf("invalid 2---> %d", money))
	}

	return money - 2, nil
}


func high(money int) (int, error) {
	if money < 3 {
		return money, errors.New(fmt.Sprintf("invalid 3---> %d", money))
	}

	return money - 3, nil
}


func main() {

	money := 5
	money, err := low(money)
	if err != nil {
		fmt.Println(err)
		return 
	}

	money, err = middle(money)
	if err != nil {
		fmt.Println(err)
		return 
	}

	money, err = high(money)
	if err != nil {
		fmt.Println(err)
		return 
	}
	
	fmt.Println("money is", money)
}

        看看main函数中那些调用吧， 正常的代码倒没有多少， 错误处理的代码倒是很多。 看着就烦， 为什么不用异常机制呢？来看看改进方法：

package main 

import (
	"fmt"
	"runtime/debug"
)

func low(money int) (int) {
	if money < 1 {
		panic(fmt.Sprintf("invalid 1---> %d", money))
	}

	return money - 1
}


func middle(money int) (int) {
	if money < 2 {
		panic(fmt.Sprintf("invalid 2---> %d", money))
	}

	return money - 2
}


func high(money int) (int) {
	if money < 3 {
		panic(fmt.Sprintf("invalid 3---> %d", money))
	}

	return money - 3
}


func main() {

	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err, string(debug.Stack()))
		}
	}()

	// 只用关心正常流程， 爽爽哒
	money := 1
	money = low(money)
	money = middle(money)
	money = high(money)
	
	fmt.Println("money is", money)

}

        清爽很多， 异常机制就是好，

        不多说。