3.15 基本数据类型和string的转换

3.1 为什么需要变量

程序就是一个世界，不论是那种语言程序都是其程序的基本组成单位

变量介绍

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

3.2 变量的使用基本步骤

1. 声明变量（有人又叫：定义变量）
2. 赋值
3. 使用

3.3 变量快速入门案例

package main

import "fmt"

func main(){
	// 定义一个变量/声明变量
	var i int;
	// 给i 赋值
	i = 10;
	// 使用变量
	fmt.Println("i=",i)
}

3.4 变量定义方式

1.第一种，指定变量类型，声明后若是不赋值，使用默认

2.第二种，根据值自行判定变量类型（类型推导）

4.第三种，省略var，注意左侧的变量不应该是已经声明过的，否则会导致编译错误

package main
import "fmt"

func main(){
	// golang的变量使用方式：
    var i int
	// 第一种：指定变量类型，声明后不赋值，使用默认值
	fmt.Println("i",i)
	// int 的默认值是0，其他再说

	// 第二种呢，根据值自行推导
	var num = 123 // int
	var num = 211.11
	fmt.Println("num",num)

	// 第三种 省略var 注意左侧的变量不应该是已经声明
	// 下面的方式等价 var 
	// :=  的：不能省略
	name := "tom"
	fmt.Println("name",name)
}

5.该区域的数值可以在同一类型范围内不断变化

package main
import "fmt"

// 变量使用的注意事项
func main(){
	// 该区域的数据可以在同一范围内不断变化
	var i int = 10;
	i = 30;
	i = 50;
	fmt.Println("i=",i)
	i = 1.2// int不是字符型 原因是不能改变数据类型
}

6.在同一作用域中（在一个函数中或代码块）内不能重名

    // 在同一作用域中（在一个函数中或代码块）内不能重名
	i := 99 // 错误的 和 var i=99相同

7.变量=变量名+值+数据类型，这点请大家注意
8.Golang的变量没有赋初始值，编译会使用默认值，比如int 默认值 0，小数 默认值0，string默认值是空

3.5变量的声明，初始化和赋值

3.6 +号使用

如果+号两边都是数字就是运算。如果+两边都是字符串就是链接。

变量类型 3.8整数类型

例子

import "fmt"

// 演示go中整数类型使用g
func main(){
	var i int = 1
	fmt.Println("i=",i)

	// 测试一下int的范围 -128~127
	var j int8 = 127
	fmt.Println("j=",j)
}

无符号类型

int的无符号

// uint8的范围
	var k uint16 = 255
	fmt.Println("k=",k)

int 的其他区类型说明

// int ,uint,rune,byte的使用
	var a int = 8900
	fmt.Println("a=",a)
	var b uint = 1
	var c byte = 255
	fmt.Println("b=",b,"c=",c)

整数的使用细节

1.Golang各整数类型分：有符号和无符号，int uint的大小和系统有关
2.Golang的整型默认声明为int型
3.如何在程序中查看某个变量的字节大小和数据类型
4.Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。【如年龄】
5.bit：计算机中的最小存储单位，byte：计算机中基本存储单位。【二进制再详细说】
一个byte = 8个bit

// 整数的使用细节
	var n1 = 100
	// fmt.Printf() 可以用于做格式化输出
	fmt.Printf("n1 的类型%T",n1)

	// 如何在程序中查看某个变量的字节大小和数据类型
	var n2 int64 = 10
	// unsafe.Sizeof(n1) 是unsafe包的一个函数 可以返回n2变量占用的字节数
	fmt.Printf("\nn2 的类型%T n2的字节数是%d",n2,unsafe.Sizeof(n2))

	// Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。【如年龄】
	var age byte = 800

3.9 浮点类型

小数类型就是用来存储小数的，比如 120.121 1.322

例子

package main
import "fmt"

// 演示golang中小数（浮点）

func main(){
	var price float32 = 321.212
	fmt.Println("price=",price)
}

小数类型的分类

对上图的说明
1.浮点数=符号位+指数位+尾数位
2.位数部分可能丢失，造成精度损失
3.浮点型的存储分为三部分：符号位+指数位+位数位 在存储过程中，精度会有丢失

package main
import "fmt"

// 演示golang中小数（浮点）

func main(){
	var price float32 = 321.212
	fmt.Println("price=",price)
	var num1 float32 = -0.0089
	var num2 float64 = -70000.09
	fmt.Println("num1=",num1,"num2=",num2)

	var num3 float32 = -13221.3212
	var num4 float64 = -13221.3212
	fmt.Println("num3=",num3,"num4=",num4)
}

说明精确度float64>float32

3.10 字符类型

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

案例

import (
	"fmt"
)

// 演示golang中字符的使用
func main(){
	var c1 byte = 'a'
	var c2 byte = '0' // 字符的0

	// 当我们直接输出byte值，就是输出了的对应的字符的码值
	fmt.Println("c1=",c1)
	fmt.Println("c2=",c2)
	// 如果我们希望输出对应字符，需要使用格式化输出
	fmt.Printf("c1=%c c2=%c\n",c1,c2)

	// var c3 byte = '北' // overflow 溢出
	var c3 int = '北'
	fmt.Printf("c3=%c c3对应的码值为%d",c3,c3)
}

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

字符类型使用细节
1.字符常量是用单引号来定义的
2.Go中允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量，例如：varchar = ‘a’ // ‘n’ 表示换行符
3.Go语言的字符使用utf-8编码
英文字母1个字符，汉字3个字节
4.在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值
5.可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出数字对应的Unicode字
6.字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码

字符类型本质讨论
1.字符型 存储到 计算机中，需要将字符对应的码值（整数）找出来
存储：字符-》对应码值-》二进制-》存储
读取：二进制-》码值-》字符-》读取

2. 字符和码值的关系是通过字符编码表决定的
3. Go语言的编码统一成了utf-8，非常方便，很统一。再也没有编码乱的困扰了

bool类型

package main
import (
	"fmt"
	"unsafe"
)

func main(){
	var b = false
	fmt.Println("b=",b)
	// 注意
	// 1. bool类型占用的空间是1个字节
	fmt.Println("b 的占用空间=",unsafe.Sizeof(b))
	// 2. bool 类型只能是true或false
	// b = 1
}

3.11 字符串类型

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

package main
import (
	"fmt"
)
func main(){
	var address string = "北京长城 12额32213212"
	fmt.Println(address)
}

3.12 string使用方法注意事项

1.Go 语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码中文乱码问题不会再困扰程序员
2. 字符串一旦赋值就不能再改变
3. 字符串的两种表现形式
a. 双引号，会识别转义字符
b.反引号，以字符串的原生形式输出，包括注释换行等其他字符，可以防止工具，输出源码等

4. 字符拼接方式

// 字符串拼接方式
	var str4 = "hello" + "world"
	str4 += "hell"
	fmt.Println(str4)

5. 当字符串过长时候+ 要保存在上面

var str5 = "hello" + "world" + 
	 "hello" + "world"
	 fmt.Printf(str5)

3.13基本数据类型默认值

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

案例

var a int // 0
	var b float32 // 0
	var c float64 // 0
	var isMarryied bool // false
	var name string // ""
	// 这里的%v 表示按照变量的原值输出
	fmt.Printf("a=%d,b=%v,c=%v,isMarryied=%v name=%v",a,b,c,isMarryied,name)

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

基本介绍
表达式T（v）将值v转换为T
T:就是数据类型 比如int32，int64，float32等
v：就是需要转换的变量

package main
import (
	"fmt"
)

//  演示
func main(){
	var i int32 = 100
	var n1 float32 = float32(i)
	var n2 int8 = int8(i)
	var n3 int64 = int64(i) // 低精度->高精度

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

细节说明

1. Go中，数据类型的转换可以是从表示范围小->表示范围大，也可以范围大-》范围小
2. 被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化
3. 在转换中，比如将int64转成【-128-127】，编译时不会报错，只是转换的结果按溢出处理，和我们想要的结果不一样。

3.15 基本数据类型和string的转换

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

基本类型转string
方式一：fmt.Sprintf(“%参数”，表达式）
函数的介绍：

package main 
import (
	"fmt"
)

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=%q\n",str,str)

	str = fmt.Sprintf("%f",num2)
	fmt.Printf("str type %T str=%q\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)
}

方式二：使用strconv

// 第二种
	var num3 int =  99
	var num4 float64 = 23.456
	var b2 bool = true

	str = strconv.FormatInt(int64(num3),10)
	fmt.Printf("str type %T str=%q\n",str,str)
	// str = strconv.FormatFloat(num,'f',10,64)
	// 说明：'f'格式 10：小数点后10位 64：表示float64
    
	str = strconv.FormatFloat(num4,'f',10,64)
	fmt.Printf("str type %T str=%q\n",str,str)

	str = strconv.FormatBool(b2)
	fmt.Printf("str type %T str=%q\n",str,str)

string类型基本数据类型

1. 使用时strconv包的函数

ParseBool,ParseFloat,ParseInt,ParseUint

2. 案例演示

package main
import (
	"fmt"
	"strconv"
)

// 演示golang中string转成基本数据类型
func main(){
	var str string = "true"
	var b bool
	// b , _= strconv.ParseBool(str)
	// 说明
	// 1. strconv.ParseBool(str) 函数会返回两个值 （value bool,err error)
	// 2. 因为我只想获取到value bool，不想获取err 所以我使用_忽略
	b , _= strconv.ParseBool(str)
	fmt.Printf("b type %T b=%v",b,b)

	var str2 string = "1234567890"
	var n1 int64
	var n2 int 
	n1, _= strconv.ParseInt(str2,10,64)
	n2 = int(n1)
	fmt.Printf("n1 type %T n1=%v\n",n1,n1)
	fmt.Printf("n2 type %T n2=%v\n",n2,n2)

	var str3 string = "12.323"
	var f1 float64
	f1, _= strconv.ParseFloat(str3,64)
	fmt.Printf("f1 type %T f1=%v\n",f1,f1)
}

3.16 指针

基本介绍

1.基本数据类型，变量存的就是值，也叫值类型
2.获取变量的地址，用&，比如：var num int 获取num的地址：&num
分析一下基本数据类型在内存的布局

3.指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值
比如：var ptr *int = &num
举例说明：指针存在内存的布局

package main
import (
	"fmt"
)

func main(){
	// 基本数据类型存在内存布局
	var i int = 10
	// 1 的地址是什么，&1
	fmt.Println("i的地址=",&i)

	// 下面的 var ptr *int = &i
	// 1. ptr 是一个指数变量
	// 2. ptr 的类型 *int
	// 3. ptr 本身的值&i
	var ptr *int = &i 
	fmt.Printf("ptr=%v\n",ptr)
	fmt.Printf("ptr 的地址=%v",&ptr)
	fmt.Printf("ptr 指向的值=%v",*ptr)
}

3.18 标识符的命名规范

标识符概念

1.Golang对各种变量，方法，函数等命名时使用的字符序列称为标识符
2.凡是自己可以起名字的地方都叫标识符

标识符的命名规则

1.由26个英文字母大小写，0-9，组成
2. 不可以数字开头
3. Golang中严格区分大小写
4. 标识符不能含有空格
5.下划线“”本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其他的标识符，但是它对应的值会被忽略（比如：忽略某个返回值）。所以仅能被作为站位符使用，不能作为标识符使用。
6.不能使用系统函数做标识符，比如if,break等…

标识符案例

hello // ok
hello2 // ok
1hello // error
h-b  // error
x h // error
h_4 // ok
_ab // ok
int // ok,不可以
float32 // ok,不可以
_ //error 
Abc // ok

标识符命名注意事项

1.包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库不要冲突fmt
2.变量名，函数名，常量名：采用驼峰法。
3.如果变量名，函数名，常量名首字母大写，则可以被其他的包访问：如果首字母小写，则只能在本包中使用（注：可以简单的理解成，首字母大写是公有的，首字母小写是私有的）

3.19 系统保留关键字

保留关键字介绍：在Go中，为了简化代码编译过程中对代码的解析，其定义的保留关键字只有25个，详见如下

系统预定义标识符

感谢大家观看，我们下次见