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个，详见如下

系统预定义标识符

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