关于golang:Golang程序设计基本语法

本文学习 Go 语言根本语法，例如变量和常量、数据类型、运算符、条件语句、循环语句。

变量和常量

变量和常量是计算机程序不可或缺的局部。本节将介绍如何在 Go 程序中申明、应用变量和常量、还将介绍申明形式和作用域。

变量申明

在 Go 语言中，申明变量的形式有多种。在后面的文章介绍过，Go 语言是一种动态类型语言，因而申明变量时必须指明其类型。

例：申明 string 类型的变量。

package main

import "fmt"

func main() {
    var s1 string = "Hello World"
    var s2 = "Hello World"
    var s3 string
    s3 = "Hello World"
    fmt.Println(s1, s2, s3)
}

• 应用关键字 var 申明变量。
• 如果变量类型能够通过值推导则不必申明类型。s2 通过值能够推导类型为 string 类型。
• 变量能够在申明后赋值，未赋值的变量值为该类型的零值。

变量的类型很重要，因为这决定了可将什么值赋给该变量。例如，对于类型为 string 的变量，不能将整数赋值给它。将不匹配的值赋值给变量时，将导致编译谬误。

例：将 string 类型的值赋值给 int 类型的变量。

package main

import "fmt"

func main() {
    var i int
    i = "Hello World"
    fmt.Println(i)
}

编译该文件将导致编译谬误。

go build main.go 
# command-line-arguments
./main.go:7:4: cannot use "Hello World" (type untyped string) as type int in assignment

多变量申明

例：申明多个 类型雷同 的变量并进行赋值（显式指定类型）。

package main

import "fmt"

func main() {
    var s1, s2 string = "S1", "S2"
    fmt.Println(s1, s2)
}

例：申明多个 类型不同 的变量并进行赋值（不能显式指定类型）。

package main

import "fmt"

func main() {
    var s1, i1= "S1", 1
    fmt.Println(s1, i1)
}

例：申明多个 类型不同 的变量（显式指定类型）。

package main

import "fmt"

func main() {
    var (
        s1 string
        i1 int
    )
    s1 = "Hello"
    i1 = 10
    fmt.Println(s1, i1)
}

申明变量后能够再次赋值，然而同一个变量只容许申明一次，否则将导致编译谬误。

简短变量申明

在 函数 中申明变量时，能够用更简洁的形式。

package main

import "fmt"

func main() {
    s1 := "Hello World"
    fmt.Println(s1)
}

• := 示意简短变量申明，能够不应用 var，不指定类型，然而必须进行赋值。
• 只能在函数中应用简短变量申明。

变量申明最佳实际

Go 语言提供了多种变量申明形式，上面的申明形式都是非法的。

var s string = "Hello"
var s1 = "Hello"
var s2 string
s2 = "Hello"
s3 := "Hello"

该应用哪种形式呢？

Go 语言对此有一个限度——只能在函数外部应用简短变量申明，在函数内部必须应用 var 进行申明。

在规范库中遵循的约定如下：有初始值的状况下，在函数内应用简短变量申明，在函数外应用 var 并省略类型；无初始值的状况下应用 var 并指定类型。

package main

import "fmt"

var s = "Hello World"

func main() {
    s1 := "Hello World"
    fmt.Println(s, s1)
}

变量和零值

在 Go 语言中，申明变量时如果未初始化，则变量为默认值，该默认值也称为零值。在其余语言中未初始化的值为 null 或 undefined。

package main

import "fmt"

func main() {
    var s string
    var i int
    var b bool
    var f float32
    fmt.Printf("%v %v %v %v\n", s, i, b, f)
}

在 Go 语言中，查看变量是否为空，必须与该类型的零值比拟。例如检测 string 类型的变量是否为空，能够与 ”” 断定。

package main

import "fmt"

func main() {
    var s string
    if s == "" {fmt.Println("s 为空")
    }
}

变量作用域

作用域指变量能够在什么中央应用，而不是说变量在哪里申明的。Go 语言应用基于块的词法作用域，简略来说就是 {} 会产生一个作用域。

Go 语言作用域规定如下：

1. 一对大括号 ({}) 示意一个块，块是能够嵌套的
2. 对于在块内申明的变量，能够在本块以及子块中拜访
3. 子块能够拜访父块的变量，父块不能拜访子块的变量

例：Go 语言的作用域。

package main

import "fmt"

func main() {
    var s1 = "s1"
    {
        var s2 = "s2"
        // 能够拜访 s1,s2
        fmt.Println(s1, s2)
        {
            var s3 = "s3"
            // 能够拜访 s1,s2,s3
            fmt.Println(s1, s2, s3)
        }
    }
    // 只能拜访 s1
    fmt.Println(s1)
}

简略来说，就是块内能够拜访块外的变量，块外不能拜访块内变量。

申明常量

常量只在整个程序运行过程中都不变的值，常量必须在申明时赋值，申明后不能够更改。

Go 语言应用 const 关键字申明常量。

package main

import "fmt"

const s = "Hello"

func main() {
    const s2 = "World"
    const s3,s4 = "Hello","World"
    fmt.Println(s, s2)
}

常量也反对一次申明多个，此外常量的作用域和变量作用域统一。

数据类型

Go 语言提供了丰盛的数据类型，按类别分为布尔型、数值型（整数、浮点数、复数）、字符串型、派生型。其中派声型包含指针类型、数组类型、构造体类型、接口类型、Channel 类型、函数类型、切片类型和 Map 类型。

派生类型咱们将在前面的内容中进行介绍。

布尔类型

布尔类型值只能为 true 或 false。某些语言容许应用 1 和 0 来示意 true 和 false，但 Go 语言不容许。

布尔类型的零值为 false。

package main

import "fmt"

func main() {
    var b bool
    if b {fmt.Println("b 是 true")
    } else {fmt.Println("b 是 false")
    }
} 

数值型

Go 语言中数值型蕴含整数、浮点数以及复数。

整数型

浮点数

复数

略

字符串类型

字符串能够是任何字符序列，包含数字、字母和符号。Go 语言应用 Unicode 来存储字符串，因而能够反对世界上所有的语言。

上面是一些字符串示例：

var s = "$%^&*"
var s2 = "1234"
var s3 = "你好"

运算符

运算符用于在程序运行时执行数据运算和逻辑运算。Go 语言反对的运算符有：

• 算术运算符
• 逻辑运算符
• 关系运算符
• 位运算符

算术运算符

算术运算符是用来对数值类型进行算术运算的。下表列出了 Go 语言反对的算术运算符。

package main

import "fmt"

func main() {
    var (
        a = 10
        b = 20
    )
    fmt.Printf("a+b=%d\n", a+b)
    fmt.Printf("a-b=%d\n", a-b)
    fmt.Printf("a*b=%d\n", a*b)
    fmt.Printf("a/b=%d\n", a/b)
    fmt.Printf("a%%b=%d\n", a%b)
    a++
    fmt.Printf("a++=%d\n", a)
    a--
    fmt.Printf("a--=%d\n", a)
}

和其余语言不同的是，Go 语言不提供 ++a，–a 运算符，只提供 a ++，a–。

关系运算符

关系运算符用来判断两个值的关系。下表列出了 Go 语言反对的关系运算符。

package main

import "fmt"

func main() {
    var (
        a = 10
        b = 20
    )
    if a == b {fmt.Println("a==b")
    } else {fmt.Println("a!=b")
    }

    if a < b {fmt.Println("a<b")
    } else {fmt.Println("a>=b")
    }

    if a <= b {fmt.Println("a<=b")
    } else {fmt.Println("a>b")
    }
}

逻辑运算符

逻辑运算符用来对操作数进行逻辑判断。下表列出了 Go 语言反对的逻辑运算符。

package main

import "fmt"

func main() {
    var a, b = true, false
    if a && b {fmt.Println("a 和 b 同时为 true")
    } else {fmt.Println("a 和 b 至多一个为 false")
    }

    if a || b {fmt.Println("a 和 b 至多一个为 true")
    } else {fmt.Println("a 和 b 都为 false")
    }
    if !a {fmt.Println("a 是 false")
    } else {fmt.Println("a 是 true")
    }
}

位运算符

位运算符用来对整数进行二进制位操作。下表列出了 Go 语言反对的位运算符。

package main

import "fmt"

func main() {
    var (
        a = 1
        b = 2
    )
    fmt.Printf("a&b=%d\n", a&b)
    fmt.Printf("a|b=%d\n", a|b)
    fmt.Printf("a^b=%d\n", a^b)
    fmt.Printf("a>>1=%d\n", a>>1)
    fmt.Printf("a<<1=%d\n", a<<1)
}

条件语句

条件语句是计算机程序的重要组成部分，简直所有编程语言都反对。简略地说，条件语句查看指定的条件是否满足，并在满足时执行指定的操作。

下表列出了 Go 语言反对的条件语句。

例：if 的应用。

package main

import "fmt"

func main() {
    var a = 10
    if a > 10 {fmt.Println("a 大于 10")
    } else if a == 10 {fmt.Println("a 等于 10")
    } else {fmt.Println("a 小于 10")
    }
}

例：switch 的应用。

package main

import "fmt"

func main() {
    var a = 10

    switch a {
    case 1:
        fmt.Println("a 等于 1")
    case 2:
        fmt.Println("a 等于 2")
    case 10:
        fmt.Println("a 等于 3")
    default:
        fmt.Println("默认分支")
    }
}

和其余语言不同，Go 语言的 case 分支不须要增加 break。

循环语句

在其余语言中个别会提供 for、while、foreach 等关键字实现循环，而在 Go 语言中只提供 for 关键字，然而也实现了相似的成果。

for

for 循环有着经典的三段式构造：

1. 循环初始化
2. 循环终止条件
3. 循环步进条件

package main

import "fmt"

func main() {
  for i := 0; i < 10; i++ {fmt.Println(i)
  }
}

while

while 循环指定循环终止条件，不满足条件时循环始终执行并向终止条件聚拢，满足条件后终止循环。（无终止条件的循环称为死循环）

package main

import "fmt"

func main() {
  i := 0
  for i < 10 {fmt.Println(i)
    i++
  }
}

死循环不须要终止条件。

package main

import (
  "fmt"
  "time"
)

func main() {
  i := 0
  for {fmt.Println(i)
    i++
    time.Sleep(time.Second)
  }
}

foreach

foreach 循环多用来遍历列表、字典等数据结构。

package main

import "fmt"

func main() {list := []int{1, 2, 3, 4, 5}
  for index, value := range list {fmt.Println(index, value)
  }
}

continue

continue 用来跳过本次循环继续执行下次循环。

package main

import "fmt"

func main() {
  for i := 0; i < 5; i++ {
    if i == 1 {continue}
    fmt.Println(i)
  }
}

该程序判断 i 为 1 时跳过并执行下次循环，该程序输入如下。

0
2
3
4

3.1.5 break

break 用来跳出循环，后续循环将不执行。

package main

import "fmt"

func main() {
  for i := 0; i < 5; i++ {
    if i == 1 {break}
    fmt.Println(i)
  }
}

该程序判断 i 为 1 时跳出循环，该程序输入如下。

0

小结

本文介绍了 Go 语言的根本语法，包含变量和常量的应用、根底数据类型、流程管制等常识。下一章将介绍 Go 语言的数据容器类型，包含数组、切片和映射。