函数

Go 语言中,函数声明通用语法如下:

func functionname(parametername type) returntype {  
    // 函数体(具体实现的功能)
}
  1. 函数的参数列表定义在 () 之间,返回值的类型则定义在之后的 returntype (返回值类型)处。
  2. 声明一个参数的语法采用 参数名 参数类型 的方式,任意多个参数采用类似 (参数1 参数1的类型,参数2 参数2的类型)的形式指定,或者(参数1, 参数2,参数类型)
  3. 函数中的参数列表和返回值并非是必须的。

示例代码:

package main
import "fmt"

func main()  {
    s := price(20, 30)
    fmt.Println(s)
}
//如果有连续个参数,它们的类型一致,无须一一罗列,只需在最后一个参数后添加该类型。
func price(apple, banana int) int  {
    sum := apple + banana
    return sum
}
多返回值

Go 语言支持一个函数可以有多个返回值。

func main()  {
    name, sum := price("苹果", 30)
    fmt.Println(name, sum)
}

func price(apple string, banana int) (string, int)  {

    return apple, banana
}
命名返回值

函数的返回值第一行就被声明为变量了。

func price(apple string, banana int)(a string, b int)  {
    a = apple + "demo"
    b = banana + 20
    return
}

函数中的 return 语句没有显式返回任何值。由于 area 和 perimeter 在函数声明中指定为返回值, 因此当遇到 return 语句时, 它们将自动从函数返回。

空白符

_ 在 Go 中被用作空白符,可以用作表示任何类型的任何值。

func main()  {
    var sum, _ = demo(4, 5)
    fmt.Println(sum)
}

func demo(a, b int)(int, int)  {
    var sum = a*b
    var cum =(a+b)*2
    return sum, cum
}

在程序的 var sum, _ = demo(4, 5) 这一行,空白符_ 用来跳过不要的计算结果。

包用于组织 Go 源代码,提供了更好的可重用性与可读性。

main 函数和 main 包

所有可执行的 Go 程序都必须包含一个 main 函数。这个函数是程序运行的入口。main 函数应该放置于 main 包中。
package packagename这行代码指定了某一源文件属于一个包。它应该放在每一个源文件的第一行。

创建自定义的包

src文件夹下新建test_one文件夹,test_one下新建test_1.go文件,在test_one文件夹下新建demo文件夹,demo文件夹中新建demo1.go,目录如下:

src
   test_one
       test_1.go
       demo
          demo1.go

在demo1.go中编辑两个测试函数:

package demo

import "fmt"

func A_demo()  {
    fmt.Println("This A_demo func")
}

func B_demo()  {
    fmt.Println("This B_demo func")
}

在test_1.go中导入demo包:

package main

import (
    "fmt"
    "test_one/demo"
)

func main()  {
    fmt.Print()
    demo.A_demo()
    demo.B_demo()
}

运行可以看到结果。

导出名字(Exported Names)

我们将 demo1 包中的函数 A 和 B 首字母大写。在 Go 中这具有特殊意义。在 Go 中,任何以大写字母开头的变量或者函数都是可被导出的名字。换句话说就是外部包可以使用这些变量或函数,小写字母的变量或函数不能被外部包使用。其它包只能访问被导出的函数和变量。在这里,我们需要在 main 包中访问 A和 B函数,因此会将它们的首字母大写。

init函数

所有包都可以包含一个 init 函数。init 函数不应该有任何返回值类型和参数,在我们的代码中也不能显式地调用它。

func init() {  
}

init 函数可用于执行初始化任务,也可用于在开始执行之前验证程序的正确性。

包的初始化顺序如下:
  1. 首先初始化包级别(Package Level)的变量
  2. 紧接着调用 init 函数。包可以有多个 init 函数(在一个文件或分布于多个文件中),它们按照编译器解析它们的顺序进行调用。
  3. 如果一个包导入了另一个包,会先初始化被导入的包。
  4. 尽管一个包可能会被导入多次,但是它只会被初始化一次。

测试init函数:给test_1.go和demo1.go中增加init函数并打印test_one和demo

func init()  {
    fmt.Println("This is test_one package init")
}

func init()  {
    fmt.Println("This is demo package init")
}

main 包的初始化顺序为:

  1. 首先初始化被导入的包。因此,首先初始化了 rectangle 包。
  2. 接着初始化了包级别的变量 rectLen 和 rectWidth。
  3. 调用 init 函数。
  4. 最后调用 main 函数。

使用空白标识符(Blank Identifier)

导入了包,却不在代码中使用它,这在 Go 中是非法的。当这么做时,编译器是会报错的。其原因是为了避免导入过多未使用的包,从而导致编译时间显著增加。

然而,在程序开发的活跃阶段,又常常会先导入包,而暂不使用它。遇到这种情况就可以使用空白标识符 _。

import (
    "fmt"
    "test_one/demo"
)

func init()  {
    fmt.Println("This is test_one package init")
}
var _ = demo.A_demo
func main()  {
    fmt.Print()

}

有时候我们导入一个包,只是为了确保它进行了初始化,而无需使用包中的任何函数或变量,可以这样写:

package main 

import (
    _ "test_one/demo" 
)
func main() {

}

运行代码后可以看到还是在demo1.go中运行了init函数。

if-else语句

if statement; condition {  
}

示例:

package main

import (  
    "fmt"
)

func main() {  
    if num := 10; num % 2 == 0 { //checks if number is even
        fmt.Println(num,"y") 
    }  else {
        fmt.Println(num,"n")
    }
}

在上面的程序中,num 在 if 语句中进行初始化,num 只能从 if 和 else 中访问。也就是说 num 的范围仅限于 if else 代码块。如果我们试图从其他外部的 if 或者 else 访问 num,编译器会不通过。

if语句中,else必须跟在}后边,不能换行,因为Go 语言的分号是自动插入。
在 Go 语言规则中,它指定在 } 之后插入一个分号,如果这是该行的最终标记。因此,在if语句后面的}会自动插入一个分号。

由于 if{…} else {…} 是一个单独的语句,它的中间不应该出现分号。

package main

import (  
    "fmt"
)

func main() {  
    num := 99
    if num = 51 && num 

for 循环语法

for initialisation; condition; post {  
}
简写:
package main

import (  
    "fmt"
)

func main() {  
    i := 0
    for i 
break,continue:
package main

import (
    "fmt"
)

func main() {
    for i := 1; i  10 {
            break //loop is terminated if i > 5
        }

        if i % 2 ==0{
            continue
        }
        fmt.Printf("%d ", i)
    }
    fmt.Printf("nline after for loop")


    for no, i := 10, 1; i 
无限循环
package main

import "fmt"

func main() {  
    for {
        fmt.Println("Hello World")
    }
}

switch 语句

func main() {
    switch finger := 8; finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 5:
        fmt.Println("Pinky")
    default: // 默认情况
        fmt.Println("incorrect finger number")
    }
}

当它不符合其中任何情况,会使用默认值。

多表达式判断
package main

import (
    "fmt"
)

func main() {
    letter := "i"
    switch letter {
    case "a", "e", "i", "o", "u": // 一个选项多个表达式
        fmt.Println("vowel")
    default:
        fmt.Println("not a vowel")
    }
}
无表达式的 switch

在 switch 语句中,表达式是可选的,可以被省略。如果省略表达式,则表示这个 switch 语句等同于 switch true,并且每个 case 表达式都被认定为有效,相应的代码块也会被执行。

package main

import (
    "fmt"
)

func main() {
    num := 75
    switch { // 表达式被省略了
    case num >= 0 && num = 51 && num = 101:
        fmt.Println("num is greater than 100")
    }

}
Fallthrough 语句

在 Go 中,每执行完一个 case 后,会从 switch 语句中跳出来,不再做后续 case 的判断和执行。使用 fallthrough 语句可以在已经执行完成的 case 之后,把控制权转移到下一个 case 的执行代码中。

package main

import (
    "fmt"
)

func number() int {
    num := 15 * 5 
    return num
}

func main() {

    switch num := number(); { // num is not a constant
    case num 

如果内容对你有帮助,记得关注作者给个赞哦~,后续会持续更新。

文章来源于互联网,如有雷同请联系站长删除:Go基础语法(二)

发表评论