GO语言结构、变量和常量

第三章 GO语言结构

结构

• package main // 声明一个 main 包
  
  import "fmt" // 导入 fmt 包，打印字符串使用
  
  func main() { // 声明 main 主函数
    fmt.Println("Hello World!") // 打印 Hello World!
  }
  
  // 单行注释
  
  /*
  多行注释/块注释
  */

执行

• 在终端中执行go run hello.go 即可运行代码
• 或者执行go build ，则会生成一个可执行的二进制代码文件（.exe文件），这是编译后的文件，执行 ./编译后的文件即可

备注

• go语言的花括号不能单独放在一行，必须放在一个函数或者其他语句后面，否则会有编译错误
• 一行代码表示一句，不需要末尾加分号
• fmt.Println()不能放在函数体外面
• 函数体外可以声明变量，但不能作赋值操作
• 如果函数体中作了赋值却没有用到，也会出现编译错误

格式化

• go文件中缩进使用tab或者空格或者混用都行，只要在终端中输入go fmt hello.go即可自动帮你格式化
  • 一般保存时软件会自动执行格式化语句，不需每次都执行

第四章 Go语言之变量和常量

变量

变量的声明

• 标准格式声明

  • var 变量名 变量类型
    
    //如：
    var name string
    var age int
    var isOk bool

• 批量声明

  • var (
        a string
        b int
        c bool
    )

变量的初始化

• 标准格式

  • var 变量名 类型 = 表达式
    
    // 如：
    var name string = "Hello"
    var age int = 18
    
    // 一次初始化多个变量
    var name,age = "Hello",18

• 类型推导

  • 解释器根据我们的赋值自动推导出变量的类型

  • var name = "Q1mi"
    var age = 18

• 短变量声明

  • 在函数体内部使用:=声明局部变量并初始化（只能用在函数体内）

  • package main
    
    import (
        "fmt"
    )
    // 全局变量m
    var m = 100
    
    func main() {
        n := 10
        m := 200 // 此处声明局部变量m
        fmt.Println(m, n)
    }

• 匿名变量

  • 使用 _ 来声明一个匿名变量

  • func main() {
        x, _ := foo()
        _, y := foo()
        fmt.Println("x=", x)
        fmt.Println("y=", y)
    }
    
    // _ 接收其他不需要的返回值

  • 匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

常量

常量的声明

• 标准声明

  • const pi = 3.1415
    const e = 2.7182

• 批量声明

  • const (
        pi = 3.1415
        e = 2.7182
    )

  • const同时声明多个常量时，如果省略了值则表示和上面一行的值相同

    • const (
         n1 = 100
         n2
         n3 = 200
         n4
      )
      
      >>>
      100 100 200 200

iota

• iota是go语言的常量计数器，只能在常量的表达式中使用

• iota在const关键字出现时将被重置为0；const中每新增一行(不是每声明一个变量)常量声明将使iota计数一次

  • const (
            n1 = iota   //0
            n2          //1
            n3          //2
            n4          //3
        )

• 使用_跳过某些值

  • const (
            n1 = iota //0
            n2        //1
            _
            n4        //3
        )

• iota声明中间插队

  • const (
            n1 = iota //0
            n2 = 100  //100
            n3 = iota //2
            n4        //3
        )
        const n5 = iota //0

• 定义数量级

  • const (
            _  = iota
            KB = 1 << (10 * iota)  // 1 << 10
            MB = 1 << (10 * iota)  // 1 << 20
            GB = 1 << (10 * iota)  // 1 << 30
            TB = 1 << (10 * iota)  // 1 << 40
            PB = 1 << (10 * iota)  // 1 << 50
        )

  • <<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024

• 多个iota定义在一行

  • const (
            a, b = iota + 1, iota + 2 //1,2
            c, d                      //2,3
            e, f                      //3,4
        )
    
    // 相当于
    const (
            a, b = iota + 1, iota + 2  //1,2
            c, d = iota + 1, iota + 2  //2,3
            e, f = iota + 1, iota + 2  //3,4
        )

GO语言结构、变量和常量

原文：https://www.cnblogs.com/zlx960303/p/12455437.html