一文详解Golang中的基础语法

package package_test

import "fmt"


func Func1（） {
    fmt.Println（"test1 func1"）
}

package package_test

import "fmt"

func Func2（） {
    fmt.Println（"test2 func2"）
}

package main

import "dir1/dir2"  // 导入的是【目录名】

func main（） {
    package_test.Func1（）  // 调用的是【包名】
}

// 方式一
go bulid testmain.go  // 编译（生成可执行文件）
./ testmain  // 运行（可执行文件）

//方式二
go run testmain.go  // 编译+运行

// 方式一：先声明（有默认值），后赋值
var a int
a = 10
var b, c string
b = "b"
c = "c"

// 方式二：声明+赋值
var a int = 10

// 方式三：自动推导类型（注意：这种方式只能在函数内使用）
a := 10
b, c := 11, 12
b, c = c, b  // 值交换

// 匿名变量
_, i, _, j = 1, 2, 3, 4

func main() {
    var ch byte = 97  // 声明字符类型
    fmt.Printf("ch=%c", ch)  //  输出 a
}

package main

import "fmt"

func main() {

    chinese := 97
    math := 99
    english := 96

    fmt.Printf("总分是 %d，平均分(整数)是 %d, 平均分(浮点数)是 %f", chinese+math+english, (chinese+math+english)/3, float32(chinese+math+english)/3)
    // 总分是 292，平均分(整数)是 97, 平均分(浮点数)是 97.333336
}

    var ch byte = 'c'
    // var a int = ch  // cannot use ch (type byte) as type int in assignment
    var b int = int(ch)  // 数据类型名(待转换的值)

package main

import fmt

func main（） {
    var age int
    fmt.Println（"请输入年龄："）
    fmt.Scanf（"%d", &age）  // 将接收的值赋给age变量
    fmt.Printf（"age=%d", age）
}

func main() {
    // 变量：程序运行期间，值可以改变，声明使用var
    // 常量：程序运行期间，值不可以改变，声明使用const
    const a int = 11
    // a = 12  // error：常量不可以修改
    
    const b = 12 // 自动推导类型（常量不可以使用:=）
}

func main() {

    // 在一个 const 声明语句中，在第一个声明的常量所在的行，iota 将会被置为 0，然后在每一个有常量声明的行递增 1
    const (
        a = iota  // 0
        b = iota  // 1
        c = iota  // 2
    )

    const d = iota // iota 遇到const，会被置为 0

    // 可以只写一个iota
    const (
        e = iota  // 0
        f // 1
        g
    )

    // 同一行值一样
    const (
        h = iota  // 0
        i, j, k = iota, iota, iota  // 1
        l = iota  // 2
    )

}

package main

import "fmt"

func main() {

    var score int
    fmt.Println("请输入成绩：")
    fmt.Scanf("%d", &score)

    // if 语句支持一个初始化语句+判断条件
    if good_score := 90; score >= good_score {
        fmt.Println("优秀")
    } else if soso_score := 60; score >= soso_score {
        fmt.Println("及格")
    } else {
        fmt.Println("需要努力")
    }
}

func main() {

    bonus := 5000
    var score string
    finish := true
    fmt.Println("请输入年终评级：")
    switch fmt.Scanf("%s", &score); score {
    case "A":
        bonus += 1000
    case "B":
        bonus += 5000
    case "C":
    case "D":
        bonus -= 1000
    default:
        finish = false
        fmt.Println("输入有误，请输入正确的评级")
    }
    if finish {
        fmt.Printf("您的年终奖为：%d", bonus)
    }

}

package main

import "fmt"

func main() {

    // 第1种方式
    for i := 0; i < 5; i++ {
        fmt.Printf("i=%d\n", i)
    }

    // 第2种方式：类似while循环
    num := 1
    for num < 5 {
        fmt.Printf("num=%d\n", num)
        num++
    }

    // 第3种方式
    for {
        fmt.Println("死循环")
    }
}

func 函数名(){
    函数体
}

import "fmt"

func MyFunc(a int, b int, args ...int) {  // 注意：不定长参数必须放在参数列表最后
    fmt.Println("定长参数为：", a, b)
    for i, data := range args {  // 若不需要编号，则可使用 for _, data := range args
        fmt.Println("编号为：", i)
        fmt.Println("数据为：", data)
    }
}

func main() {
    MyFunc(1, 2, 3, 4, 5)
}

// 定义返回值类型
func Add(a int, b int) int {
    return a + b
}

// 给返回值命名
func Sub(a int, b int) (sub int) {
    sub = a - b
    return sub  // 也可以只写 return
}

// 返回多个值
func Sub(a, b, c int) {
    a, b, c = 1, 2, 3
    return a, b, c  // 也可以只写 return
}

func Test(a, b int) int {
    return a + b
}

// 定义函数类型：即需要传递两个整型参数，有一个整型返回值的函数类型
type FuncType func(a int, b int) int  // type关键字后面跟着类型的名字（FunType）

func main() {
    var result FuncType  // 类型是FuncType类型，即函数类型
    result = Test
    s := result(1, 2)
    fmt.Printf("s=%d", s)
}

package main

import "fmt"

func main() {
    num := 9

    // 使用方式一：定义匿名函数并赋值给变量
    f1 := func() {
        // 在匿名函数中可以直接访问main()中定义的局部变量
        // 并且在匿名函数中对变量的值进行了修改，最终会影响到整个main()函数中定义的变量值
        num++
        fmt.Println("匿名函数：", num)
    }
    f1()                        // 10
    fmt.Println("main函数：", num) // 10

    // 使用方式二：通过函数类型
    type FuncType func() // 没有参数，没有返回值
    var f2 FuncType = f1
    f2()

    // 使用方式三：直接调用
    func(a, b int) {
        fmt.Println("a + b =", a+b)
    }(3, 6)

    // 有参有返回值的匿名函数
    min, max := func(a, b int) (min, max int) {
        if a > b {
            return b, a
        } else {
            return a, b
        }
    }(12, 13)
    fmt.Printf("min=%d, max=%d\n", min, max)
}

func Test(num int) int {
    if num == 1 {
        return 1
    }
    return num * Test(num-1)
}

func main() {
    var num int
    fmt.Println("请输入需要阶乘的数：")
    fmt.Scanf("%d", &num)
    fmt.Printf("%d的阶乘结果为：%d", num, Test(num))
}