Go 运算符与表达式

Go 运算符与表达式

上一篇：Go 基本数据类型
下一篇: Go 控制结构

文章目录

• Go 运算符与表达式
• 前言
• 一 运算符
• 二 算术运算符
• • 2.1 算术运算符案例
• 三 赋值运算符
• 四 比较运算符
• 五 逻辑运算符
• 六 位运算符
• 七 表达式与表达式求值
• 总结

前言

在上一篇，我们介绍了 Go 提供的基本类型。本节我们学习 运算符

一 运算符

运算符用于对变量和值执行操作。例如，+ 运算符将两个值相加，如下例所示

package main

import "fmt"

func main() {

	var a = 15 + 25
	fmt.Println(a)
}

虽然 + 操作符通常用于将两个值相加，但它 也可以用于将一个变量和一个值相加，或者 将一个变量和另一个变量相加

package main

import "fmt"

func main() {
	var (
		sum1 = 100 + 50    // 150 (100 + 50)  值 + 值
		sum2 = sum1 + 250  // 400 (150 + 250) 变量 + 值
		sum3 = sum2 + sum2 // 800 (400 + 400) 变量 + 变量
	)
	fmt.Println(sum1, sum2, sum3)
}

二 算术运算符

算术运算符用于 执行常见的数学运算

package main

/* 算术运算：执行常规算术运算符 */

import "fmt"

func main() {
	a := 10                          // int
	b := 3                           // int
	quotient := a / b                // quotient = 3 int
	remainder := a % b               // 返回的是 a / b 的余数 int
	fmt.Println(quotient, remainder) // 3 1
}

两个整型变量 执行除法运算(/)，得到 结果为整型，即不超过真实值的最大整数，除数不能为 0，这个限制和 C 语言一致

两个浮点型变量 执行除法运算(/)，得到 结果为浮点型，即真实值，除数为 0 0 0 时，得到Inf

与 C 语言不同的时，++ 和 -- 在 Go 中不以运算符的形式出现，仅仅是单独的一条语句，且 只能出现在变量的后面

package main

/* 算术运算：执行常规算术运算符 */

import "fmt"

func main() {
	a := 10                          // int
	b := 3                           // int
	
	a++
	b--
	
	fmt.Println(a, b) // 11 2

	//--a // 错误的
	//++b  // 错误的
	// result = a++ // 错误的，++ 不是运算符，而是语句，没有返回值
}

在执行操作时，两个操作数必须具有相同的类型。在 C 语言中，C 编译器提供了隐士类型转换，使得我们可以对不同类型的数据直接执行操作。然而，Go 编译器并未提供隐式类型转换，当遇到两个不同类型的数据执行算术运算时，需要进行强制类型转换，通常，将类型尺寸较小的操作数转换为类型尺寸较大的类型

package main

/* 算术运算：执行常规算术运算符 */

import "fmt"

func main() {
	a := 10   			// int
	b := 3.14		 	// float64
	//result := a * b 	//  由于 a 和 b 的类型不同，因此需要将 int 类型转换为 float64 类型

	result := float64(a) * b
	fmt.Println(result)
}

2.1 算术运算符案例

案例1：计算 46 46 46 天的整数周数和剩余天数

package main

/* 算术运算：执行常规算术运算符 */

import "fmt"

func main() {
	fmt.Println(46/7, 46%7) // 6 4
}

案例2： 107653 107653 107653 秒是几天几小时几分几秒

package main  
  
/* 算术运算：执行常规算术运算符 */  
import "fmt"  
  
func main() {  
  
    total_seconds := 107653                // 总秒数  
    day := total_seconds / (24 * 60 * 60)  // 天数  
    hour := total_seconds / (60 * 60) % 24 // 小时  
    minute := total_seconds / 60 % 60      // 分钟  
    seconds := total_seconds % 60          // 秒  
    fmt.Printf("%v s is %v day %v hour %v m %v s\n", total_seconds, day, hour, minute, seconds)  
}

三 赋值运算符

赋值操作符用于为 变量赋值。我们已经在

在下面的例子中，我们使用 赋值运算符(=) 将值 10 10 10 赋值给一个名为 x 的变量

package main  
  
import "fmt"  
  
func main() {  
    var x int  
    x = 10  
    fmt.Println(x)  
}

有时候，当我们对两个变量操作时，需要将结果存放在其中一个变量中，通常采用

a := 10
b := 5
a = a + b

然而，这个操作会读取三次内存。Go 语言提供另一种赋值运算符来完成此操作

a := 10
b := 5
a += b

a += b 等价于 a = a + b，但是 a += b 只会读取两次内存，提高了一定的执行效率

下表列出了所有赋值运算符

变量的值只有在赋值时才会被影响。数据是在 CPU 中进行运算的，不会影响到内存中的值

四 比较运算符

比较运算符用于比较两个值

[!NOTE] 注意
注意:比较的返回值要么为 true ，要么为 false。

在下面的示例中，我们使用大于运算符 ( > ) 来确定 5 5 5 是否大于 3 3 3：

package main  
  
import "fmt"  
  
func main() {  
    var x = 5  
    var y = 3  
    fmt.Println(x > y) // true  
}

下表列出了所有比较运算符

[!NOTE] [[控制结构]] 中了解有关比较运算符以及如何使用它们的更多信息

五 逻辑运算符

用于布尔逻辑运算符。Go 提供下面三种逻辑运算符

• 逻辑非 ! 作用在 bool 类型返回值的表达式之上，对布尔值进行取反操作
• 逻辑或 ||: 短路运算符，只要遇到 true 就返回 true，后续表达式就不再求值
• 逻辑与 &&: 短路运算符，只要遇到 false 就返回 false，后续表达式就不再求值

六 位运算符

位运算符对 整数 在内存中的二进制位进行操作

package main

import "fmt"

func main() {
	// 位运算符, 作用在二进制位上的操作
	// 5: 101
	// 2: 010
	// & 按位与，同位1取1，有0则取0
	fmt.Printf("5 & 2: %b\n", 5&2)
	// | 按位或, 有1取1
	fmt.Printf("5 | 1: %b\n", 5|2)
	// ^ 异或，不同则取1，同则取0
	fmt.Printf("5 ^ 2: %b\n", 5^2)
	// << 左移指定位数: 左移n位就是乘以2的n次方。
	fmt.Printf("5 << 1: %b\n", 5<<1) // 1010
	// >> 右移指定位数: 右移n位就是除以2的n次方。
	fmt.Printf("5 >> 1: %b\n", 5>>1) // 10
	// ~ 按位取反 ~n = -(n+1)，Go 使用 ^ 替换了其他语言的 ~
	fmt.Printf("~5: %b\n", ^5) // ~5 = -(5 + 1)
}

七 表达式与表达式求值

表达式由运算符和操作数构成，表达式的值执行需要根据 运算符的优先级 和 结合性 进行求值。下表列出了所有运算符的优先级，数字越大优先级越高

• 其他的运算符将在后续内容给出

总结

本节介绍了常用的运算符。还有更多的运算符将在后续内容给出