变量的学习
变量是程序的基本组成单位
概念:
变量相当于内存一个数据存储空间的表示,你可以把变量看做是一个房间的门牌号,通过门牌号我们可以找到房间,同样的道理,通过变量名可以访问到变量(值)
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)文章来源:https://www.toymoban.com/news/detail-673692.html
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)
}文章来源地址https://www.toymoban.com/news/detail-673692.html
### 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
到了这里,关于go语言学习之有关变量的知识的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!