Golang DAY04:浮点、字符、布尔、字符串类型；基本数据类型默认值；基本数据类型转换

记录一个编辑器的问题

每次重新开机后编辑器识别不了环境变量

解决方案: vsCode终端执行以下shell，使当前的PowerShell实例从计算机加载最新的路径变量。

$env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine")

浮点类型

基本介绍

用于存放小数的。如 3.14

浮点类型分类

关于浮点数在机器中存放形式的简单说明.浮点数=符号位+指数位+尾数位说明: 浮点数都是有符号的
尾数部分可能丢失，造成精度损失。float64 的精度比 float32 的要准确，如果我们要保存一个精度高的数，则应该选用 float64
浮点型的存储分为三部分:符号位+指数位+尾数位在存储过程中，精度会有丢失

func main () {
	// 浮点数都是有符号的
	 var num1 float32 = -0.32
	 var num2 float32 = 0.32

	 fmt.Println("num1", num1, "num2", num2)
	 fmt.Println("\n")
	
	 // 精度丢失
	 var num3 float32 = 1.00000000001
	 var num4 float64 = 1.00000000001
	 fmt.Println("num3=", num3, "num4=", num4)
}

注意事项

Golang 浮点类型有固定的范围和字段长度，不受具体 OS(操作系统)的影响。
Golang 的浮点型默认声明为 float64 类型。
浮点型常量有两种表示形式：

十进制数形式:如: 5.12 .512 (必须有小数点)
科学计数法形式:如: 5.1234e2 = 5.12 * 10 的2 次方 5.12E-2 = 5.12/10 的 2 次方

通常情况下，应该使用 float64 ，因为它比 float32 更精确。[开发中，推荐使用 float64]

func main() {
	var num1 = 0.01
	fmt.Println("默认类型=", reflect.TypeOf(num1))

	// 十进制表示方式
	var num2 = 5.21
	var num3 = .21
	fmt.Println("num2=", num2, "num3=", num3)
	// 科学计数法表示方式
	var num4 = 0.001e2 // 表示0.01 * 10的2次方
	var num5 = 0.001E2 // 表示0.01 * 10的2次方
	var num6 = 1E-2 // 表示1 / 10的2次方
	fmt.Println("num4=", num4, "num5=", num5, "num6=", num6)
}

字符类型

基本介绍

Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而 Go 的字符串不同，它是由字节组成的。

如果我们保存的字符在 ASCII表的,比如[0-1,a-z,A-Z..]直接可以保存到 byte
如果我们保存的字符对应码值大于 255.这时我们可以考虑使用 int 类型保存
如果我们需要安装字符的方式输出，这时我们需要格式化输出，即 fimt.Printf(“%c”,c1)

package main

import (
	"fmt"
)
func main() {
	var c1 byte = 'a'
	var c2 byte = '0'
	// 当我们直接输出byte，就是直接输出的码值
	fmt.Println("c1=", c1, "c2=", c2)
	// 如果我们想输出对应的字符，需要进行格式化输出
	fmt.Printf("c1=%c c2=%c", c1, c2)

	// 我们也可以将int进行格式化输出
	var c3 int = '北'
	fmt.Printf("c3=%c 对应的码值%d", c3, c3)
}

注意事项

字符常量是用单引号(")括起来的单个字符。例如: var cl byte ='a'var c2 int ='中varbyte ='9Go 中允许使用转义字符’来将其后的字符转变为特殊字符型常量。例如: var c3 char =“n//"n表示换行符
Go 语言的字符使用 UTF& 编码如果想查询字符对应的 utf 码 http://www.mytju.com/classcode/tools/encode utf8.asp （英文字母-1 个字节汉字-3 个字节）
在 Go 中，字符的本质是一个整数，直接输出时，是该字符对应的 UTF-8 编码的码值。
可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的 unicode 字符
字符类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码

func main() {
	// 我们可以直接对一个码值格式化输出为一个字符
	var c1 int = 120
	fmt.Printf("格式化输出c1=%c", c1)
	
	// 字符是可以进行运算的
	var n1 = 10 + 'a'
	fmt.Println("\n n1 = ", n1)
}

本质探讨

字符型存储到计算机中，需要将字符对应的码值(整数) 找出来存储:

字符--->对应码值---->二进制-->存储
读取:二进制----> 码值 ----> 字符 -> 读取

字符和码值的对应关系是通过字符编码表决定的(是规定好)
Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了

布尔类型

基本介绍

布尔类型也叫 bool 类型，bool 类型数据只允许取值 true 和 false
bool 类型占1 个字节。
bool 类型适于逻辑运算，一般用于程序流程控制:

if 条件控制语句
for 循环控制语句

package main

import(
	"fmt"
	"unsafe"
)

func main() {
	var b1 = true
	fmt.Println("b1=", b1)

	// bool只占一个字节
	fmt.Println("b1的占用空间=", unsafe.Sizeof(b1))
}

字符串类型

基本介绍

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本

注意事项

Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本,这样 Golang 统一使用 UTF-8 编码,中文乱码问题不会再困扰程序员。
字符串一旦赋值了，字符串就不能修改了: 在 Go 中字符串是不可变的。
字符串的两种表示形式

双引号，会识别转义字符
反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果

字符串拼接方式
当一行字符串太长时，需要使用到多行字符串，可以如下处理，需要注意的是将+保留在上一行

package main

import (
	"fmt"
)

func main() {
	// 字符串的基本使用
	var str1 string = "hahaha"
	fmt.Println(str1)

	// 在 Go 中字符串是不可变的
	//var str2 string = "1sjx"
	//str2[0] = "2" // 这样是错误的
	

	// 双引号，会识别转义字符
	var str3 string = "111\n222"
	fmt.Println("str3=", str3)
	// 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
	var str4 string = `
	func main() {
		var b1 = true
		fmt.Println("b1=", b1)
	
		// bool只占一个字节
		fmt.Println("b1的占用空间=", unsafe.Sizeof(b1))
	}
	`
	fmt.Println("str4=", str4)

	// 拼接字符串
	var str5 = "111" + "2222"
	str5 += "333"
	fmt.Println("str5=", str5)
	// 当一行字符串太长时，需要使用到多行字符串，可以如下处理，需要注意的是将+保留在上一行
	var str6 = "hshshsh" + "hshshsh" + "hshshsh" + "hshshsh" +
	"hshshsh" + "hshshsh" 
	fmt.Println("str6=", str6)

}

基本数据类型默认值

基本介绍

在 go 中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在 go 中，默认值又叫零值。

默认值

数据类型	默认值
整数类型	0
浮点类型	0
布尔类型	false
字符串类型	""

package main

import(
	"fmt"
)

func main() {
	var i1 int
	var i2 float64
	var i3 bool
	var i4 string
	// %v表示按照变量的原值输出
	fmt.Printf("i1=%v, i1=%v, i3=%v, i4=%v", i1, i2, i3,i4)

	fmt.Println("\ni1=", i1, "i2=", i2, "i3=", i3, "i4=", i4)
}

基本数据类型转换

基本介绍

Golang 和 java/c 不同，Go 在不同类型的变量之间赋值时需要显式转换。也就是说 Golang 中数据类型不能自动转换。

基本语法

表达式 T(v) 将值转换为类型 T

T: 就是数据类型，比如 int32，int64，float32 等等

v: 就是需要转换的变量

package main

import (
	"fmt"
)

func main() {

	var i int32 = 1
	var f float32 = float32(i)
	var i2 int64 = int64(i)

	fmt.Printf("f=%v, i2=%v", f, i2)

}

注意事项

Go 中，数据类型的转换可以是从表示范围小-->表示范围大，也可以范围大--->范围小
被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化!
转成 int8[-128---127]3)在转换中，比如将 int64 溢出处理，和我们希望的结果不一样。因此在转换时，需要考虑范围.

package main

import (
	"fmt"
)

func main() {

	// 被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化!
	var i int32 = 1
	var i2 int64 = int64(i)
	fmt.Printf("i的数据类型%T", i2)

	// int8[-128---127]3)在转换中，比如将 int64 溢出处理，和我们希望的结果不一样
	var i3 int64 = 9999999
	var i4 int8 = int8(i3)
	fmt.Printf("\ni4的值%v", i4)

}

易错点

package main

import (
	"fmt"
	// _ "fmt" // _表示这个包不用
)

func main() {
	var n1 int32 = 12
	var n2 int64
	var n3 int8

	//n2 = n1 + 8 // int32不能直接转换为int64 编译错误
	//n3 = n1 + 8 // int32不能直接转换为int8 编译错误

	// 以下为正确的写法
	n2 = int64(n1) + 8
	n3 = int8(n1) + 8

	fmt.Printf("n1=%v,n2=%v,n3=%v", n1, n2, n3)
}

package main

import (
	"fmt"
	// _ "fmt" // _表示这个包不用
)

func main() {
	var n1 int32 = 12

	var n2 int8

	var n3 int8

	n2 = int8(n1) + 127 // 编译通过

	n3 = int8(n1) + 128 // 编译不通过

	fmt.Printf("n1=%v,n2=%v,n3=%v", n1, n2, n3)
}

基本数据类型和string相互转换

基本介绍

在程序开发中，我们经常将基本数据类型转成 string,或者将 string 转成基本数据类型。

基本数据类型转String

fimt.Sprintf("%参数"，表达式)
使用 strconv包的函数

package main

import(
	"fmt"
)

func main() {

	var num1 int = 1

	var num2 float64 = 2.2

	var b byte = 'a'

	var bool1 bool = true

	var str string
	// int转string
	str = fmt.Sprintf("%d", num1)
	fmt.Printf("\nnum1 = %v", str)
	// float转string
	str = fmt.Sprintf("%f", num2)
	fmt.Printf("\nnum2 = %v", str)
	// byte转string
	str = fmt.Sprintf("%c", b)
	fmt.Printf("\nb = %v", str)
	// boolean转string
	str = fmt.Sprintf("%t", bool1)
	fmt.Printf("\nbool1 = %v", str)

}

package main

import(
	"fmt"
	"strconv"
)

func main() {

	var num1 int = 1

	var num2 float64 = 2.2

	var bool1 bool = true

	var str string

	str = strconv.FormatInt(int64(num1), 10)
	fmt.Printf("\nnum1 = %v", str)

	str = strconv.FormatFloat(num2, 'f', 10, 64)
	fmt.Printf("\nnum2 = %v", str)

	str = strconv.FormatBool(bool1)
	fmt.Printf("\nbool1 = %v", str)

}

String转基本数据类型

使用时 strconv 包的函数，因为返回的是 int64 或者 float64,如希望要得到int32,float32等如下处理

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var str1 = "true"
	var str2 = "111"
	var str3 = "11.11"

	// string转boolean
	//说明
	// 1.strconv.ParseBool(str) 函数会返两个值 (value bool，err error
	//2因为我只想获取到 value bool不想获取 err 所以我使用 忽略
	var b bool
	b, _ = strconv.ParseBool(str1)
	fmt.Printf("b=%v", b)

	// string转int
	var num int64
	num, _ = strconv.ParseInt(str2, 10, 64)
	fmt.Printf("\nnum=%v", num)

	// string转float
	var f float64
	f, _ = strconv.ParseFloat(str3, 64)
	fmt.Printf("\nf=%v", f)
}

注意事项

在将 String 类型转成基本数据类型时，要确保 String 类型能够转成有效的数据，比如我们可以把"123"，转成一个整数，但是不能把“hello”转成一个整数，如果这样做，Golang 直接将其转成 0，其它举型也是一样的道理 foat => 0 bool => false

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var str = "hello"
	// 输出默认值0
	var num int64
	num, _ = strconv.ParseInt(str, 10, 64)
	fmt.Printf("num=%v", num)
	// 输出默认值 flase
	var b bool
	b, _ = strconv.ParseBool(str)
	fmt.Printf("\nb=%v", b)
}