GO语言变量和常量、语言控制语句流程

1.算术运算符 （比较简单，可以跳过）

+  添加两个操作数 A+B

- 从第一个操作数中减去第二个操作数 A-B

/ 将分子除分母

% 模数运算符，整数除法的余数 B%A

++ 增加（递增）运算符，将整数值加一 A++

--  相减（递减）运算符，将整数值减一 A--

代码都懒得上了~~~~~~~

2.关系运算符（比较简单，可以跳过）

== 检查两个操作数的值是否相等，如果相等，则条件为真。（A==B）结果为假

!= 检查两个操作数的值是否相等，如果值不相等，则条件为真。（A!=B）结果为真

> 检查左操作数的值是否大于右操作数的值，如果是，则条件为真 (A>b） 结果为假

< 检查左操作数的值是否小于右操作数的值，如果是，则条件为真 (A<b） 结果为真

>= 检查左操作数的值是否大于右或等于操作数的值，如果是，则条件为真 (A>=b） 结果为假

 <= 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件为真 (A<=b） 结果为真

3.逻辑运算符（比较简单，可以跳过）

&&　逻辑与运算符。如果两个操作数都不为零，则条件为真。（Ａ＆＆Ｂ）结果为真

||　逻辑或运算符。如果两个操作数中任何一个非零，则条件为真。（Ａ || Ｂ）结果为真

！ 逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为真，则逻辑非运算符将为假。!(A && B)结果为真

4. 按拉运算符

& 按位与：都为1则结果为1  ==对应位数上都为1，结果为1

| 按位或：有一个为1 结果为1 ==对应位数上有一个为1，结果为1

^ 按位异或：对应位不同数值时结果为1 ==对应位数上数值不同，结果为1

<< 左移：把数整体向左移动 ==整体向左移动1位，相当与数字中数值*2，空出以0表达

>> 右移：把数整体向右移动 ==整体向右移动1位，相当与数字中数值/2，空出以0表达

byteTest.go

//程序所属包 *必须
package main

//导入依赖包

import (
   "fmt"
)


//main函数
func main(){

   a := byte(0)
   b := byte(1)
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(a&b) //对应位数上都为1，结果为1 因为a为0，所以结果即为0
   fmt.Println(a|b) //对应位数上有一个为1，结果为1 因为b为a，所以结果即为1
   fmt.Println(a^b) //对应位数上数值不同，结果为1 因为ab值不同，所以结果即为1
   fmt.Println(a^a) //对应位数上数值不同，结果为1 因为两个值相同，所以结果即为0
   fmt.Println(b<<1) //1*2
   fmt.Println(b<<3) //1*2*2*2
   fmt.Println(b>>1) //1/2
}

5.赋值运算符

= 表达式的值赋给一个左值    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<<=A 等于 C=C<<A

>>= 右移后再赋值 C>>=A 等于 C=C>>A

&= 按位与后再赋值 C&=A 等于 C=C&A

^= 按位异后再赋值 C^=A 等于 C=C^A

|= 按位或后再赋值 C|=A 等于 C=C|A

 

6.控制语句

条件语句if ,if else ,嵌套if,else if

选择语句switch,select

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。。

switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break

package main

import "fmt"

func main() {
   var x interface{} //设置A什么类型都可以
     
   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("未知型")     
   }   
}

循环语句 for 目前只有一个for

//程序所属包 *必须
package main

//导入依赖包

import (
   "fmt"
   "time"
)


//main函数
func main(){
   //无限循环
   //for{
   // fmt.Println("333");
   // time.Sleep(1*time.Second)
   //}
   for i:=1; i<10; i++ {
      if i<3{
            fmt.Println("333");
            time.Sleep(1*time.Second)
      }
   }
   //foreach效果
   a :=[]string{"a", "b", "c"}
   for key,value:= range a{
      fmt.Println(key)
      fmt.Println(value)
   }

   //不用key,_垃圾桶
   for _,value:= range a{
      fmt.Println(value)
   }
}

控制语句中使用到的关键字goto,break,continue

goto 直接跳过到指定代码块

break 是直接跳出当前循环体，如果是嵌套循环是只能跳出当前的

continue 跳出当次循环

//程序所属包 *必须

package main

//导入依赖包

import (
   "fmt"

   "time"
)


//main函数
func main(){
   goto One //直接运行1234,跳出下面的-----
   fmt.Println("--------")
One :
   fmt.Println("1234")

   for i:=1; i<6; i++ {
      fmt.Println(i)
      for j:=1; j<3; j++ {
         fmt.Println(j)
         time.Sleep(1 * time.Second)
         break //只能跳出当前J的循环体
      }

   }

   for i:=1; i<6; i++ {
      if i<3 {
         fmt.Println("当前")
         fmt.Println(i)
         continue //当次循环后面不再运行
      }
      fmt.Println(i)

   }
}

结果：

1234
1
1
2
1
3
1
4
1
5
1
当前
1
当前
2
3
4
5