Skip to main content

运算

算术运算​

Go语言中不存在隐式类型转化，参与运算的变量类型必须要保持一致：

package main

func main() {
  a := 3.14
  b := 100
  // invalid operation: a + b (mismatched types float64 and int)
  res := a + b
  
  c := "abc"
  d := 1
  // invalid operation: c + d (mismatched types string and int)
  e := c + d
}

声明具体的类型是为了开启空间或类型推断时确定，而如下示例其运算是在运行时返回一个类型推断结果：

package main

import "fmt"

func main() {
  fmt.Println(100 + 3.14)
}

bool类型不能参与算术运算：

package main

func main() {
  a, b := true, false
  // invalid operation: operator + not defined on a (variable of type bool)
  res := a + b
}

字符串可通过加法运算符进行拼接，其它运算都无意义：

package main

func main() {
  a, b := "abc", "def"
  res := a + b
}

int类型之间进行除法运算，结果的小数部分可能丢失：

package main

import "fmt"

func main() {
  a, b := 1, 2  
  res := a / b
  fmt.Println(res) // 0
}

byte类型之间进行算术运算相当于uint8之间的运算：

package main

import "fmt"

func main() {
  var a byte = 'a'
  var b byte = 'b'
  res := a + b
  fmt.Println(res) // 195
}

Go语言中整数0不能作为除数，否则会产生运行时错误：

package main

import "fmt"

func main() {
  a, b := 1, 0
  // panic: runtime error: integer divide by zero
  fmt.Println(a / b)
}

浮点类型的0.0可以作为除数：

package main

import (
  "fmt"
  "math"
)

func main() {
  a, b := 1.0, 0.0
  c, d := 0.0, 0.0

  // +Inf 正无穷
  fmt.Println(a / b) 
  
  // NaN 非数 一个标识符
  fmt.Println(c / d) 

  // undefined: NaN
  // fmt.Println(NaN)  

  // NaN
  fmt.Println(math.NaN())

  // false
  fmt.Println(math.NaN() == math.NaN())
}
  1. 不合理的运算在Go语言中是不能进行的，如字符串减法、布尔值算术运算。
  2. 参与运算的变量类型不统一不能进行运算。
  3. byte、rune类型的运算按照原类型进行(unit8、int32)。
  4. 字符串之间的加法由字符串拼接进行。
  5. 数值类型不统一，需要用类型转换进行算术运算。
  6. 与字符串相加的其它类型需要将其它类型转换成字符串再拼接。

自加自减​

  1. Go语言中，++、--不是表达式，不能参与运算或赋值。
  2. ++、--是语句，只能单独出现。
  3. ++、--只能出现在变量后，不能出现在变量前。
package main

import "fmt"

func main() {
  a := 1

  // expected ';', found '++'
  // b := a++  

  a++

  // expected statement, found '++'
  // ++a

  b := a
  fmt.Println(b)
}

赋值运算​

赋值运算使用=作为赋值符号，与其它编程语言一样。

package main

import "fmt"

func main() {
  var x = 1
  var y int  

  y = x + 1
  y += x  
  
  fmt.Println(y)
}

关系运算​

所有关系运算都会返回bool值，true代表成立，false代表不成立。

Go语言中没有===、!==关系运算，且比较运算时类型必须相同。

  1. 大于 >
  2. 小于 <
  3. 相等 ==
  4. 大于等于 >=
  5. 小于等于 <=
  6. 不等于 !=
package main

import "fmt"

func main() {
  a := 1
  b := 2  

  fmt.Println(a > b) // false
  fmt.Println(a < b) // true
}

逻辑运算​

所有关系运算都会返回bool值，true代表成立，false代表不成立。

  1. 与运算 &&，两个同时为true时，返回true，其它返回fase
  2. 或运算 ||，有一个为true时则返回true，两个都为false时返回false
  3. 非运算 !
package main

import "fmt"

func main() {
  a := 1
  b := 2
  c := 3  

  fmt.Println(a >= 1 && b < 3) // true
  fmt.Println(a > 1 && c > 3)  // false
  fmt.Println(!(a == 1)) // false
}
Last updated on