Go 语言编程 — 运算符

目录

运算符

Golang 内置的运算符包括：

• 赋值运算符
• 算术运算符
• 逻辑运算符
• 关系运算符
• 位运算符
• 其他运算符

赋值运算符

算术运算符

注意：Golang 的自增，自减只能作为表达式使用，而不能用于赋值语句，例如：

a++    // 这是允许的，等同于 a = a + 1
a--
a = a++ // 这是不允许的，会出现变异错误 syntax error: unexpected ++ at end of statement

逻辑运算符

关系运算符

位运算符

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

示例：

package main

import "fmt"

func main() {

   var a uint = 60      /* 60 = 0011 1100 */  
   var b uint = 13      /* 13 = 0000 1101 */
   var c uint = 0          

   c = a & b       /* 12 = 0000 1100 */
   fmt.Printf("第一行 - c 的值为 %d\n", c )

   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("第二行 - c 的值为 %d\n", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("第三行 - c 的值为 %d\n", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("第四行 - c 的值为 %d\n", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("第五行 - c 的值为 %d\n", c )
}

指针运算符、取值运算符和取址运算符

“*” 与数据类型预留标识符结合使用时，表示一个指针变量；其余则表示一个取值运算符，取出指针指向的内存数据值。

示例：

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int     // 定义一个整型指针变量 ptr

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a);
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b);
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c);

   /*  & 和 * 运算符实例 */
   ptr = &a     // 'ptr' 包含了 'a' 变量的地址
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("ptr 为 %d\n", ptr);      // 取的整型指针变量 ptr 的地址值
   fmt.Printf("*ptr 为 %d\n", *ptr);    // 取的整型指针变量 ptr 指向的数据值
}

结果：

第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
ptr 为 824634458120
*ptr 为 4

运算符优先级

表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低。

其中，二元运算符的运算方向均是从左至右：

package main

import "fmt"

func main() {
   var a int = 20
   var b int = 10
   var c int = 15
   var d int = 5
   var e int

   e = (a + b) * c / d      // ( 30 * 15 ) / 5
   fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e)

   e = ((a + b) * c) / d    // (30 * 15 ) / 5
   fmt.Printf("((a + b) * c) / d 的值为  : %d\n" ,  e)

   e = (a + b) * (c / d)   // (30) * (15/5)
   fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e)

   e = a + (b * c) / d     //  20 + (150/5)
   fmt.Printf("a + (b * c) / d 的值为  : %d\n" ,  e)

… 语法糖

… 是 Golang 的一种语法糖：

1. 用于函数的变长形参列表。
2. 用于打散 Slice 类型变量的元素，类似于 Python 中的 List.extend（散列合并两个列表）。

示例 1：

// 传入一个可变长的形参列表，args 实际上是 Slice 类型的。
func test(args ...string) {
    for _, v:= range args{
        fmt.Println(v)
    }
}

示例 2：

var strss1= []string{
    "qwr",
    "234",
    "yui",
}

var strss2= []string{
    "qqq",
    "aaa",
    "zzz",
    "zzz",
}

strss=append(strss1, strss2...) // strss2 的元素会被打散，并一个个的 append 到 strss1
fmt.Println(strss1)

结果：

[qwr 234 yui qqq aaa zzz zzz]