「关键字分析」Go内置关键字分析（一）

关键字分析

Go语言中总共有25个关键字，如下所示：

Go关键字按类型不同做如下区分(注：图片来自网络，若有侵权，请联系删除)：

1. 基本结构类

1.1变量与常量

(1) Var

作用：定义变量

举例：

var x int=4 or x:=4

注意：a.在函数中，:= 简洁赋值语句在明确类型的前提下，可以用于替代 var 定义。b.:= 结构不能使用在函数外，函数外的每个语法块都必须以关键字开始。

演示：

package main

import (   

    "fmt"

)

func main() {

 

    var x int = 4

    fmt.println(x)//输出4

    fmt.Println(&x)//输出指针

    //fmt.Println(*x) //错误

    y := 4

    

    fmt.Println(y)//输出4

    fmt.Println(&y)//输出指针

    //fmt.Println(*y) //错误

 

   var v *int = new(int)//返回值为指针

    fmt.Println(*v)//输出为0，它只是将内存清零，而不是初始化内存

*v = 4//赋值

    fmt.Println(v)//输出指针

    fmt.Println(*v)//输出4

    z := new(int)//代替var v *int = new(int)

    *z = 3

    fmt.Println(z)//输出指针

    fmt.Println(*z)//输出3

}

(2) const

作用：定义常量

定义：

const identifier [type] = value

a.[type]类型可以省略,编译器可以根据变量的值来推断其类型.

显示类型：const b string = "abc"

 隐式类型：const b = "abc"

b.多个相同类型的声明可以简写为：

const name1 , name2  = value1 , value2

演示：

package main

import "fmt"

 

func main()  {

    //长度 int  3

    const LENGTH int = 3

    //宽度 int 2

    const  WIDTH int = 2

    //面积 int

    var AREA int

    //多重赋值 int ,bool,字符串

    const  a,b,c = 1 , true , "str"

    //求面积

    AREA = LENGTH * WIDTH

    //输出面积

    fmt.Printf("面积为 : %d\n" ,AREA)

    //输出a,b,c

    fmt.Println(a,b,c)

}

1.2“包”管理

(1)Package

作用：包管理

a. package是golang最基本的分发单位和工程管理中依赖关系的体现。

b. 每个golang源代码文件开头都拥有一个package声明，表示该golang代码所属的package。

c. 要生成golang可执行程序，必须建立一个名为main的package，并且在该package中必须包含一个名为main()的函数。

d. 在golang工程中，同一个路径下只能存在一个package，一个package可以拆成多个源文件组成。

(2 )Import

作用：导入

a. import关键字导入的是package路径

b. import的目录名和源文件中使用的package名一致容易造成import关键字后即是package名的错觉，真正使用时，这两者可以不同。

举例：

c. import “fmt”最常用的一种形式

d. import “./test”导入同一目录下test包中的内容

e. import f “fmt”导入fmt，并给他启别名f

f. import . “fmt”，将fmt启用别名”.”，这样就可以直接使用其内容，而不用再添加fmt，如fmt.Println可以直接写成Println

g. import _ “fmt” 表示不使用该包，而是只是使用该包的init函数，并不显示的使用该包的其他内容。注意：这种形式的import，当import时就执行了fmt包中的init函数，而不能够使用该包的其他函数。

2. 基本组件类

2.1函数类

(1) Func

作用：定义函数

定义：

func (p myType ) funcName ( a, b int , c string ) ( r , s int ) {

    	return

}

注：关键字——func

方法名——funcName

参数——— a,b int,b string

返回值—— r,s int

函数体—— {}

演示：

//判断a是否等于b

func (a double) IsEqual(b double) bool {

  	var r = a - b

    	if r == 0.0 {

        	return true

    	} else if r < 0.0 {

        	return r > -0.0001

    	}

    	return r < 0.0001

}

(2) Return

作用：用于在函数内部，退出函数执行过程

应用：

a.退出函数执行过程，不指定返回值

通常有两种情况不需要指定返回值退出函数执行过程。第一是：函数没有返回值；第二是：函数返回值有变量名，不需要显示的指定返回值。

package main

import (

    "fmt"

)

func say(flag bool) {

    if !flag {

        fmt.Println("false")

        return

    }

    fmt.Println("没有返回值")

}


func getStatus() (num int) {

    // num是在返回值中定义的变量

    num = 100

    return

}

 

func main() {

    say(true)

    say(false)

    fmt.Println(getStatus())

}

b.退出函数执行过程，并指定返回值

当函数有返回值时，如果返回值没有定义变量，那么一定要使用return加上返回值退出函数。如下：

package main



import (

    "fmt"

)

 

// getMsg函数需要返回一个string类型值

func getMsg() string {

    return "hello"

}

 

func main() {

    fmt.Println(getMsg())

}

延伸：

a. 在返回值中定义变量，而return其它结果

在函数定义时，虽然在返回值中定义了变量，但是在return出函数时，指定另外的变量作为返回结果，这样也是可行的，但是意义却不大。如下：

package main

import (

    "fmt"

)

 

func getMsg() (msg string) {

    msg = "world"

    return "hello"

}

 

func main() {

    fmt.Println(getMsg())

}

b. 在函数递归调用中使用return

递归调用，就是函数在函数体内调用自身。函数在没有结束之前，调用自身，表示嵌套层级增加一层。各个调用层中，函数执行完成，表示这一层执行完成。在函数递归调用中使用return，只会退出当前这一层的函数执行，并不会结束其他层的函数执行过程。使用return可以结束函数执行过程，阻止函数体内后边的代码执行。将对自身的调用写在return后边，可以停止函数的递归调用。如下：

package main

 

import (

    "fmt"

)

 

func getMsg(index int) {

    if index == 5 {

        fmt.Println("递归调用嵌套层级达到5层，结束递归")

        return

    }

 

    fmt.Println("递归调用层级是：", index)

    getMsg(index + 1)

}

 

func main() {

    var index = 1

    getMsg(index)

}

注：由于作者是初入Go语言时间不长，文章中有些技术点表述可能不是很详细或者有问题，还望各位海涵，后期会逐渐增加，若有问题可联系作者，谢谢。

Go内置关键字分析（一）