关于编程语言:Go语言基础语法总结

在后面的《Go 的装置和应用》这篇文章中曾经写过 HelloWorld.go 了，当初就来逐行认识一下它。

package main

import "fmt"

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

第 1 行：咱们的 Go 程序是由包——package形成的，包的申明模式为：package < 包名 >。该行的意思是：以后 HelloWorld.go 文件属于 main 包。

第 2 行：如果你应用过 Java 或 Python，那你对 import 必定不生疏。该行的意思是：导入一个名为 fmt 的包。如果须要导入多个包，有两种写法：

import "fmt"
import "math"

或者应用分组模式同时导入多个包

import (
    "fmt"
    "math/rand"
)

显然第二种应用括号，以分组的模式导入更加不便。

第 3 行：咱们应用 func 关键字来申明一个函数，在这个例子中，咱们申明的是 main 函数。如果你有过其余语言的编程教训，必定相熟 main 函数的作用：程序的入口。

第 4 行：咱们的函数内容放在函数的 {} 中，在该例中，调用了 fmt 包中的打印办法，由此可见，Golang 语言调用函数的办法和 Java、Python 一样应用小数点：< 包名 >.< 函数名 >。

看完这几行简略代码，咱们发现：在 Go 语言中，并不需要分号 ; 来完结语句。

Go 语言要求标识符以一个字母或下划线结尾，前面能够跟任意数量的字母、数字、下划线。不能应用关键字作为标识符

辨别大小写，变量 num 和变量 Num 是两个变量。

Go 语言的变量申明形式和其余语言（如 C、Java、Python）不太一样。

比方，咱们申明一个为 int 类型的变量 a：

var a int

能够看出，Go 语言申明变量的形式为：

var < 变量名 > < 变量类型 >

咱们还能够同时申明多个类型雷同的变量：

var < 变量名 1 >, < 变量名 2 >, < 变量名 3 >, ... < 变量类型 >

应用分组同时申明多个类型不同的变量：

var (
    < 变量名 1 > < 变量类型 1 >
    < 变量名 2 > < 变量类型 2 >
    < 变量名 3 > < 变量类型 3 >
    ...
)

上面是一个具体的例子：

package main

import "fmt"

var i bool// 类型在后

func main() {
    var a, b, c int// 多个
    fmt.Println(i, a, b, c)
}

当咱们申明变量时，能够对其进行初始化。当有初始值时，咱们能够省略变量的类型，变量会依据对应的初始值获取正确的类型。见下例：

package main

import "fmt"

var a int = 1
var b, c bool = true, false

func main() {
    var i, j, k = 2, false, "行小观"    // 省略变量类型
    fmt.Println(a, b, c, i, j, k)
    k = "行小观 2 号" // 赋值操作
    fmt.Println(k)
}

若咱们在申明变量时，不给变量赋初始值，则这些变量会被赋予“零值”。

这些零值为：

数值类型为 0
布尔类型为 false
字符串为 ””（即空字符串）

如果上例中的代码中的变量不进行初始化，即：

package main

import "fmt"

var a int
var b, c bool

func main() {
    var i int
    var j bool
    var k string
    fmt.Println(a, b, c, i, j, k)
}

则打印后果为：0 false false 0 false（变量 k 因为是空字符串，所以打印进去了然而看不到）

后面介绍了当咱们申明变量时有以下几种形式：

var i int    // 申明一个 int 变量
var i, j, k int    // 同时申明多个 int 变量
var i int = 1    // 申明一个 int 变量并初始化
var i, j, k int = 1, 2, 3    // 同时申明多个 int 变量并别离初始化
var i = 1    // 省略类型，申明一个 int 变量并初始化
var i, j, k = 1, 2, 3    // 省略类型，同时申明多个 int 变量并别离初始化

除此之外还有一种更简洁的申明变量的形式：

i := 1
i, j, k := 1, 2, 3

当咱们应用 := 申明变量时，不必写 var 也不必写类型，然而这种形式 只能在函数外部应用，不能在函数内部应用。当在函数内部申明变量时，只能应用var。

package main

import "fmt"

var a int = 1    // 函数内部

func main() {
    var i, j int = 2, 3    // 函数外部

    k := 4 // 只能在函数中应用
    v1, v2, v3 := true, false, "行小观"

    fmt.Println(a, i, j, k, v1, v2, v3)
}

此外，咱们申明的变量必须要应用，如果申明了变量，然而没应用，会在编译时报错。比方：

package main

import "fmt"

func main() {
    var i bool
    var j int // 申明了，但没应用，会报错
    fmt.Println(i)
}

对于咱们导入的包也有此要求，即：导入的包必须应用。

布尔类型为 bool，值可取true 或false，默认值为false。

字符串类型为string，默认为空字符串""。

整数类型分为：

有符号数：int、int8、int16、int32 (rune)、int64
无符号数：uint、uint8 (byte)、uint16、uint32、uint64、

其中 int 和uint的两种类型的长度雷同，取决于具体的编译器，比方在 32 位零碎上通常为 32 位，在 64 位零碎上通常为 64 位。

像 int8、uint8 这些类型则是 Go 语言间接定义好位数的类型。rune、byte是 int32、uint8 的别名。

当咱们须要应用整数时，该当尽量应用 int 类型。当然，如果你有非凡的理由应用其余整数类型，便另当他论。

浮点数类型有两种：float32和 float64，留神没有所谓的float 类型。

复数类型也有两种：complex64和complex128

留神：不同类型的变量之间不能间接进行赋值或其余运算（比方加减乘除）

package main

import "fmt"

var (
    a int = 1
    b int8 = 2
    c int16
)

func main() {c = b    // 不同类型之间进行赋值操作，[报错 1]
    d := a + b    // 不同类型之间进行相加运算，[报错 2]
    fmt.Printf("c = %v, d = %v", c, d)
}

以上代码在编译过程中会报错：

[报错 1]：cannot use b (type int8) as type int16 in assignment

[报错 2]：invalid operation: a + b (mismatched types int and int8)

后面一节说过：不同类型的变量之间不能间接进行赋值或其余运算，所以咱们能够间接地做。

比方：将 int8 类型转换为 int 类型，这样就能够间接地进行赋值和其余运算。

应用表达式 T(v) 将变量 v 的值的类型转换为 T 。留神是转换的是 变量的值，变量自身的类型不变。

package main

import "fmt"

var (
    a int = 1
    b int8 = 2
    c uint
    d int64
)

func main() {c = uint(b) // 将变量 b 的值 2 的类型从 int8 转换为 uint
    d = int64(a) + int64(b)

    fmt.Printf("c(%T):%v = b(%T):%v\n", c, c, b, b)
    fmt.Printf("a(%T):%v + b(%T):%v = d(%T):%v\n", a, a, b, b, d, d)
}

留神：Go 语言中的类型转换是显示的，表达式 T() 是必须的，不能省略。

常量是固定的值，值在程序运行期间不会扭转。

常量能够定义为数值、字符串、布尔类型

常量的申明形式和变量差不多，区别在于常量须要用 const 关键字润饰，不能应用 := 进行申明。

package main

import "fmt"

const num int = 555
var a int = 1

func main() {

    const world = "世界"
    const truth = true

    fmt.Println("Hello,", world)
    fmt.Println("num =", num)
    fmt.Println("a =", a)
    fmt.Println("对吗?", truth)
}

如果你之前学习过 C 或者 Java 等语言，必定曾经对函数（办法）有了肯定的意识。

简略地来说，函数是对能实现某个性能的局部代码的形象。当当前再须要该性能，咱们只须要调用其对用的函数即可，不用再反复编写代码。

咱们在后面的内容曾经应用到了函数，即 main()。咱们应用func 关键字申明函数。

func func_name() {}

Go 语言中，函数能够有 0 个或多个参数。

package main

import "fmt"

func printName(name string, age int) {fmt.Println("我叫", name, ", 往年", age, "岁了")
}

func sayHello() {fmt.Println("行小观说：“你好”")
}

func main() {printName("行小观", 1)
    sayHello()}

如果你有多个参数的类型雷同，你能够进行简写，只须要在这几个雷同的参数最初写一遍类型即可。

func foo(x int, y int, z int)
能够简写为：func foo(x, y, x int)

函数的类型在函数名之后。（尽快适应 Go 的这种格调：类型在变量名后）

package main

import "fmt"

func add(x int, y int) int {return x + y}

func main() {fmt.Println(add(1, 2))
}

当函数没有返回值时，不须要写函数的类型：

func sayHello() {// 没有返回值，不写函数类型
    fmt.Println("行小观说：“你好”")
}

函数能够有 0 个或多个返回值。

多个返回值就意味着该函数有多个返回值类型：

package main

import "fmt"

func sumAndDiff(x, y int) (int, int) { // 两个返回值类型
    sum := x + y
    diff := x - y
    return sum, diff // 两个返回值
}

func main() {a, b := sumAndDiff(5, 1)
    fmt.Println(a, b)
}

留神：和参数不同，有几个返回值就写几个返回值类型，不能简写。

Go 语言还提供了另一种函数返回的形式：命名返回值。

顾名思义，咱们通过给返回值进行命名，应用空 return 语句，这样会间接返回已命名的返回值。如上例的 sumAndDiff 函数能够写为：

func sumAndDiff(x, y int) (sum int, diff int) {// 提前命名返回值
    sum = x + y
    diff = x - y // 返回值在函数中被初始化
    return // 返回值曾经初始化了，不须要再在 return 语句中写变量了
}

上面总结一下函数的应用：

func functionName(input1, input11 type1, input2 type2 ...) (type1, type11, type2 ...){
    
    // 函数体
    
    return value1, value11, value2 ...
}

或者命名返回值

func functionName(input1, input11 type1, input2 type2 ...) (output1 type1, output11 type11, output2 type2 ...){
    
    // 函数体
    output1 = ...
    output11 = ...
    output2 =  ...
    ...
    return
}

后面咱们曾经应用了 import 导入性能，比方improt "fmt"，该行代码能够让咱们在本包中应用其余包里的函数。

那么咱们如何让其余包可能应用到本包的办法或变量呢？答案是：将办法或变量导出。

在 Go 语言中，如果一个名字以大写字母结尾，那么它就是已导出的，这意味着别的包能够应用它。（相当于 Java 中的 public 的作用）

比方咱们罕用的打印函数 fmt.Println(...)，能够看到Println() 的首字母是大写的，所以咱们可能导入 fmt 包后应用该办法。

if 语句是条件判断语句，用来判断是否满足某种条件，如果满足，则执行某段代码；如果不满足，则不执行。

if ... {// 代码} else if ... {// 代码} else {// 代码}

留神格局：条件判断语句 不须要 应用小括号()。

上面是几个例子：

if a > 0 {// 如果满足 a >0，则打印 Hello, World
    fmt.Println("Hello, World")
}

if a > 0 {// 如果满足 a >0，则打印 Hello, World
    fmt.Println("Hello, World!")
} else {// 否则（即不满足 a >0), 则打印 你好，世界！fmt.Println("你好，世界！")
}

if a > 5 {// 如果满足 a >5，则打印 Hello, World
    fmt.Println("Hello, World!")
} else if a <= 5 && a > 0 {// 如果满足 0 <a<=5，则打印 好好学习，天天向上
    fmt.Println("好好学习，天天向上")
} else {// 否则（即下面的条件都不满足），则打印 你好，世界！fmt.Println("你好，世界！")
}

Go 语言的 if 语句有一个个性：能够在条件表达式前执行一个简略的语句。上面是一个例子：

package main

import "fmt"

func sum(x, y int) int {return x + y}

func main ()  {if i := sum(1, 2); i > 0 {fmt.Println("Hello, World!")// 作用域内，能打印 i
    }
    //fmt.Println(i)// 作用域外，不能打印 i
}

在 if 语句中，应用 sum(x, y int) 函数计算出 i 的值，再进行判断。留神：变量 i 的作用域只在 if 语句中无效。

for 语句是 Go 语言中的循环管制语句。它有几种模式：

（一）根本模式：

for 初始化语句; 条件表达式; 后置语句 {// 循环体代码}

初始化语句：在第一次循环前之前，且只执行这一次
条件表达式：每次循环都会计算该表达式，如果满足（值为 true）则持续循环；如果不满足（值为 false），则跳出循环
后置语句：每次循环执行完都会执行该语句

上面是一个例子，循环打印 5 次 ”Hello,World！”

for i := 0; i < 5; i++ {fmt.Println("Hello, World!", i)
}

留神该例的初始化语句 i := 0 是一个短变量申明，变量 i 只在该 for 循环中失效。

（二）省略模式：

for 循环中的初始化语句和后置语句是能够省略的。

i := 0
for ; i < 5; i++ {fmt.Println("Hello, World!", i)
}

i := 0
for ; i < 5; {fmt.Println("Hello, World!", i)
    i++
}

从某种意义上来讲，下面两个例子并没有省略初始化语句或后置语句，只是扭转了地位。

（三）while 模式

诸如 C、Java 等语言中都有 while 循环，然而 Go 语言中没有 while 循环，然而咱们能够应用 for 循环来实现“while 循环”。

其实 （二）省略模式 中的第二个 for 循环例子就曾经能够看做是 while 循环了。咱们再稍做改良：

i := 0
for i < 5 {// 去掉两个分号，只写条件表达式
    fmt.Println("Hello, World!", i)
    i++
}

（四）有限循环模式

// 打印有限多个 Hello, World!
for  {fmt.Println("Hello, World!")
}

下面提到的循环语句只有当条件表达式的值为 false 时，才会进行循环。但理论开发中，咱们可能在条件表达式的值为 true 的状况下，须要退出循环。这种时候，就须要应用 break 或continue语句。

break语句用来跳出以后循环，continue语句用来跳过本次循环。

上面是两个实例（改良下面循环打印 5 次 ”Hello,World！” 的例子）：

实例 1：减少需要，当打印完第 2 遍 Hello,World! 时，进行打印

for i := 0; i < 5; i++ {
    if i == 2 {break}
    fmt.Println("Hello, World!", i)
}

实例 2：减少需要，不打印第 3 遍Hello,World!

for i := 0; i < 5; i++ {
    if i == 2 {continue}
    fmt.Println("Hello, World!", i)
}

咱们能够应用 if…else if…else if… 进行一连串的条件判断，然而这样过于繁冗。switch 语句就是用来简化这个问题的。

switch 变量 {
    case 选项 1 :
        // 操作 1 代码
    case 选项 2 :
        // 操作 2 代码
    case 选项 3 :
        // 操作 3 代码
    case 选项 n:
        // 操作 n 代码
    default :
        // 默认操作
}

switch语句中有许多 case 和一个 default，只有当变量和 case 的选项相匹配时，才会执行对应的操作代码。如果没有 case 的选项能够匹配，则默认执行default 的代码。

上面是一个例子：

package main

import "fmt"

func sum(x, y int) int {return x + y}

func main ()  {result := sum(3, 2)
    switch result {
    case 1 :
        fmt.Println("后果为 1")
    case 2, 3, 4:    // 多种状况聚合在一起
        fmt.Println("后果为 2 或 3 或 4")
    case sum(1, 4):    // 反对表达式
        fmt.Println("后果为 5")
    default:
        fmt.Println("其余后果")
    }
}

从下面的例子能够看出，Go 语言中 switch 的 case 反对常量（不用为整数）、表达式、多个值聚合。留神：不论是常量、表达式，还是多个值聚合，都要保障常量、表达式的值、多个值的类型和 switch 的变量雷同。

switch 语句的匹配程序是自上到下。Go 语言主动为每个 case 提供了 break 语句，所以在泛滥选项中只能执行 1 个 case 或default，而后完结，残余的不再执行。

然而能够应用 fallthrough 强制执行残余的 case：

result := sum(1, 1)
switch result {
    case 1 :
    fmt.Println("后果为 1")
    fallthrough
    case 2, 3, 4:
    fmt.Println("后果为 2 或 3 或 4")
    fallthrough
    case sum(1, 4):
    fmt.Println("后果为 5")
    fallthrough
    default:
    fmt.Println("其余后果")
}

还是下面的那个例子，然而在每个 case 中应用fallthrough，当初的打印后果为：

后果为 2 或 3 或 4
后果为 5
其余后果

如有谬误，还请斧正。

文章首发于公众号『行人观学』

关于编程语言:Go语言基础语法总结

1. 意识 HelloWorld

2. 变量

2.1. 命名标准

2.2. 申明

2.3. 初始化

2.4. 短变量申明

3. 数据类型

3.1. 布尔类型

3.2. 字符串类型

3.3. 数值类型

3.4. 类型转换

4. 常量

5. 初识函数

5.1. 函数的申明

5.2. 函数的参数

5.3. 函数的类型和返回值

6. 导出名

7. 流程管制语句

7.1. if 语句

7.2. for 语句

7.3. break 和 continue

7.4. switch 语句