Go基础一：包、变量和函数

包 #

每个Go程序都由包构成，程序从main方法开始执行。

通过下面这段代码来学习「包」相关的几个知识点。 

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

package main

import (#1#
  "fmt"
  "math/rand"
  "math"
)

func main() {
  fmt.Println("My favorite number is", rand.Intn(10))#2#
  fmt.Println(math.pi)#3#
}

  • 1程序导入了fmt math/rand两个包。
  • 1可以用圆括号进行“分组”导入，也可以分别导入。 
    1
2

    import "fmt"
import "math"
  • 2程序中以路径中的最后一段为包名。
  • 3以大写字母开头的变量是导出的，此处用小写的math.pi就不会导出，会报错，需要改完大写的math.Pi才能正常运行。

函数 #

  1. 函数可以没有参数或接收多个参数
1
2
3

func add(x int, y int) int {
	return x + y
}
  1. 多个相同的类型可用省略写法
1
2
3

func add(x, y int) int {
	return x + y
}
  1. 可返回任意数量的返回值
1
2
3

func swap(x, y string) (string, string) {
	return y, x
}
  1. 返回值可以被命名，它们被视为定义在函数的顶部
1
2
3
4
5

func split(sum int) (x, y int) {
	x = sum * 4 / 9
	y = sum - x
	return
}
  • 无参数的 return 返回已命名的返回值
  • 无参数的 return 应该仅在这样短小的函数中使用，否则会影响可读性

变量 #

  1. var 用于声明变量列表，类型在最后。可出现在包和函数级别
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package main

import "fmt"

var c, python, java bool

func main() {
	var i int
	fmt.Println(i, c, python, java)
}
  1. 声明可以包含初始值，每个变量对应一个。有初始值的话，可以省略类型。
1
2

var i, j int = 1, 2
var c, java, python = true, false, "no!"
  1. 在..函数中..，且..类型明确..，则可以使用..简洁赋值..语句:=代替var。在函数外，每个语句都必须以关键字开始（var，func等），因此:=不能在函数外使用。
1
2
3

var i, j int = 1, 2
k := 3
c, python, java := true, false, "no!"
  1. 基本类型
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
    // 表示一个 Unicode 码点

float32 float64

complex64 complex128

int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。 当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。

  1. 没有明确初始值的变量声明会被赋值为它们的「零值」。
1
2
3
4

var i int		// 数值类型为 0
var f float64	// 数值类型为 0
var b bool		// 布尔类型为 false
var s string	// 字符串为 ""（空字符串）
  1. 类型转换：表达式 T(v) 将值 v 转换为类型 T
1
2
3

var i int		= 42
var f float64	= float64(i)
u := uint(f)
  1. 类型推断：声明变量但未指定类型时，类型由右值推导得出。
    • 当右值声明了类型时，新变量的类型与其相同
    • 当右值包含未指定类型的数值常量时，由其精度决定类型
1
2
3
4

i := 42				// int
f := 3.142			// float64
g := 0.867 + 0.5i	// complex128
fmt.Printf("g is of type %T\n", g)
  1. 常量使用 const 声明，语法与声明变量类似。常量不能用 := 语法声明
1

const World = "世界"
  1. 数值常量：高精度的值，未指定类型的常量由上下文决定其类型
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

const (
	// 将 1 左移 100 位来创建一个非常大的数字
	// 即这个数的二进制是 1 后面跟着 100 个 0
	Big = 1 << 100
	// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2
	Small = Big >> 99
)

func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
	return x * 0.1
}

func main() {
	fmt.Println(needInt(Small))		// Small可以作为int
	fmt.Println(needFloat(Small))		// Small可以作为float64
	fmt.Println(needFloat(Big))
}
Edit Edit this page