c后缀表达式求值_程序猿学Go：运算符与表达式和语句

一：Go语言运算符

运算符用于在程序运行时执行数学或逻辑运算。

Go 语言内置的运算符有：

• 算术运算符

• 关系运算符

• 逻辑运算符

• 位运算符

• 赋值运算符

• 其他运算符

接下来让我们来详细看看各个运算符的介绍。

package main
 
import "fmt"
 
func main() {
 
   var a int = 21
   var b int = 10
   var c int
 
   c = a + b
   fmt.Printf("第一行 - c 的值为 %dn", c )
   c = a - b
   fmt.Printf("第二行 - c 的值为 %dn", c )
   c = a * b
   fmt.Printf("第三行 - c 的值为 %dn", c )
   c = a / b
   fmt.Printf("第四行 - c 的值为 %dn", c )
   c = a % b
   fmt.Printf("第五行 - c 的值为 %dn", c )
   a++
   fmt.Printf("第六行 - a 的值为 %dn", a )
   a=21   // 为了方便测试，a 这里重新赋值为 21
   a--
   fmt.Printf("第七行 - a 的值为 %dn", a )
}

二：Go语言语句

2.1 控制结构

if 是一个条件语句。if 语句的语法为：

 if condition {  
 }

如果 condition 为 true，那么就执行 { 和 } 之间的代码。

与其它语言（如C）不同，即使 {} 之间只有一条语句，{} 也是必需的。

if 语句后面可以接可选的 else if 和 else 语句：

 if condition {  
 } else if condition {
 }else {
 }

if 后面可以接任意数量的 else if 语句。condition 的求值由上到下依次进行，直到某个 if 或者 else if 中的 condition 为 true 时，执行相应的代码块。如果没有一个 conditon 为 true，则执行 else 中的代码块。

if 语句还有如下的变体。这种形式的 if 语句先执行 statement，然后再判断 conditon 。

 if statement; condition {  
 } 
  if num := 10; num % 2 == 0 { //checks if number is even
    fmt.Println(num,"is even") 
  }  else {
   fmt.Println(num,"is odd")
  }

• 循环语句

for 语句是 Go 中唯一的循环语句。Go 没有提供其他语言（如 C）中的 while 和 do while 语句。

for 语句语法

for 语句的语法如下：

for initialisation; condition; post {  
}

其中， initialisation 为初始化语句，该语句仅执行一次。initialisation 语句结束后，接着对 condition 求值，如果 condition 求值结果为 true，则执行大括号 {} 里面的循环体，然后执行 post 语句，如果 condition 求值结果为 false 则退出循环。post 语句会在每次循环体执行结束后执行。执行完 post 语句之后，condition 会被重新求值，如果是true，则继续执行循环体，否则退出循环。

在 Go 中 for 语句头部的三个部分：initialisation，condition，post 都是可选的。让我们看一个例子以更好的理解 for 语句。

• break

break 语句用于终止 for 循环，继续执行 for 循环后面的语句。

下面的程序打印 1 到 5 之间的整数。请注意该程序中 break 的用法。

package main
import (  
    "fmt"
)
func main() {  
    for i := 1; i <= 10; i++ {
        if i > 5 {
            break //loop is terminated if i > 5
        }
        fmt.Printf("%d ", i)
    }
    fmt.Printf("nline after for loop")
}

• continue

continue 语句用于跳过 for 循环的当前迭代。循环体中 continue 语句之后的所有语句将被跳过不予执行。循环将继续执行下一次迭代。

让我们写一个程序利用 continue 来打印 1 到 10 之间的奇数。

package main
import (  
    "fmt"
)
func main() {  
    for i := 1; i <= 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Printf("%d ", i)
    }
}

• 下面的程序 打印 0 到 10 之间的所有偶数。

package main
import (  
    "fmt"
)
 
func main() {  
    i := 0
    for ;i <= 10; { // initialisation and post are omitted
        fmt.Printf("%d ", i)
        i += 2
    }
}

我们已经知道 for 循环头部的三个部分 initialisation，condition，post 都是可选的。上面的程序中，忽略了 initialisation 和 post 部分。i 在 for 循环之外初始化为 0，只要 i <= 10 循环就一直执行，i 在循环体内每次递增 2。上面的程序输出为：0 2 4 6 8 10。

上面程序中的分号（;）也可以省略。这种形式的 for 循环可以视为 while 循环的替代品。上面的程序可以被重写如下：

package main
import (  
    "fmt"
)
func main() {  
    i := 0
    for i <= 10 { //semicolons are ommitted and only condition is present
        fmt.Printf("%d ", i)
        i += 2
    }
}

可以在 for 循环中声明和操作多个变量，比如下面的程序：

package main
import (  
    "fmt"
)
func main() {  
    for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { //multiple initialisation and increment
        fmt.Printf("%d * %d = %dn", no, i, no*i)
    }
}

上面的程序中，no 和 i 被声明并初始化为 10 和 1。它们在每次迭代结束时递增 1。在 condition 部分使用 && 操作符来确保 i 小于或等于 10 并且 no 小于或等于 19。

package main
import (
 "fmt"
)
func main() {
 //testif()
 //testfor()
 testwhile()
}
func testif() {
 var grade int = 80
 if grade > 90 {
  fmt.Println("A")
 } else if grade > 80 {
  fmt.Println("B")
 } else {
  fmt.Println("C")
 }
}
func testfor() {
 var sum int = 0
 for i := 0; i < 10; i++ {
  sum += i
 }
 fmt.Println(sum)
}
 
func testwhile() {
 var i int = 0
 
 for true {
  fmt.Printf("这是无限循环。n")
 }
 
 for i < 10 {
  fmt.Printf("这是无限循环。n")
  i++
 }
}
 
打印9*9乘法表
 for i := 1; i <= 9; i++ { // i 控制行，以及计算的最大值
  for j := 1; j <= i; j++ { // j 控制每行的计算个数
   fmt.Printf("%d*%d=%d ", j, i, j*i)
  }
  fmt.Println("")
 }
 
 
 

2.1 switch控制语句使用

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。

switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break.

func testSwitch() {
 /* 定义局部变量 */
 var grade string = "B"
 var marks int = 90
 
 switch marks {
 case 90:
  grade = "A"
 case 80:
  grade = "B"
 case 50, 60, 70:
  grade = "C"
 default:
  grade = "D"
 }
 
 switch {
 case grade == "A":
  fmt.Printf("优秀!n")
 case grade == "B", grade == "C":
  fmt.Printf("良好n")
 case grade == "D":
  fmt.Printf("及格n")
 case grade == "F":
  fmt.Printf("不及格n")
 default:
  fmt.Printf("差n")
 }
 fmt.Printf("你的等级是 %sn", grade)
}

• 包含多个表达式的 case

可以在一个 case 中包含多个表达式，每个表达式用逗号分隔。

• 没有表达式的 switch

switch 中的表达式是可选的，可以省略。如果省略表达式，则相当于 switch true，这种情况下会将每一个 case 的表达式的求值结果与 true 做比较，如果相等，则执行相应的代码。

• fallthrough

在 Go 中执行完一个 case 之后会立即退出 switch 语句。fallthrough语句用于标明执行完当前 case 语句之后按顺序执行下一个case 语句。

让我们写一个程序来了解 fallthrough。下面的程序检测 number 是否小于 50，100 或 200。例如，如果我们输入75，程序将打印 75 小于 100 和 200，这是通过 fallthrough 语句实现的。

package main
import (
 "fmt"
)
func number() int {
 num := 15 * 5
 return num
}
 
func main() {
 
 switch num := number(); { //num is not a constant
 case num < 50:
  fmt.Printf("%d is lesser than 50n", num)
  fallthrough
 case num < 100:
  fmt.Printf("%d is lesser than 100n", num)
  fallthrough
 case num < 200:
  fmt.Printf("%d is lesser than 200", num)
 }
}

switch 与 case 中的表达式不必是常量，他们也可以在运行时被求值。在上面的程序中 num 初始化为函数 number() 的返回值。程序首先对 switch 中的表达式求值，然后依次对每一个case 中的表达式求值并与 true 做匹配。匹配到 case num < 100: 时结果是 true，因此程序打印：75 is lesser than 100，接着程序遇到 fallthrough 语句，因此继续执行下一个 case 中的语句，打印：75 is lesser than 200。最后的输出如下：

 75 is lesser than 100
 75 is lesser than 200

注意：fallthrough 必须是 case 语句块中的最后一条语句。如果它出现在语句块的中间，编译器将会报错：fallthrough statement out of place。