Go基础知识全面总结

news2024/12/28 19:24:27

文章目录

go基本数据类型
- bool类型
- 数值型
- 字符
- 字符串
数据类型的转换
运算符和表达式
- 1. 算数运算符
- 2.关系运算符
- 3. 逻辑运算符
- 4. 位运算符
- 5. 赋值运算符
- 6. 其他运算符
- 运算符优先级
- 转义符

go基本数据类型

bool类型

布尔型的值只可以是常量 true 或者 false。⼀个简单的例⼦：var b bool = true

数值型

整数型

⼆进制和位数的关系，以及 int 和 uint 的关系

int8 有符号 8 位整型 (-128 到 127) ⻓度：8bit
int16 有符号 16 位整型 (-32768 到 32767)
int32 有符号 32 位整型 (-2147483648 到 2147483647)
int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
uint8 ⽆符号 8 位整型 (0 到 255) 8位都⽤于表示数值：
uint16 ⽆符号 16 位整型 (0 到 65535)
uint32 ⽆符号 32 位整型 (0 到 4294967295)
uint64 ⽆符号 64 位整型 (0 到 18446744073709551615)

浮点型

float32 32位浮点型数
float64 64位浮点型数

其他
byte 等于 uint8
rune 等于 int32
uint 32 或 64 位

字符

Golang中没有专⻔的字符类型，如果要存储单个字符(字⺟)，⼀般使⽤byte来保存。
字符串就是⼀串固定⻓度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，⽽Go的字符串不同，它是由字节组成的。

package main
	import (
		"fmt"
	)
	func main() {
		var a byte
		a = 'a'
		//输出ascii对应码值 。。 这⾥说明⼀下什么是ascii码
		fmt.Println(a)
		fmt.Printf("a=%c", a)
}

字符常量只能使⽤单引号括起来，例如：var a byte = ‘a’ var a int = ‘a’

package main
import (
	"fmt"
)
func main() {
	var a byte
	a = "a"
	//输出ascii对应码值 。。 这⾥说明⼀下什么是ascii码
	fmt.Println(a)
	fmt.Printf("a=%c", a)
}

字符本质是⼀个数字，可以进⾏加减乘除

package main
import (
	"fmt"
	"reflect"
)
func main() {
	a := 'a'
	//这⾥注意⼀下 1. a+1可以和数字计算 2.a+1的类型是32 3. int类型可以直接变成字符
	fmt.Println(reflect.TypeOf(a+1))
	fmt.Printf("a+1=%c", a+1)
}

字符串

字符串就是⼀串固定⻓度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语⾔的字符串的字节使⽤ UTF-8 编码标识 Unicode ⽂本。

数据类型的转换

valueOfTypeB = typeB(valueOfTypeA)

a := 5.0
b := int(a)
type IT int
var a IT = 5
b := int(5)
c := IT(b)
var a int32 = 1
var b int64 = 3
b = int64(a)
fmt.Println(a, b)

int 转换为字符串：Itoa()

println("a" + strconv.Itoa(32))

string 转换为 int：Atoi()

i,_ := strconv.Atoi("3")
println(3 + i) 
i,err := strconv.Atoi("a")
if err != nil {
 println("converted failed")
}

Parse 类函数⽤于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)

ParseInt() 和 ParseUint() 有 3 个参数：

func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)

说明：

bitSize 参数表示转换为什么位的 int/uint，有效值为 0、8、16、32、64。当 bitSize=0 的时候，表示转换为 int 或 uint 类型。例如 bitSize=8 表示转换后的值的类型为 int8 或 uint8。
base 参数表示以什么进制的⽅式去解析给定的字符串，有效值为 0、2-36。当 base=0 的时候，表示根据string 的前缀来判断以什么进制去解析： 0x 开头的以 16 进制的⽅式去解析， 0 开头的以 8 进制⽅式去解析，其它的以 10 进制⽅式解析

将给定类型格式化为 string 类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16)
s := strconv.FormatUint(42, 16)

第⼆个参数 base 指定将第⼀个参数转换为多少进制，有效值为 2<=base<=36 。当指定的进制位⼤于 10 的时候，超出 10 的数值以 a-z 字⺟表示。例如 16 进制时，10-15 的数字分别使⽤ a-f 表示，17 进制时，10-16 的数值分别使⽤ a-g 表示。

FormatFloat() 参数众多：

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

bitSize 表示 f 的来源类型（32：float32、64：float64），会据此进⾏舍⼊。
fmt 表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为⼆进制）、‘e’（-d.dddde±dd，⼗进制指数）、‘E’（-d.ddddE±dd，⼗进制指数）、‘g’（指数很⼤时⽤’e’格式，否则’f’格式）、‘G’（指数很⼤时⽤’E’格式，否则’f’格式）。
prec 控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示⼩数点后的数字个数；对’g’、‘G’，它控制总的数字个数。如果 prec 为 - 1，则代表使⽤最少数量的、但⼜必需的数字来表示 f。

运算符和表达式

1. 算数运算符

在这里插入图片描述

2.关系运算符

== != > < >= <=

3. 逻辑运算符

这个和 python 不⼀样，python 中使⽤ and or 来连接


package main
import "fmt"
func main() {
	 var a bool = true
	 var b bool = false
	 if ( a && b ) {
	 	 fmt.Printf("第⼀⾏ - 条件为 true\n" )
	 }
	 if ( a || b ) {
		  fmt.Printf("第⼆⾏ - 条件为 true\n" )
	 }
	 a = false
	 b = true
	 if ( a && b ) {
	 	 fmt.Printf("第三⾏ - 条件为 true\n" )
	 } else {
	  	fmt.Printf("第三⾏ - 条件为 false\n" )
	 }
	 if ( !(a && b) ) {
	  	fmt.Printf("第四⾏ - 条件为 true\n" )
	 }
}

4. 位运算符

位运算符对整数在内存中的⼆进制位进⾏操作。
下表列出了位运算符 &, |, 和 ^ 的计算：

假定 A = 60; B = 13; 其⼆进制数转换为：

A = 0011 1100
B = 0000 1101

A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001

Go 语⾔⽀持的位运算符如下表所示。假定 A 为 60，B 为 13：

package main
import "fmt"
func main() {
	 var a uint = 60    
	 var b uint = 13   
	 var c uint = 0     
	 c = a & b   
	 fmt.Printf("第⼀⾏ - c 的值为 %d\n", c )
	 c = a | b   
	 fmt.Printf("第⼆⾏ - c 的值为 %d\n", c )
	 c = a ^ b   
	 fmt.Printf("第三⾏ - c 的值为 %d\n", c )
	 c = a << 2  
	 fmt.Printf("第四⾏ - c 的值为 %d\n", c )
	 c = a >> 2  
	 fmt.Printf("第五⾏ - c 的值为 %d\n", c )
}

5. 赋值运算符

下表列出了所有 Go 语⾔的赋值运算符。

package main
	import "fmt"
func main() {
	 var a int = 21
	 var c int
	 c = a
	 fmt.Printf("第 1 ⾏ - = 运算符实例，c 值为 = %d\n", c )
	 c += a
	 fmt.Printf("第 2 ⾏ - += 运算符实例，c 值为 = %d\n", c )
	 c -= a
	 fmt.Printf("第 3 ⾏ - -= 运算符实例，c 值为 = %d\n", c )
	 c *= a
	 fmt.Printf("第 4 ⾏ - *= 运算符实例，c 值为 = %d\n", c )
	 c /= a
	 fmt.Printf("第 5 ⾏ - /= 运算符实例，c 值为 = %d\n", c )
	 c = 200;
	 c <<= 2
	 fmt.Printf("第 6⾏ - <<= 运算符实例，c 值为 = %d\n", c )
	 c >>= 2
	 fmt.Printf("第 7 ⾏ - >>= 运算符实例，c 值为 = %d\n", c )
	 c &= 2
	 fmt.Printf("第 8 ⾏ - &= 运算符实例，c 值为 = %d\n", c )
	 c ^= 2
	 fmt.Printf("第 9 ⾏ - ^= 运算符实例，c 值为 = %d\n", c )
	 c |= 2
	 fmt.Printf("第 10 ⾏ - |= 运算符实例，c 值为 = %d\n", c )
}

6. 其他运算符

package main
	import "fmt"
func main() {
	 var a int = 4
	 var b int32
	 var c float32
	 var ptr *int
	 fmt.Printf("第 1 ⾏ - a 变量类型为 = %T\n", a );
	 fmt.Printf("第 2 ⾏ - b 变量类型为 = %T\n", b );
	 fmt.Printf("第 3 ⾏ - c 变量类型为 = %T\n", c );
	 ptr = &a  
	 fmt.Printf("a 的值为 %d\n", a);
	 fmt.Printf("*ptr 为 %d\n", *ptr);
}

运算符优先级

有些运算符拥有较⾼的优先级，⼆元运算符的运算⽅向均是从左⾄右。下表列出了所有运算符以及它们的优先级，由上⾄下代表优先级由⾼到低

当然，你可以通过使⽤括号来临时提升某个表达式的整体运算优先级。


package main
	import "fmt"

func main() {
	 var a int = 20
	 var b int = 10
	 var c int = 15
	 var d int = 5
	 var e int;
	 e = (a + b) * c / d;   
	 fmt.Printf("(a + b) * c / d 的值为 : %d\n", e );
	 e = ((a + b) * c) / d;  
	 fmt.Printf("((a + b) * c) / d 的值为 : %d\n" , e );
	 e = (a + b) * (c / d); 
	 fmt.Printf("(a + b) * (c / d) 的值为 : %d\n", e );
	 e = a + (b * c) / d;  
	 fmt.Printf("a + (b * c) / d 的值为 : %d\n" , e ); 
}