首页 > 代码库 > go 基本语法了解

go 基本语法了解

Packages

每个 Go 程序都是由包组成的。

程序运行的入口是包 `main`。

这个程序使用并导入了包 "fmt" 和 `"math/rand"`。

按照惯例,包名与导入路径的最后一个目录一致。例如,`"math/rand"` 包由 package rand 语句开始。

注意: 这个程序的运行环境是固定的,因此 rand.Intn 总是会返回相同的数字。 (为了得到不同的数字,需要生成不同的种子数,参阅 rand.Seed。)

 

package mainimport (	"fmt"	"math/rand")func main() {	fmt.Println("My favorite number is", rand.Intn(10))}

 

导入

这个代码用圆括号组合了导入,这是“factored”导入语句。同样可以编写多个导入语句,例如:

import "fmt"import "math"

package mainimport (	"fmt"	"math")func main() {	fmt.Printf("Now you have %g problems.",		math.Nextafter(2, 3))}

 

导出名

在导入了一个包之后,就可以用其导出的名称来调用它。

在 Go 中,首字母大写的名称是被导出的。

Foo 和 FOO 都是被导出的名称。名称 foo 是不会被导出的。

执行代码。然后将 math.pi 改名为 math.Pi 再试着执行一下。

 

package mainimport (	"fmt"	"math")func main() {	fmt.Println(math.pi)}

函数

函数可以没有参数或接受多个参数。

在这个例子中,`add` 接受两个 int 类型的参数。

注意类型在变量名 _之后_。

(参考 这篇关于 Go 语法定义的文章了解类型以这种形式出现的原因。)

package mainimport "fmt"func add(x int, y int) int {	return x + y}func main() {	fmt.Println(add(42, 13))}

函数(续)

当两个或多个连续的函数命名参数是同一类型,则除了最后一个类型之外,其他都可以省略。

在这个例子中 ,

x int, y int

被缩写为

x, y int
package mainimport "fmt"func add(x, y int) int {	return x + y}func main() {	fmt.Println(add(42, 13))}

多值返回

函数可以返回任意数量的返回值。

这个函数返回了两个字符串。

package mainimport "fmt"func swap(x, y string) (string, string) {	return y, x}func main() {	a, b := swap("hello", "world")	fmt.Println(a, b)}

 

命名返回值

函数接受参数。在 Go 中,函数可以返回多个“结果参数”,而不仅仅是一个值。它们可以像变量那样命名和使用。

如果命名了返回值参数,一个没有参数的 return 语句,会将当前的值作为返回值返回。

package mainimport "fmt"func split(sum int) (x, y int) {	x = sum * 4 / 9	y = sum - x	return}func main() {	fmt.Println(split(17))}

 


变量

var 语句定义了一个变量的列表;跟函数的参数列表一样,类型在后面。

package mainimport "fmt"var i intvar c, python, java boolfunc main() {	fmt.Println(i, c, python, java)}

 

初始化变量

变量定义可以包含初始值,每个变量对应一个。

如果初始化是使用表达式,则可以省略类型;变量从初始值中获得类型。

package mainimport "fmt"var i, j int = 1, 2var c, python, java = true, false, "no!"func main() {	fmt.Println(i, j, c, python, java)}

 

短声明变量

在函数中,`:=` 简洁赋值语句在明确类型的地方,可以用于替代 var 定义。

函数外的每个语法块都必须以关键字开始(`var`、`func`、等等),`:=` 结构不能使用在函数外。

package mainimport "fmt"func main() {	var i, j int = 1, 2	k := 3	c, python, java := true, false, "no!"	fmt.Println(i, j, k, c, python, java)}

基本类型

Go 的基本类型有Basic types

boolstringint  int8  int16  int32  int64uint uint8 uint16 uint32 uint64 uintptrbyte // uint8 的别名rune // int32 的别名// 代表一个Unicode码float32 float64complex64 complex128

package mainimport (	"fmt"	"math/cmplx")var (	ToBe   bool       = false	MaxInt uint64     = 1<<64 - 1	z      complex128 = cmplx.Sqrt(-5 + 12i))func main() {	const f = "%T(%v)\n"	fmt.Printf(f, ToBe, ToBe)	fmt.Printf(f, MaxInt, MaxInt)	fmt.Printf(f, z, z)}

类型转换

表达式 T(v) 将值 v 转换为类型 `T`。

一些关于数值的转换:

var i int = 42var f float64 = float64(i)var u uint = uint(f)

或者,更加简单的形式:

i := 42f := float64(i)u := uint(f)

与 C 不同的是 Go 的在不同类型之间的项目赋值时需要显式转换。 试着移除例子中float64 或 int 的转换看看会发生什么。

package mainimport (	"fmt"	"math")func main() {	var x, y int = 3, 4	var f float64 = math.Sqrt(float64(x*x + y*y))	var z int = int(f)	fmt.Println(x, y, z)}

 

常量

常量的定义与变量类似,只不过使用 const 关键字。

常量可以是字符、字符串、布尔或数字类型的值。

常量不能使用 := 语法定义。

package mainimport "fmt"const Pi = 3.14func main() {	const World = "世界"	fmt.Println("Hello", World)	fmt.Println("Happy", Pi, "Day")	const Truth = true	fmt.Println("Go rules?", Truth)}

数值常量

数值常量是高精度的 _值_。

一个未指定类型的常量由上下文来决定其类型。

也尝试一下输出 needInt(Big) 吧。

package mainimport "fmt"const (	Big   = 1 << 100	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))	fmt.Println(needFloat(Small))	fmt.Println(needFloat(Big))}