Go 语言运算符+条件语句

 
 
Go 语言运算符
运算符用于在程序运行时执行数学或逻辑运算。
Go 语言内置的运算符有：
  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符
  • 其他运算符
接下来让我们来详细看看各个运算符的介绍。
 
算术运算符
下表列出了所有Go语言的算术运算符。假定 A 值为 10，B 值为 20。
运算符
描述
实例
+
相加
A + B 输出结果 30
-
相减
A - B 输出结果 -10
*
相乘
A * B 输出结果 200
/
相除
B / A 输出结果 2
%
求余
B % A 输出结果 0
++
自增
A++ 输出结果 11
--
自减
A-- 输出结果 9
以下实例演示了各个算术运算符的用法：
实例
package main
 
import "fmt"
 
func main() {
 
   var a int = 21
   var b int = 10
   var c int
 
   c = a + b
   fmt.Printf("第一行 - c 的值为 %d\n", c )
   c = a - b
   fmt.Printf("第二行 - c 的值为 %d\n", c )
   c = a * b
   fmt.Printf("第三行 - c 的值为 %d\n", c )
   c = a / b
   fmt.Printf("第四行 - c 的值为 %d\n", c )
   c = a % b
   fmt.Printf("第五行 - c 的值为 %d\n", c )
   a++
   fmt.Printf("第六行 - a 的值为 %d\n", a )
   a=21   // 为了方便测试，a 这里重新赋值为 21
   a--
   fmt.Printf("第七行 - a 的值为 %d\n", a )
}
以上实例运行结果：
第一行 - c 的值为 31 第二行 - c 的值为 11 第三行 - c 的值为 210 第四行 - c 的值为 2 第五行 - c 的值为 1 第六行 - a 的值为 22 第七行 - a 的值为 20
 
关系运算符
下表列出了所有Go语言的关系运算符。假定 A 值为 10，B 值为 20。
运算符
描述
实例
==
检查两个值是否相等，如果相等返回 True 否则返回 False。
(A == B) 为 False
!=
检查两个值是否不相等，如果不相等返回 True 否则返回 False。
(A != B) 为 True
>
检查左边值是否大于右边值，如果是返回 True 否则返回 False。
(A > B) 为 False
<
检查左边值是否小于右边值，如果是返回 True 否则返回 False。
(A < B) 为 True
>=
检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
(A >= B) 为 False
<=
检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。
(A <= B) 为 True
以下实例演示了关系运算符的用法：
实例
package main
 
import "fmt"
 
func main() {
   var a int = 21
   var b int = 10
 
   if( a == b ) {
      fmt.Printf("第一行 - a 等于 b\n" )
   } else {
      fmt.Printf("第一行 - a 不等于 b\n" )
   }
   if ( a < b ) {
      fmt.Printf("第二行 - a 小于 b\n" )
   } else {
      fmt.Printf("第二行 - a 不小于 b\n" )
   }
   
   if ( a > b ) {
      fmt.Printf("第三行 - a 大于 b\n" )
   } else {
      fmt.Printf("第三行 - a 不大于 b\n" )
   }
   /* Lets change value of a and b */
   a = 5
   b = 20
   if ( a <= b ) {
      fmt.Printf("第四行 - a 小于等于 b\n" )
   }
   if ( b >= a ) {
      fmt.Printf("第五行 - b 大于等于 a\n" )
   }
}
以上实例运行结果：
第一行 - a 不等于 b 第二行 - a 不小于 b 第三行 - a 大于 b 第四行 - a 小于等于 b 第五行 - b 大于等于 a
 
逻辑运算符
下表列出了所有Go语言的逻辑运算符。假定 A 值为 True，B 值为 False。
运算符
描述
实例
&&
逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。
(A && B) 为 False
||
逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。
(A || B) 为 True
!
逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。
!(A && B) 为 True
以下实例演示了逻辑运算符的用法：
实例
package main
 
import "fmt"
 
func main() {
   var a bool = true
   var b bool = false
   if ( a && b ) {
      fmt.Printf("第一行 - 条件为 true\n" )
   }
   if ( a || b ) {
      fmt.Printf("第二行 - 条件为 true\n" )
   }
   /* 修改 a 和 b 的值 */
   a = false
   b = true
   if ( a && b ) {
      fmt.Printf("第三行 - 条件为 true\n" )
   } else {
      fmt.Printf("第三行 - 条件为 false\n" )
   }
   if ( !(a && b) ) {
      fmt.Printf("第四行 - 条件为 true\n" )
   }
}
以上实例运行结果：
第二行 - 条件为 true 第三行 - 条件为 false 第四行 - 条件为 true
 
位运算符
位运算符对整数在内存中的二进制位进行操作。
下表列出了位运算符 &, |, 和 ^ 的计算：
p
q
p & q
p | q
p ^ q
0
0
0
0
0
0
1
0
1
1
1
1
1
1
0
1
0
0
1
1
假定 A = 60; B = 13; 其二进制数转换为：
A = 0011 1100 B = 0000 1101 ----------------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001
Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：
运算符
描述
实例
&
按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。上下：1相同取1，0相同取0，不同的都为0
(A & B) 结果为 12, 二进制为 0000 1100
|
按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或 看见1就取1，其他都为0
(A | B) 结果为 61, 二进制为 0011 1101
^
按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 不同的为1，相同为0
(A ^ B) 结果为 49, 二进制为 0011 0001
<<
左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
A << 2 结果为 240 ，二进制为 1111 0000
>>
右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。
A >> 2 结果为 15 ，二进制为 0000 1111
以下实例演示了位运算符的用法：
实例
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 */ 上下：1相同取1，0相同取0，不同的都为0
   fmt.Printf("第一行 - c 的值为 %d\n", c )
 
   c = a | b       /* 61 = 0011 1101 */ 看见1就取1，其他都为0
   fmt.Printf("第二行 - c 的值为 %d\n", c )
 
   c = a ^ b       /* 49 = 0011 0001 */ 不同的为1，相同为0
   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 )
}
以上实例运行结果：
第一行 - c 的值为 12 第二行 - c 的值为 61 第三行 - c 的值为 49 第四行 - c 的值为 240 第五行 - c 的值为 15
 
赋值运算符
下表列出了所有Go语言的赋值运算符。
运算符
描述
实例
=
简单的赋值运算符，将一个表达式的值赋给一个左值
C = A + B 将 A + B 表达式结果赋值给 C
+=
相加后再赋值
C += A 等于 C = C + A
-=
相减后再赋值
C -= A 等于 C = C - A
*=
相乘后再赋值
C *= A 等于 C = C * A
/=
相除后再赋值
C /= A 等于 C = C / A
%=
求余后再赋值
C %= A 等于 C = C % A
<<=
左移后赋值
C <<= 2 等于 C = C << 2
>>=
右移后赋值
C >>= 2 等于 C = C >> 2
&=
按位与后赋值
C &= 2 等于 C = C & 2
^=
按位异或后赋值
C ^= 2 等于 C = C ^ 2
|=
按位或后赋值
C |= 2 等于 C = C | 2
以下实例演示了赋值运算符的用法：
实例
package main
 
import "fmt"
 
func main() {
   var a int = 21
   var c int
 
   c =  a
   fmt.Printf("第 1 行 - =  运算符实例，c 值为 = %d\n", c )
 
   c +=  a
   fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c )
 
   c -=  a
   fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c )
 
   c *=  a
   fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c )
 
   c /=  a
   fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c )
 
   c  = 200;
 
   c <<=  2
   fmt.Printf("第 6行  - <<= 运算符实例，c 值为 = %d\n", c )
 
   c >>=  2
   fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c )
 
   c &=  2
   fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c )
 
   c ^=  2
   fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c )
 
   c |=  2
   fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c )
 
}
以上实例运行结果：
第 1 行 - = 运算符实例，c 值为 = 21 第 2 行 - += 运算符实例，c 值为 = 42 第 3 行 - -= 运算符实例，c 值为 = 21 第 4 行 - *= 运算符实例，c 值为 = 441 第 5 行 - /= 运算符实例，c 值为 = 21 第 6行 - <<= 运算符实例，c 值为 = 800 第 7 行 - >>= 运算符实例，c 值为 = 200 第 8 行 - &= 运算符实例，c 值为 = 0 第 9 行 - ^= 运算符实例，c 值为 = 2 第 10 行 - |= 运算符实例，c 值为 = 2
 
其他运算符
下表列出了Go语言的其他运算符。
运算符
描述
实例
&
返回变量存储地址
&a; 将给出变量的实际地址。
*
指针变量。
*a; 是一个指针变量
以下实例演示了其他运算符的用法：
实例
package main
 
import "fmt"
 
func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int
 
   /* 运算符实例 */
   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);
}
以上实例运行结果：
第 1 行 - a 变量类型为 = int 第 2 行 - b 变量类型为 = int32 第 3 行 - c 变量类型为 = float32 a 的值为 4 *ptr 为 4
 
运算符优先级
有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：
优先级
运算符
5
* / % << >> & &^
4
+ - | ^
3
== != < <= > >=
2
&&
1
||
当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。
以上实例运行结果：
实例
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 );  
}
以上实例运行结果：
(a + b) * c / d 的值为 : 90 ((a + b) * c) / d 的值为 : 90 (a + b) * (c / d) 的值为 : 90 a + (b * c) / d 的值为 : 50
 
Go 语言条件语句
条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。
Go 语言提供了以下几种条件判断语句：
语句
描述
if 语句
if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
if...else 语句
if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
if 嵌套语句
你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句
switch 语句用于基于不同条件执行不同动作。
select 语句
select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。
Go语言if语句
if 语句由布尔表达式后紧跟一个或多个语句组成。
语法
Go 编程语言中 if 语句的语法如下：
if 布尔表达式 { /* 在布尔表达式为 true 时执行 */ }
If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则不执行。
实例
使用 if 判断一个数变量的大小：
实例
package main
 
import "fmt"
 
func main() {
   /* 定义局部变量 */
   var a int = 10
 
   /* 使用 if 语句判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" )
   }
   fmt.Printf("a 的值为 : %d\n", a)
}
以上代码执行结果为：
a 小于 20 a 的值为 : 10
 
Go 语言 if...else 语句
if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
语法
Go 编程语言中 if...else 语句的语法如下：
if 布尔表达式 { /* 在布尔表达式为 true 时执行 */ } else { /* 在布尔表达式为 false 时执行 */ }
If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则执行 else 语句块。
实例
使用 if else 判断一个数的大小：
实例
package main
 
import "fmt"
 
func main() {
   /* 局部变量定义 */
   var a int = 100;
 
   /* 判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" );
   } else {
       /* 如果条件为 false 则执行以下语句 */
       fmt.Printf("a 不小于 20\n" );
   }
   fmt.Printf("a 的值为 : %d\n", a);
 
}
以上代码执行结果为：
a 不小于 20 a 的值为 : 100
 
Go 语言 if 语句嵌套
你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
语法
Go 编程语言中 if...else 语句的语法如下：
if 布尔表达式 1 { /* 在布尔表达式 1 为 true 时执行 */ if 布尔表达式 2 { /* 在布尔表达式 2 为 true 时执行 */ } }
你可以以同样的方式在 if 语句中嵌套 else if...else 语句
实例
嵌套使用 if 语句：
实例
package main
 
import "fmt"
 
func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int = 200
 
   /* 判断条件 */
   if a == 100 {
       /* if 条件语句为 true 执行 */
       if b == 200 {
          /* if 条件语句为 true 执行 */
          fmt.Printf("a 的值为 100 ， b 的值为 200\n" );
       }
   }
   fmt.Printf("a 值为 : %d\n", a );
   fmt.Printf("b 值为 : %d\n", b );
}
以上代码执行结果为：
a 的值为 100 ， b 的值为 200 a 值为 : 100 b 值为 : 200
 
Go 语言 switch 语句
switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。
switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。
switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。
语法
Go 编程语言中 switch 语句的语法如下：
switch var1 { case val1: ... case val2: ... default: ... }
变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。
流程图：
实例
package main
 
import "fmt"
 
func main() {
   /* 定义局部变量 */
   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("你的等级是 %s\n", grade );      
}
以上代码执行结果为：
优秀! 你的等级是 A
 
Type Switch
switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。
Type Switch 语法格式如下：
switch x.(type){ case type: statement(s); case type: statement(s); /* 你可以定义任意个数的case */ default: /* 可选 */ statement(s); }
实例
package main
 
import "fmt"
 
func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:  
         fmt.Printf(" x 的类型 :%T",i)                
      case int:  
         fmt.Printf("x 是 int 型")                      
      case float64:
         fmt.Printf("x 是 float64 型")          
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )      
      default:
         fmt.Printf("未知型")    
   }  
}
以上代码执行结果为：
x 的类型 :<nil>
fallthrough
使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。
实例
package main
 
import "fmt"
 
func main() {
 
    switch {
    case false:
            fmt.Println("1、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("2、case 条件语句为 true")
            fallthrough
    case false:
            fmt.Println("3、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("4、case 条件语句为 true")
    case false:
            fmt.Println("5、case 条件语句为 false")
            fallthrough
    default:
            fmt.Println("6、默认 case")
    }
}
以上代码执行结果为：
2、case 条件语句为 true 3、case 条件语句为 false 4、case 条件语句为 true
从以上代码输出的结果可以看出：switch 从第一个判断表达式为 true 的 case 开始执行，如果 case 带有 fallthrough，程序会继续执行下一条 case，且它不会去判断下一个 case 的表达式是否为 true。
 
Go 语言 select 语句
select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。
select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。
语法
Go 编程语言中 select 语句的语法如下：
select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}
以下描述了 select 语句的语法：
  • 每个 case 都必须是一个通信
  • 所有 channel 表达式都会被求值
  • 所有被发送的表达式都会被求值
  • 如果任意某个通信可以进行，它就执行，其他被忽略。
  • 如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。
否则：
    1. 如果有 default 子句，则执行该语句。
    2. 如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。
实例
select 语句应用演示：
实例
package main
 
import "fmt"
 
func main() {
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
      case i1 = <-c1:
         fmt.Printf("received ", i1, " from c1\n")
      case c2 <- i2:
         fmt.Printf("sent ", i2, " to c2\n")
      case i3, ok := (<-c3):  // same as: i3, ok := <-c3
         if ok {
            fmt.Printf("received ", i3, " from c3\n")
         } else {
            fmt.Printf("c3 is closed\n")
         }
      default:
         fmt.Printf("no communication\n")
   }    
}
以上代码执行结果为：
no communication
 
//校内举办跑步比赛，10s内进去比赛，分性别，进入男子组，女子组
package main
 
import "fmt"
 
//if语句嵌套
//校内举办跑步比赛，10s内进去比赛，分性别，进入男子组，女子组
func main() {
    var (
        a = 9
        b = "男"
    )
    if a < 10 && b == "男" {
        fmt.Println("进去决赛")
        fmt.Println("进入男子")
    }
    if a < 10 && b == "女" {
        fmt.Println("进去决赛")
        fmt.Println("进入女子组")
    }
    if a > 10 {
        fmt.Println("滚")
    }
 
    /*
        if a < 10 {
            fmt.Println("进去决赛")
 
            if b == "男" {
                fmt.Println("进入男子")
            } else {
                fmt.Println("进入女子")
            }
        } else {
            fmt.Println("滚")
        }*/
}
 
//switch语句，对学生成绩进行考评，90-100：优秀，80-89：良好，60-79及格，60以下，不及格
package main
 
import "fmt"
 
func main() {
 
    var vaule = 1
 
    switch vaule {
    case 1:
        fmt.Println("1")
 
    case 2:
        fmt.Println("2")
 
    case 3:
        fmt.Println("3")
    default:
        fmt.Println("滚犊子")
    }
 
    /*
        var a = 77
        //等效于if else 语句
        switch {
        case a >= 90 && a <= 100:
            fmt.Println("好")
        case a >= 80 && a <= 89:
            fmt.Println("还行")
        case a >= 60 && a <= 79:
            fmt.Println("合格")
        default:
            fmt.Println("不合格")
        }*/
}
 
 
 
 


posted @   十一没有撤退可言！  阅读(158)  评论(0)  编辑  收藏  举报
相关博文：
·  Go 语言结构+基础语法+数据类型+变量（银河、极光，这些美好的事物你可以欣赏，却不能拥有。原来两个人坐在一起，也能走散。）
·  Go 语言循环语句
·  GO 条件语句
·  go语言条件语句
·  Go 语言条件语句
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· 写一个简单的SQL生成工具
· AI 智能体引爆开源社区「GitHub 热点速览」
· C#/.NET/.NET Core技术前沿周刊 | 第 29 期（2025年3.1-3.9）
点击右上角即可分享
微信分享提示