2-5. 基础语法

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 次方。 其功能是把 >> 左边的运算数的各二进位全部右移若干位， >> 右边的数指定移动的位数。

6 数据类型

Go 语言按类别有以下几种数据类型：

• 字符串格式化

  

  • %v是万能的
  • %T查看数据类型,类似reflect.typeOf()

6.1 字符串类型

1
2
3
4
5
6

a := "hello"
unsafe.Sizeof(a)
/*
输出结果为：16
字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。
*/

• 关键字string,用"“或者``反引号表示(’““支持控制符号,反引号所有的都会原样输出)
• 占位符 ‘%s
• 万能占位符’%v’

6.1.1 字符串常用操作

• 长度 **len(str) ** ,返回一个int, 返回的是字节的长度, 中文的字节长3

• 拼接: 使用**+或者fmt.Sprintf()**

• 分割: strings.Split(str,‘分割标识’), 返回一个切片

• 是否存在:

1. 字符串转数字

• strconv.Atoi：

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

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var str = "111"
    i, _ := strconv.Atoi(str)
    fmt.Printf("%d\n", i) // 输出：111
}

2. 大小写规则转换 strings.ToUpperSpecial：将字符串s中的所有字符修改为其大写格式，优先使用c中的规则进行转换 strings.ToLowerSpecial：将字符串s中的所有字符修改为其小写格式，优先使用c中的规则进行转换 strings.ToTitleSpecial：将字符串s中的所有字符修改为其Title格式，优先使用c中的规则进行转换 c规则说明，以下列语句为例： unicode.CaseRange{‘A’, ‘Z’, [unicode.MaxCase]rune{3, -3, 0}}

• 其中 ‘A’, ‘Z’ 表示此规则只影响 ‘A’ 到 ‘Z’ 之间的字符。
• 其中[unicode.MaxCase]rune数组表示：
• 当使用 ToUpperSpecial 转换时，将字符的 Unicode 编码与第一个元素值（3）相加
• 当使用 ToLowerSpecial 转换时，将字符的 Unicode 编码与第二个元素值（-3）相加
• 当使用 ToTitleSpecial 转换时，将字符的 Unicode 编码与第三个元素值（0）相加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    // 定义转换规则
    var _MyCase = unicode.SpecialCase{
        // 将半角逗号替换为全角逗号，ToTitle 不处理
        unicode.CaseRange{',', ',',
            [unicode.MaxCase]rune{'，' - ',', '，' - ',', 0}},
        // 将半角句号替换为全角句号，ToTitle 不处理
        unicode.CaseRange{'.', '.',
            [unicode.MaxCase]rune{'。' - '.', '。' - '.', 0}},
        // 将 ABC 分别替换为全角的 ＡＢＣ、ａｂｃ，ToTitle 不处理
        unicode.CaseRange{'A', 'C',
            [unicode.MaxCase]rune{'Ａ' - 'A', 'ａ' - 'A', 0}},
    }

    s := "ABCDEF,abcdef."
    us := strings.ToUpperSpecial(_MyCase, s)
    fmt.Printf("%q\n", us) // 输出："ＡＢＣDEF，ABCDEF。"
    ls := strings.ToLowerSpecial(_MyCase, s)
    fmt.Printf("%q\n", ls) // 输出："ａｂｃdef，abcdef。"
    ts := strings.ToTitleSpecial(_MyCase, s)
    fmt.Printf("%q\n", ts) // 输出："ABCDEF,ABCDEF."
}

6.2 字符串原理

• 单引号是字符,双引号是字符串

• 字符串的底层就是一个byte数组,所以可以和 []byte 类型互相转换

• 字符串是由byte字节组成的,所以字符串的长度是byte字节的长度

• rune类型用来表示utf8字符,一个rune字符由1个或多个byte组成

  • 对包含中文的字符串排序

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

    package main import ( "fmt" ) func main() { str := "ABCDEFGH你好" strRune := []rune(str) for i:=0 ; i<len(strRune)/2;i++{ item := strRune[i] strRune[i] = strRune[len(strRune)-1-i] strRune[len(strRune)-1-i] = item } fmt.Println(len(str)) // 14 fmt.Println(strRune) // [22909 20320 72 71 70 69 68 67 66 65] fmt.Println(string(strRune)) //好你HGFEDCBA }

• 扩展

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

  //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、中、+、*、の......均表示一个字符； unicode,万国码,32位既4个字节表示一个字符;      一般 utf-8 编码下，一个汉字 字符 占用 3 个 字节；      一般 gbk 编码下，一个汉字  字符  占用 2 个 字节； //4、字节和字符： 字节是计算机传输数据的格式，供计算识别的。 字符是供人类观看的内容 //5、编码： 编码（encoding）:把…译成密码。==》二进制 解码（decoding）：破译(尤指密码) ==》破解密码成可以看的懂的 //6.编码格式： 字节和字符之间转换，参照的规则就是编码格式。 Unicode 编码共有三种具体实现，分别为utf-8,utf-16,utf-32，其中utf-8占用一到四个字节，utf-16占用二或四个字节，utf-32占用四个字节。 Unicode码的前128个字符就是ASCII码，之后是ASCII码的扩展码。

6.3 数字类型

• Go 也有基于架构的类型，例如：int、uint 和 uintptr。

• 所有整数初始化为0,所有浮点数初始化为0.0,布尔类型初始化为 false

6.3.1 浮点型

6.3.2 其他数字类型

以下列出了其他更多的数字类型：

7 时间和日期

time 包

• 时间

  1 2 3 4 5 6 7 8 9

  now := time.Now() fmt.Println(now) // 分别获取年月日等 year := now.Year() month := now.Month() day := now.Day() hour := now.Hour() minute := now.Minute() send := now.Second()

// 时间格式化 timer := time.Now() res := timer.Format(“2006-01-02 15:04:05”)

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

- `%02d 不足两位的数字在前面补0`

- 时间戳

```go
// 获取时间戳
timeStamp := time.Now().Unix()
fmt.Println(timeStamp)
// 时间戳转时间
nowObj := time.Unix(timeStamp,0)
year =nowObj.Year()
month =nowObj.Month()
day =nowObj.Day()
fmt.Printf("%02d-%02d-%02d ",year,month,day) 
// %02d 不足两位的数字在前面补0

8 运算符

Go 语言内置的运算符有：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

8.1 算术运算符

下表列出了所有Go语言的算术运算符。假定 A 值为 10，B 值为 20。

8.2 关系运算符

下表列出了所有Go语言的关系运算符。假定 A 值为 10，B 值为 20。

8.3 逻辑运算符

下表列出了所有Go语言的逻辑运算符。假定 A 值为 True，B 值为 False。

8.4 位运算符

位运算符对整数在内存中的二进制位进行操作。

下表列出了位运算符 &, |, 和 ^ 的计算：

假定 A = 60; B = 13; 其二进制数转换为：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：

以下实例演示了位运算符的用法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

import "fmt"

func main() {

  var a uint = 60   /* 60 = 0011 1100 */
  var b uint = 13   /* 13 = 0000 1101 */
  var c uint = 0      

  c = a & b    */\* 12 = 0000 1100 \*/*
  fmt.Printf("第一行 - c 的值为 %d**\n**", c )

  c = a | b    */\* 61 = 0011 1101 \*/*
  fmt.Printf("第二行 - c 的值为 %d**\n**", c )

  c = a ^ b    */\* 49 = 0011 0001 \*/*
  fmt.Printf("第三行 - c 的值为 %d**\n**", c )

  c = a << 2   */\* 240 = 1111 0000 \*/*
  fmt.Printf("第四行 - c 的值为 %d**\n**", c )

  c = a >> 2   */\* 15 = 0000 1111 \*/*
  fmt.Printf("第五行 - c 的值为 %d**\n**", c )
}

/*
第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15
*/

8.5 赋值运算符

下表列出了所有Go语言的赋值运算符。

8.6 其他运算符

下表列出了Go语言的其他运算符。

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

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

   /*  & 和 * 运算符实例 */
   ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);
}

8.7 运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

9 Golang代码执行步骤