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

03【保姆级】-GO语言变量和数据类型和相互转换
03【保姆级】-GO语言变量和数据类型
之前我学过C、Java、Python语言时总结的经验：
1. 先建立整体框架，然后再去抠细节。
2. 先Know how，然后know why。
3. 先做出来，然后再去一点点研究，才会事半功倍。
4. 适当的囫囵吞枣。因为死抠某个知识点很浪费时间的。
5. 对于GO语言，切记遵守语法格式规则。（例如python语言、例如SpringBoot框架等）
  解释：某些知识点，就是很难了解，那么先做出来，然后继续向前学习，可能在某个时间点我们就会恍然大悟。
一、变量

 1.1 变量的定义：
- 任何高级程序语言写程序，变量都是程序的基本组成单位。
- 变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量()
1.2 变量的声明、初始化、赋值
1. 声明变量（定义变量）
基本语法： var 变量名数据类型
var a int
1. 变量赋值
在声明变量的时候，就给值
var a int = 1
var b = 300
1. 使用变量
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
2
3
4
5
6
7
8
9
10
11
12
13
14
```
1.3 变量使用的注意事项
1. 变量表示内存中的一个存储区域
2. 该区域有自己的名称(变量名)和类型(数据类型)
所有代码会用磁盘中读取到内存中，进行运行。
那么变量，例如a = 10 。那么就会存储到内存中。
1. Golang变量使用的三种方式
  1. 第一种:指定变量类型，声明后若不赋值，使用默认值。
  int类型默认为0
  String类型默认为空
  1. 第二种:根据值自行判定变量类型(类型推导)
  如果不指定类型，那么就会go语言类型推导。
  var a = “abc” 在打印的时候就会输出string类型
  1. 第三种省略var,注意:=左侧的变量不应该是已经声明过的，否则会导致编译错误
  两种方式：（方式一的两句话，等价于方式二）
  ＞ var name1 string
  name1 = “zhangsan1”　//方式一
  name2 := “zhangsan2” //方式二
2. 多变量声明
  在编程中，有时我们需要一次性声明多个变量，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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
```
关于全局变量：
```
var (
	a    = 1
	b    = 2
	c    = 3
	d    = 4
	name = "zhangsan"
)
func main() {
	fmt.Println(a, b, c, d, name)
}
1
2
3
4
5
6
7
8
9
10
```
1. 该区域的数据值可以在同一类型范围内不断变化
2. 变量在同一个作用域内不能重名
3. 变量=变量名+值+数据类型，这一点请大家注意。
4. 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    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
```
二、变量的数据类型

 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 整型的使用细节
1. Golang 各整数类型分: 有符号和无符号，int uint 的大小和系统有关
2. Golang 的整型默认声明为 int 型
3. 如何在程序查看某个变量的字节大小和数据类型
```
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
1
2
3
4
5
6
7
8
9
10
11
```
1. olang 程序中整型变量在使用时，遵守保小不保大的原则，即:在保证程序正确运行下，尽量使用占用空间小的数据类型。[如: 年龄]
2. bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。[二进制再详细说] 1byte = 8 bit
2.2 浮点类型

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

 2.2.1 小数类型分类
1. 关于浮点数在机器中存放形式的简单说明.浮点数=符号位+指数位+尾数位说明: 浮点数都是有符号的.
2. 如果使用float32 可能造成精度损失。
开发过程中，推荐使用float64。并且默认也是float64 .
Golang浮点类型有固定的范围和字段类型，不受具体操作系统的影响。
1. 浮点型的存储分为三个部分：符号位+指数位+尾数位。在存储过程中，精度会有丢失
2.3 字符类型

 2.3.1 基本介绍

Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而 Go 的字符串不同，它是由字节组成的。
1. 如果我们保存的字符在 ASCII 表的,比如[0-1,a-z,A-Z.]直接可以保存到 byte2)
2. 如果我们保存的字符对应码值大于 255,这时我们可以考虑使用 int 类型保存3)
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) 			//你
1
2
3
4
5
6
7
```
2.3.2 字符使用细节
1. 字符型存储到计算机中，需要将字符对应的码值 (整数) 找出来存储:字符—>对应码值---->二进制–>存储
  读取:二进制----> 码值 ----> 字符 -> 读取
2. 字符和码值的对应关系是通过字符编码表决定的(是规定好)
3. Go 语言的编码都统一成了 utf-8。非常的方便，很统一，再也没有编码乱码的困扰了
2.4 布尔类型

 2.4.1 基本概述
1. 布尔类型也叫 bool类型，bool 类型数据只允许取值 true 和 false
2. bool类型占1 个字节。
3. bool 类型适于逻辑运算，一般用于程序流程控制
```
	seg := true
	fmt.Printf("%T  \n", seg) //bool
	fmt.Println("seg=", seg)    //seg= true

if seg {
		fmt.Println("如果是true， 我就打印")
	} else {
		fmt.Println("如果是false， 我就打印")
	}
1
2
3
4
5
6
7
8
9
```
2.5 String类型

 2.5.1 基本概述

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
```
var name string = "今年张三，英文ZhangSan，23岁了。"
	fmt.Println(name)
1
2
```
2.5.2 String使用注意事项和细节
1. Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用Utf-8编码，中文乱码就不会出现了。
2. 字符串一旦赋值后，字符串就不能单个字符修改了。在Go中字符串是不可变的。
```
var str = "hello"
str[0] = 'b'  //这里就会报错了。字符串单个字符是不可变的。

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

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

4. 字符串拼接方式
```
	str := "hello "
	name := "zhangsan"
	strName := str + name
	fmt.Println(strName)  //hello zhangsan
1
2
3
4
```
1. 当一行字符串太长时，需要使用多行字符串，可以用“” + 进行绑定。重点是：+ 号必须保持在上一行中。
```
str := "lisi " + "wangwu " + " zhaoliu " + " a" +
	" b" + "c " +
	"D"

fmt.Println(str)  //lisi wangwu  zhaoliu  a bc D
1
2
3
4
5
```
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
1
2
3
4
5
6
```
2.8 转换的细节（重要）
1. 在Go中，数据类型的转换可以是从小范围转换到大范围。也可以从大范围转换成小范围。
2. 被转换的是变量存储的数据（既值） ，变量本身的数据类型并没有变化。
例如：
我们将 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
1. 在转换结果中，比如将Int64转换成int8 ，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。
```
var n1 int64 = 999999
var n2 int8 = int8(n1)
fmt.Printf("n1=%v, n2=%v", n1, n2)
//  n1=999999, n2=63
1
2
3
4
```
2.9 基本数据类型转String（重要）

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

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

方式一： fmt.Sprintf(“%参数", 表达式）
1. 参数需要和表达式的数据类型相匹配
2. 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" 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
```
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
```
关于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)
1
2
3
4
5
```
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
1
2
3
4
5
6
```
- 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
1
2
3
4
5
```
相关阅读:
Scrapy 框架之 Item Pipeline 的使用
 软件测试的内容包含什么？
traffic control
MySQL JDBC编程
 记录sentry的踩坑之路
 Android开源 Skeleton 骨架屏 V1.3.0
MySQL报错：unknown collation: ‘utf8mb4_0900_ai_ci‘
Android Material Design之Chip, ChipGroup(十二)
网络——IPv6（一）
pdfmake不能设置表格边框颜色？
原文地址：https://blog.csdn.net/weixin_43989347/article/details/134187201

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包的函数

二、变量的数据类型