go学习（5）、整型以及进制之间的转换、math数学运算

一、整型

Go中的整型分为有符号和无符号两大类，有符号的包含负值，无符号不包含负值。

1、有符号整型：

• int8（-128 -> 127）

• int16（-32768 -> 32767）

• int32（-2,147,483,648 -> 2,147,483,647）

• int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

• int

  • 在 32 位操作系统上使用 32 位（-2,147,483,648 -> 2,147,483,647） 2**32

  • 在 64 位操作系统上使用 64 位（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,80）2**64

2、无符号整数：

• uint8（0 -> 255）

• uint16（0 -> 65,535）

• uint32（0 -> 4,294,967,295）

• uint64（0 -> 18,446,744,073,709,551,615）

• uint

  • 在 32 位操作系统上使用32 位（0 -> 4,294,967,295） 2**32

  • 64 位操作系统上使用 64 位（0 -> 18,446,744,073,709,551,615） 2**64

不同整型可表示的数据范围不同，不同数据类型之间不能进行直接的运算

3、整型之间的转换

注意：

• 低位转高位，没问题。

• 高位转低位，会出现问题，如下：

        由于int8表示的范围为（-128-127），所以int8最大表示的数为127。而以下的值均都大于127，所以在高位转低位时出现的轮回的现象即，-128，-127，-126.........

var i int16 = 128
var j int16 = 129
var k int16 = 130
fmt.Println(int8(i), int8(j), int8(k))
//
-128 -127 -126

var i int8 = 1
var j int16 = 2
c := int16(i) + j
fmt.Println(c)

4、整型与字符串相互转换

整型转字符串

string：可接受所有整型类型

strconv.Itoa(i int)：只接受int类型

//1
var num int32 = 666
fmt.Println(string(num), reflect.TypeOf(num))
//2
var num2 int = 123
fmt.Println(strconv.Itoa(num2), reflect.TypeOf(num2))//Itoa只接收转换int类型

字符串转整型

通过strconv.AtoI(s String)将字符串转换为整型，该函数会返回两个值：

        result：转换成功为整型数字，转换不成功为0

        err：转换成功为空，转换不成功为错误提示

成功 

s := "666"
result, err := strconv.Atoi(s)
if err != nil {
	fmt.Println(err)
}else {
	fmt.Println(result, reflect.TypeOf(s))
}

//
666 string

失败
 

s := "sb"
result, err := strconv.Atoi(s)
if err != nil {
	fmt.Println(err)
} else {
	fmt.Println(result, reflect.TypeOf(s))
}

//
strconv.Atoi: parsing "sb": invalid syntax

二、进制之间的转换

• Go代码中：

  • 十进制，以整型的方式存在。

  • 其他进制，是以字符串的形式存在。

1、十进制（整型）转二进制、八进制、十六进制（字符型）

 strconv.FormatInt(i int64，base int），接收两个参数

        i：需要进行转换的数据，类型为int64

        base : 需要转换的进制 ，类型为int

num := 88
r := strconv.FormatInt(int64(num), 16)
fmt.Println(r, reflect.TypeOf(r))

//
58 string

2、二进制、八进制、十六进制（字符型） 转 十进制（整型）

strconv.ParseInt(s string, base int, i int):

        接收三个参数：

                s：需要转换为十进制即整型（int64）的数据，类型需为字符串

                base: 将s当作什么进制转换为十进制，如2、8、16，类型需为int

                i：转换的过程中对结果进行约束，类型需为int

        返回值：

                result：成功即为转换后的十进制整型数据（int64），失败即为0

                err : 成功为空，失败为提示信息

        

s := "11001"
result, err := strconv.ParseInt(s, 2, 64)
if err != nil {
	fmt.Println(err)
} else {
	fmt.Println(result, reflect.TypeOf(result))
}

//
25 int64

3、例题

十进制转换为十六进制

num := 14
fmt.Println(strconv.FormatInt(int64(num), 16))
//
e

二进制转换为十进制

str := "1101"
result1, _ := strconv.ParseInt(str, 2, 64)
fmt.Println(result1)

//
13

二进制转换为十六进制

先将二进制转换为10进制

再将十进制转换为十六进制

str2 := "1101"
//二进制先转换为十进制
result2, _ := strconv.ParseInt(str2, 2, 64)
//十进制转换为十六进制
fmt.Println(strconv.FormatInt(result2, 16))
//
d

 三、math包进行数学运算

fmt.Println(math.Abs(-19))                // 取绝对值
fmt.Println(math.Floor(3.14))             // 向下取整
fmt.Println(math.Ceil(3.14))              // 向上取整
fmt.Println(math.Round(3.3478))           // 就近取整
fmt.Println(math.Round(3.5478*100) / 100) // 保留小数点后两位
fmt.Println(math.Mod(11, 3))              // 取余数，同11 % 3
fmt.Println(math.Pow(2, 5))               // 计算次方，如：2的5次方
fmt.Println(math.Pow10(2))                // 计算10次方，如：2的10次方
fmt.Println(math.Max(1, 2))               // 两个值，取较大值
fmt.Println(math.Min(1, 2))               // 两个值，取较小值


/*
19
3
4
3
3.55
2
32
100
2
1
*/