一、数据类型
package main
import (
"fmt"
"unsafe"
)
func main() {
/*
1.如何计算数据占用大小
在C语言中我们可以通过sizeof来计算数据类型占用的内存大小
在Go语言中我们也可以通过sizeof来计算数据类型占用的内存大小
2.如何使用sizeof
2.1导入unsafe
2.2利用unsafe.Sizeof调用函数
注意点:
Go语言中的int类型, 会根据当前系统自动调整, 如果系统是64位的, 那么int就会自动变成int64,
如果系统是32位的, 那么int就会自动变成int32
*/
// 1.有符号的整型
fmt.Println("int size = ", unsafe.Sizeof(int(0)))
fmt.Println("int8 size = ", unsafe.Sizeof(int8(0)))
fmt.Println("int16 size = ", unsafe.Sizeof(int16(0)))
fmt.Println("int32 size = ", unsafe.Sizeof(int32(0)))
fmt.Println("int64 size = ", unsafe.Sizeof(int64(0)))
fmt.Println("-------------------------------------")
// 2.无符号的整型
fmt.Println("uint size = ", unsafe.Sizeof(uint(0)))
fmt.Println("uint8 size = ", unsafe.Sizeof(uint8(0)))
fmt.Println("uint16 size = ", unsafe.Sizeof(uint16(0)))
fmt.Println("uint32 size = ", unsafe.Sizeof(uint32(0)))
fmt.Println("uint64 size = ", unsafe.Sizeof(uint64(0)))
fmt.Println("uintptr size = ", unsafe.Sizeof(uintptr(0)))
fmt.Println("-------------------------------------")
// 3.字符类型
// byte相当于C语言中的char, 专门用于保存一个字符 'a'
// rune本质是int32, 专门用于保存一个中文字符 '李'
// 注意点: GO语言默认就支持中文,默认就是按照UTF-8来处理 , 在UTF-8中一个中文占3个字节
// 过去有时候在Windows中一个中文占2个字节, 在Linux中一个中文占3个字节, 非常不方便我们做兼容处理, 所以Go有效的解决了过去的这个问题
fmt.Println("byte size = ", unsafe.Sizeof(byte(0)))
fmt.Println("rune size = ", unsafe.Sizeof(rune(0)))
fmt.Println("-------------------------------------")
// 4.浮点 类型
fmt.Println("float32 size = ", unsafe.Sizeof(float32(0)))
fmt.Println("float64 size = ", unsafe.Sizeof(float64(0)))
fmt.Println("-------------------------------------")
// 5.布尔类型
fmt.Println("true size = ", unsafe.Sizeof(true))
fmt.Println("false size = ", unsafe.Sizeof(false))
}
结果：
int size = 8
int8 size = 1
int16 size = 2
int32 size = 4
int64 size = 8
-------------------------------------
uint size = 8
uint8 size = 1
uint16 size = 2
uint32 size = 4
uint64 size = 8
uintptr size = 8
-------------------------------------
byte size = 1
rune size = 4
-------------------------------------
float32 size = 4
float64 size = 8
-------------------------------------
true size = 1
false size = 1
Process finished with exit code 0
二、变量的基本使用
package main
import "fmt"
func main() {
/*
1.什么是变量?
1.1在C语言中可以改变的数据我们称之为变量
1.2Go语言和C语言一样, 改变的数据我们称之为变量
2.为什么要定义变量?
1.1在C语言中就是为了告诉操作系统, 需要分配多大的存储空间来存储数据
1.2在Go语言中也是一样
3.如何定义变量?
3.1C语言定义变量的格式: 数据类型 变量名称;
3.2Go语言中定义变量的格式: var 变量名称 数据类型;
4.如何使用变量?
4.1C语言中如果变量名称在等号的左边, 代表往变量中存储数据
如果变量名称在等号的右边出现, 代表从变量中获取存储的数据
4.2Go语言和C语言一样
5.变量的初始化
5.1在C语言中第一次给变量赋值我们称之为变量的初始化
在C语言中变量的初始化有两种方式: 1.先定义在初始化 2.定义的同时初始化
5.2Go语言和C语言一样
注意点:
在Go语言中, 除了有和C语言一样的定义变量的格式以外, 还有一些其它的格式
1.如果定义的同时初始化, 那么定义变量时, 数据类型可以省略(系统会自动根据赋值推导变量的类型)
2.如果定义的同时初始化, 那么定义变量时, 除了可以省略数据类型以外, 还可以利用:=继续省略var
:=注意点:
1.如果利用:=定义变量, 那么不能写var也不能写数据类型
2.因为:=会先定义一个变量, 所以不能把:=当做=来使用(=必须先定义，否则报错)
*/
// 1.定义一个变量
/*
var num int
num = 666
// 注意点: 在Go语言中, 输出整型只能使用%d, 不能使用%i
fmt.Printf("%d\n", num)
*/
// 2.先定义再初始化
// var num int
// num = 888
//fmt.Printf("%d\n", num)
// 3.定义的同时初始化
//var num int = 999
//fmt.Printf("%d", num)
// 4.定义的同时初始化, 并省略数据类型
//var num = 999
//fmt.Printf("%d\n", num)
//// 在Go语言中, 可以利用%T输出变量的数据类型
//fmt.Printf("%T\n", num)
// 5.定义的同时初始化, 并省略数据类型和var
// :=做了两件事情 , 1.会先定义一个变量 2.给定义的变量赋值
// 在Go语言开发中非常非常非常常用
//num := 666
//fmt.Printf("%d\n", num)
// 6.:=注意点
//var num := 666 // 语法错误
//num int := 666 // 语法错误
//fmt.Printf("%d\n", num)
var num int = 666
// var num int
// num = 888
//num := 888 // 重复定义
fmt.Printf("%d\n", num)
}
三、变量的连续定义
package main
import "fmt"
func main() {
/*
1.变量的连续定义
1.1在C语言中我们可以通过逗号来连续定义变量 int a, b, c;
1.2在Go语言中我们也可以通过逗号来连续定义变量 var a, b, c int
1.3在Go语言中除了可以利用逗号来连续定义变量以外, 还可以使用变量组的语法来同时定义多个变量
var(
a int
b int
c int
)
2.同时定义多个变量, 也可以在定义的时候初始化
2.1在C语言中我们可以通过 int a = 10, b = 20, c = 30;
2.2在Go语言中如果通过逗号定义多个变量, 我们可以通过 var a, b, c = 10, 20, 30
2.3在Go语言中如果通过变量组定义多个变量, 我们可以通过
var(
a int = 10
b int = 20
c int = 30
)
注意点:
在变量组中, 不能使用:=
*/
// 1.通过逗号定义多个变量
/*
var a, b, c int
a = 123
b = 456
c = 789
fmt.Printf("%d,%d,%d\n", a, b, c)
*/
// 2.通过变量组定义多个变量
/*
var(
a int
b int
c int
)
a = 123
b = 456
c = 789
fmt.Printf("%d,%d,%d\n", a, b, c)
*/
// 3.同时定义多个变量, 并且同时初始化
//var a, b, c int = 10, 20, 30
//var a, b, c = 10, 20, 30
// a, b, c := 10, 20, 30
//fmt.Printf("%d,%d,%d\n", a, b, c)
// 4.同时定义多个变量, 并且同时初始化
//var(
// a int = 10
// b int = 20
// c int = 30
//)
//var(
// a = 10
// b = 20
// c = 30
//)
//fmt.Printf("%d,%d,%d\n", a, b, c)
// 5.注意点: 在变量组中, 不能使用:=
var(
a := 10
b := 20
c := 30
)
fmt.Printf("%d,%d,%d\n", a, b, c)
}
结果：
syntax error: unexpected :=, expecting type
四、全局变量和局部变量
package main
import "fmt"
func test() {
//fmt.Printf("%d\n", num) //报错，找不到num
fmt.Printf("%d\n", value)
}
var value int // 全局变量
//var value int // 报错 重复定义
func main() {
/*
1.什么是局部变量?
1.1在C语言中写在{}中或者函数中或者函数的形参, 就是局部变量
1.2Go语言中的局部变量和C语言一样
2.什么是全局变量?
2.1在C语言中写在函数外面的就是全局变量
2.2Go语言中的全局变量和C语言一样
3.局部变量和全局变量的作用域
3.1在C语言中局部变量的作用域是从定义的那一行开始, 直到遇到}结束或者遇到return为止
3.2Go语言中局部变量的作用域和C语言一样
3.3在C语言中全部变量的作用域是从定义的那一行开始, 直到文件末尾为止
3.4Go语言中的全局变量, 只要定义了, 在定义之前和定义之后都可以使用
4.局部变量和全局变量的生命周期
4.1在C语言中局部变量, 只有执行了才会分配存储空间, 只要离开作用域就会自动释放, C语言的局部变量存储在栈区
4.2Go语言局部变量的生命周期和C语言一样
4.3在C语言中全局变量, 只要程序一启动就会分配存储空间, 只有程序关闭才会释放存储空间, C语言的全局变量存储在静态区(数据区)
4.4Go语言全局变量的生命周期和C语言一样
5.局部变量和全局变量的注意点
5.1在C语言中相同的作用域内, 不能出现同名的局部变量
5.2Go语言和C语言一样, 相同的作用域内, 不能出现同名的局部变量
5.3在C语言中相同的作用域内, 可以出现同名的全局变量
5.4在Go语言中相同的作用域内, 不能出现同名的全局变量
6.特殊点
6.1在C语言中局部变量没有初始化存储的是垃圾数据, 在Go语言中局部变量没有初始化, 会默认初始化为0
6.2在C语言中全局变量没有初始化存储的是0, Go语言和C语言一样
6.3在Go语言中, 如果定义了一个局部变量, 但是没有使用这个局部变量, 编译会报错
6.4在Go语言中, 如果定义了一个全局变量, 但是没有使用这个全局变量, 编译不会报错
*/
//var num int; // 局部变量
//var num int; // 报错
//fmt.Printf("%d\n", num)
test()
}
五、变量的注意点
package main
import "fmt"
//value := 789 //编译不通过
func main() {
/*
1.相同的作用域内, 无论是全局变量还是局部变量, 都不能出现同名的变量
2.变量离开作用域就不能使用
3.局部变量如果没有使用, 编译会报错, 全局变量如果没有使用, 编译不会报错
4.:=只能用于局部变量, 不能用于全局变量
5.:=如果用于同时定义多个变量, 会有退化赋值现象
*/
// 1.:=只能用于局部变量
//num := 666
//fmt.Printf("%d\n", num)
// 2.:=退化赋值现象
// 2.1 var num int
// 2.2 num = 123
num := 123
//num := 456 // 报错
// 如果通过:=定义多个变量, 但是多个变量中有的变量已经在前面定义过了,
// 那么只会对没有定义过的变量执行:=, 而定义过的变量只执行=操作
// 1. var value int
// 2. num = 456
// 3. value = 789
num, value := 456, 789
fmt.Printf("%d, %d", num, value)
}
