字符串与数值之间进行转换是一个高频操作，在go语言中，SDK提供 strconv.ParseInt 将字符串转换为数值，strconv.FormatInt 可以将数值转换为字符串。

1.首先看下 strconv.ParseInt 函数如何使用：

func ParseInt(s string, base int, bitSize int) (i int64, err error){}

参数:

• s：数字的字符串形式
• base：数字字符串的进制，比如：2进制、10进制。
• bitSize：预期数值的bit大小，用于数值上限限制，最终返回的还是int64类型

2.下面看下函数的具体实现：

strconv.ParseInt 是 strconv.ParseUint 的一个包装层，区别在数值结果的基础上处理符号，因此具体的实现在strconv.ParseUint里面。

func ParseUint(s string, base int, bitSize int) (uint64, error) {
        ...
	case base == 0:
		// Look for octal, hex prefix.
		base = 10    // 当base = 0，默认 base 按赋值10进制
		if s[0] == '0' {
			switch {
			case len(s) >= 3 && lower(s[1]) == 'b':    // 根据字符串的前缀，来判断二进制。下面同理
				base = 2
				s = s[2:]
			case len(s) >= 3 && lower(s[1]) == 'o':
				base = 8
				s = s[2:]
			case len(s) >= 3 && lower(s[1]) == 'x':
				base = 16
				s = s[2:]
			default:
				base = 8    // 当 0 开头，默认8进制
				s = s[1:]
			}
		}
	default:
		return 0, baseError(fnParseUint, s0, base)
	}
}

根据进制 base 进制数计算数值，支持2~ 36进制[0-9A-Z]

func ParseUint(s string, base int, bitSize int) (uint64, error) {
      ...
      // 逐个字符判断，然后累加求和
      for _, c := range []byte(s) {
		var d byte
		switch {
		case c == '_' && base0:
			underscores = true
			continue
		case '0' <= c && c <= '9':
			d = c - '0'
                 // 支持2 ~ 36进制
		case 'a' <= lower(c) && lower(c) <= 'z':
			d = lower(c) - 'a' + 10
		default:
			return 0, syntaxError(fnParseUint, s0)
		}

		if d >= byte(base) {
			return 0, syntaxError(fnParseUint, s0)
		}

		if n >= cutoff {
			// n*base overflows
			return maxVal, rangeError(fnParseUint, s0)
		}
		n *= uint64(base)

		n1 := n + uint64(d)
		if n1 < n || n1 > maxVal {
			// n+v overflows
			return maxVal, rangeError(fnParseUint, s0)
		}
		n = n1
	}
}

3.使用strconv.FormatInt将数值转换为字符串

func FormatInt(i int64, base int) string {}

参数：

• i：10进制数值
• base：进制数

示例：

 // 将10进制数 15 转换为 16 进制的字符串形式
func Test_FormatUint(t *testing.T) {
	val := strconv.FormatUint(15, 16)
	fmt.Println(val) // output：f
}