03【保姆级】-GO语言变量和数据类型和相互转换

03【保姆级】-GO语言变量和数据类型

一、变量
- 1.1 变量的定义：
- 1.2 变量的声明、初始化、赋值
- 1.3 变量使用的注意事项
插播-关于fmt.Printf格式打印%的作用
二、变量的数据类型
- 2.1整数的基本类型
- - 2.1.1 有符号类型 int8/16/32/64
  - 2.1.2 无符号类型 int8/16/32/64
  - 2.1.3 整型类型 int、uint、rune、byte
  - 2.1.4 整型的使用细节
- 2.2 浮点类型
- - 2.2.1 小数类型分类
- 2.3 字符类型
- - 2.3.1 基本介绍
  - 2.3.2 字符使用细节
- 2.4 布尔类型
- - 2.4.1 基本概述
- 2.5 String类型
- - 2.5.1 基本概述
  - 2.5.2 String使用注意事项和细节
- 2.6 基本数据类型的默认值
- 2.7 基本数据类型的相互转换
- 2.8 转换的细节（重要）
- 2.9 基本数据类型转String（重要）
- - 2.9.1 fmt.Sprintf("%参数", 变量名)
  - 2.9.2 使用strconv包的函数
- 2.10 String类型转为基本类型
- - 2.10.1 使用strconv包的函数

之前我学过C、Java、Python语言时总结的经验：

先建立整体框架，然后再去抠细节。
先Know how，然后know why。
先做出来，然后再去一点点研究，才会事半功倍。
适当的囫囵吞枣。因为死抠某个知识点很浪费时间的。
对于GO语言，切记遵守语法格式规则。（例如python语言、例如SpringBoot框架等）
解释：某些知识点，就是很难了解，那么先做出来，然后继续向前学习，可能在某个时间点我们就会恍然大悟。

一、变量

1.1 变量的定义：

任何高级程序语言写程序，变量都是程序的基本组成单位。
变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量()

1.2 变量的声明、初始化、赋值

声明变量（定义变量）

基本语法： var 变量名数据类型
var a int

变量赋值

在声明变量的时候，就给值
var a int = 1
var b = 300

使用变量

var a int
a = 100

例如下面的a/b/c都是变量


package main

import "fmt"

func main() {
	var a int  //声明变量
	a = 10     //变量赋值
	b := 20    //变量赋值
	c := a + b //使用变量
	fmt.Println(a) // 10
	fmt.Println(b) // 20
	fmt.Println(c) // 30
}

1.3 变量使用的注意事项

变量表示内存中的一个存储区域
该区域有自己的名称(变量名)和类型(数据类型)

所有代码会用磁盘中读取到内存中，进行运行。
那么变量，例如a = 10 。那么就会存储到内存中。

Golang变量使用的三种方式
1. 第一种:指定变量类型，声明后若不赋值，使用默认值。
int类型默认为0
String类型默认为空
1. 第二种:根据值自行判定变量类型(类型推导)
如果不指定类型，那么就会go语言类型推导。
var a = “abc” 在打印的时候就会输出string类型
1. 第三种省略var,注意:=左侧的变量不应该是已经声明过的，否则会导致编译错误
两种方式：（方式一的两句话，等价于方式二）
＞ var name1 string
name1 = “zhangsan1”　//方式一
name2 := “zhangsan2” //方式二
多变量声明
在编程中，有时我们需要一次性声明多个变量，Golang也提供这样的语法

形式一：
var a, a1, a2, a3 int
a = 10
a1 = 20
a2 = 30
a3 = 40


形式二：
var a1, a2, a3, name = 1, 2, 3, "zhangsan"
	fmt.Println(a1,a12,a23,a4)

形式三：
a, b, c, d, name := 1, 2, 3, 4, "zhangsan"
fmt.Println(a,b,c,d,name)

关于全局变量：

var (
	a    = 1
	b    = 2
	c    = 3
	d    = 4
	name = "zhangsan"
)
func main() {
	fmt.Println(a, b, c, d, name)
}

该区域的数据值可以在同一类型范围内不断变化
变量在同一个作用域内不能重名
变量=变量名+值+数据类型，这一点请大家注意。
Golang的变量如果没有赋初值，编译器会使用默认值,比如int默认值0 string默认值为空用

插播-关于fmt.Printf格式打印%的作用

参考的官网地址是：https://studygolang.com/pkgdoc

通用：
%v	值的默认格式表示
%+v	类似%v，但输出结构体时会添加字段名
%#v	值的Go语法表示
%T	值的类型的Go语法表示
%%	百分号

布尔值：
%t	单词true或false

整数：

%b	表示为二进制
%c	该值对应的unicode码值
%d	表示为十进制
%o	表示为八进制
%q	该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
%x	表示为十六进制，使用a-f
%X	表示为十六进制，使用A-F
%U	表示为Unicode格式：U+1234，等价于"U+%04X"

浮点数与复数的两个组分：

%b	无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat
%e	科学计数法，如-1234.456e+78
%E	科学计数法，如-1234.456E+78
%f	有小数部分但无指数部分，如123.456
%F	等价于%f
%g	根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
%G	根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

字符串和[]byte：

%s	直接输出字符串或者[]byte
%q	该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%x	每个字节用两字符十六进制数表示（使用a-f）
%X	每个字节用两字符十六进制数表示（使用A-F）    

指针：

%p	表示为十六进制，并加上前导的0x

二、变量的数据类型

在这里插入图片描述

2.1整数的基本类型

简单的说，就是用于存放整数值的，比如 0,-1,2345 等等。

2.1.1 有符号类型 int8/16/32/64

在这里插入图片描述

** int8 范围是：-128 ~ 127**
在这里插入图片描述

2.1.2 无符号类型 int8/16/32/64

int 无符号类型：
在这里插入图片描述

2.1.3 整型类型 int、uint、rune、byte

在这里插入图片描述

2.1.4 整型的使用细节

Golang 各整数类型分: 有符号和无符号，int uint 的大小和系统有关
Golang 的整型默认声明为 int 型
如何在程序查看某个变量的字节大小和数据类型

import (
	"fmt"
	unsafe "unsafe"
)

	var n1 = 100
	fmt.Printf("n1 的类型是 %T ", n1) //n1 的类型是 int

	var n2 int64 = 1
	fmt.Printf("n1 的数据类型是 %T, n2 占用的字节数是%d", n2, unsafe.Sizeof(n2))
	//   n1 的数据类型是 int64, n2 占用的字节数是8

olang 程序中整型变量在使用时，遵守保小不保大的原则，即:在保证程序正确运行下，尽量使用占用空间小的数据类型。[如: 年龄]
bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。[二进制再详细说] 1byte = 8 bit

2.2 浮点类型

Golang的浮点类型可以表示一个小数，比如1.2 / 3333.11 / 3232.324等等

2.2.1 小数类型分类

在这里插入图片描述

关于浮点数在机器中存放形式的简单说明.浮点数=符号位+指数位+尾数位说明: 浮点数都是有符号的.
如果使用float32 可能造成精度损失。

开发过程中，推荐使用float64。并且默认也是float64 .
Golang浮点类型有固定的范围和字段类型，不受具体操作系统的影响。

浮点型的存储分为三个部分：符号位+指数位+尾数位。在存储过程中，精度会有丢失

2.3 字符类型

2.3.1 基本介绍

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

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

var n2 int = '你'
	fmt.Printf("n2 的数据类型是 %T, n2 占用的字节数是%d.  \n", n2, unsafe.Sizeof(n2))
	// n2 的数据类型是 int, n2 占用的字节数是8. 

	var c3 int = '你'
	fmt.Printf("c3 = %c \n", c3)	//c3 = 你	
	fmt.Printf("%c", c3) 			//你

2.3.2 字符使用细节

在这里插入图片描述

字符型存储到计算机中，需要将字符对应的码值 (整数) 找出来存储:字符—>对应码值---->二进制–>存储
读取:二进制----> 码值 ----> 字符 -> 读取
字符和码值的对应关系是通过字符编码表决定的(是规定好)
Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了

2.4 布尔类型

2.4.1 基本概述

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

	seg := true
	fmt.Printf("%T  \n", seg) //bool
	fmt.Println("seg=", seg)    //seg= true

if seg {
		fmt.Println("如果是true， 我就打印")
	} else {
		fmt.Println("如果是false， 我就打印")
	}

2.5 String类型

2.5.1 基本概述

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

var name string = "今年张三，英文ZhangSan，23岁了。"
	fmt.Println(name)

2.5.2 String使用注意事项和细节

Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用Utf-8编码，中文乱码就不会出现了。
字符串一旦赋值后，字符串就不能单个字符修改了。在Go中字符串是不可变的。

var str = "hello"
str[0] = 'b'  //这里就会报错了。字符串单个字符是不可变的。

可以直接从新赋值：
str ="word"

在这里插入图片描述
3. 字符串的两种表示方式
1. 双引号，会识别转义字符
2. 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果。

4. 字符串拼接方式

	str := "hello "
	name := "zhangsan"
	strName := str + name
	fmt.Println(strName)  //hello zhangsan

当一行字符串太长时，需要使用多行字符串，可以用“” + 进行绑定。重点是：+ 号必须保持在上一行中。

str := "lisi " + "wangwu " + " zhaoliu " + " a" +
	" b" + "c " +
	"D"

fmt.Println(str)  //lisi wangwu  zhaoliu  a bc D

2.6 基本数据类型的默认值

在Go中，数据类型都有一个默认值，当没有赋值时，就会保留默认值，在Go中，默认值又叫“零值”
在这里插入图片描述

2.7 基本数据类型的相互转换

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

基本语法：

表达式T(v) 将值 v 转换为类型T
- T：就是数据类型，比如：int32 , int64 ,float32, float64等
- V：就是需要转换的变量

var n1 int = 100
var n2 float64 = float64(n1)
n2 += 0.905
var n3 int = int(n2)
fmt.Printf("n1=%v, n2=%v, n3=%v", n1, n2, n3)
// n1=100, n2=100.905, n3=100

2.8 转换的细节（重要）

在Go中，数据类型的转换可以是从小范围转换到大范围。也可以从大范围转换成小范围。
被转换的是变量存储的数据（既值） ，变量本身的数据类型并没有变化。

例如：
我们将 n1 float =1.23 转换成 n2 int = 100
那么分别打印 n1 =1.23. 打印n2 =100
var n1 float64 = 1.23
var n2 int = int(n1)
fmt.Printf(“n1=%v, n2=%v”, n1, n2)
// 打印结果：n1=1.23, n2=1

在转换结果中，比如将Int64转换成int8 ，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。

var n1 int64 = 999999
var n2 int8 = int8(n1)
fmt.Printf("n1=%v, n2=%v", n1, n2)
//  n1=999999, n2=63

2.9 基本数据类型转String（重要）

在程序开发中，我们经常需要将基本数据类型转成String类型。
或者String类型转换成基本数据类型。

2.9.1 fmt.Sprintf(“%参数”, 变量名)

方式一： fmt.Sprintf(“%参数", 表达式）

参数需要和表达式的数据类型相匹配
fmt.Sprintf() 会返回转换后的字符串

package main

import "fmt"

func main() {
	var n1 int = 123
	var n2 float64 = 1.23
	var n3 byte = 'a'
	var n4 bool = true
	var str string

	// %T 的意思是：该变量的类型
	// %q 的意思是：打印变量的类型，并且用双引号，引起来。
	str = fmt.Sprintf("%d", n1)
	fmt.Printf("str的类型是：%T, Str等于%q\n", str, str)

	str = fmt.Sprintf("%f", n2)
	fmt.Printf("str的类型是%T,str等于：%q \n", str, str)

	str = fmt.Sprintf("%c", n3)
	fmt.Printf("str的类型是:%T,str等于%q \n", str, str)
	str = fmt.Sprintf("%t", n4)
	fmt.Printf("str的类型是%T,str等于%q \n", str, str)
}
str的类型是string, Str等于"123"
str的类型是string, str等于："1.230000" 
str的类型是:string str等于"a" 
str的类型是string, str等于"true"

2.9.2 使用strconv包的函数

方式二：使用strconv包的函数
3. func FomatBool(b lool) String
4. func FomatInt(i int64, base int ) String

	var num1 int = 123
	var num2 float64 = 1.234
	var num3 bool = true
	var str string

	fmt.Printf("num1的类型是：%T \n", num1)
	str = strconv.FormatInt(int64(num1), 10)
	fmt.Printf("str的类型是：%T,str的值是：%q \n", str, str)

	//要转换的变量，
	//'f'：格式是：ddd.dddd。 一般使用的比较多
	//精度（小数点后面几位），该float的位数，例如64/32
	str = strconv.FormatFloat(num2, 'f', 2, 64)
	fmt.Printf("str的类型是：%T,str的值是%q \n", str, str)

	str = strconv.FormatBool(num3)
	fmt.Sprintf("str的类型是:%T,str的值是%q", str, str)

num1的类型是：int 
str的类型是：string,str的值是："123" 
str的类型是：string,str的值是"1.23" 

 
Itoa 将int类型转为String类型：
var num1 int = 100
	var str string = strconv.Itoa(num1)
	fmt.Printf(str)

关于strconv.FormatFloat的参数说明：
在这里插入图片描述

2.10 String类型转为基本类型

2.10.1 使用strconv包的函数

func ParseBool
func ParseBool(str string) (value bool, err error)
返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误。

	var str string = "true"
	var err error
	var b bool
	b, err = strconv.ParseBool(str)
	fmt.Printf("b的类型是 %T,b的值是%v,b的错误结果是：%v \n", b, b, err)

func ParseInt
func ParseInt(s string, base int, bitSize int) (i int64, err error)
返回字符串表示的整数值，接受正负号。

base指定进制（2到36），如果base为0，则会从字符串前置判断，"0x"是16进制，"0"是8进制，否则是10进制；
bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64；返回的err是*NumErr类型的，如果语法有误，err.Error = ErrSyntax；如果结果超出类型范围err.Error = ErrRange。

	var str string = "123"
	var i int64
	// 要转的字符串，base：转成10进制，bitSize：转成64位
	i, _ = strconv.ParseInt(str, 10, 0)
	fmt.Printf("i的格式是:%T,  i的值是:%v", i, i)
	// i的格式是:int64,  i的值是:123

func ParseFloat
func ParseFloat(s string, bitSize int) (f float64, err error)

解析一个表示浮点数的字符串并返回其值。
如果s合乎语法规则，函数会返回最为接近s表示值的一个浮点数（使用IEEE754规范舍入）。bitSize指定了期望的接收类型，32是float32（返回值可以不改变精确值的赋值给float32），64是float64；返回值err是*NumErr类型的，语法有误的，err.Error=ErrSyntax；结果超出表示范围的，返回值f为±Inf，err.Error= ErrRange。

	var str string = "1.2345"
	var f float64
	f, _ = strconv.ParseFloat(str, 64)
	fmt.Printf("f的类型是%T, f的值是:%v", f, f)
	// f的类型是float64, f的值是:1.2345