关于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 语言作用域规定如下：

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

例：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 语言中数值型蕴含整数、浮点数以及复数。

整数型

类型	字节数	范畴
byte	1	0 ~ 28
uint8	1	0 ~ 28
int8	1	-27 ~ 27-1
uint16	2	0 ~ 216
int16	2	-215 ~ 215-1
uint32	4	0 ~ 232
int32	4	-231 ~ 231-1
uint64	8	0 ~ 264
int64	8	263 ~ 263-1
int	平台相干(32 位或 64 位)
uint	平台相干(32 位或 64 位)

浮点数

类型	字节数	范畴
float32	4	-3.403E38 ~ 3.403E38
float64	8	-1.798E308 ~ 1.798E308

复数

略

字符串能够是任何字符序列，包含数字、字母和符号。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 语言反对的逻辑运算符。

运算符	阐明
&&	逻辑与。两边操作数都为 true 则后果为 true，否则为 false
\	\	逻辑或。两边操作数只有有一个为 true 则后果为 true，否则为 false
!	逻辑非。如果操作数为 true 则后果为 false，否则为 true

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	由一个布尔表达式后紧跟一个或多个语句组成。
if…else if…else	由多个布尔表达式分支组成，并提供例外分支
switch	基于不同条件执行不同操作，并提供默认操作

例：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 循环有着经典的三段式构造：

循环初始化
循环终止条件
循环步进条件

package main

import "fmt"

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

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 循环多用来遍历列表、字典等数据结构。

package main

import "fmt"

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

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

package main

import "fmt"

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

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

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

package main

import "fmt"

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

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

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

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

变量和常量

变量申明

多变量申明

简短变量申明

变量申明最佳实际

变量和零值

变量作用域

申明常量

数据类型

布尔类型

数值型

字符串类型

运算符

算术运算符

关系运算符

逻辑运算符

位运算符

条件语句

循环语句

for

while

foreach

continue

3.1.5 break

小结

Just My Socks（注册教程内含优惠码）

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

变量和常量

变量申明

多变量申明

简短变量申明

变量申明最佳实际

变量和零值

变量作用域

申明常量

数据类型

布尔类型

数值型

字符串类型

运算符

算术运算符

关系运算符

逻辑运算符

位运算符

条件语句

循环语句

for

while

foreach

continue

3.1.5 break

小结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）