整型
有符号整型
无符号整型
其他整型
package main
import "fmt"
import "unsafe"
//整型
func main(){
//定义一个整数类型:
var num1 int8 = 23
fmt.Println(num1)
var num2 uint8 = 20
fmt.Println(num2)
var num3 = 28
//Printf函数的作用是:格式化的,把num3的类型填充到%T的位置上
fmt.Printf("num3的类型是:%T",num3) //num3的类型是:int
fmt.Println(unsafe.Sizeof(num3))
}
整数类型默认为int类型
浮点型
Golang中浮点型仅有:float32 / float64 没有float!
//浮点型
func main(){
//定义浮点类型的数据
var num1 float32 = 3.14
fmt.Println(num1)
//可以表示正/负浮点数
var num2 float32 = -3.14
fmt.Println(num2)
//可以用十进制表示 / 科学计数法表示 e/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.000000777
fmt.Println(num7)
var num8 float64 = 256.000000777
fmt.Println(num8)
//golang中默认的浮点类型:float64
var num9 = 123.4
fmt.Printf("num9对应的类型是:%T",num9) //float64
}
浮点型默认为float64
字符型
Golang中没有专门的字符类型,存储单个字符,使用byte
//字符型
func main(){
var c1 byte = 'a' //97
fmt.Println(c1)
var c2 byte = '6' //54
fmt.Println(c2)
var c3 byte = '!' //33
fmt.Println(c3)
var c4 byte = '!'
fmt.Println(c4+12) //45
//字符类型,本质上是一个整数,可以直接参与运算,会将对应的码值进行输出
//ASCII码值
var c6 byte = 'A'
fmt.Printf("c6对应的具体字符为:%c",c6)
//想输出对应的字符,要采用格式化输出
fmt.Println() //换行
//var c5 byte = '中'
var c5 int = '中'
fmt.Println(c5)
//汉字字符,底层对应Unicode码值
//对应码值为20013,byte类型溢出,可使用int
//Golang的字符对应使用的时是UTF-8编码
//Unicode是对应的字符集,UTF-8是Unicode的其中的一种编码方案
}
汉字属于字符 - 一个汉字占3个字节
UTF-8编码表:查看字符编码(UTF-8)
转义字符
//转义字符
func main(){
//\n换行
fmt.Println("aaa\nbbb")
//\b退格
fmt.Println("aaa\bbbb")
//\r - 光标回到本行开头,后续输入会替代原有字符
fmt.Println("aaaaa\rbb")
//\t 制表符 - 补全8位
fmt.Println("aaaaaaaaaaa")
fmt.Println("aaa\tbbb")
fmt.Println("aaaaa\tbbb")
//\"
fmt.Println("\"Golang\"")
}
布尔Bool类型 - true/false
func main(){
//测试布尔类型的数值:
var flag01 bool = true
fmt.Println(flag01) //true
var flag02 bool = false
fmt.Println(flag02) //false
var flag03 bool = 1 < 3
fmt.Println(flag03) //true
}
字符串类型 - string
func main(){
//1.定义一个字符串:
var s1 string = "咩Golang"
fmt.Println(s1)
//2.字符串不可变:指的是字符串一旦定义好,其中字符的值不能进行改变
var s2 string = "abc"+"def"
//s2 = "Aaa" - ok
//s2[0]= "A" - err
fmt.Println(s2)
//3.字符串的表现形式:
//(1)如果字符串中没有特殊字符,字符串的表现形式用双引号
var s3 string = "sfadfgeweasdf"
fmt.Println(s3)
//(2)含有特殊字符,字符表现形式用反引号``
var s4 string = `
func main(){
//1.定义一个字符串:
var s1 string = "咩Golang"
fmt.Println(s1)`
fmt.Println(s4)
//4.字符串的拼接效果
var s5 string = "abc"+"def"
s5+="hjk"
fmt.Println(s5)
//当一个字符串过长时:注意 + 保留在上一行行末
var s6 string = "abc" + "def" + "jkl" + "def" + "jkl" +
"def" + "jkl" + "def" + "jkl" +
"def" + "jkl" + "def" + "jkl" + "def" +
"jkl" + "def" + "jkl"
fmt.Println(s6)
}
默认值 - 未赋值时默认
//默认值
func main(){
var a int //0
var b float32 //0
var c float64 //0
var d bool //false
var e string //"" - 空
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)
}
强制类型转换 /显式类型转换
T(v) - 将v转换为类型T
func main(){
var n1 int = 100
fmt.Println(n1)
//var n2 float32 = n1 -err
var n2 float32 = float32(n1)
fmt.Println(n2)
fmt.Printf("%T",n1) //int
fmt.Println()
var n3 int64 = 888888
var n4 int8 =int8(n3) // 56
fmt.Println(n4)
//int64 转为 int8 编译未报错,但会造成数据的溢出
var n5 int32 = 12
var n6 int64 = int64(n5) + 30 // = 左右类型一定要匹配
fmt.Println(n6)
var n7 int64 = 12
var n8 int8 = int8(n7) + 127 //编译通过,但结果可能会溢出 - -117
//var n9 int8 = int8(n7) + 128 //编译无法通过
fmt.Println(n8)
//fmt.Println(n9)
}
基本类型转string类型
1.fmt.Sprintf("%参数",表达式) -- 推荐
func main(){
var n1 int = 19
var s1 string = fmt.Sprintf("%d",n1)
fmt.Printf("s1对应的类型是:%T ,s1=%q \n",s1,s1)
var n2 float32 = 4.78
var s2 string = fmt.Sprintf("%f",n2)
fmt.Printf("s2对应的类型是:%T ,s2=%q \n",s2,s2)
var n3 bool = false
var s3 string = fmt.Sprintf("%t",n3)
fmt.Printf("s3对应的类型是:%T ,s3=%q \n",s3,s3)
var n4 byte = 'a'
var s4 string = fmt.Sprintf("%c",n4)
fmt.Printf("s4对应的类型是:%T ,s4=%q \n",s4,s4)
}
方法2:使用strconv包的函数
func main(){
var n1 int = 18
var s1 string = strconv.FormatInt(int64(n1),10)
//参数:1.必须转为int64类型;2.指定字面值的进制形式为十进制
fmt.Printf("s1对应的类型是:%T ,s1=%q\n",s1,s1)
var n2 float64 = 4.29
var s2 string = strconv.FormatFloat(n2,'f',9,64)
//参数:1.本人 2.'f'(-ddd.dddd) 3.9 保留小数点后9位 4.表示此数为float64类型
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)
}
string类型转换为基本类型
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)
fmt.Printf("f1的类型是:%T,f1=%v \n",f1,f1)
//ps:string向基本数据类型转换时,一定要确保string类型能够转换为有效的数据类型
// 否则最后得到的结果就是该类型的默认值
var s4 string = "golang"
var b1 bool
b1,_=strconv.ParseBool(s4)
fmt.Printf("b1的类型是:%T,b1=%v \n",b1,b1)
}
指针
func main(){
var age int = 18
//&符号+变量 可以获取到这个变量内存的地址
fmt.Println(&age) //0xc00000e098
}
指针变量
func main(){
var age int = 18
fmt.Println(&age)
//定义一个指针变量
//var - 声明一个变量
//ptr - 指针变量的名字
//ptr对应的类型:*int 是一个指针类型 指向int的指针
//&age是一个地址,是ptr变量具体的值
var ptr *int = &age
fmt.Println(ptr)
fmt.Println("ptr本身这个存储空间的地址为:",&ptr) //0xc00000a030
//获取ptr指针/地址所指向的具体数据
fmt.Printf("ptr指向的数值为:%v",*ptr) //18
//通过指针改变指向值
var num int = 10
fmt.Println(num)
var ptr *int = &num
*ptr = 20
fmt.Println(num)
}