文章目录
- 0、进制
- 1、变量的声明
- 2、数据类型
- 3、整型
- 4、浮点型
- 5、字符类型
- 6、布尔类型
- 7、字符串类型
- 8、基本数据类型的默认值
- 9、类型转换
- 10、基本类型转String
- 11、String转其他类型
0、进制
N进制，逢N进一
1、变量的声明
go
//声明 + 赋值
var age int = 18
go
//声明、赋值、使用
func main(){
var age int
age = 18
fmt.Println("age = ", age)
}通过变量名在内存中找到它（通过房间号找到在一栋楼里找到某个房间），变量类型，即区分空间大小（类比单人间、双人间）
变量定义的四种形式：
go
package main
import "fmt"
func main(){
//定义在{}中的变量叫：局部变量
//第⼀种：变量的使⽤⽅式：指定变量的类型，并且赋值，
var num int = 18
fmt.Println(num)
//第⼆种：指定变量的类型，但是不赋值，使⽤默认值
var num2 int
fmt.Println(num2)
//第三种：如果没有写变量的类型，那么根据=后⾯的值进⾏判定变量的类型 （⾃动类型推断）
var num3 = "tom"
fmt.Println(num3)
//第四种：省略var，注意 := 不能写为 =
sex := "男"
fmt.Println(sex)
}也可一次声明多个变量，不论局部还是全局变量
go
package main
import "fmt
//全局变量：定义在函数外的变量
var n7 = 100
var n8 = 9.7
//设计者认为上⾯的全局变量的写法太麻烦了，可以⼀次性声明：
var (
n9 = 500
n10 = "netty"
)
func main(){
//声明多个变量：
var n1,n2,n3 int
fmt.Println(n1) //0
fmt.Println(n2) //0
fmt.Println(n3) //0
var n4,name,n5 = 10,"jack",7.8
fmt.Println(n4)
fmt.Println(name)
fmt.Println(n5)
n6,height := 6.9,100.6
fmt.Println(n6)
fmt.Println(height)
fmt.Println(n7)
fmt.Println(n8)
fmt.Println(n9)
fmt.Println(n10)
}2、数据类型
3、整型
有符号整数型：
go
//首位为符号位，127即
0111 1111 无符号型：
go
//255即
1111 1111其他类型：
不加类型声明整形，go默认是int类型：
导入unsafe包，查看变量所占的字节数：
4、浮点型
不同于Java的float和double，go中是float32和float64：
go
package main
import "fmt"
func main(){
//定义浮点类型的数据：
var num1 float32 = 3.14
fmt.Println(num1)
//可以表示正浮点数，也可以表示负的浮点数
var num2 float32 = -3.14
fmt.Println(num2)
//浮点数可以用十进制表示形式，也可以用科学计数法表示形式 E 大写小写都可以的
var num3 float32 = 314E-2
fmt.Println(num3)
var num4 float32 = 314E+2
fmt.Println(num4)
var num5 float32 = 314e+2
fmt.Println(num5)
var num6 float64 = 314e+2
fmt.Println(num6)
//浮点数可能会有精度的损失，所以通常情况下，建议你使用：float64
var num7 float32 = 256.000000916
fmt.Println(num7)
var num8 float64 = 256.000000916
fmt.Println(num8)
//golang中默认的浮点类型为：float64
var num9 = 3.17
fmt.Printf("num9对应的默认的类型为：%T",num9)
}运行发现精度损失：
因此，通常建议用float64，且go中浮点类型默认也是float64
5、字符类型
和Java有char不同，Go中没有专⻔的字符类型，如果要存储单个字符(字⺟)，⼀般使⽤byte类型来保存，且Go中字符使用utf-8编码
go
package main
import "fmt"
func main(){
//定义字符类型的数据：
var c1 byte = 'a'
fmt.Println(c1)//97
var c2 byte = '6'
fmt.Println(c2)//54
var c3 byte = '('
fmt.Println(c3 + 20)//40
//字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
//字母，数字，标点等字符，底层是按照ASCII进行存储。
var c4 int = '中'
fmt.Println(c4)
//汉字字符，底层对应的是Unicode码值
//对应的码值为20013，byte类型溢出，能存储的范围：可以用int
//总结：Golang的字符对应的使用的是UTF-8编码（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案）
var c5 byte = 'A'
//想显示对应的字符，必须采用格式化输出
fmt.Printf("c5对应的具体的字符为：%c",c5)
}
关于转义字符：
go
import "fmt"
func main(){
//练习转义字符：
//\n 换行
fmt.Println("aaa\nbbb")
//\b 退格
fmt.Println("aaa\bbbb")
//\r 光标回到本行的开头，后续输入就会替换原有的字符
fmt.Println("aaaaa\rbbb")
//\t 制表符
fmt.Println("aaaaaaaaaaaaa")
fmt.Println("aaaaa\tbbbbb")
fmt.Println("aaaaaaaa\tbbbbb")
//\"
fmt.Println("\"Golang\"")
}
6、布尔类型
go
package main
import "fmt"
func main(){
//测试布尔类型的数值：
var flag01 bool = true
//true
fmt.Println(flag01)
var flag02 bool = false
//false
fmt.Println(flag02)
var flag03 bool = 5 < 9
//true
fmt.Println(flag03)
}7、字符串类型
字符串是不可变的：指的是字符串⼀旦定义好，其中的字符的值不能变，如str[0] = 'b'
- 如果字符串中没有特殊字符，字符串的表示形式⽤双引号
- 如果字符串中有特殊字符，字符串的表示形式⽤反引号 ``
- +号进行字符串拼接
go
package main
import "fmt"
func main(){
//1.定义一个字符串：
var s1 string = "你好Golang"
fmt.Println(s1)
//2.字符串是不可变的：指的是字符串一旦定义好，其中的 字符 的值不能改变
var s2 string = "abc"
s2 = "def"
//s2[0] = 't'
fmt.Println(s2)
//3.字符串的表示形式：
//（1）如果字符串中没有特殊字符，字符串的表示形式用双引号
//var s3 string = "asdfasdfasdf"
//（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``
var s4 string = `
package main
import "fmt"
func main(){
//测试布尔类型的数值：
var flag01 bool = true
fmt.Println(flag01)
var flag02 bool = false
fmt.Println(flag02)
var flag03 bool = 5 < 9
fmt.Println(flag03)
}
`
fmt.Println(s4)
//4.字符串的拼接效果：
var s5 string = "abc" + "def"
s5 += "hijk"
fmt.Println(s5)
//当一个字符串过长的时候：注意：+保留在上一行的最后
var s6 string = "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" +
"def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+
"abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" +
"def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" +
"abc" + "def"+ "abc" + "def"
fmt.Println(s6)
}
最后，注意换行拼接时，+保留在上⼀⾏的最后，因为和Java不一样，没封号，你换行，编译器会认为这个语句结束了
8、基本数据类型的默认值
9、类型转换
go不同类型变量之间赋值，需要显式转换（强制转换）
go
语法：
T(v)
//将值v转换为类型T
go
package main
import "fmt"
func main(){
var n1 int = 100
//进行类型转换：
//var n2 float32 = n1 在这里自动转换不好使，比如显式转换
var n2 float32 = float32(n1)
fmt.Println(n2)
//注意：n1的类型其实还是int类型，只是将n1的值100转为了float32而已，n1还是int的类型
fmt.Printf("%T",n1) //int
fmt.Println()
//将int64转为int8的时候，编译不会出错的，但是会数据的溢出
var n3 int64 = 888888
var n4 int8 = int8(n3)
fmt.Println(n4)//转型后结果是56，就像把一个大面包强塞到一个小盒子，面包肯定要掉渣
var n5 int32 = 12
var n6 int64 = int64(n5) + 30 //一定要匹配=左右两边的数据类型
fmt.Println(n6)
var n7 int64 = 12
var n8 int8 = int8(n7) + 127 //编译通过，但是结果可能会溢出
//var n9 int8 = int8(n7) + 128 //编译不会通过
fmt.Println(n8)
//fmt.Println(n9)
}注意最后的两个，int8类型-128到127，所以这个编译能通过，但是结果可能会溢出
go
var n7 int64 = 12
var n8 int8 = int8(n7) + 127 而这个则编译都不通过：
go
var n9 int8 = int8(n7) + 128 10、基本类型转String
- 方式一：fmt.Sprintf("%参数",表达式)
go
package main
import "fmt"
func main(){
var n1 int = 19
var n2 float32 = 4.78
var n3 bool = false
var n4 byte = 'a'
//int转string %d
var s1 string = fmt.Sprintf("%d",n1)
fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
var s2 string = fmt.Sprintf("%f",n2)
fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
var s3 string = fmt.Sprintf("%t",n3)
fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
//byte转string %c
var s4 string = fmt.Sprintf("%c",n4)
fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4) //%q即将结果用引号引起来
}- 方式二：使⽤strconv包的函数
go
package main
import(
"fmt"
"strconv"
)
func main(){
var n1 int = 18
//参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
var s1 string = strconv.FormatInt(int64(n1),10)
fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1) //18
var n2 float64 = 4.29
//第二个参数：'f'（-ddd.dddd） 第三个参数：9 保留小数点后面9位 第四个参数：表示这个小数是float64类型
var s2 string = strconv.FormatFloat(n2,'f',9,64)
fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
var n3 bool = true
var s3 string = strconv.FormatBool(n3)
fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
}11、String转其他类型
使用strconv包的函数
go
package main
import(
"fmt"
"strconv"
)
func main(){
//string-->bool
var s1 string = "true"
var b bool
//ParseBool这个函数的返回值有两个：(value bool, err error)，返回值结果不能只用一个变量去接收
//value就是我们得到的布尔类型的数据，err表示可能出现的错误
//我们只关注得到的布尔类型的数据，err可以用_直接忽略
b , _ = strconv.ParseBool(s1)
fmt.Printf("b的类型是：%T,b=%v \n",b,b)
//string---》int64
var s2 string = "19"
var num1 int64
num1,_ = strconv.ParseInt(s2,10,64)
fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
//string-->float32/float64
var s3 string = "3.14"
var f1 float64
f1,_ = strconv.ParseFloat(s3,64) //转float64
fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)
//注意下面转完后，输出Boolean的默认值false
var s4 string = "golang"
var b1 bool
b1 , _ = strconv.ParseBool(s4)
fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)
//无效转，最后输出int的默认值0
var s5 string = "golang"
var num2 int64
num2,_ = strconv.ParseInt(s5,10,64)
fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
}string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出