go基础——变量与常量

变量

package main

import "fmt"

/*
        变量：variable
        概念：一小块内存，用于存储数据，在程序运行过程中数值可以改变
        特性：静态语言，强类型语言
*/
func main() {
        //使用：
        //一、变量的声明，也叫定义

        //第一种：定义变量，然后进行赋值
        var num1 int //var 变量名 数据类型
        num1 = 30    //变量名 = 赋值
        //写在一行
        var num2 int = 15 //var 变量名 数据类型 = 赋值
        fmt.Printf("num1的数值是:%d\n", num1)
        fmt.Printf("num2的数值是:%d\n", num2)

        //第二种：类型推断，省略数据类型
        var name = "小李" //var 变量名 = 赋值
        fmt.Printf("类型是:%T,数值是:%s\n", name, name)

        //第三种：简短定义，也叫简短声明，省略var
        sum := 100 //变量名 := 赋值
        fmt.Println(sum)

        //多个变量同时定义
        var a, b, c int
        a = 1
        b = 2
        c = 3
        fmt.Println(a, b, c)

        var m, n int = 4, 5
        fmt.Println(m, n)

        var (
                sname = "小张"
                age   = 18
                sex   = "男"
        )
        fmt.Printf("姓名：%s，年龄：%d，性别：%s\n", sname, age, sex)

        //二、变量的访问，赋值和取值
        /*
                注意点:
                1.变量必须先定义才能使用
                2.变量的类型和赋值必须一致
                3.同一个作用域内，变量名不能冲突
                4.简短定义的方式，左边的变量至少有一个是新的
                5.简短定义不能定义全局变量
        */
        var num int
        num = 100
        fmt.Printf("num的数值是：%d，地址是：%p\n", num, &num)
        num = 200
        fmt.Printf("num的数值是：%d，地址是：%p\n", num, &num)

        //6.变量的零值，也叫默认值。
        var s1 int     //0
        var s2 float64 //0.0，简写成0
        var s3 string  //""
        var s4 []int   //nil
        fmt.Println(s1, s2, s3)
        fmt.Println(s4 == nil)

        //7.变量定义了就要使用
}

num1的数值是:30

num2的数值是:15

类型是:string,数值是:小李

100

1 2 3

4 5

姓名：小张，年龄：18，性别：男

num的数值是：100，地址是：0xc0000ac098

num的数值是：200，地址是：0xc0000ac098

0 0

true

常量

package main

import "fmt"

/*
        常量：
        1.概念：同变量类似，程序执行过程种数值不能改变
        2.语法：
                显式类型定义
                隐式类型定义
        3.常数：
                固定的数值：100，"abc"
*/
func main() {

        //使用：
        //1.定义常量
        const PATH string = "baidu.com"
        const PI = 3.14

        //2.定义一组常量
        const C1, C2, C3 = 100, 3.14, "hello"
        const (
                MALE   = 0
                FEMALE = 1
                UNKNOW = 3
        )

        //3.一组常量中，如果某个常量没有初始值，默认和上一行一致
        const (
                a int = 100
                b
        )
        fmt.Printf("%T,%d\n", a, a)
        fmt.Printf("%T,%d\n", b, b)

        //4.枚举类型：使用常量组作为枚举类型，一组相关数值的数据
        const (
                SPRING = 0
                SUMMER = 1
                AUTUMN = 2
                WINTER = 3
        )

        //注意事项：
        //常量中的数据类型只可以是布尔型、数字型（整数、浮点、复数）和字符串型。
        //不曾使用的常量，编译不会报错。
        //赋值与常量类型必须一致。
}

int,100

int,100

iota

package main

import "fmt"

/*
        iota：特殊常量，可以认为是一个可以被编译器修改的常量。
                每当定义一个const，iota的初始值为0；
                每当定义一个常量，就会自动累加1；
                直到下一个const出现，清零
*/
func main() {

        const (
                a = iota //0
                b = iota //1
                c = iota //2
        )
        const (
                d = iota //0
                e        //1
        )
        fmt.Println(a, b, c)
        fmt.Println(d, e)

        const (
                A = iota   //0
                B = "haha" //iota=1
                C          //C="haha",iota=2
                D = iota   //3
                E          //4
        )
        fmt.Println(A, B, C, D, E)
}

0 1 2

0 1

0 haha haha 3 4