Skip to content

基础语法

关键字、标识符

保留的关键字只有25个

名称 名称 名称 名称 名称
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

36个预定的标识符，其中包括基础数据类型和系统内置函数

append bool byte cap close complex
complex64 complex128 uint16 copy false float32
float64 imag int int8 int16 uint32
int32 int64 iota len make new
nil panic uint64 print printIn real
recover string TRUE uint uint8 uintprt

基础结构详解

 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
34
35
36
37
// 程序所属包 【正式程序的第一行必须有 package】
package main

// 导入依赖包
import "fmt"

// 常量定义
const NAME string = "elasticnotes"

// 全局变量的声明与赋值
var a string = "elasticnoets"

// 一般类型声明
type elasticnoetsInt int

// 结构的声明
type Learn struct {
}

// 声明接口
type Ilearn interface {
}

// 函数定义
func ElasticNotes() {
    fmt.Print("hello elasticnotes")
}

// main 函数
func main() {
    ElasticNotes()
    fmt.Print("hello notes")
}

// 运行输出
MacintoshdeMacBook-Pro-139:practice elasticnotes$ go run demo.go 
hello elasticnoteshello notes

package 的用法

  • package 是最基本的分发单位 和 工程管理中依赖关系的体现；
  • 每个 GO 语言源代码文件开头必须拥有一个 package 的声明，表示源代码文件所属代码包；
  • 要生成 GO 语言可执行程序，必须要有 main 的 package 包，且必须在该包下有 main() 函数；
  • 同一个路径下只能存在一个package，一个 package 可以拆分成多个源文件组成；

import 概念

  • import 语句可以导入源代码文件所依赖的package包；
  • 不得导入源代码文件中没有用到的package，否则Go语言编译器会报编译错误；
  • import 语法格式主要有两种

Import语法格式主要有两种

1
2
3
4
import "package1"
import "package2"
import "package3"
import "..."

1
2
3
4
5
6
import (
    "package1"
    "package2"
    "package3"
    "..."
)

import 原理

  • 如果一个main导入其他包，包将被顺序导入；
  • 如果导入的包中依赖其他包（包B），会首先导入包B，然后初始化包B中的常量和变量，最后如果包B中有init，会自动执行init()；
  • 所有包导入完成后才会对main中常量和变量进行初始化，然后执行包中的init函数（如果存在），最后执行mian函数；
  • 如果一个包被导入多次则该包只会被导入一次；
graph LR
  A[import pkg1] -->|先执行被导入的pkg1| B[pkg1<br/>import pkg2];
  B -->|pkg1中又被导入pkg2先执行pkg2| C[pkg2相关结构体];
  C -->|pkg2执行完返回执行上层pkg1| B[pkg1<br/>import pkg2];
  B -->|再返回执行main函数| A;

import 别名用法

  • 别名操作的含义是：将导入包的命名为另一个容易记的别名；
  • 点(.)操作的含义是：点(.)标识的包导入后，调用该包中函数时可以省略前缀包名；
  • 下划线( _ ) 操作的含义是：导入该包但不导入整个包，而是执行该包中的init函数，因此无法通过包名来调用包中的其他函数。使用下划线( _ )操作往往是为了注册包里的引擎，让外部可以方便的使用
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
package main

import (
    // 别名方式
    elasticnotes "fmt"

    // . 方式
    . "fmt"

    // _ 方式
    _ "fmt"
)

func main() {
    // 别名方式
    elasticnotes.Print("Hello World")

    // .方式
    Print("Hello World")
}

数据类型

数值类型，字符串类型和布尔类型

  • 整型，浮点型，复数，字符串和布尔型
    • 数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
    • 布尔型的值只能是常量 true 或 false。一个简单的例子：var a bool = true。

    • 字符串类型 string，编码统一为 UTF-8。

      • 整型

        序号 类型和描述
        1 uint8 无符号8位整型（0到255）
        2 uint16 无符号16位整型（0到65535）
        3 uint32 无符号32位整型（0到4294967295）
        4 uint64 无符号64位整型（0到18446744073709551615）
        5 int8 无符号8位整型（-128到127）
        6 int16 无符号8位整型（-32768到32767）
        7 int32 无符号8位整型（-2147483648到2147483647）
        8 int64 无符号8位整型（-9223372036854775808到9223372036854775807）

      • 浮点和复数类型

        序号 类型和描述
        1 float32 IEEE-754 32位浮点型数 必须跟32 或 64
        2 float64 IEEE-754 64位浮点型数 必须跟32 或 64
        3 complex64 32 位实数和虚数
        4 complex128 64 位实数和虚数

      • 其他数值类型

        序号 类型和描述
        1 byte 类似 uint8
        2 rune 类似 int32
        3 uint 32 或 64 位
        4 int 与 uint 一样大小
        4 uintptr 无符号整型，用于存放一个指针 
 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
package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var i int8 = 1
    fmt.Print(unsafe.Sizeof(i))
    // 1

    var j int32 = 1
    fmt.Print(unsafe.Sizeof(j))
    // 4

    var k int64 = 1
    fmt.Print(unsafe.Sizeof(k))
    // 8

    var l int = 1 // 当前环境为64位 估int默认为8位 此处会根据计算机位数类型相同 占位不同
    fmt.Print(unsafe.Sizeof(l))
    // 8

    // 一个字节8位
}

派生类型

  • 指针类型（Pointer）
  • 数组类型
  • 结构化类型（struct）
  • Channel类型（chan）
  • 函数类型（func）
  • 切片类型（slice）
  • 接口类型（interface）
  • Map 类型（map）

类型零值和类型别名

  • 类型零值不是空值，而是某个变量被声明后的默认值，一般情况下，值类型的默认值为 0 ，布尔类型默认值为 false，string默认值为空字符串；
  • 我们可以对类型设置别名； 
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    package main

import (
    "fmt"
    "unsafe"
)

type 别名 int32

func main() {
    var i 别名
    var j int32
    fmt.Print(unsafe.Sizeof(i))
    // 4

    fmt.Print(unsafe.Sizeof(j))
    // 4
}
    📢：别名默认值一样 占用内存空间一样 但是不能运算 
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    package main

import (
    "fmt"
)

type 别名 int32

func main() {
    var i 别名
    var j int32
    fmt.Print(i + j)
    // 报错：Error: invalid operation: i + j (mismatched types 别名 and int32)

    var k 别名 = 3
    fmt.Print(i + k)
    // 正常：3
}

类型所占存储大小

Image title

类型所占存储大小