Golang——2、基本数据类型和运算符
基本数据类型和运算符
- 1、基本数据类型
- 1.1、整形
- 1.2、浮点型
- 1.3、布尔值
- 1.4、字符串
- 1.5、byte和rune类型
- 1.6、修改字符串
- 2、基本数据类型之间的转换
- 2.1、数值类型之间的相互转换
- 2.2、其他类型转换成string类型
- 2.3、string类型转换成数值类型
- 3、Golang中的运算符
- 3.1、算数运算符
- 3.2、关系运算符
- 3.3、逻辑运算符
- 3.4、赋值运算符
- 3.5、位运算符
1、基本数据类型
Go语言中数据类型分为：基本数据类型和复合数据类型
基本数据类型有：整型、 浮点型、 布尔型、 字符串
复合数据类型有：数组、切片、结构体、函数、map、通道(channel)、接口等。
1.1、整形
整型分为以下两个大类：
有符号整形按长度分为：int8、int16、int32、int64。
对应的无符号整型：uint8、uint16、uint32、uint64。
package main import ( "fmt" "unsafe" ) func main() { // 使用unsafe.Sizeof查看存储空间 var num int = 20 fmt.Printf("num: %v, num类型为: %T, 所占字节数: %d\n", num, num, unsafe.Sizeof(num)) var num1 int8 = 111 var num2 int16 = 300 var num3 int32 = 1000 var num4 int64 = 55434 fmt.Printf("num1: %v, num类型为: %T, 所占字节数: %d\n", num1, num1, unsafe.Sizeof(num1)) fmt.Printf("num2: %v, num类型为: %T, 所占字节数: %d\n", num2, num2, unsafe.Sizeof(num2)) fmt.Printf("num3: %v, num类型为: %T, 所占字节数: %d\n", num3, num3, unsafe.Sizeof(num3)) fmt.Printf("num4: %v, num类型为: %T, 所占字节数: %d\n", num4, num4, unsafe.Sizeof(num4)) }
两种不同的类型相加，涉及到类型转换问题：
var a1 int32 = 10 var a2 int64 = 20 fmt.Println(int64(a1) + a2) // 将a1转换成int64 fmt.Println(a1 + int32(a2)) // 将a2转换成int32
但是要注意高位向地位转换的情况，可能会发生截断。
数字字面量语法：Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：v := 0b00101101， 代表二进制的101101，相当于十进制的45。 v := 0o377， 代表八进制的377，相当于十进制的255。v := 0x1p-2，代表十六进制的1除以 2²，也就是0.25。而且还允许我们用_来分隔数字，比如说：v := 123_456 等于123456。
var a = 11 fmt.Printf("a=%v\n", a) // 原样输出 fmt.Printf("a=%d\n", a) // 十进制输出 fmt.Printf("a=%b\n", a) // 二进制输出 fmt.Printf("a=%o\n", a) // 八进制输出 fmt.Printf("a=0x%x\n", a) // 十六进制输出
1.2、浮点型
Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准：float32的浮点数的最大范围约为3.4e38，可以使用常量定义：math.MaxFloat32。float64的浮点数的最大范围约为1.8e308，可以使用一个常量定义：math.MaxFloat64。
打印浮点数可以使用%f，默认保留六位小数，使用%v就是原样输出。
package main import ( "fmt" "unsafe" ) func main() { var f1 float32 = 3.1415 fmt.Printf("f1: %v--%f--%.2f, 类型为: %T, 所占字节数: %d\n", f1, f1, f1, f1, unsafe.Sizeof(f1)) var f2 float64 = 3.1513213 fmt.Printf("f2: %v--%f--%.2f, 类型为: %T, 所占字节数: %d\n", f2, f2, f2, f2, unsafe.Sizeof(f2)) }
Golang中浮点数默认是float64：
f3 := 2.12345 fmt.Printf("f3: %v--%f--%.2f, 类型为: %T, 所占字节数: %d\n", f3, f3, f3, f3, unsafe.Sizeof(f3))
Golang中浮点数精度丢失问题：
d := 1129.6 fmt.Println(d * 100) m1 := 8.2 m2 := 3.3 fmt.Println(m1 - m2)
这里我们期望输出的分别是112960和4.9，但是由于精度损失，所以不符合我们预期。
怎么解决呢？可以使用第三方包来解决：https://github.com/shopspring/decimal
这个后面再细说。
Golang科学计数法表示浮点数类型：
f4 := 3.14e2 f5 := 3.14e-2 fmt.Printf("f4: %v--%f\n", f4, f4) fmt.Printf("f5: %v--%f\n", f5, f5)
1.3、布尔值
Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true(真)和false(假)两个值。
注意：
1、布尔类型变量的默认值为false。
2、Go语言中不允许将整型强制转换为布尔型。
3、布尔型无法参与数值运算，也无法与其他类型进行转换。
var flag1 bool flag2 := true fmt.Printf("flag1: %v\n", flag1) fmt.Printf("flag2: %v\n", flag2)
另外，整形和浮点型数据不初始化默认为0，string类型不初始化默认为空串。
注意点2、3，bool不行与其他类型转换，也不能用整数转bool，这点与C/C++以示区分。
if flag2 { fmt.Println("true") } else { fmt.Println("false") }所以上面if条件判断里面就不能写一个整数。
1.4、字符串
Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型(int、 bool、float32、 float64等)一样。Go语言里的字符串的内部实现使用UTF-8编码。
package main import "fmt" func main() { var s1 string = "hello world" s2 := "hello world" fmt.Println(s1, s2) }
Golang中定义一个多行字符串时，需要使用到反引号字符`：
s3 := `hello 鹏哥, hello 杭哥, hello 蛋哥。` fmt.Println(s3)
// 1.len计算字符串长度 var str1 = "hello golang" fmt.Println(len(str1)) // 2.fmt.Sprintf拼接字符串 var str2 = "hello C++" str3 := str1 + " " + str2 str4 := fmt.Sprintf("%v %v", str1, str2) fmt.Println(str3) fmt.Println(str4) // 3.strings.Split分割字符串 str5 := "123-456-789" arr := strings.Split(str5, "-") // 返回值是一个切片 fmt.Println(arr) // 4.strings.contains判断是否包含 str6 := "this is string" var flag = strings.Contains(str6, "this") fmt.Println(flag) // 5.前缀/后缀判断 strings.HasPrefix/strings.HasSuffix var flag1 = strings.HasPrefix(str6, "is") var flag2 = strings.HasSuffix(str6, "string") fmt.Printf("flag1: %v, flag2: %v\n", flag1, flag2) // 6.获取字串的下标 strings.Index() / strings.LastIndex() pos1 := strings.Index(str6, "is") pos2 := strings.LastIndex(str6, "ing") fmt.Printf("pos1: %v, pos2: %v\n", pos1, pos2) // 找不到返回-1 // 7.strings.Join操作，将切片转换成字符串 str7 := strings.Join(arr, "-") fmt.Println(str7)
1.5、byte和rune类型
组成每个字符串的元素叫做“字符”， 可以通过遍历字符串元素获得字符。 字符用单引号（’）包裹起来。
var a = 'a' fmt.Printf("值: %v, 字符: %c, 类型: %T\n", a, a, a) var str = "this is string" fmt.Printf("值: %v, 字符: %c, 类型: %T\n", str[2], str[2], str[2])
golang中定义字符属于int类型，可以看到上面a的类型是int32，字符串中字符类型是uint8。
如果要计算字符串占用字节数呢？可以使用unsafe.Sizeof吗？
var str = "this is string" fmt.Printf("str所占字节数为: %d\n", unsafe.Sizeof(str))
实际上str字符串所占字节数应该是14个字节，但是计算出来的确实16。所以不能使用unsafe.Sizeof来计算，需要使用len函数来计算。
var str1 = "hello world" var str2 = "你好golang" fmt.Printf("str1所占字节数为: %d\n", len(str1)) fmt.Printf("str2所占字节数为: %d\n", len(str2))
str2所占字节数为12，这是因为golang中汉字采用的是utf8编码，所以一个汉字占3个字节，英文字母占一个字节，所以算下来总共12字节。
var ch = '你' fmt.Printf("值: %v, 字符: %c, 类型: %T\n", ch, ch, ch)
Go 语言的字符有以下两种：
1、uint8类型，或者叫byte型，代表了ASCII码的一个字符。
2、rune类型，代表一个UTF-8字符。
当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。
Go使用了特殊的rune类型来处理Unicode，让基于Unicode的文本处理更为方便，也可以使用byte型进行默认字符串处理，性能和扩展性都有照顾。
下面看遍历字符串：
var str = "hello 你好" for i := 0; i
这样遍历对于纯英文数字的字符串是没有问题的，但是对于有中文汉字的字符串就不行了。因为这样遍历每次是取一个字节出来，所以对于有汉字的字符串不能这样遍历。
而应该采下面rune的遍历方式：
var str = "hello 你好" for _, ch := range str { // rune fmt.Printf("%v(%c) ", ch, ch) }
1.6、修改字符串
要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。
var str1 = "hello golang" byteStr := []byte(str1) byteStr[0] = 'H' fmt.Println(string(byteStr)) var str2 = "你好 golang" runeStr := []rune(str2) runeStr[0] = '哈' fmt.Println(string(runeStr))
2、基本数据类型之间的转换
2.1、数值类型之间的相互转换
注意：golang中只有强制类型转换，没有隐式类型转换。
// 1.整形和整形之间的转换 var a int8 = 20 var b int16 = 111 fmt.Println(int16(a) + b) // 2.浮点型和浮点型之间的转换 var f1 float32 = 3.1415 var f2 float64 = 3.2131 fmt.Println(float64(f1) + f2) // 3.整形和浮点型之间的转换 var x int = 30 var y float64 = 3.154 fmt.Println(float64(x) + y)
一般是从低位向高位进行转换，高位向低位转换可能会溢出。
2.2、其他类型转换成string类型
1、sprintf把其他类型转换成string类型。
package main import "fmt" func main() { var i int = 20 var f float64 = 3.1415 var b bool = true var ch = 'a' str := fmt.Sprintf("%d %f %t %c", i, f, b, ch) fmt.Printf("值: %v, 类型: %T\n", str, str) }
注意：Sprintf使用中需要注意转换的格式int为%d、float为%f、bool 为%t、byte为%c。
2、使用strconv包里面的几种转换方法进行转换。
func FormatInt(i int64, base int) string func FormatFloat(f float64, fmt byte, prec, bitSize int) string func FormatBool(b bool) string func FormatUint(i uint64, base int) string
1、FormatInt的第一个参数就是要转换的数值，第二个参数表示进制数。
2、FormatFloat第一个参数表示要转换的数值，第二参数是格式化类型，第三个参数表示保留的小数位数，第四个参数表示格式化的类型（32/64）。
格式化类型：
‘f’（-ddd.dddd）、
‘b’（-ddddp±ddd，指数为二进制）、
‘e’（-d.dddde±dd，十进制指数）、
‘E’（-d.ddddE±dd，十进制指数）、
‘g’（指数很大时用’e’格式，否则’f’格式）、
‘G’（指数很大时用’E’格式，否则’f’格式）。
3、FormatBool直接传对应的bool类型即可。
4、FormatUint用于将字符转换成字符串，第一个参数表示字符需要强转成Uint64，第二个参数表示进制数。
var a int = 10 str1 := strconv.FormatInt(int64(a), 10) fmt.Printf("值: %v, 类型: %T\n", str1, str1) var f float32 = 3.14159 str2 := strconv.FormatFloat(float64(f), 'f', 6, 64) fmt.Printf("值: %v, 类型: %T\n", str2, str2) str3 := strconv.FormatBool(true) fmt.Printf("值: %v, 类型: %T\n", str3, str3) x := 'x' str4 := strconv.FormatUint(uint64(x), 10) fmt.Printf("值: %v, 类型: %T\n", str4, str4)
2.3、string类型转换成数值类型
func ParseInt(s string, base int, bitSize int) (i int64, err error) func ParseFloat(s string, bitSize int) (float64, error) func ParseBool(str string) (bool, error)
以上四个函数用户将字符串类型string转换成对应的类型。
1、ParseInt第一个参数字符串，第二参数表示进制数，第三个参数表示转换后的位数——32/64。
2、ParseFloat第一个参数字符串，第二个参数表示转换的位数。
可以注意到它们的返回值都是两个，第一个返回值表示结果，第二个表示出错，而当我们调用函数接收返回值时可以把error省略掉，直接用前面说的_来表示即可。
str1 := "123456" num1, _ := strconv.ParseInt(str1, 10, 64) fmt.Printf("值: %v, 类型: %T\n", num1, num1) str2 := "1233.1415926" num2, _ := strconv.ParseFloat(str2, 64) fmt.Printf("值: %v, 类型: %T\n", num2, num2) str3 := "true" flag, _ := strconv.ParseBool(str3) fmt.Printf("值: %v, 类型: %T\n", flag, flag)
上面的string类型转bool类型其实没什么意义。
注意：在go语言中数值类型没法直接转换成bool类型bool类型也没法直接转换成数值类型。
3、Golang中的运算符
Golang运算符包括：算数运算符、关系运算符、逻辑运算符、赋值运算符、位运算符。
3.1、算数运算符
这边最主要是%运算：求余=被除数 -（被除数/除数）*除数
fmt.Println(10%3, -10%3)
注意：在golang中，++和--只能独立使用，且不存在前置++/--，错误写法如下
正确写法：
var x int = 1 x++ fmt.Println(x)
3.2、关系运算符
例如：
var a = 10 var b = 9 fmt.Println(a > b) // true fmt.Println(a >= b) // true fmt.Println(a == b) // false fmt.Println(a
最主要在于逻辑运算符的短路问题：
先来看正常的情况，所有条件满足的情况下执行if语句内的代码
package main import "fmt" func test() bool { fmt.Println("test...") return true } func main() { var x int = 10 if x > 5 && test() { fmt.Println("ok...") } }
对于&&运算符，只要第一个条件不满足，就不会再去判断后面的条件了，因此在下面没有输出任何信息：
package main import "fmt" func test() bool { fmt.Println("test...") return true } func main() { var x int = 10 if x > 10 && test() { fmt.Println("ok...") } }
对于||运算符，只要第一个条件满足，就无需再判断后面的条件了，所以下面的代码只输出ok：
package main import "fmt" func test() bool { fmt.Println("test...") return true } func main() { var x int = 10 if x > 5 || test() { fmt.Println("ok...") } }
3.4、赋值运算符
3.5、位运算符
package main import "fmt" func main() { var x int = 10 // 1010 var y int = 2 // 0010 fmt.Println(x > y) // 2 fmt.Println(x & y) // 0010->2 fmt.Println(x | y) // 1010->10 fmt.Println(x ^ y) // 1000->8 }
