美文网首页
Go运算符、控制语句

Go运算符、控制语句

作者: 泥人冷风 | 来源:发表于2020-12-15 17:24 被阅读0次

    1 运算符

    假定 A 值为 10，B 值为 20。

    1.1 算数运算符

    运算符 描述 实例
    + 相加 A + B 输出结果 30
    - 相减 A - B 输出结果 -10
    * 相乘 A * B 输出结果 200
    / 相除 B / A 输出结果 2
    % 求余 B % A 输出结果 0
    ++ 自增 A++ 输出结果 11
    -- 自减 A-- 输出结果 9

    1.2 关系运算符

    运算符 描述
    == 检查两个值是否相等，如果相等返回 True 否则返回 False。
    != 检查两个值是否不相等，如果不相等返回 True 否则返回 False。
    > 检查左边值是否大于右边值，如果是返回 True 否则返回 False。
    < 检查左边值是否小于右边值，如果是返回 True 否则返回 False。
    >= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
    <= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

    1.3 逻辑运算符

    运算符 描述
    && 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。
    | | 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。
    ! 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。

    1.4 位运算符，假定 A 为60，B 为13

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

    1.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 <<= 2 等于 C = C << 2
    >>= 右移后赋值 C >>= 2 等于 C = C >> 2
    &= 按位与后赋值 C &= 2 等于 C = C & 2
    ^= 按位异或后赋值 C ^= 2 等于 C = C ^ 2
    = 按位或后赋值 C

    1.6 其他运算符

    运算符 描述 实例
    & 返回变量存储地址 &a; 将给出变量的实际地址。
    * 指针变量 *a; 是一个指针变量

    1.7 优先级

    优先级 运算符
    5 * / % << >> & &^
    4 + - | ^
    3 == != < <= > >=
    2 &&
    1 ||

    2 控制语句

    2.1 条件语句

    指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。

    2.1.1 if语句

    • if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
    • if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
    • if 或 else if 语句中可嵌入一个或多个 if 或 else if 语句。
    • 同各类主流语言，不多赘述。但注意，Go 没有三目运算符，所以不支持 ?: 形式的条件判断
    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

    2.1.2 switch语句

    • 用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。
    • 匹配项后面不需要再加 break。
    • switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。
    • fallthrough:强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true
    switch x.(type){
  case type:
    statement(s);
  case type:
    statement(s);
  default: // 可选
    statement(s);
}

    解释：从第一个判断表达式为 true 的 case 开始执行，如果 case 带有 fallthrough，程序会继续执行下一条 case，且它不会去判断下一个 case 的表达式是否为 true。

    1. 支持多条件匹配
    2. 不同的 case 之间不使用 break 分隔，默认只会执行一个 case
    3. 如果想要执行多个 case，需要使用 fallthrough 关键字，也可用 break 终止
    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>

    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

    2.1.3 select语句

    select {
  case communication clause  :
    statement(s);
  case communication clause  :
    statement(s);
  default : // 可选
    statement(s);
}
    • 每个 case 都必须是一个通信
    • 所有 channel 表达式都会被求值
    • 所有被发送的表达式都会被求值
    • 如果任意某个通信可以进行，它就执行，其他被忽略。
    • 如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。 否则：
      1. 如果有 default 子句，则执行该语句。
      2. 如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。
    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

    2.2 循环语句

    2.2.1 for循环

    for init; condition; post { } //for
for condition { } //while
for {}
init： 一般为赋值表达式，给控制变量赋初值；
condition： 关系表达式或逻辑表达式，循环控制条件；
post： 一般为赋值表达式，给控制变量增量或减量。

    package main

import "fmt"

func main() {
        sum := 0
        for i := 0; i <= 10; i++ {
                sum += i
        }
        fmt.Println(sum)
}

    执行结果

    55

    package main

import "fmt"

func main() {
        sum := 1
        for ; sum <= 10; {
                sum += sum
        }
        fmt.Println(sum)

        // 这样写也可以，更像 While 语句形式
        for sum <= 10{
                sum += sum
        }
        fmt.Println(sum)
}

    执行结果

    16
16

    for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环：

    for key, value := range oldMap {
  newMap[key] = value

    package main
import "fmt"

func main() {
        strings := []string{"google", "runoob"}
        for i, s := range strings {
                fmt.Println(i, s)
        }


        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

    0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

    2.2.2 循环嵌套

    循环套循环，格式：

    for [condition |  ( init; condition; increment ) | Range] {
 for [condition |  ( init; condition; increment ) | Range] {
   statement(s);
 }
 statement(s);
}

    package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var i, j int

   for i=2; i < 100; i++ {
      for j=2; j <= (i/j); j++ {
         if(i%j==0) {
            break; // 如果发现因子，则不是素数
         }
      }
      if(j > (i/j)) {
         fmt.Printf("%d  是素数\n", i);
      }
   }  
}

    执行结果

    2  是素数
3  是素数
5  是素数
7  是素数
11  是素数
13  是素数
17  是素数
19  是素数
23  是素数
29  是素数
31  是素数
37  是素数
41  是素数
43  是素数
47  是素数
53  是素数
59  是素数
61  是素数
67  是素数
71  是素数
73  是素数
79  是素数
83  是素数
89  是素数
97  是素数

    2.2.3 循环控制语句

    1. break语句：
      • 用于循环语句中跳出循环，并开始执行循环之后的语句。
      • break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
      • 在多重循环中，可以用标号 label 标出想 break 的循环。
    package main

import "fmt"

func main() {

    // 不使用标记
    fmt.Println("---- break ----")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
                for i2 := 11; i2 <= 13; i2++ {
                        fmt.Printf("i2: %d\n", i2)
                        break
                }
        }

    // 使用标记
    fmt.Println("---- break label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                break re
            }
        }
}

    执行结果

    ---- break ----
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11
---- break label ----
i: 1
i2: 11
    1. continue语句：跳过当前循环的剩余语句，然后继续进行下一轮循环。
    package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* for 循环 */
   for a < 20 {
      if a == 15 {
         /* 跳过此次循环 */
         a = a + 1;
         continue;
      }
      fmt.Printf("a 的值为 : %d\n", a);
      a++;    
   }  
}

    执行结果

    a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19
    1. goto：无条件转移到过程中指定行，与条件语句配合，实现条件转移、构成循环、跳出循环体等（不建议用，造成混乱）
    package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* 循环 */
   LOOP: for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++    
   }  
}

    执行结果

    a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19

    相关文章

      网友评论

          本文标题：Go运算符、控制语句

          本文链接：https://www.haomeiwen.com/subject/hgqwgktx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Go运算符、控制语句|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！