1. 整型
package main
// import "fmt"
// import "unsafe"
import (
"fmt"
"unsafe"
)
// ====================演示golang中整数类型使用=======================
func main() {
// ------------int-----------
// uint是无符号
// int是有正负
// int/uint类型看操作系统，32位是4个字节，64位是8个字节
var i int = 1
fmt.Println("i=", i)
// ------------int8-----------
// 测试一下int8的范围 -128~127,
// 其它的 int16, int32, int64,类推...
var j int8 = 127
fmt.Println("j=", j)
// 测试一下 uint8的范围(0-255),其它的 uint16, uint32, uint64类推即可
var k uint16 = 255
fmt.Println("k=", k)
// ------------int , uint , rune , byte-----------
// rune与int32一样
// byte和uint8等价，存储字符时选用byte
var a int = 8900
fmt.Println("a=", a)
var b uint = 1
var c byte = 255
fmt.Println("b=", b, "c=", c)
// ------------整型的使用细节-----------
var n1 = 100 // n1 是什么类型? // 整形默认为int型
// 这里我们给介绍一下如何查看某个变量的数据类型
// fmt.Printf() 可以用于做格式化输出。
fmt.Printf("n1 的 类型 %T \n", n1)
// 如何在程序查看某个变量的占用字节大小和数据类型 （使用较多）
var n2 int64 = 10
// unsafe.Sizeof(n1) 是unsafe包的一个函数，可以返回n1变量占用的字节数
fmt.Printf("n2 的 类型 %T n2占用的字节数是 %d ", n2, unsafe.Sizeof(n2)) // %T type // %d数字
}
2. 浮点型
package main
import (
"fmt"
"unsafe"
)
// float32 float64的使用
func main() {
var price float32 = 89.12
fmt.Println("price=", price) // price= 89.12
var num1 float32 = -0.00089
var num2 float64 = -7809656.09
fmt.Println("num1=", num1, "num2=", num2) // num1= -0.00089 num2= -7.80965609e+06
// 尾数部分可能丢失，造成精度损失
// 浮点数 = 符号位 + 指数位 + 尾数位 // 小数转二进制的时候会出现无限循环，尾数位会导致损失
var num3 float32 = -123.0000901
var num4 float64 = -123.0000901
fmt.Println("num3=", num3, "num4=", num4) // num3= -123.00009 num4= -123.0000901
// GOlang 的浮点数有固定的范围和字段长度，不受os（操作系统）所影响
// 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=", num7) // num6= 5.12 num7= 0.123
// 科学计数法形式
num8 := 5.1234e2 // ? 5.1234 * 10的2次方
num9 := 5.1234E2 // ? 5.1234 * 10的2次方 shift+alt+向下的箭头
num10 := 5.1234E-2 // ? 5.1234 / 10的2次方 0.051234
fmt.Println("num8=", num8, "num9=", num9, "num10=", num10) // num8= 512.34 num9= 512.34 num10= 0.051234
}
3. 字符
package main
import (
"fmt"
)
// 演示golang中字符类型使用
func main() {
var c1 byte = 'a'
var c2 byte = '0' //字符的0
//当我们直接输出byte值，就是输出了的对应的字符的码值
// 'a' ==>
fmt.Println("c1=", c1) // c1= 97
fmt.Println("c2=", c2) // c2= 48
//如果我们希望输出对应字符，需要使用格式化输出
fmt.Printf("c1=%c c2=%c\n", c1, c2)
//var c3 byte = '北' //overflow溢出
var c3 int = '北' //overflow溢出
fmt.Printf("c3=%c c3对应码值=%d\n", c3, c3) // c3=北 c3对应码值=21271
//可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode 字符
var c4 int = 22269 // 22269 -> '国' 120->'x'
fmt.Printf("c4=%c\n", c4) // c4=国
//字符类型是可以进行运算的，相当于一个整数,运输时是按照码值运行
var n1 = 10 + 'a' // 10 + 97 = 107
fmt.Println("n1=", n1) // n1= 107
}
3.1 代码说明
3.2 字符使用细节
3.3 字符串本质
4. 布尔
package main
import (
"fmt"
"unsafe"
)
//演示golang中bool类型使用
func main() {
var b = false
fmt.Println("b=", b)
//注意事项
//1. bool类型占用存储空间是1个字节
fmt.Println("b 的占用空间 =", unsafe.Sizeof(b) )
//2. bool类型只能取true或者false
}
5. 字符串
package main
import (
"fmt"
)
// 演示golang中string类型使用
func main() {
//string的基本使用
var address string = "北京长城 110 hello world!"
fmt.Println(address)
// 字符串一旦赋值了，字符串就不能修改了：在Go中字符串是不可变的
// var str = "hello"
// str[0] = 'a' //这里就不能去修改str的内容，即go中的字符串是不可变的。
// 字符串的两种表示形式(1) 双引号, 会识别转义字符(2) 反引号
// 以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击
str2 := "abc\nabc"
fmt.Println(str2)
//使用的反引号 ``，和Python的r一样
str3 := `
package main
import (
"fmt"
"unsafe"
)
// 演示golang中bool类型使用
func main() {
var b = false
fmt.Println("b=", b)
// 注意事项
//1. bool类型占用存储空间是1个字节
fmt.Println("b 的占用空间 =", unsafe.Sizeof(b) )
//2. bool类型只能取true或者false
}
`
fmt.Println(str3)
// 字符串拼接方式
var str = "hello " + "world"
str += " haha!"
fmt.Println(str)
// 当一个拼接的操作很长时，怎么办，可以分行写,但是注意，需要将+保留在上一行
// python中是\表示分行
str4 := "hello " + "world" + "hello " + "world" + "hello " +
"world" + "hello " + "world" + "hello " + "world" +
"hello " + "world"
fmt.Println(str4)
var a int // 0
var b float32 // 0
var c float64 // 0
var isMarried bool // false
var name string // ""
//这里的%v 表示按照变量的值输出
fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v name=%v",a,b,c,isMarried, name)
// a=0,b=0,c=0,isMarried=false name=
}
6. 基本数据类型的默认值
7. 基本数据类型的转换
7.1 语法
package main
import (
"fmt"
)
// 演示golang中基本数据类型的转换
// 不管是高精度转低精度还是...都需要强制转换
func main() {
var i int32 = 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 \n", i ,n1, n2, n3)
// 被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化
fmt.Printf("i type is %T\n", i) // int32
// 在转换中，比如将 int64 转成 int8 【-128---127】 ，编译时不会报错，
// 只是转换的结果是按溢出处理，和我们希望的结果不一样
var num1 int64 = 999999
var num2 int8 = int8(num1)
fmt.Println("num2=", num2)
}
7.2 注意事项
扫描二维码关注公众号，回复：
8478505 查看本文章
