3.1 为什么需要变量
程序就是一个世界，不论是那种语言程序都是其程序的基本组成单位
变量介绍
变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的们牌号。通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量（值）
3.2 变量的使用基本步骤
- 声明变量（有人又叫：定义变量）
- 赋值
- 使用
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) }
- 如果保存的字在ASCII表的，比如【0-1，a-z，A-Z】直接可以保存到byte
- 如果我们保存的字符对应的字符对应码大于255，这时我们可以考虑使用int类型保存
- 如果我们需要按照字符的方式输出，我们需要格式化输出，即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.字符型 存储到 计算机中，需要将字符对应的码值（整数）找出来
存储：字符-》对应码值-》二进制-》存储
读取：二进制-》码值-》字符-》读取
- 字符和码值的关系是通过字符编码表决定的
- 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.反引号，以字符串的原生形式输出，包括注释换行等其他字符，可以防止工具，输出源码等
- 字符拼接方式
// 字符串拼接方式 var str4 = "hello" + "world" str4 += "hell" fmt.Println(str4)
- 当字符串过长时候+ 要保存在上面
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) }
细节说明
- Go中，数据类型的转换可以是从表示范围小->表示范围大，也可以范围大-》范围小
- 被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化
- 在转换中，比如将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类型基本数据类型
- 使用时strconv包的函数
ParseBool,ParseFloat,ParseInt,ParseUint
- 案例演示
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个，详见如下
系统预定义标识符
感谢大家观看，我们下次见
