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

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

变量和常量

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

变量申明

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

例：申明string类型的变量。

package mainimport "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 mainimport "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 mainimport "fmt"func main() {    var s1, s2 string = "S1", "S2"    fmt.Println(s1, s2)}

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

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

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

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

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

简短变量申明

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

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

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

变量申明最佳实际

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

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

该应用哪种形式呢？

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

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

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

变量和零值

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

package mainimport "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 mainimport "fmt"func main() {    var s string    if s == "" {        fmt.Println("s为空")    }}

变量作用域

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

Go语言作用域规定如下：

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

例：Go语言的作用域。

package mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "fmt"func main() {  for i := 0; i < 10; i++ {        fmt.Println(i)  }}

while

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

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

死循环不须要终止条件。

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

foreach

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

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

continue

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

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

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

0234

3.1.5 break

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

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

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

0

小结

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