GO语言学习之路3

2021/12/27

1、在go中，数据类型都有一个默认值，在go中又叫零值。
		整形		0
		浮点型		0
		字符串		""
		布尔类型	false
		
2、golang在不同类型的变量之间赋值时需要显式转换，不会自动转换

	表达式T(v)：将值v转换为类型T
	希望把i => float
				var i int32 = 100
				var n1 float32 = float32(i)
			=> int8
				var i int32 = 100
				var n2 int8 = int32(i)
	//在转换中如果从高精度转化为低精度，编译不会报错，只是转换的结果是按溢出处理，
    //和我们希望的结果不一样
	
	Demo1:
		func main() {
			var n1 int32 = 12
			var n2 int64
			var n3 int8

			n2 = n1 + 20  //n1是int32，n1+20 也是int32， 把int32 赋值给 int64 .错误
			n3 = n1 + 20  //n1是int32，n1+20 也是int32， 把int32 赋值给 int8 .错误
		}
		//可以通过显式转换修改
		n2 = int64(n1) + 20 
		n3 = int8(n1) + 20 
	
	Demo2:
		func main() {
			var n1 int32 = 12
			var n3 int8
			var n4 int8
			n3 = int8(n1) + 127   //超出int8范围  溢出
			n4 = int8(n1) + 128	  //超出int8范围  溢出
			fmt.Println(n3)
		}
		//编译报错
		
3、基本数据类型转换为string类型
	（1）fmt.Sprintf("%参数", 表达式)
	（2）使用strconv包的函数
	
	======使用第一种方式转换======
	func main() {
		var num1 int = 99
		var num2 float64 = 23.456
		var b bool = true
		var myChar byte = 'h'

		var str string // 默认空串
		//使用第一种方式来转换
		str = fmt.Sprintf("%d", num1)
		fmt.Printf("str type %T str = %v \n", str, str)

		str = fmt.Sprintf("%f", num2)
		fmt.Printf("str type %T str = %v \n", str, str)

		str = fmt.Sprintf("%t", b)
		fmt.Printf("str type %T str = %q \n", str, str)

		str = fmt.Sprintf("%c", myChar)
		fmt.Printf("str type %T str = %q \n", str, str)
	}
	
	======使用第二种方式转换======
	func main() {
		var num1 int = 99
		var num2 float64 = 23.456
		var b bool = true

		var str string // 默认空串
		//使用第二种方式来转换
		str = strconv.FormatInt(int64(num1), 10)
		fmt.Printf("str type %T str = %q \n", str, str)

		str = strconv.Itoa(num1)
		fmt.Printf("str type %T str = %q \n", str, str)//int转字符串多一个函数itoa

		str = strconv.FormatFloat(num2, 'f', 5, 64)
		fmt.Printf("str type %T str = %q \n", str, str)

		str = strconv.FormatBool(b)
		fmt.Printf("str type %T str = %q \n", str, str)
	}
	
4、string类型转换为基本数据类型
	func main() {
		var str string = "true"
		var b bool
		b, _ = strconv.ParseBool(str) //函数有两个返回值， value bool ， err error
		fmt.Printf("b byte %T, b = %v \n", b, b)

		var str2 string = "123456"
		var num1 int64
		num1, _ = strconv.ParseInt(str2, 10, 64)
		fmt.Printf("num1 byte %T, num1 = %v \n", num1, num1)

		var str3 string = "123.2222"
		var num2 float64
		num2, _ = strconv.ParseFloat(str3, 64)
		fmt.Printf("num2 byte %T, num2 = %v \n", num2, num2)
	}
	
	////////////在将string类型转换成基本数据类型时，要确保string类型能够转成有效的数据
	比如我们可以把"123"转成一个整数，但是不能把"hello",转换成一个整数。
	**如果这样做，golang直接将其转成0
	**如果转换为bool值，则输出为false
	//如果转换不成功，就会返回数据类型的默认值
	func main() {
		var str string = "hello"
		var num int64
		num, _ = strconv.ParseInt(str, 10, 64) //函数有两个返回值， value bool ， err error
		fmt.Printf("num byte %T, num = %v \n", num, num)
	}//"num byte int64, num = 0"

5、golang的指针与C语言类似（不过多说明）

	func main() {
		var num int = 123
		fmt.Println("num address = ", &num)//取num的地址

		var numPtr *int
		numPtr = &num
		*numPtr = 456
		fmt.Println("num data = ", num)//通过指针修改值 
	}
	
	//所有值类型都有对应的指针类型。
		值类型包括： 基本数据类型： int系列， float系列， bool， string， 数组和结构体struct
		
6、值类型和引用类型	
		值类型：基本数据类型： int系列， float系列， bool， string， 数组和结构体struct
		//=============>>>>变量直接存储值，内存通常在栈中分配
		
		引用类型：指针， slice切片， map， 管道chan， interface等都是引用类型
		//=============>>>>变量存储的是一个地址，这个地址对应的空间才是真正存储数据的值，
		//=============>>>>内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收

7、标识符的命名规范
	规则：  1、由大小写字母，数字，下划线组成
			2、数字不可以开头
			3、golang严格区分大小写
			4、标识符不能包含空格
			5、下划线本身在golang中是一个特殊的标识符，称为空标识符，可以代表任何其他的标识符
			但是它对应的值会被忽略，比如忽略某个返回值，所以单独只能作为占位符，不能作为标识符
			6、不能用关键字做标识符
			
			//规范
			//公有的变量，函数，常量名  首字母大写
			//私有的变量，函数，常量名  首字母小写