后端实习の准备：小白从零学习Go语言第四天

---

往期链接

小白从零学习Go语言第二天

小白从零学习Go语言第三天

---

Day4

4.1 位运算符

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

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

• & 按位与运算符&是双目运算符。 其功能是参与运算的两数各对应的二进位相与。
• | 按位或运算符|是双目运算符。 其功能是参与运算的两数各对应的二进位相或。
• ^ 按位异或运算符^是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。
• << 左移运算符<<是双目运算符。左移n位就是乘以2的n次方。 其功能把<<左边的运算数的各二进位全部左移若干位，由<<右边的数指定移动的位数，高位丢弃，低位补0。
• >> 右移运算符>>是双目运算符。右移n位就是除以2的n次方。 其功能是把>>左边的运算数的各二进位全部右移若干位，>>右边的数指定移动的位数。

4.2 运算符优先级

• 下表列出了所有运算符以及它们的优先级，优先级值越大，表示优先级越高。

优先级	分类	运算符	结合性
1	逗号运算符	,	从左到右
2	赋值运算符	=、+=、-=、*=、/=、 %=、 >>=、 <<=、&=、^=、|=	从右到左
3	逻辑或	||	从左到右
4	逻辑与	&&	从左到右
5	按位或	|	从左到右
6	按位异或	^	从左到右
7	按位与	&	从左到右
8	相等/不等	==、!=	从左到右
9	关系运算符	<、<=、>、>=	从左到右
10	位移运算符	<<、>>	从左到右
11	加法/减法	+、-	从左到右
12	乘法/除法/取余	*（乘号）、/、%	从左到右
13	单目运算符	!、*（指针）、& 、++、--、+（正号）、-（负号）	从右到左
14	后缀运算符	( )、[ ]、->	从左到右

• 当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。

4.3 条件语句 if

• Go 编程语言中 if 语句的语法如下：

if 布尔表达式 {
     
   /* 在布尔表达式为 true 时执行 */
   ...
}else {
     
    /* 在布尔表达式为 false 时执行 */
}

• Go 的 if 还可以在条件判断语句里声明一个变量，这个变量的作用域只在该条件逻辑块内，其他地方不起作用，如下所示:

package main
  
import "fmt"
func main() {
     
    if num := 9; num < 0 {
     
        fmt.Println(num)
    } else if num < 10 {
     
        fmt.Println(num)
    } else {
     
        fmt.Println(num)
    }
}

• 需要注意的是，
  • （1） 不需使用括号将条件包含起来
  • （2） 大括号{}必须存在，即使只有一行语句
  • （3） 左括号必须在if或else的同一行
  • （4） 在if之后，条件语句之前，可以添加变量初始化语句，使用;进行分隔
  • （5） 在有返回值的函数中，最终的return不能在条件语句中

4.4 条件语句 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。
• 实例1:

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); 
    default: 
       statement(s);
}

• 实例2:

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 bool, string:
         fmt.Printf("x 是 bool 或 string 型" )      
      default:
         fmt.Printf("未知型")    
   }  
}

• fallthrough : 使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。
• 实例3:

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。

• 可用 break 终止switch 语句。