golang初识 和 变量，常量，iota

目录

• 一、go语言与python
  • 1. go语言
  • 2. python
• 二、变量相关
  • 1. go语言的基本语法
  • 2. 标识符和关键字
  • 3. 变量声明
    • （1）声明变量时未指定初始值
    • （2）声明变量时指定初始值
    • （3）声明变量时不指定类型
    • （4）短变量声明
    • （5）匿名变量
    • （6）注意小结
• 三、常量
• 四、iota

一、go语言与python

1. go语言

1. go语言语法固定，没有那么多花里胡哨的写法，语法也简单。一共25个关键字

2. 本身支持高并发，数据计算，做后端天然有优势。（云计算，区块链，网络服务行业，新兴的公司基本都用go语言）

2. python

1. 开发效率高，所以周期短
2. 爬虫加数据分析
3. 人工智能

二、变量相关

1. go语言的基本语法

• package 后面跟的是包名，用来声明当前这个文件是属于哪个包。，如果是属于main包，则在执行这个文件后，会把该文件打包成一个.exe程序。

• import 包名 用来导入的包

• func main()是整个程序的入口，没有参数。

• 在函数外部只能放置标识符（即 变量，常量，函数，类型）的声明

2. 标识符和关键字

• 标识符就是python中的变量名， 由字母数字和_(下划线）组成，并且只能以字母和_开头 。

• 关键字就是有各种特定作用的名字。如python中的if def return等等。go语言里有25个关键字，并且还有37个保留字。我们不建议用关键字或保留字当做变量名即标识符。

3. 变量声明

• 类似前端JavaScript的变量声明方式

（1）声明变量时未指定初始值

格式1： var 变量名 变量类型

行尾无需分号

例如：
var name string
var age int
var isOk bool

格式2：批量声明
var (
    a string
    b int
    c bool
    d float32
)

• 已经声明的变量若未对其进行初始化，他们都会有一个默认值

  • 数字类型是0，字符串是空字符串， 布尔型变量默认为false。 切片、函数、指针变量的默认为nil

（2）声明变量时指定初始值

• 格式：
  var 变量名 类型 = 表达式
  
  例子：
  var name string = "Q1mi"
  var age int = 18
  
  一次初始化多个变量：
  var name, age = "Q1mi", 20
  

（3）声明变量时不指定类型

• 声明变量时不指定类型，则这个时候编译器会根据等号右边的值来推导变量的类型完成初始化

  var name = "Q1mi"
  var age = 18
  

（4）短变量声明

• 在函数内部，可以使用更简略的 := 方式声明并初始化变量

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

（5）匿名变量

• 类似python中的解压缩时，用_代替不需要的值。 匿名变量用一个下划线_表示

  func foo() (int, string) {
      return 10, "Q1mi"
  }
  func main() {
      x, _ := foo()
      _, y := foo()
      fmt.Println("x=", x)
      fmt.Println("y=", y)
  }
  

  • 匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。 (在Lua等编程语言里，匿名变量也被叫做哑元变量。

（6）注意小结

1. 函数外的每个语句都必须以关键字开始（var、const、func等）
2. :=不能使用在函数外。
3. _多用于占位，表示忽略值

三、常量

• 什么是常量

• 常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值

• 声明常量只是把var换成了const，**常量在定义的时候必须赋值 **

1.普通声明常量方式：
const pi = 3.1415
const e = 2.7182

2.批量声明不同值的常量方式：
const (
    pi = 3.1415
    e = 2.7182
)

3.批量声明同一值的常量：const同时声明多个常量时，如果省略了值则表示和上面一行的值相同
const (
    n1 = 100
    n2
    n3
)

四、iota

• 什么是iota

  • iota是go语言的常量计数器，只能在常量的表达式中使用
  • iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次
  • iota**可理解为const语句块中的行索引 **

• 5种实例：

  1. 普通例子
  const (
          n1 = iota //0
          n2        //1
          n3        //2
          n4        //3
      )
  
  
  2. 使用_跳过某些值
  const (
          n1 = iota //0
          n2        //1
          _
          n4        //3
      )
  
  
  3.iota声明中间插队
  const (
          n1 = iota //0
          n2 = 100  //1
          n3 = iota //2
          n4        //3
      )
      const n5 = iota //0
  
  
  4. 定义数量级
  // 这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8
  const (
          _  = iota 
          KB = 1 &lt;&lt; (10 * iota)
          MB = 1 &lt;&lt; (10 * iota)
          GB = 1 &lt;&lt; (10 * iota)
          TB = 1 &lt;&lt; (10 * iota)
          PB = 1 &lt;&lt; (10 * iota)
      )
  
  
  5. 多个iota定义在一行
  const (
          a, b = iota + 1, iota + 2 //1,2
          c, d                      //2,3
          e, f                      //3,4
      )