Golang变量-学习笔记

1.为什么需要变量

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

func getVal(num1,int,num2,int)(int,int){
    sum := num1 + num2
    sub := num2 - num2
    return sum,sub
}
func main(){
    sum,sub := getVal(30,30)
    fmt.Println("sum=",sum,"sub=",sub)
    sum2,_ := getVal(10,30)//只取出第一个返回值
    fmt.Println("sum=",sum2)
}

上例中的sum,sub都是变量。

2.变量的介绍

1）变量相当于内存中一个数据存储空间的表示，通过变量名可以访问到变量(值)。
2）变量的使用步骤
声明变量(也叫：定义变量)
非变量赋值
使用变量

3.变量快速入门案例

package main
import "fmt"
func main(){
    //定义变量、声明变量
    var i int
    i = 10
    //使用变量
    fmt.Println("i=",i)
}

4.变量使用注意事项

1)变量表示内存中的一个存储区域
2)该区域有自己的名称（变量名）和类型（数据类型)
示意图:

3) Golang 变量使用的三种方式
第一种：指定变量类型，声明后若不赋值，使用默认值

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

第二种：根据值自行判定变量类型(类型推导)

package main
import "fmt"

func main(){
//第二种：根据值自行判定变量类型(类型推导)
	var num = 10.11
    fmt.Println("num=",num)
}

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

package main
import "fmt"
func main(){
    //第三种 := 省略var，注意 := 左侧的变量不应该是已经声明过的，否则会导致编译错误
    //下面的方式等价var name string name = "tom"
    // := 的 : 不能省略，否则错误
    name := "tom"
    fmt.Println("name=",name)
}

多变量声明
在编程中，有时需要一次性声明多个变量，Golang也提供这样的语法
举个栗子：

package main
import "fmt"
func main(){
    // golang如何一次性声明多个变量
    var n1,n2,n3 int
	fmt.Println("n1=",n1, "n2=",n2,"n3=",n3)

    // 一次性声明多个变量的方式2
    var n4,name , n5 = 100,"tom",888
	fmt.Println("n4=",n4,"name=", name,"n5=",n5)

    // 一次性声明多个变量的方式3,同样可以使用类型推导
    n6, name1, n7 := 200, "jack",999
    fmt.Println("n6=", n6, "name1=", name1, "n7=", n7)
}

如何一次性声明多个全局变量【在go中函数外部定义变量就是全局变量】

// 定义全局变量
var n1 = 100
var n2 = 200
var name = "jack"
//上面的声明方式，也可以改成一次声明
var(
    n3 = 300
    n4 = 900
    name2 = "mary"
)

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

变量在同一作用域内（在一个函数或者在代码块）不同重名

变量=变量名+值+数据类型
Golang的变量如果没有附初始值，编译器会使用默认值，比如int默认值0，string默认值空串，小数默认值为0

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

声明变量
基本语法：var, 变量名, 数据类型
var a int 这就是声明了一个变量，变量名是a
var num1 float32 这也声明了一个变量，表示一个单精度类型的小数，变量名是num1
初始化变量
在声明变量的时候，就给值。
var a int = 45这就是初始化变量a
使用细节：如果声明时就直接赋值，可省略数据类型
var b = 400
给变量赋值
比如先声明了变量：var num int //默认0
然后，再给值num = 780；这就是给变量赋值.

6.程序中+号的使用

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

package main
import "fmt"
// golang中+的使用
func main(){
    var i = 1
    var j = 2
    var r = i + j  //加法运算
    fmt.Println("r=",r)
    var str1 = "hello"
    var str2 = "world"
    var res = str1 + str2 //拼接作用
    fmt.Println("res=",res)
}

7.数据类型的基本介绍

8.整数类型

1）基本介绍
简单的说，就是用于存放整数值的，比如 0，-1，2345等等。
2）案例演示

package main
import "fmt"
// golang 中整数类型的使用
func main(){

    var i int = 1
    fmt.Println("i=",i)
    // 测试一下int8的范围，-128~127
    // 其他的int16，int32，int64，类推
    var j int8 = 127
    // var j int8 = 128
    // var j int8 = -129
	fmt.Println("j=",j)
}

3）整数的各个类型

类型	有无符号	占用存储空间	表示数范围
int8	有	1字节	-128 ~ 127
int16	有	2字节	-2^15 ~ 2^15-1
int32	有	4字节	-2^31 ~ 2^31-1
int64	有	8字节	-2^63 ~ 2^63-1

int的无符号的类型

类型	有无符号	占用存储空间	表示数范围
uint8	无	1字节	0 ~ 255
uint16	无	2字节	0 ~ 2^16-1
uint32	无	4字节	0 ~ 2^32-1
uint64	无	8字节	0 ~ 2^64-1

//测试一下uint8的范围（0-255）,其他的int16，int32，int64，类推
var k uint16 = 255
fmt.Println("k=",k)

int的其他类型的说明

类型	有无符号	占用存储空间	表示数范围	备注
int	有	32位系统4个字节 64位系统8个字节	-2^31 ~ 2^31-1 -2^63 ~ 2^63-1
uint	无	32位系统4个字节 64位系统8个字节	0 ~ 2^32-1 0 ~ 2^64-1
rune	有	与int32一样	-2^31 ~ 2^31-1	等价int32，表示一个Unicode码
byte	无	与uint8等价	0 ~ 255	与uint8等价 0~255 当要存储字符时选用byte

package main
import "fmt"
func main(){
    // 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)
}

4）整型的使用细节
1)Golang各整数类型分：有符号和无符号，int uint的大小和系统有关。
2) Golang 的整型默认声明为int型

// 整数的使用细节
var n1 = 100 //？n1是什么类型
// 这里介绍一下如何查看某个变量的数据类型
// fmt.Printf()可以用于格式化输出
fmt.Printf("n1 的类型 %T \n",n1)

3)如何在程序中查看某个变量的字节大小和数据类型（使用较多）

package main
import "fmt"
import "unsafe"
func main(){
    // //如何在程序查看某个变量的占用字节大小和数据类型(使用较多)
    var n2 int64 =10
    //unsafe.sizeof(n1)是unsafe包的一个函数，可以返回n1变量占用的字节数
    fmt.Printf("n2 的 类型%T n2占用的字节数是 %d ", n2, unsafe.Sizeof(n2))
}

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

//Golang程序中整型变量在使用时,遵守保小不保大的原则
// 即:在保证程序正确运行下,尽量使用占用空间小的数据类型
var age byte = 90

5)bit：计算机中的最小存储单位。byte：计算机中基本存储单元。1byte = 8 bit

9.小数类型/浮点型

1）基本介绍
小数类型就是用于存放小数，比如1.2 ，0.23， -1.911
2）案例演示

package main
import "fmt"
//演示golang中小数类型使用
func main(){
	var price float32 = 89.12
    fmt.Println("price=", price)
}

3）小数类型分类

类型	占用存储空间	表示数范围
单精度float32	4个字节	-3.403E38 ~ 3.403E38
双精度float64	8个字节	-1.798E308 ~ 1.798E308

注:
（1）关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位

package main
import "fmt"
    //演示golang中小数类型使用
func main(){
    var num1 float32 = -0.00089
    var num2 float64 = -7809656.09
	fmt.Println("num1=",num1, "num2=",num2)
}

说明：浮点数都是有符号的。
（2）尾数部分可能丢失，造成精度损失。-123.0000901

package main
import "fmt"
//演示golang中小数类型使用
func main(){
//尾数部分可能丢失,造成精度损失。-123.0000901
    var num3 float32 =-123.0000901
    var num4 float64 = -123.0000901
fmt.Println("num3=",num3,"num4=", num4)
}

注：float64 的精度比 float32的要准确
注：如果我们要保存一个精度高的数，则应该选用float64
（3）浮点型的存储分为三部分：符号位+指数位+尾数位 在存储过程中，精度会有丢失
4）浮点型使用细节
（1）Golang 浮点类型有固定的范围和字段长度，不受具体OS(操作系统)的影响。
（2） Golang 的浮点型默认声明为float64类型。

// Golang的浮点型默认声明为float64类型
var num5 =1.1
fmt. Printf("num5的数据类型是%T \n", num5)

（3）浮点型常量有两种表示形式
十进制数形式：如：5.12 .512(必须有小数点)
科学计数法形式：如：5.1234e2 = 5.12*10的2次方 5.12E-2=5.12/10的2次方

package main
import "fmt"
//演示golang中小数类型使用
func main(){
    // 十进制数形式：如：5.12    .512(必须有小数点)
    num6 :=5.12
    num7 :=.123
    fmt.Println("num6=",num6,"num7=",num7)
    // 科学计数法形式
    // 5.1234*10的2次方    
    num8 :=5.1234e2
    num9 := 5.1234E2
    // 5.1234 / 10 的2次方
    num10 := 5.1234E-2
    fmt.Println("num8=",num8,"num9=",num9,"num10=",num10)
}

（4）通常情况下，应该使用float64，因为它比float32更精确。

10.字符类型

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

package main
import "fmt"
//演示golang中字符类型使用
func main(){
    var c1 byte = 'a'
    var c2 byte = '0'//字符的0
    //当我们直接输出byte值,就是输出了的对应的字符的码值
    //  'a' ==>
    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表的，比如[O-1, a-z,A-Z…]直接可以保存到byte
（2）如果我们保存的字符对应码值大于255，这时我们可以考虑使用int类型保存
（3）如果我们需要安装字符的方式输出，这时我们需要格式化输出，即 fmt.Printf(%c", c1)…
3）字符类型的使用细节
（1）字符常量是用单引号(")括起来的单个字符。
例如：var c1 byte = ‘a’ var c2 int = '中’ var c3 byte = ‘9’
（2）Go中允许使用转义字符 ‘’ 来将其后的字符转变为特殊字符型常量。
例如: var c3 char = ‘\n’ // '\n’表示换行符
（3）Go 语言的字符使用UTF-8 编码，如果想查询字符对应的utf8码值http://www.mytju.com/classcode/tools/encode_utf8.asp
英文字母: 1个字节 汉字: 3个字节
（4）在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值。
（5）可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符

package main
import "fmt"
//演示golang中字符类型使用
func main(){
    // 可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符
    var c4 int = 22269 //22269 '国'，120 'x'
	fmt.Printf("c4=%c\n",c4)
}

（6）字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码。

package main
import "fmt"
//演示golang中字符类型使用
func main(){
    var n1 = 10 + 'a'
	fmt.Println("n1=",n1)
}

4）字符类型本质探讨
（1）字符型存储到计算机中，需要将字符对应的码值（整数）找出来
存储：字符—>对应码值—>二进制–>存储
读取：二进制—>码值—>字符–>读取
（2）字符和码值的对应关系是通过字符编码表决定的(是规定好)
（3）Go语言的编码都统一成了utf-8。非常的方便，很统一，再也没有编码乱码的困扰了
11.布尔类型
1）基本介绍
（1）布尔类型也叫 bool类型，bool类型数据只允许取值 true和 false
（2）bool类型占1个字节。
（3）bool 类型适于逻辑运算，一般用于程序流程控制[注:这个后面会详细介绍]：
if条件控制语句
for循环控制语句
2）案例演示

package main
import "fmt"
import "unsafe"
//演示golang中bool类型使用
func main(){
    var b = false
    // 注意事项
    // 1、bool类型占用存储空间是1个字节
    fmt.Println("b 占用的空间 = ",unsafe.Sizeof(b))
    // 2、bool类型只取true和false
}

12.string类型
1）基本介绍
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
2）案例演示

package main
import "fmt"
//演示golang中string类型使用
func main(){
    // string的基本使用
    var address string = "北京长城 110 hello world"
    fmt.Println(address)
}

3）string使用注意事项和细节
（1）Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码，中文乱码问题不会再困扰程序员。
（2）字符串一旦赋值了，字符串就不能修改了：在Go中字符串是不可变的。

（3）字符串的两种表示形式
双引号，会识别转义字符
反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果
【案例演示】

package main
import "fmt"
//演示golang中string类型使用
func main(){
    str2 := "abc\nabc"
	fmt.Println(str2)
    // 使用的反引号
    str3 := `
    使用的反引号
    `
    fmt.Println(str3)
}

（4）字符串拼接方式

package main
import "fmt"
//演示golang中string类型使用
func main(){
    var str = "hello " + "world "
    str += "hahahah"
    fmt.Println(str)
}

（5）当一行字符串太长时，需要使用到多行字符串，可以如下处理

13.基本数据类型的默认值
1）基本介绍
在go中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在go中，默认值又叫零值。
2）基本数据类型的默认值如下

数据类型	默认值
整数	0
浮点型	0
字符串	“”
布尔类型	false

案例：

package main
import "fmt"
func main(){
    var a int
    var b float32
    var c float64
    var isMa bool
    var name string
    // %v表示按照变量的值输出
    fmt.Printf("a=%d,b=%v,c=%v,isMa=%v,name=%v",a,b,c,isMa,name)
}

未完。。。