Golang 基本语法

package main

import "fmt"

// 基本语法
func main(){

    // 一、变量声明 Go有多种方式声明变量

    // 1.显式声明
    var x int
    x = 10

    // 2.简短声明 (简短声明只能是新变量，现在给上面的x使用简短声明，则会报错)
    k := 10

    // 二、数据类型
    // 1.整型 int int8 int16 int32 int64
    var int_a int = 5

    // 2.浮点型 float32 float64
    var float_a float32 = 3.14

    // 3.字符串 string
    var string_a string = "你好,Golang"

    // 4.布尔型 bool
    var bool_a bool = true
    var bool_b bool = false

    // 5.字符型 rune

    // 三、常量声明 (常量一旦声明就不能更改其值。常量声明使用cost关键字)
    const PI = 3.14
    const Greeting = "Hello"

    // 四、控制结构
    // 条件语句 Go使用 if 语句进行条件判断
    ifa := 10

    if ifa > 10 {
        fmt.Println("ifa 大于 10")
    } else {
        fmt.Println("ifa 小于等于 10")
    }

    // 循环语句 Go只有一个循环语句 for, 它可以用于多种情况
    for i :=0; i < 5; i++ {
        fmt.Println(i)
    }

    // 使用for 模拟 while 循环
    wi := 0
    for wi < 5 {
        fmt.Println(wi)
        wi++
    }

    // 无限循环
    for {
        fmt.Println("这是一个无限循环(死循环)")
    }

    // Switch 语句
    day := 2
    switch day {
    case 1:
        fmt.Println("这是1")
    case 2:
        fmt.Println("这是2")
    default:
        fmt.Println("不是1也不是2")
    }

    // Select语句 (用于多路选择 常用于 goroutines ) 此处略过

    // 五、函数
    // 函数声明 (函数使用func 关键字声明，函数可以有多个返回值)
    func add(a int, b int) int {
        return a + b
    }

    // 多返回值函数
    func divide(a int, b int) (int, int) {
        return a / b, a % b
    }

    // 匿名函数
    addfunc := func(a, b int) int {
        return a + b
    }
    fmt.Println(addfunc(3, 4))

    // 函数作为参数(go支持将函数作为参数传递)
    func apply(a int, f func(int) int) int {
        return f(a)
    }
    func square(x int) int {
        return x * x
    }
    fmt.Println(apply(5, square)) // 25

    // 六、数组与切片
    // 数组(Go中的数组大小是固定的，一旦声明不能更改大小)
    var arr [3]int = [3]int{1, 2, 3}
    fmt.Println(arr)

    // 切片(切片是GO中更加灵活的数组，可以动态增长)
    var slice []int = []int{1, 2, 3}
    slice = append(slice, 4)
    fmt.Println(slice)

    // 七、结构体(结构体是 Go 中的复合数据类型，通常用来表示对象或记录)
    type Person struct {
        Name string
        Age  int
    }

    p := Person{Name: "John", Age: 30}
    fmt.Println(p.Name)

    // 八、接口(接口是 Go 中的核心概念之一，它定义了行为而不关心具体类型)
    type Speaker interface {
        Speak() string
    }

    type Person struct {
        Name string
    }

    func (p Person) Speak() string {
        return "Hello, my name is " + p.Name
    }

    func introduce(speaker Speaker) {
        fmt.Println(speaker.Speak())
    }

    p := Person{Name: "John"}
    introduce(p)

    // 九、错误处理(Go 中没有异常处理机制，而是通过返回值来传递错误信息)
    func divide(a, b int) (int, error) {
        if b == 0 {
            return 0, fmt.Errorf("cannot divide by zero")
        }
        return a / b, nil
    }

    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }

}