变量的概念和基础

依照idea中的配置设置一下我们的字体、背景色、背景图片

package main

import "fmt"

func main(){
    /*
    变量：variable
    概念：一小块内存，用于存储数据，在程序运行过程中数值可以改变

    使用：
        1. 变量的声明，也叫定义
            第一种：定义变量，然后进行赋值
            第二种：类型推断
            第三种：简短声明
        2. 变量的访问，赋值和取值
            直接通过变量名访问

    go特性：
        静态语言：强类型语言
            go、java、C++、c#
        动态语言：弱类型语言
            JavaScript、php、python、ruby
    */

    //第一种：定义变量，然后进行赋值
    var num1 int
    num1 = 30
    fmt.Printf("num1的数值是：%d\n",num1)

    //写在一行
    var num2 int = 15
    fmt.Printf("num2的数值是：%d\n",num2)

    //第二种：类型推断
    var name = "王二狗"
    fmt.Printf("类型是：%T,数值是：%s\n",name,name)

    //第三种：简短声明
    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 = 100, 200
    fmt.Println(m, n)

    var n1, f1, s1 = 100, 3.14, "Go"
    fmt.Println(n1, f1, s1)

    var (
        studentName = "小红"
        age = 18
        sex = "女"
    )
    fmt.Printf("学生姓名：%s，年龄：%d，性别：%s\n", studentName, age, sex)
}

2. 变量的内存分析和注意事项

ctrl+D 复制粘贴一行代码
ctrl+shift+上下键 移动一行代码

package main

import "fmt"

func main() {
    var num int
    num = 100
    fmt.Printf("num的数值是：%d，地址是：%p\n", num, &num)
    // main1()

    num = 200
    fmt.Printf("num的数值是：%d，地址是：%p\n", num, &num)

}

值改变，地址不变

注意事项

package main

import "fmt"

var a = 1000

func main() {
    /*
    注意：
    1. 变量必须先定义才能使用
    2. 变量的类型和赋值必须一致
    3. 同一个作用域内，变量名不能冲突
    4. 简短定义左边的变量至少有一个是新的
    5. 简短定义方式不能定义全局变量（类似于上面的 a ）
    6. 变量的默认值
        整形：0
        浮点型 ： 0
        字符串 ： ""
    7. 导入的包和创建的变量必须使用，不然报错
    */
    var num int
    num = 100
    fmt.Printf("num的数值是：%d，地址是：%p\n", num, &num)
    // main1()

    num = 200
    fmt.Printf("num的数值是：%d，地址是：%p\n", num, &num)

    fmt.Println("--------------------------------------")

    // 默认值
    var m int //整数 0
    fmt.Println(m)

    var n float64 // 0.0  0
    fmt.Println(n)

    var s string // ""
    fmt.Println(s)

    var s2 []int // 切片 ""
    fmt.Println(s2)
    fmt.Println(s2 == nil)
}

3. 常量的使用

package main

import "fmt"

func main() {
    /*
    常量：
    1. 概念：同变量类似，程序执行过程中数值不能发生改变
    2. 语法：
        显示类型定义
        隐示类型定义

    3. 常数：
        固定的数值：100，"abc"
    */

    // 常数
    fmt.Println(100)

    // 定义常量 不使用不会报错 不能重新赋值
    const PATH string = "http://www.baidu.com"
    const PI = 3.14
    fmt.Println(PATH)

    //3. 定义一组变量
    const C1,C2,C3 = 100, 3.14, "haha"
    const (
        MALE = 0
        FEMALE = 1
    )

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

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

iota

package main

import "fmt"

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

    */
    const (
        a = iota
        b = iota
        c = iota
    )

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)

    const (
        d = iota
        e
    )

    fmt.Println(d)
    fmt.Println(e)

    const (
        MALE = iota
        FEMALE
        UNKNOW
    )
    fmt.Println(MALE, FEMALE, UNKNOW)
}

package main

import "fmt"

func main() {
    const (
        A = iota //0
        B        //1
        C        //2
        D = "haha" //iota = 3
        E          //iota = 4
        F = 100    //iota = 5
        G          //iota = 6
        H = iota   //iota = 7
        I          //iota = 8
    )

    const (
        J = iota   //iota = 0
    )

    fmt.Println(A)
    fmt.Println(B)
    fmt.Println(C)
    fmt.Println(D)
    fmt.Println(E)
    fmt.Println(F)
    fmt.Println(G)
    fmt.Println(H)
    fmt.Println(I)
    fmt.Println(J)
}