目录

一、概述

1、变量使用注意事项

2、变量的数据类型

3、整型的使用细节

4、浮点类型

浮点型的分类

浮点类型使用细节

5、字符类型(char)

字符类型使用细节

6、布尔类型：bool

7、字符串类型：string

二、类型转换

1、基本数据类型的转换

2、基本数据类型和string的转换

2.1、基本数据类型转string

2.2、string类型转基本数据类型

---

一、概述

为什么需要变量？

1. 一个程序就是一个世界
2. 变量是程序的基本组成单位
3. 不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位。

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量(值)。

声明变量
基本语法：var 变量名 数据类型

1、变量使用注意事项

1. 变量表示内存中的一个存储区域
2. 该区域有自己的名称（变量名）和类型（数据类型）
3. Golang变量使用的三种方式
   1. 指定变量类型，声明后若不赋值，使用默认值
   2. 根据值自行判定变量类型（类型推导）
   3. 省略var，注意:=左侧的变量不应该是已经声明过的，否则会导致编译错误
4. 多变量声明，一次性声明多个变量
5. 该区域的数据值可以在同一类型范围内不断变化
6. 变量在同一个作用域(一个函数或者代码块)内不能重名
7. 变量=变量名+值+数据类型
8. Golang的变量如果没有赋初值，编译器会使用默认值，比如int默认值0，string默认值为空串
9. 不能改变数据类型存储

package main
import "fmt"
//全局变量
var m1=100
var m2=24.5
var m3="marry"//一次性声明
var (x1=100x2=24.5x3="marry"
)
func main(){var i intfmt.Println("i=",i)var num=10.11fmt.Println("num=",num)name :="tom"//等价于：var name string      name="tom"fmt.Println("name=",name)//var n1,n2,n3 int//var n1,n2,n3=100,"tom",33.20n1,n2,n3 :=100,"tom",33.20fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)
}

程序中+号的使用

1. 当左右两边都是数值型时，则做加法运算。
2. 当左右两边都是字符串，则做字符串拼接。

2、变量的数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间。

数据类型

1. 基本数据类型
   1. 数值型
      1. 整数类型(int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte)
      2. 浮点类型(float32,float64)
   2. 字符型(没有专门的字符型，使用byte来保存单个字母字符)
   3. 布尔型(bool)
   4. 字符串(string)
   5. rune://int32的别名,表示一个Unicode码点
   6. byte://uint8的别名
   7. complex64,complex128
2. 派生/复杂数据类型
   1. 指针(Pointer)
   2. 数组
   3. 结构体(struct)
   4. 管道(Channel)
   5. 函数(也是一种类型)
   6. 切片(slice)
   7. 接口(interface)
   8. map
   9. note

注：在Golang中，官方文档将string归属在基本数据类型

基本数据类型默认值

1. 整型 默认值：0
2. 浮点型 默认值：0
3. 字符串 默认值：""
4. 布尔类型 默认值：false

3、整型的使用细节

1. Golang各整数类型分：有符号和无符号。
2. Golang的整型默认声明为int型
3. Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型[如:年龄]
4. bit:计算机中的最小存储单位。byte：计算机中基本存储单元。
5. 如何在程序中查看某个变量的占用字节大小和数据类型

package main
import ("fmt""unsafe"
)func main(){var n1 = 100fmt.Printf("n1的类型 %T,n1占用的字节数是 %d ",n1,unsafe.Sizeof(n1))
}

4、浮点类型

1. Golang的浮点类型可以表示一个小数。
2. 小数类型就是用于存放小数的，比如：1.2

浮点型的分类

1. 单精度float32,占用存储空间:4字节,表数范围:-3.403E38~3.403E38
2. 双精度float64,占用存储空间:8字节,表数范围:-1.798E308~1.798E308

说明一下:

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

package main
import ("fmt"
)func main(){var price float32 = 90.34fmt.Println("price",price)var num1 float32 = -123.0000901var num2 float64 = -123.0000901fmt.Println("num1=",num1,"num2=",num2)//num1= -123.00009 num2= -123.0000901
}

浮点类型使用细节

1. Golang的浮点类型有固定的范围和字节长度，不受具体的操作系统的影响。
2. Golang的浮点类型默认声明为float64类型。
3. 浮点型常量有两种表示形式
   1. 十进制数形式:如:5.12 .512 (必须有小数点)
   2. 科学计数法形式:如:5.1234e2=5.12*10的2次方 5.12E-2=5.12/10的2次方
4. 通常情况下，应该使用float64，因为它比float32更精确。

5、字符类型(char)

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

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

package main
import ("fmt"
)
func main() {var c1 byte ='a'var c2 byte ='0'fmt.Println("c1=",c1,"c2=",c2)//c1= 97 c2= 48fmt.Printf("c1=%c c2=%c\n",c1,c2)//c1=a c2=0   输出字符，使用格式化输出var c3 int ='北'var c4 int =22269fmt.Printf("c3=%c c4=%c\n",c3,c4)//c3=北 c4=国var n1=10 +'a'fmt.Println("n1=",n1)//n1= 107
}

字符类型使用细节

1. 字符常量是用单引号''括起来的单个字符。
2. Go中允许使用转义字符''来将其后的字符转变为特殊字符型常量。
3. Go语言的字符使用UTF-8编码英文字母1个字节，汉字3个字节
4. 在Go中字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值。
5. 可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符
6. 字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。
7. 字符型存储到计算机中，需要将字符对应的码值找出来。 存储:字符-->码值-->二进制-->存储 读取:二进制-->码值-->字符-->读取
8. 字符和码值的对应关系是通过字符编码表决定的(是规定好的)

6、布尔类型：bool

1. 布尔类型也叫bool类型，bool类型数据只允许值true和false
2. bool类型占1个字节
3. bool类型适用于逻辑运算，一般用于程序流程控制
4. 不可以0或非0的整数替代false和true，这点和c语言不同

package main
import ("fmt""unsafe"
)
func main(){var f =falsefmt.Printf("f的类型 %T,f占用的字节数是 %d ",f,unsafe.Sizeof(f))//f的类型 bool,f占用的字节数是 1
}

7、字符串类型：string

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

1. 字符串一旦赋值了，字符串就不能修改了，在Go中字符串是不可变的

2. 字符串的两种表现形式

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

3. 字符串的拼接方式 +

4. 当一行字符串太长时，需要使用到多行字符串，+号留在上一行

二、类型转换

1、基本数据类型的转换

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

基本语法:
表达式 T(v)：将值v转换为类型T
T:就是数据类型，比如int32，int64,float32等等
v:就是需要转换的变量
例:var i int =42var f float64 = float64(i)var u uint8 = uint8(f)fmt.Println(i,f,u)

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

	var n1 int32 = 12var n2 int8 =int8(n1) + 127//编译通过，但是结果不是127+12 按溢出处理fmt.Println(n1,n2)

2、基本数据类型和string的转换

2.1、基本数据类型转string

方式1:

"fmt"下的Sprintf方法
func Sprintf(format string, a ...interface{}) string
：Sprintf根据format参数生成格式化的字符串并返回该字符串。
-----------------------------------------------------
package main
import ("fmt"
)
func main() {var n1 int = 99var n2 float64 =23.45var b bool = truevar c byte = 'a'var str stringstr=fmt.Sprintf("%d",n1)fmt.Printf("str type %T value=%v\n",str,str)str=fmt.Sprintf("%.2f",n2)fmt.Printf("str type %T value=%v\n",str,str)str=fmt.Sprintf("%t",b)fmt.Printf("str type %T value=%v\n",str,str)str=fmt.Sprintf("%c",c)fmt.Printf("str type %T value=%v\n",str,str)
}

方式2：

使用strconv包的函数
func Itoa(i int) string:Itoa是FormatInt(i, 10) 的简写。
func FormatBool(b bool) string:根据b的值返回"true"或"false"。
func FormatInt(i int64, base int) string:返回i的base进制的字符串表示。base 必须在2到36之间，结果中会使用小写字母'a'到'z'表示大于10的数字。
func FormatUint(i uint64, base int) string:是FormatInt的无符号整数版本。
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。
---------------------------------------------------------------------
package main
import ("fmt""strconv"
)
func main() {var n1 int64 = 99var n2 float64 =23.45var b bool = truevar n3 uint64 = 123var str stringstr = strconv.FormatInt(n1,10)fmt.Printf("str type %T value=%v\n",str,str)str = strconv.Itoa(int(n1))fmt.Printf("str type %T value=%v\n",str,str)str = strconv.FormatFloat(n2,'f',10,64)//说明:'f':格式 10:表示小数位保留10位 64:表示这个小数是float64fmt.Printf("str type %T value=%v\n",str,str)str = strconv.FormatBool(b)fmt.Printf("str type %T value=%v\n",str,str)str = strconv.FormatUint(n3,10)fmt.Printf("str type %T value=%v\n",str,str)
}

2.2、string类型转基本数据类型

使用strconv包的函数
func ParseBool(str string) (value bool, err error):返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误。
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。
func ParseUint(s string, base int, bitSize int) (n uint64, err error):ParseUint类似ParseInt但不接受正负号，用于无符号整型。
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。
-------------------------------------------------------------------------------
package main
import ("fmt""strconv"
)
func main() {var str string = "true"var b boolb , _ = strconv.ParseBool(str)fmt.Printf("b type %T value=%v\n",b,b)str = "1234567"n1, _ := strconv.ParseInt(str,10,0)fmt.Printf("n1 type %T value=%v\n",n1,n1)str = "123.35"f1, _ := strconv.ParseFloat(str,64)fmt.Printf("f1 type %T value=%v\n",f1,f1)
}

注意：在将string类型转成基本数据类型时，要确保string类型能够转成有效的数据。例：不能把"hello"转成一个整数，如果这样做Golang直接将其转换成0.其他类型也是一样的道理，没有转成功，则转成默认值。

干我们这行，啥时候懈怠，就意味着长进的停止，长进的停止就意味着被淘汰，只能往前冲，直到凤凰涅槃的一天！