iota

# iota 用法

package main
import "fmt"

func main() {
  const (
      a = iota  *//0*
      b      *//1*
      c      *//2*
      d = "ha"  *//独立值，iota += 1*
      e      *//"ha"  iota += 1*
      f = 100   *//iota +=1*
      g      *//100  iota +=1*
      h = iota  *//7,恢复计数*
      i      *//8*
  )
  fmt.Println(a,b,c,d,e,f,g,h,i)
}
// 0 1 2 ha ha 100 100 7 8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

iota 只是在同一个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始。
iota代表了const声明块的行索引（下标从0开始）
const 声明第一个常量必须指定一个表达式，后续的常量如果没有表达式，则继承上面的表达式。

# iota 和左右运算符

code-1

package main

import "fmt"
const (
  i=1<<iota
  j=3<<iota
  k
  l
)

func main() {
  fmt.Println("i=",i)
  fmt.Println("j=",j)
  fmt.Println("k=",k)
  fmt.Println("l=",l)
}

/*
i= 1
j= 6
k= 12
l= 24 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

const 声明第一个常量必须指定一个表达式，后续的常量如果没有表达式，则继承上面的表达式。

iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

简单表述:
- i=1：左移 0 位,不变仍为 1;
- j=3：左移 1 位,变为二进制 110, 即 6;
- k=3：左移 2 位,变为二进制 1100, 即 12;
- l=3：左移 3 位,变为二进制 11000,即 24;

注：<<n==*(2^n)。

// 左移运算符 << 是双目运算符。左移 n 位就是乘以 2 的 n 次方。 其功能把 << 左边的运算数的各二进位全部左移若干位，由 << 右边的数指定移动的位数，高位丢弃，低位补 0。

//右移运算符 >> 是双目运算符。右移 n 位就是除以 2 的 n 次方。 其功能是把 >> 左边的运算数的各二进位全部右移若干位， >> 右边的数指定移动的位数。

1
2
3

code-2

const (
    bit0, mask0 = 1 << iota, 1<<iota - 1   //const声明第0行，即iota==0
    bit1, mask1                            //const声明第1行，即iota==1, 表达式继承上面的语句
    _, _                                   //const声明第2行，即iota==2
    bit3, mask3                            //const声明第3行，即iota==3
)

1
2
3
4
5
6

第0行的表达式展开即bit0, mask0 = 1 << 0, 1<<0 - 1，所以bit0 == 1，mask0 == 0；
第1行没有指定表达式继承第一行，即bit1, mask1 = 1 << 1, 1<<1 - 1，所以bit1 == 2，mask1 == 1；
第2行没有定义常量
第3行没有指定表达式继承第一行，即bit3, mask3 = 1 << 3, 1<<3 - 1，所以bit0 == 8，mask0 == 7；

# iota 使用规则

iota代表了const声明块的行索引（下标从0开始）
iota 只是在同一个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始。
const 声明第一个常量必须指定一个表达式，后续的常量如果没有表达式，则继承上面的表达式。

#Go #

上次更新: 2023/04/16, 18:35:33

← string 实现原理 slice 实现原理→