zoukankan      html  css  js  c++  java
  • golang基础--控制语句

    go基础之控制语句

    补充知识

    • 指针

      • 与其他语言不同,在Go中不支持指针运算即->运算符,而直接采用.选择符来操作指针目标对象的成员。
    • 操作符&取变量的地址,使用*通过指针间间接访问目标对象

    • 默认值位nil,而非NULL

    • 实例代码如下

      //指针的使用
      package main
      import "fmt"
      func main() {
          a := 1          //定义一个变量,类型位int
          a++             //必须单独放一行
          var p *int = &a // 指针p指向a的内存地址
          fmt.Println(p)  //访问p
          fmt.Println(*p) //取p内存地址指向的值
      }
      

      运行结果

      	0xc04200e0b8   //内存地址
      	2			 //地址指向的值	
      

    判断if控制语句

    • 条件表达式没有括号

    • 支持一个初始化表达式(可以是并行的方式)

    • 左侧的大括号和条件语句或else在同一行

    • 支持当行模式

    • 初始化语句中的变量为block级别,同时颖仓外部同名变量
      eg1:

      //if语句:初始化语句a :1
      package main
      import (
          "fmt"
      )
      func main() {
          a := 10
          if a := 1; a > 0 { 	//此时a是局部变量,作用域只在if语句内
              fmt.Println(a)   
          }
          fmt.Println(a)
      }
      

    eg2:

    //if..else语句:同时判断两种情况
    package main
    import  "fmt"
    func main() {
        a := 10
        if a, b := 1, 2; a > 1 {
            fmt.Println(a)
        } else {
            fmt.Println(b)
        }
        fmt.Println(a)
    }
     /*output
    2
    10
    */
    

    for 循环语句

    • go只有for一个循环语句关键字,但支持3种形式

    • 初始化和进步表达式可以是多个值

    • 条件语句每次循环都会被重新检查,因此不建议在条件语句中使用函数,尽量提前计算好条件并以变量或常量代替

    • 左侧大括号必须和条件语句在同一行
      eg1: 無限循環

        // for语句:正常循环
        package main
      
        import (
            "fmt"
        )
      
        func main() {
            a := 1
            for {
                a++
                if a > 10 {
                    break
                }
                fmt.Println(a)
            }
            fmt.Println("over")
      
        }
      

      eg2:for 接条件表达式

         //for 条件表达式
      package main
      import (
         "fmt"
      )
      func main() {
         a := 1
         for a < 3 { //条件表达式
             a++
             fmt.Println(a)
         }
         fmt.Println("over")
      }
      

      eg3:最常见

      //for :步进表达式,最常见
      package main
      import (
          "fmt"
      )
      func main() {
          a := 1
          for i := 0; i < 3; i++ { //步进设置:当i<3时,控制a
              a++
              fmt.Println(a)
          }
          fmt.Println("over")
      }
      

    注意: for 循环中声明的变量在每次循环结束后都会消失,作用域只在当此循环中有效

    ```go
    package main
    import "fmt"
    
    func main() {
    for i := 0; i < 3; i++ {
    	a := 1
    	fmt.Println(&a) //输出a的内存地址
    }
    }
    /*输出
    0xc04204a080
    0xc04204a088
    0xc04204a0b0
    */
    ```
    

    选择语句switch

    • 可以使用任何类型或表达式作为条件语句

    • 不需要写break,一旦条件符合自动终止

    • 如希望继续执行下一个case,需要使用fallthrough关键词

    • 支持一个初始化表达式(可以时并行方式),右侧需跟分号

    • 左侧大括号必须和条件语句在同一行

    • eg1: 最经典用法

      /*
      检查a:
      如果a=0;输出a =0;
      如果a=1;输出a=1;
      ...
      如果条件都不满足:默认输出None
      */
      package main
      import (
          "fmt"
      )
      func main() {
          a := 1
          switch a {
          case 0:
              fmt.Println("a=0")
          case 1:
              fmt.Println("a=1")
          default:
              fmt.Println("None")
          }
      }
      
    • eg2:条件同时满足多个条件,使用关键词fallthrough

      /*
      同时满足多种情况,使用关键词fallthrough
      */
      package main
      import "fmt"
      func main() {
          a := 1
          switch {
          case a >= 0:
              fmt.Println("a=0")
              fallthrough //fallthrough用法,类似于elif
          case a >= 1:
              fmt.Println("a=1")
          default:
              fmt.Println("None")
          }
      }
      
    • eg3: swith后跟初始化语句

      /*
      swtich后面跟初始化语句
      ♥: 初始化语句中的变量作用域在switch语句中
      */
      package main
      import "fmt"
      func main() {
          switch a := 1; {
          case a >= 0:
              fmt.Println("a=0")
              fallthrough //fallthrough用法,类似于elif
          case a >= 1:
              fmt.Println("a=1")
          default:
              fmt.Println("None")
          }
      }
      

    跳转语句goto,break,continue

    • 三个语法都可以配合标签使用

    • 标签名区分大小写,若不使用会造成编译错误

    • Break与continue配合标签可用于多层循环的跳出

    • Goto是调整执行位置,与其它2个语句配合标签的结果并不相同

    • eg1:break语句

      //break跳转语句,可以跳转出多存循环
      package main
      import "fmt"
      
      func main() {
      LABEL1: //定义标签
         for { //这是一个无线循环
         	for i := 0; i < 10; i++ { //有限循环
             	print(i)  //循环四遍跳出循环
                 if i > 3 {
                     fmt.Println("OK")
                     break LABEL1 //直接跳出N层循环
                 }
             }
         }
         fmt.Println("OK")
      }
      
    • eg2: goto语句,调到某个循环,继续执行

      package main
      import  "fmt"
      
      func main() {
          for { 						    //这是一个无线循环
              for i := 0; i < 10; i++ {    //有限循环
                  if i > 3 {
                      goto LABEL1 	    //返回到LABEL1层继续执行
                  }
              }
          }
      LABEL1: //使用goto跳转的话,尽量将标签放goto语句之后
          fmt.Println("OK")
      }
      
    • eg3 : Continue语句,内部for每循环遇到Continue后,返回LABEL1

      // continue语句
      package main
      import "fmt"
      
      func main() {
      LABEL1:
         for i := 0; i < 10; i++ { //有限循环
             for { //无限循环
                 fmt.Println(i)
                 continue LABEL1     // 遇到LABEL1后,不会继续执行,而是跳到同级别
                 fmt.Println("here") //永远不会执行这项操作
             }
         }
         fmt.Println("OK")   //循环十次,最后执行
      }
      
  • 相关阅读:
    239. [LeetCode ]Sliding Window Maximum
    152.[LeetCode] Maximum Product Subarray
    53. [LeetCode] Maximum Subarray
    90 [LeetCode] Subsets2
    78[LeetCode] Subsets
    练习7.52
    练习7.47、7.48、7.49、7.51
    关于类类型的隐式类型转换
    练习7.44、7.45、7.46
    练习7.36、7.37、7.39、7.40
  • 原文地址:https://www.cnblogs.com/failymao/p/9271545.html
Copyright © 2011-2022 走看看