02-Go语言常量和变量

Go语言的数据类型

C语言的数据类型

Go语言的数据类型

Go语言各数据类型占用内存空间

• Go语言中也可以使用sizeof()
  • 如何使用sizeof(): 导入unsafe包, 利用unsafe.Sizeof调用函数
    重点: Go语言中的int类型会根据系统自动调整,如果系统是64位,那么int就会自动变成int64,如果是32位那么int会自动变成int32,所以企业开发中一般使用int

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 有符号整型,int数字代表的是位数
    fmt.Println("int size = ", unsafe.Sizeof(int(0))) //8
    fmt.Println("int8 size =", unsafe.Sizeof(int8(0))) //1
    fmt.Println("int16 size = ", unsafe.Sizeof(int16(0))) //2
    fmt.Println("int32 size = ", unsafe.Sizeof(int32(0))) //4
    fmt.Println("int64 size = ", unsafe.Sizeof(int64(0))) //8

    //无符号整型
    fmt.Println("uint size = ", unsafe.Sizeof(uint(0)))//8
    fmt.Println("uint8 size = ", unsafe.Sizeof(uint8(0)))//1
    fmt.Println("uint16 size = ", unsafe.Sizeof(uint16(0)))//2
    fmt.Println("uint32 size = ", unsafe.Sizeof(uint32(0)))//4
    fmt.Println("uint64 size = ", unsafe.Sizeof(uint64(0)))//8
    fmt.Println("uintptr size = ", unsafe.Sizeof(uintptr(0)))//8

    //字符类型
    //byte相当于C语言中的char,专门用于保存一个字符'a'
    //rune本质是int32,专门用于保存一个中文字符 '王'
    //Go语言编写的代码默认UTF-8,Go语言默认支持中文,在UTF-8中一个中文占3个字节,所以无论什么平台Go中的中文都占用三个字节
    fmt.Println("byte size = ", unsafe.Sizeof(byte(0)))//1
    fmt.Println("rune size = ", unsafe.Sizeof(rune(0)))//4

    //浮点类型
    fmt.Println("float32 size = ", unsafe.Sizeof(float32(0))) //4
    fmt.Println("float64 size = ", unsafe.Sizeof(float64(0))) //8

    //布尔类型
    fmt.Println("true size = ", unsafe.Sizeof(true)) //1
    fmt.Println("false size = ", unsafe.Sizeof(false)) //1
}

Go语言数据类型的本质

• Go语言就是根据C语言来编写的,所以内部实现使用了C语言的很多代码

// 第8行到35行
typedef signed char     int8;
typedef unsigned char       uint8;
typedef signed short        int16;
typedef unsigned short      uint16;
typedef signed int      int32;
typedef unsigned int        uint32;
typedef signed long long int    int64;
typedef unsigned long long int  uint64;
typedef float           float32;
typedef double          float64;

#ifdef _64BIT
typedef uint64      uintptr;
typedef int64       intptr;
typedef int64       intgo; // Go's int
typedef uint64      uintgo; // Go's uint
#else
typedef uint32      uintptr;
typedef int32       intptr;
typedef int32       intgo; // Go's int
typedef uint32      uintgo; // Go's uint
#endif

#ifdef _64BITREG
typedef uint64      uintreg;
#else
typedef uint32      uintreg;
#endif

// 第153行到157行
enum
{
    true    = 1,
    false   = 0,
};

---

Go语言变量

Go语言中的变量和C语言一样

    1. 什么是变量?
    在C语言和Go语言中可以改变的数据,称之为变量

    2. 为什么要定义变量
    告诉操作系统我们要开辟多大的内存来存储数据

    3.如何定义变量
    在C语言中格式 数据类型 变量名称
    在Go语言中格式 var 变量名称 数据类型

    4.如何使用变量
    在C语言中,变量名称在等号左边意味着往变量中存储数据,在等号的右边意味着从变量中获取数据
    Go语言变量的使用和C语言一样

    5.变量的初始化
    在C语言中第一次给变量赋值叫做初始化，初始化有两种方式
    第一种先定义变量再初始化，第二种是定义变量的同时初始化
    Go语言变量初始化和C一样

Go语言中定义单个变量

    注意点:
    在Go语言中, 除了有和C语言一样的定义变量的格式以外, 还有一些其它的格式
    1.如果定义的同时初始化, 那么定义变量时, 数据类型可以省略(系统会自动根据赋值推倒变量的类型)
    2.如果定义的同时初始化, 那么定义变量时, 除了可以省略数据类型以外, 还可以利用:=继续省略var

    使用 :=注意点:
    1.如果利用:=定义变量, 那么不能写var也不能写数据类型
    2.因为:=会先定义一个变量, 所以不能把:=当做=来使用

 package main

 import "fmt"

 func main() {
    // 1. 先定义变量再初始化
    var num1 int
    num1 = 6
    fmt.Println(num1)
    // 2. 定义的同时初始化
    var num2 int = 7
    fmt.Println(num2)

    //3. 定义的同时初始化可以省略数据类型
    var num3 = 3.12
    fmt.Println(num3)
    //在Go语言中可以通过%T来输出变量的数据类型
    fmt.Printf("%T\n", num3)

    //4. 定义的同时初始化使用 := 形式可以省略var关键字和数据类型
    // := 做了两件事情,第一是定义一个变量,第二个是给这个变量赋值(经常使用)
    num4 := 7.1
    fmt.Println(num4)
}

Go语言中定义多个变量

    1. 变量的连续定义
    在C语言中我们可以通过逗号来连续定义多个变量 int a,b,c;
    在Go语言中也可以使用逗号连续定义变量 var a,b,c int
    而且Go中还可以使用变量组的形式定义多个变量
    var (
        a int
        b int
        c int
    )

    2.同时定义多个变量, 也可以在定义的时候初始化
    在C语言中,int a = 10, b = 20, c = 30;
    在Go语言中可以使用 var a,b,c int = 10, 20, 30
    并且Go中还可以使用变量组定义多个变量并初始化
    var(
        a int = 10
        b int = 20
        c int = 30

     注意点:在变量组中, 不能使用:=
    )

package main

import "fmt"

func main() {
    //先定义,后初始化
    var a, b, c int
    a = 11
    b = 22
    c = 33
    fmt.Println(a, b, c)

    //先定义变量组的形式,在初始化
    var (
        a int
        b int
        c int
    )
    a = 10
    b = 20
    c = 30
    fmt.Println(a, b, c)


    //同时定义多个变量且同时初始化
    var a, b, c float64 = 2.1, 3.4, 3.8
    fmt.Println(a, b, c)

    var a, b, c = 10, 20, 30
    fmt.Println(a, b, c)

    //企业开发中经常使用这种方法
    a, b, c := 10, 20, 30
    fmt.Println(a, b, c)


    //使用变量组定义的同时初始化
    var (
        a int = 10
        b int = 20
        c int = 30
    )
    fmt.Println(a, b, c)

    //使用变量组定义的同时初始化,可以省略数据类型
    var(
        a = 10
        b = 4
        c = 6
    )
    fmt.Println(a, b, c)
    //使用常量组定义多个变量
     var(
        a, b = 10, 20
        c, d = 30, 40
    )
    fmt.Printf("%d, %d\n", a, b)
    fmt.Printf("%d, %d\n", c, d)

}

---

全局变量和局部变量

• Go语言全局变量和局部变量基本差不多,但是也有一些不同点

    1. 什么是局部变量
    在C语言中局部变量就是在{}中,函数中或者函数的形参,都是局部变量
    Go语言的局部变量和C语言一样

    2. 什么是全局变量
    C语言中写在函数的外面就是全局变量,Go语言的局部变量和C语言一样

    3.局部变量和全局变量的作用域
    C语言中局部变量作用域是从定义的那行开始,直到遇到}或者return结束,Go语言和C一样
    C语言中全局变量从定义的那行开始,直到文件末尾
    Go语言中全局变量只要定义了,在定义之前和定义之后都可以使用

    4.局部变量和全局变量的生命周期
    在C语言中局部变量, 只有执行了才会分配存储空间, 只要离开作用域就会自动释放, C语言的局部变量存储在栈区
    Go语言的局部变量生命周期和C语言一样
    在C语言中全局变量,只要是程序启动就会给其分配存储空间,程序结束后才会释放存储空间,全局变量存储在静态区(数据区)
    Go语言的全局变量生命周期和C语言一样

    5.局部变量和全局变量的注意点
    在C语言中作用域相同不能出现相同名称的局部变量
    Go语言和C语言一样, 相同的作用域内, 不能出现同名的局部变量
    在C语言中相同的作用域内, 可以出现同名的全局变量
    在Go语言中,在相同的作用域内,不能出现同名的全局变量

    6.特殊点
    在C语言中局部变量没有初始化存储的是垃圾数据
    在C语言中全局变量没有初始化存储的是0, Go语言和C语言一样
    在Go语言中, 如果定义了一个局部变量, 但是没有使用这个局部变量, 编译会报错
    在Go语言中, 如果定义了一个全局变量, 但是没有使用这个全局变量, 编译不会报错

    注意点总结:
    在Go语言中,不管是全局变量还是局部变量,没有初始化默认存储的数据都是0
    相同的作用域内, 无论是全局变量还是局部变量, 都不能出现同名的变量
    局部变量不使用,编译器会报错
    全局变量不使用,编译器不会报错

package main

func main() {
var num int; //不使用局部变量报错: num declared and not used
}

---

Go语言简短模式定义变量

使用 := 定义局部变量

• 简短模式定义变量是定义变量的同时初始化
• :=不能当做赋值运算符来使用
• 简短模式:= 只能定义局部变量,不能定义全局变量

package main

import "fmt"

//value := 333  编译器会报错
var value int =  333 //编译器不会报错

func main() {
}

• 使用简短模式定义变量,就不能再使用var关键字和数据类型
• :=不能使用在变量组中
• 通过:=同时定义多个变量, 必须给所有变量初始化

package main
import "fmt"
func main() {
    //num1, num2 := 666, 888 // 正确
    num1, num2 := 666 // 报错
    fmt.Printf("%d, %d\n", num1, num2)
}

• 通过:=同时定义多个变量, 只要任意一个变量没有定义过,都会做退化赋值操作

package main

import "fmt"

//value := 789
func main() {
     // 退化赋值现象
     num := 123
     //num := 456 // 报错
     // 如果通过:=定义多个变量, 但是多个变量中有的变量已经在前面定义过了, 那么只会对没有定义过的变量执行:=, 而定义过的变量只执行=操作
     // 1. var value int
     // 2. num = 456
     // 3. value = 789
    num, value := 456, 789
    fmt.Printf("%d, %d", num, value)
}

---

Go语言常量

package main

import "fmt"

func main() {
    /*
    1.在C语言中可以通过const来定义常量
    2.在Go语言中一样
    3.格式:
    const 变量名称 数据类型 = 值;
    注意点:
    1.数据类型可以省略,默认是int类型,但是const不能省略
    2.定义常量不能使用 := , := 是专门用于定义局部变量的
    3.定义局部变量没有使用, 编译会报错, 定义全局变量和常量没有使用, 不会报错

    4.在Go语言中可以连续定义多个变量, 所以也可以连续定义多个常量
    格式:
    const 变量名称1, 变量名称2 数据类型 = 值1, 值2;
    const(
      变量名称1 数据类型 = 值1
      变量名称2 数据类型 = 值2
    )

    5.常量组的注意点
    在常量组中, 如果常量没有赋值, 那么默认值就是上一行的取值
    */

    //1.定义常量
    const num int64 = 10
    fmt.Println(num)
    fmt.Printf("%T\n", num) //int64

    //2. 可以省略数据类型
    const num2  = 20
    fmt.Println(num2)
    fmt.Printf("%T\n", num2) //int

    //定义常量不使用
    const num3  = 10 //不使用不会报错
    //定义多个常量
    const a, b, c = 120, 20 ,30
    fmt.Println(a,b,c)

    //使用常量组定义多个常量,可以直接赋值,并且可以省略数据类型默认就是int类型
    const(
        d  = 10
        e   //没有赋值默认就是上一行的值
    )
    fmt.Println(d,e)
    fmt.Printf("%T\n", d) //int

    //使用常量组定义多个常量
    const(
        f,g = 10, 20
        i,j //默认和上一行一样的值
    )
    fmt.Println(f,g)
    fmt.Println(i,j)
}