西维蜀黍

【Golang】模块管理与引用

包声明 - package

在go源文件的开头必须申明文件所属的package,如下所示:

package name
......

一些实验发现

实验 1

注意,位于同一个文件夹下的所有 .go 文件,它们的 package name 一定要完全一致。比如,由于 ccc.go 和 ddd.go 两个文件都位于 bbb 文件夹下,因此这两个文件的 package name 必需要完全一致(但这个 package name 不要求一定为 bbb,即不一定要和所在文件夹的文件夹名称相同)。

如果不一致,则会提示以下错误:

  ...


【Golang】变量

变量声明

可以一次声明多个变量:

var identifier1, identifier2 type

实例2

package main
import "fmt"

var c, python, java bool

func main() {
  var a string = "test"
  fmt.Println(a)

  var b, c int = 1, 2
  fmt.Println(b, c)
  
  var i int
	fmt.Println(i, c, python, java)
}

以上实例输出结果为:

test
1 2
  • 数值类型(包括complex64/128)为 0

  • 布尔类型为 false

  • 字符串为 ""(空字符串)

  • 以下几种类型为 nil

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

实例

package main

import "fmt"

func main() {
  var i int
  var f float64
  var b bool
  var s string
  fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

输出结果是:

0 0 false ""

根据值自行判定变量类型

var v_name = value

实例

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

输出结果是:

true

省略 var

Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type.

Outside a function, every statement begins with a keyword (var, func, and so on) and so the := construct is not available.

注意 *:=* 左侧如果没有声明新的变量,就产生编译错误,格式:

v_name := value

例如:

var intVal int 

intVal :=1 // 这时候会产生编译错误

intVal,intVal1 := 1,2 // 此时不会产生编译错误,因为有声明新的变量,因为 := 是一个声明语句

可以将 var f string = “Runoob” 简写为 f := “Runoob”:

实例

package main
import "fmt"
func main() {
  f := "Runoob" // var f string = "Runoob"

  fmt.Println(f)
}

输出结果是:

Runoob

多变量声明

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型,自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的,否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

实例

package main

var x, y int
var ( *// 这种因式分解关键字的写法一般用于声明全局变量*
  a int
  b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

*//这种不带声明格式的只能在函数体中出现*
*//g, h := 123, "hello"*

func main(){
  g, h := 123, "hello"
  println(x, y, a, b, c, d, e, f, g, h)
}

以上实例执行结果为:

0 0 0 false 1 2 123 hello 123 hello

常量声明(const)

const identifier [type] = value

你可以省略类型说明符 [type],因为编译器可以根据变量的值来推断其类型。

  • 显式类型定义: const b string = "abc"
  • 隐式类型定义: const b = "abc"

多个相同类型的声明可以简写为:

const c_name1, c_name2 = value1, value2

以下实例演示了常量的应用:

实例

package main

import "fmt"

func main() {
  const LENGTH int = 10
  const WIDTH int = 5 
  var area int
  const a, b, c = 1, false, "str" *//多重赋值*

  area = LENGTH * WIDTH
  fmt.Printf("面积为 : %d", area)
  println()
  println(a, b, c) 
}

以上实例运行结果为:

面积为 : 50
1 false str

Default Values

Variables declared without an explicit initial value are given their zero value.

The zero value is:

  • 0 for numeric types,
  • false for the boolean type, and
  • "" (the empty string) for strings.
package main

import "fmt"

func main() {
	var i int
	var f float64
	var b bool
	var s string
	fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
//output 0 0 false ""

变量作用域

局部变量

在函数体内声明的变量称之为局部变量,它们的作用域只在函数体内,参数和返回值变量也是局部变量。

以下实例中 main() 函数使用了局部变量 a, b, c:

实例

package main

import "fmt"

func main() {
  */\* 声明局部变量 \*/*
  var a, b, c int

  */\* 初始化参数 \*/*
  a = 10
  b = 20
  c = a + b

  fmt.Printf ("结果: a = %d, b = %d and c = %d\n", a, b, c)
}

以上实例执行输出结果为:

结果: a = 10, b = 20 and c = 30

全局变量

在函数体外声明的变量称之为全局变量,全局变量可以在整个包甚至外部包(被导出后)使用。

全局变量可以在任何函数中使用,以下实例演示了如何使用全局变量:

实例

package main

import "fmt"

*/\* 声明全局变量 \*/*
var g int

func main() {

  */\* 声明局部变量 \*/*
  var a, b int

  */\* 初始化参数 \*/*
  a = 10
  b = 20
  g = a + b

  fmt.Printf("结果: a = %d, b = %d and g = %d\n", a, b, g)
}

以上实例执行输出结果为:

结果: a = 10, b = 20 and g = 30

Go 语言程序中全局变量与局部变量名称可以相同,但是函数内的局部变量会被优先考虑。实例如下:

实例

package main

import "fmt"

*/\* 声明全局变量 \*/*
var g int = 20

func main() {
  */\* 声明局部变量 \*/*
  var g int = 10

  fmt.Printf ("结果: g = %d\n", g)
}

以上实例执行输出结果为:

结果: g = 10

形式参数

形式参数会作为函数的局部变量来使用。实例如下:

实例

package main

import "fmt"

*/\* 声明全局变量 \*/*
var a int = 20;

func main() {
  */\* main 函数中声明局部变量 \*/*
  var a int = 10
  var b int = 20
  var c int = 0

  fmt.Printf("main()函数中 a = %d\n", a);
  c = sum( a, b);
  fmt.Printf("main()函数中 c = %d\n", c);
}

*/\* 函数定义-两数相加 \*/*
func sum(a, b int) int {
  fmt.Printf("sum() 函数中 a = %d\n", a);
  fmt.Printf("sum() 函数中 b = %d\n", b);

  return a + b;
}

以上实例执行输出结果为:

main()函数中 a = 10
sum() 函数中 a = 10
sum() 函数中 b = 20
main()函数中 c = 30

初始化局部和全局变量

不同类型的局部和全局变量默认值为:

数据类型 初始化默认值
int 0
float32 0
pointer nil
  ...


【Golang】枚举(enumeration)

枚举(enumeration)

Golang 语言并没有提供enum的定义,我们可以使用const来模拟枚举类型。

type PolicyType int32

const (
    Policy_MIN      PolicyType = 0
    Policy_MAX      PolicyType = 1
    Policy_MID      PolicyType = 2
    Policy_AVG      PolicyType = 3
)

这里定义了一个新的类型PolicyType,并且定义了4个常量(Policy_MIN, Policy_MAX, Policy_MID, Policy_AVG),类型是PolicyType。

  ...


【Golang】变量访问域

变量修饰符(Access Modifier)

当标识符(包括常量、变量、类型、函数名、结构字段等等)以一个大写字母开头,如:Group1,那么使用这种形式的标识符的对象就可以被外部包的代码所使用(客户端程序需要先导入这个包),这被称为导出(像面向对象语言中的 public 标识符。

如果以小写字母开头,则对包外是不可见的,但是他们在整个包的内部是可见并且可用的(像面向对象语言中的 protected

Go 语言中变量的声明必须使用空格隔开,如:

var age int;
  ...


【Golang】map 基础

定义 map

可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量,默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map,那么 map_variable 就是一个 nil。

nil map 不能写入键值对,但是可以读取内部的值(虽然这并没有任何意义,因为一定会得到已知的结果,即 value 为 0)。

package main

func main() {
	var a map[int]int
	println(a[22]) // Return 0

	a[1] = 33 // https://blog.golang.org/maps
}
  ...