2-1. 变量

1 位-字节-字符-编码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

1、位：数据存储的最小单位。每个二进制数字0或者1就是1个位；

2、字节：8个位构成一个字节；即：1 byte (字节)= 8 bit(位)；
     1 KB = 1024 B(字节)；
     1 MB = 1024 KB;   (2^10 B)
     1 GB = 1024 MB;  (2^20 B)
     1 TB = 1024 GB;   (2^30 B)

3、字符：a、A、中、+、*、の......均表示一个字符 ；
	  unioncode 一个汉字 4 个字节表示
    一般 utf-8 编码下，一个汉字 字符 占用 3 个 字节；
    一般 gbk 编码下，一个汉字  字符  占用 2 个 字节；

2 assic码

3 命名

• go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则

  • 一个名字必须以一个字母或下划线开头，后面可以跟任意数量的字母、数字或下划线

• go语言中有25个关键字，不能用于自定义名字

  1 2 3 4 5

  break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var

• 还有30多个预定义的名字，用于内建的常量、类型和函数

  1 2 3 4 5 6 7 8 9 10 11

  //内建常量: true false iota nil //内建类型: int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error //内建函数: make len cap new append copy close delete complex real imag panic recover

4 变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func main()  {
	var a int
	var b , c string
	var (/* */
		d int
		e string
		f bool
	)
	fmt.Println(a,b,c,d,e,f)  // 0   0  false
}

1. 第一种，指定变量类型，如果没有初始化，则变量默认为零值。

   零值就是变量没有做初始化时系统默认设置的值。

• 数值类型（包括complex64/128）为 0

• 布尔类型为 false

• 字符串为 ""（空字符串）

• 以下几种类型为 nil：

  1 2 3 4 5 6

  var a *int var a []int var a map[string] int var a chan int var a func(string) int var a error // error 是接口

2. 第二种，根据值自行判定变量类型。

   1 2 3 4 5 6

   package main import "fmt" func main() { var d = true fmt.Println(d) }

3. 第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：

   1 2	v_name := value //可以将 var f string = "Runoob" 简写为 f := "Runoob"：

5 常量

常量的定义格式：

1

const identifier [type] = value

• 在定义常量组时，如果不提供初始值，则表示将使用上行的表达式。

• 常量是一个简单值的标识符，在程序运行时，不会被修改的量。

• 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

5.1 iota

• iota，特殊常量，可以认为是一个可以被编译器修改的常量, 变量中不可使用。

• iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

1
2
3
4
5

const (
	a = iota  //0
	b = iota  //1
	c = iota  //2
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

1
2
3
4
5

const (
    a = iota
    b
    c
)

• iota 只是在同一个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始。

5.2 iota 用法

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

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

• iota 只是在同一个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始。

5.3 Iota 和左右运算符

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

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 */

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)。

1
2
3

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

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