学Golang的第二天！

文章	评论	标签
20	14	10

（昨天出门买衣服去了，晚上看时间已经过凌晨了，所以鸽了一天）

今天学习了一下go语言的常量以及函数

常量

首先是常量，跟其他语言定义常量的方式没太多区别

定义单个

const length int = 10

还有定义多个常量(枚举)的

const (
    BEIJING   = 1
    SHANGHAI  = 2
    GUANGZHOU = 3
    SHENZHEN  = 4
)

然后还有一个iota，这个我暂时没理解实际能应用到什么上面，不过目前是学习，所以先不管；

iota：从0开始每行+1(自增)

然后我简单的尝试了一下：

const (
    BEIJING   = 10 + iota // 新表达式 10+0 = 10
    SHANGHAI              // 继承表达式 10+1 = 11
    GUANGZHOU = 10 * iota // 新的表达式 10*2 = 20
    SHENZHEN              // 继承新的表达式 10*3 = 30
)

结论：

iota只能在常量定义中使用
iota的值始终独立自增，从0开始每行+1，即使中间有赋值表达式，也不会影响iota的自增
如果某一行定义了表达式，则后续行如果没有定义表达式，则会继承前一行的表达式，直到遇到下一行有定义表达式为止

函数(方法)

首先是定义函数的格式：

func 函数名(参数列表) 返回值类型 {

 函数体
 return 返回值

}

例如

func test1(a string, b int) int {
    fmt.Println("==========test1==========")
    fmt.Printf("test1函数被调用，参数a=%s, b=%d\n", a, b)
    return b + 100
}

也可多个返回值,匿名的

func test2(x int, y int) (int, int) {
    fmt.Println("==========test2==========")
    return x + y, x * y
}

返回多个返回值，有形参名称的

func test3(x int, y int) (sum int, prod int) {
    fmt.Println("==========test3==========")
    sum = x + y
    prod = x * y
    return
}

如果返回类型都一样，可以简写

func test4(x, y int) (a1, a2 int) {
    fmt.Println("==========test4==========")
    // a1 = x + y
    // a2 = x * y
    // return

    // 此外注意，因为上面已经定义了a1和a2，所以这里也可以直接返回，且没赋值，所以默认是0
    fmt.Println("a1 = ", a1)
    fmt.Println("a2 = ", a2)

    // 也可以这样写
    return x + y, x * y
}

package main

import "fmt"

// 常量
const length int = 10

// 设定枚举
const (
    BEIJING   = 10 + iota // 新表达式 10+0 = 10
    SHANGHAI              // 继承表达式 10+1 = 11
    GUANGZHOU = 10 * iota // 新的表达式 10*2 = 20
    SHENZHEN              // 继承新的表达式 10*3 = 30
)

/*
结论：iota的值始终独立自增，从0开始每行+1，即使中间有赋值表达式，也不会影响iota的自增
如果某一行定义了表达式，则后续行如果没有定义表达式，则会继承前一行的表达式，直到遇到下一行有定义表达式为止
*/

func main() {

    fmt.Println("length = ", length)

    // length = 20 // 常量不可修改

    fmt.Println("BEIJING = ", BEIJING)
    fmt.Println("SHANGHAI = ", SHANGHAI)
    fmt.Println("GUANGZHOU = ", GUANGZHOU)
    fmt.Println("SHENZHEN = ", SHENZHEN)

    // var a int = iota // iota只能在常量定义中使用
}

package main

import "fmt"

/*
函数的定义和调用
函数定义的格式：
func 函数名(参数列表) 返回值类型 {
     函数体
     return 返回值
}
例如
*/
func test1(a string, b int) int {
    fmt.Println("==========test1==========")
    fmt.Printf("test1函数被调用，参数a=%s, b=%d\n", a, b)
    return b + 100
}

// 也可多个返回值,匿名的
func test2(x int, y int) (int, int) {
    fmt.Println("==========test2==========")
    return x + y, x * y
}

// 返回多个返回值，有形参名称的
func test3(x int, y int) (sum int, prod int) {
    fmt.Println("==========test3==========")
    sum = x + y
    prod = x * y
    return
}

// 如果返回类型都一样，可以简写
func test4(x, y int) (a1, a2 int) {
    fmt.Println("==========test4==========")
    // a1 = x + y
    // a2 = x * y
    // return

    // 此外注意，因为上面已经定义了a1和a2，所以这里也可以直接返回，且没赋值，所以默认是0
    fmt.Println("a1 = ", a1)
    fmt.Println("a2 = ", a2)

    // 也可以这样写
    return x + y, x * y
}

func main() {
    // 调用test1函数
    ret := test1("hello", 200)
    fmt.Println("test1函数的返回值是：", ret)

    // 调用test2函数
    sum, prod := test2(10, 20)
    fmt.Printf("test2函数的返回值是：sum=%d, prod=%d\n", sum, prod)

    // 调用test3函数
    s, p := test3(30, 40)
    fmt.Printf("test3函数的返回值是：s=%d, p=%d\n", s, p)

    // 调用test4函数
    s1, p1 := test4(50, 60)
    fmt.Printf("test4函数的返回值是：s1=%d, p1=%d\n", s1, p1)
}

学Golang的第二天！

星语