go语言学习之有关变量的知识

变量的学习

变量是程序的基本组成单位

概念：

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

1.变量的使用步骤

1）声明变量（也叫定义变量）

2）给变量赋值

3）使用变量

package main

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

2.变量的注意事项

1)变量表示内存中的一个存储区域

2)该区域有自己的名称(变量名)和类型(数据类型)

示意图：

3.变量使用的三种方式：

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

2）第二种，根据值自行判断变量的类型(类型推导)

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

package main

import "fmt"
func main(){
	//1.golang的变量使用方式1
	//第一种，指定变量类型，声明后不赋值的话，使用默认值
	//int 的默认值为0
	var i int
	fmt.Println("i=",i)//结果为0
	//第二种，根据值自行判断变量的类型(类型推导)
	var num = 10.11
	fmt.Println("num=",num)
	//第三种：省略var，注意:=左侧的变量不应该是已经声明的，否则会导致编译报错
	//下面的方式等价于var name string name = "tom"
	name :="tom"//这个地方的:不能省略
	fmt.Println("name=",name)
	//4）多变量声明
    //在编程过程中，有时我们需要一次声明多个变量，golang也提供这样的语法
     

}

4）多变量声明

在编程过程中，有时我们需要一次声明多个变量，golang也提供这样的语法

package main

import "fmt"
func main(){
	
	//该案例演示golang如何一次性声明多个变量
	// var n1, n2, n3 int
	// fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)
	//一次性声明多个变量方式二
	 n1,name, n3 := 100, "tom_",888
	fmt.Println("n1=",n1,"name=",name,"n3=",n3)

	//同样使用类型推导
}

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

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

package main

import "fmt"

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

6）变量在同一个作用域(一个函数或者一个代码块中)内不能重名

package main

import "fmt"

//变量使用的注意事项
func main(){
	//该区域的数据值可以在同一类型范围内不断变化
	var i  int =10
	i = 30
	i = 50
	fmt.Println("i=",i)
	//i = 1.23 //汇报错，因为不是int,不能改变数据类型

	//变量在同一个作用域(在一个函数或者在代码块中)内不能重名
	//var i int = 50
	//i := 99  //也会报错。这样写就包含了定义变量
}

7）变量=变量名 + 值 +数据类型，这一点大家要注意，变量的三要素

8）goglang的变量如果没有赋初值，编译器会使用默认值，比如int会默认值是0,string的默认值是空串

4.程序中 + 号的使用

1）当左右两边都是数值类型的时候，则做加法运算

2）当左右两边都是字符串，则做字符串拼接

package main

import "fmt"

//展示Golang的使用
func main(){
	
	var i =1
	var j =2
	var r = i+j //做加法运算
	fmt.Println("r=",r) //result is 5

	var str1 = "hello"
	var str2 = "world"
	var res = str1 + str2
	fmt.Println("res=",res) //result is helloworld

}

5.变量的数据类型

1）int数据类型

package main

import "fmt"

//展示Golang整数类型的使用
func main(){
	
	var i int =1
	fmt.Println("i=",i)
	//测试一下int的范围
	var j int8 = -129 //会报错 因为其范围是-128 ~ 128
	fmt.Println("j=",j)

}

无符号int整型介绍：

	//测试一下
    var k uint8 = -1  //会报错
	fmt.Println("k=",k)

整型的类型

//int,uint,rune, byte的使用
	var a int =8900
	fmt.Println("a=",a)
	var b uint = 1
	var c byte = 3 //范围是0~255
	fmt.Println("b=",b,"c=",c)

整型的使用细节

1）Golang各个整数类型分为：有符号和无符号 int uint的大小和系统有关系

2)Golang的整型默认为int型

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

package main

// import "fmt"
// import "unsafe"
import (
	"fmt"
	"unsafe"
)

//展示Golang整数类型的使用
func main(){
	
	// var i int =1
	// fmt.Println("i=",i)
	//测试一下int的范围
	//var j int8 = -129 //会报错
	//fmt.Println("j=",j)
	//测试一下
    var k uint8 = 255
	fmt.Println("k=",k)
	//int,uint,rune, byte的使用
	var a int =8900
	fmt.Println("a=",a)
	var b uint = 1
	var c byte = 3 //范围是0~255
	fmt.Println("b=",b,"c=",c)

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

	fmt.Printf("n1 的类型 %T ",n1)

	 //如何查看某个变量的占用字节大小和数据类型 （使用较多）
    var n2 int64 = 10
	//unsafe.Sizeof(n2)) 是unsafe包的一个函数，可以返回n1变量占用的字节数
	fmt.Printf("n2 的类型 %T n2占用的字节数为 %d ",n2,unsafe.Sizeof(n2))


}

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

//golang程序中整型变量在使用时，遵守保大不保小的原则
	//即，在程序正常运行下，尽量使用占用空间小的数据类型
    var age byte = 45

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

2）小数类型浮点型

基本介绍

小数类型就是用于存放小数的，比如 1.2 0.23 1.911

案例演示：

func main(){

	var price float32 = 89.12
	fmt.Println("price",price)
	

}

浮点类型的使用

func main(){

	var price float32 = 89.12
	fmt.Println("price",price)
	var num1 float32 = -0.00089
	var num2 float64 = -780956.09
	fmt.Println("num1",num1,"num2",num2)

}

//位数部分可能丢失，造成精度损失。 -123.00000901

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

说明float64 的精度比float32的更高

//保存精度更高的数应该用float64

package main

import "fmt"

//演示golang中小数类型的使用
func main(){

	var price float32 = 89.12
	fmt.Println("price",price)
	var num1 float32 = -0.00089
	var num2 float64 = -780956.09
	fmt.Println("num1",num1,"num2\n",num2)
    
	//位数部分可能丢失，造成精度损失。 -123.00000901

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

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

	//十进制整数形式.如：5.12    .512(必须有小数点)
	num6 := 5.12
	num7 := .123 //=> 0.123
	fmt.Println("num6",num6,"num7\n",num7)

	//科学计数法模式
	num8 := 5.1234e2 // ?5.1234 *10的2次方
	num9 := 5.1234E2 // ?5.1234 *10的2次方
	num10 := 5.1234E-2 // ?5.1234 *10的-2次方
	fmt.Println("num8=",num8,"num9=",num9,"num10",num10)
}

3）字符类型

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

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

[官方string、归属为https://tour,go-zh.org/basic/11]

package main

import (
	"fmt"
)

//演示golang中字符类型使用
func main(){
	
	var c1 byte = 'a'
	var c2 byte = '0'
	//当我们输出byte值时，就直接输出了对应的字符ASCI码值
    fmt.Println("c1=",c1,"c2=",c2) //c1=92 c2=48
	//如果我们希望输出对应的字符，需要使用格式化输出
	fmt.Printf("c1=%c c2=%c\n",c1,c2) //输出结果为 c1=a c2=0

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

对上面代码说明

1)如果我们保存的字符在ASCII表，比如0-1,a-z,A-Z.直接可以保存到byte

2)如果我们保存的字符对应的码值大于255,这是我们考虑int类型

3)如果我们需要按照字符的方式输出，这时我们只需要格式化输出printf(“%c”)

字符类型使用细节

package main

import (
	"fmt"
)

//演示golang中字符类型使用
func main(){
	
	var c1 byte = 'a'
	var c2 byte = '0'
	//当我们输出byte值时，就直接输出了对应的字符ASCI码值
    fmt.Println("c1=",c1,"c2=",c2) //c1=92 c2=48
	//如果我们希望输出对应的字符，需要使用格式化输出
	fmt.Printf("c1=%c c2=%c\n",c1,c2) //输出结果为 c1=a c2=0

	//var c3 byte = '北'  //overflow 溢出
	var c3 int = '北'  //汉字的ASCI码值比较大
	fmt.Printf("c3=%c c3对应的码值为=%d\n",c3,c3) //北 c3对应的码值为21271
    
	var c4 int = 22269 // 22269的ASCI码是国字
	fmt.Printf("c4=%c",c4) //输出的结果就是国字

   //字符类型是可以进行运算的，相当于于一个整数，运算时是按照码值进行运算的
   var num1 = 10 + 'a' //10 +97 =107
   fmt.Println("num1=",num1)
}

字符类型的本质探讨

1）字符类型存储到计算机中，需要将字符对应的码值（整数）找出来

存储：字符=》对应值–》二进制–》存储

读取：二进制—》码值----》字符—》读取

2）字符和码值的对应关系是通过字符编码表决定的（是规定好的）

3）Go语言的编码都统一成了utf-8，和其他的编程语言来说，非常的方便，很统一，再也没有编码的困扰了

布尔类型

基本介绍

1）布尔类型也是bool类型，bool类型数据只允许取值true和false

2）bool类型占一个字节

3）boolean类型适用于逻辑运算，一般用于程序流程控制：这个后面会详细介绍

package main

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

}

if条件控制语句

for循环控制语句

4）字符串（String）类型

基本介绍

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

package main

import (
	"fmt"
)

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

	
}

String 使用的注意事项和细节

1）Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码，乱码问题不会困扰程序员

2）字符串一旦赋值，字符串就不能更改了，在go中字符串是不可变的

//字符串一旦赋值了，字符串就不能修改了，在Go中字符串是不可变的
	var str ="hello"
	//str[0] = 'a'  //这里不能去修改str的内容，即Go中的字符串是不可变的
    fmt.Println(str)

3）字符串的两种表示形式

（1）双引号，会识别转义字符

（2）反引号，以字符串的原生形式输出，包括换行和特殊字符，可以防止攻击、输出源代码等效果

4）字符串的拼接方式

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

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

// var str6 = "hello" + "world" 
	// +"hello"+"hello"
	// +"world"
	// fmt.Println(str6) //会报错，+号要在上面

	var str6 = "hello" + "world" +
	"hello"+
	"hello"+
	"world"
	fmt.Println(str6) //正确输出

---

5）基本数据类型默认值

基本介绍：

在go中所有的数据类型都有一个默认值，当程序员没有赋值时就会保留默认值，在go中，默认值又叫0值，以下就是这个默认值：

基本数据类型一览表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ebld3UFY-1692969282528)(D:\myfile\数据库\数据库资料\Mysql笔记（黑马）\结构图\新建文件夹\pic12.jpg)]

//查看这些基本数据类型的默认值
//%v表示的意思是按照变量的值输出
	var a int //0
	var b float32 //0
	var c float64 // 0 
	var isMarryied bool  //false
	var name string // " "
	fmt.Printf("a=%d,b=%f,c=%v,isMarryied=%v,name=%v",a,b,c,isMarryied,name)

6）Golang基本数据类型的转换

介绍

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

基本语法

表达式T(v)将值V转换为类型T

T:就是数据类型，比如int32,int64,float32等等
V:就是需要转换的变量
package main

import (
	"fmt"
	// "unsafe"
)
//演示golang中基本数据类型的转换
func main(){
	
var i int = 100
//希望将i => float
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）G哦，数据类型的转换可以是从表示范围小–>表示范围大，也可以是 范围大–》范围小

2）被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化

/被转换的是变量存储的数据（即值），变量本身的数据类型并没有变化
fmt.Printf("i type is %T",i)  //输出结果为int32
}

3）在转换中，比如将int64转成int8[-128~127]，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。因此在转换时需要考虑范围。

var nu1 int64 =999999
var nu2 int8 = int8(nu1) //结果会按照溢出处理
fmt.Println("nu2=",nu2)  //输出结果是63

练习题：

func main(){
	//练习题
var n1 int32 = 12
var n2 int64
var n3 int8

n2 = n1+ 20  //int32交给int64 错误
n3 =n1 + 20   //int32交给int8 错误

func main(){
	//练习题
var n1 int32 = 12
var n2 int64
var n3 int8
var n4 int8

n2 = int64(n1)+ 20  
n3 =int8(n1) + 128 // 编译不通过   
n4 = int8(n1) +127 //编译不通过 但是结果不是127+12
fmt.Println("n2=",n2,"n3",n3)


}

6.基本数据类型和string的转换

1)基本介绍

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

基本类型转为string类型

方式1:fmt,Sprintf(“%参数”，表达式)

func main(){
	var num1 int = 99
	var num2 float64  = 23.456
	 var b bool = true
	 var mychar byte = 'h'
	var str string

	//是用第一种方式来转换 fmt.Sprint()
	str = fmt.Sprintf("%d",num1)  //num1转化为string
	fmt.Printf("str type %T str=%v\n",str,str) //结果为string 和99
    

	str = fmt.Sprintf("%f",num2)
	fmt.Printf("str type %T str=%v\n",str,str) //float64 23.456
    
	str = fmt.Sprintf("%t",b)
	fmt.Printf("str type %T str=%v\n",str,str)

	str = fmt.Sprintf("%c",mychar)
	fmt.Printf("str type %T str=%v",str,str)

}

2)函数的介绍

func Sprintf

func Sprintf(format string, a ...interface{}) string
Sprint根据format参数生成格式化的字符串并返回该字符串

参数需要和表达式的数据类型相匹配

fmt.Sprintf()会返回转换后的字符串

方式2：fmt.Sprintf()…会返回转换后的字符串

func FormatBool(b bool) string
func FormatFloat(f float64,fmt byte,prec bitSize int) string
func FormatInt(int64,base int) string
func FormatUnit(i int64,base int) string

//第二种方式 是用 strconv函数的包
	var num3 int = 99
	 var num4 float64  = 23.456
	 var b2 bool = true
    //将int转换为字符串类型
	str = strconv.FormatInt(int64(num3),10)
	fmt.Printf("str type %T str=%q\n",str,str)

	//说明 f代表格式
	str = strconv.FormatFloat(num4,'f',10,64)
    fmt.Printf("str type %T str=%q\n",str,str)
	//将bool类型转换为字符串类型
	str =strconv.FormatBool(b2)
	fmt.Printf("str type %T str=%q\n",str,str)

案例演示：

package main

import(
	"fmt"
	"strconv"
)

//golang基本数据类型转string

func main(){
	var num1 int = 99
	var num2 float64  = 23.456
	 var b bool = true
	 var mychar byte = 'h'
	var str string

	//是用第一种方式来转换 fmt.Sprint()
	str = fmt.Sprintf("%d",num1)  //num1转化为string
	fmt.Printf("str type %T str=%v\n",str,str) //结果为string 和99
    

	str = fmt.Sprintf("%f",num2)
	fmt.Printf("str type %T str=%v\n",str,str) //float64 23.456
    
	str = fmt.Sprintf("%t",b)
	fmt.Printf("str type %T str=%v\n",str,str)

	str = fmt.Sprintf("%c",mychar)
	fmt.Printf("str type %T str=%v",str,str)


	//第二种方式 是用 strconv函数的包
	var num3 int = 99
	 var num4 float64  = 23.456
	 var b2 bool = true
    //将int转换为字符串类型
	str = strconv.FormatInt(int64(num3),10)
	fmt.Printf("str type %T str=%q\n",str,str)

	//说明 f代表格式
	str = strconv.FormatFloat(num4,'f',10,64)
    fmt.Printf("str type %T str=%q\n",str,str)
	//将bool类型转换为字符串类型
	str =strconv.FormatBool(b2)
	fmt.Printf("str type %T str=%q\n",str,str)
     //strconv包中有一个函数Itoa
	var num5 int = 4567
	str = strconv.Itoa(num5)
	fmt.Printf("str type %T str=%q\n",str,str)

}

7.String类型转基本数据类型

1)使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pWbnfC66-1692969282529)(D:\myfile\数据库\数据库资料\Mysql笔记（黑马）\结构图\新建文件夹\pic13.jpg)]

package main

import(
	"fmt"
	"strconv"
)

//golang基本数据类型转string

func main(){
	var str string = "true"
	var b bool
	//b, _ = strconv.ParseBool(str)
	//说明
	//1.strconv,PareseBool(str) 函数会返回两个值（value bool,err erro）
	//2.因为我只想获取到value bool ，不想获取 err所以我是用下划线
	b , _ = strconv.ParseBool(str)
    fmt.Printf("b type %T b=%v\n",b,b)	

	var str2 string ="123456"
	var n1 int64
	var n2 int
	n1, _ = strconv.ParseInt(str2,10,64)
	n2 = int(n1)  //将int64转化成int类型的
	fmt.Printf("n1 type %T n1=%v\n",n1,n1)
	fmt.Printf("n2 type %T n2=%v\n",n2,n2)	

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

}

2)注意事项

在将string类型转成基本数据类型时，要确保string类型能够转换成有效的数据，比如我们可以把“123” 转成一个整数，但是不能把"hello" 转成一个整数，如果这样做，Golang直接将其转成0.

//注意
	var str4 string = "hello"
	var n3 int64
	n3, _ =strconv.ParseInt(str4, 10,64)
	fmt.Printf("n3 type %T n3=%v\n",n3,n3) //输出是0

b, _ = strconv.ParseBool(str)
//说明
//1.strconv,PareseBool(str) 函数会返回两个值（value bool,err erro）
//2.因为我只想获取到value bool ，不想获取 err所以我是用下划线
b , _ = strconv.ParseBool(str)
fmt.Printf(“b type %T b=%v\n”,b,b)

var str2 string ="123456"
var n1 int64
var n2 int
n1, _ = strconv.ParseInt(str2,10,64)
n2 = int(n1)  //将int64转化成int类型的
fmt.Printf("n1 type %T n1=%v\n",n1,n1)
fmt.Printf("n2 type %T n2=%v\n",n2,n2)	

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

}

### 2)注意事项

在将string类型转成基本数据类型时，要确保string类型能够转换成有效的数据，比如我们可以把“123” 转成一个整数，但是不能把"hello" 转成一个整数，如果这样做，Golang直接将其转成0.

```go
//注意
	var str4 string = "hello"
	var n3 int64
	n3, _ =strconv.ParseInt(str4, 10,64)
	fmt.Printf("n3 type %T n3=%v\n",n3,n3) //输出是0