目录
1. go程序的基本组成
1.1 包
每一个GO程序都是由包组成的。
下面这个程序从main
包开始。
1.2 import导入包
import导入包有两种形式,
- 分组导入,使用括号在括号内进行多个包导入。
- 单包导入,用import语句一条一条导入。
在这段代码中我们使用分组导入
,用了括号组合导入了两个包,一个是fmt标准输入输出包,一个math里的rand包用来生成随机数。
例子:
package main
import (
"fmt"
"math/rand"
)
func main() {
fmt.Println("My favorite number is", rand.Intn(100))
}
导包也可以也可以通过一条一条导入。例如:
import "fmt"
import "math/rand"
通过调用fmt的Println来输出语句,
fmt.Println("My favorite number is", rand.Intn(100))
输出结果:
My favorite number is 81
1.3 导出名
在Go中如果一个名字是以大写字母开头的,说明这个名字是已经导出的,而如果当将这个名字大写换成小写,将会找不到这个名字,导致报错。
这种以大写字母开头的名字我们称之为导出名,导出名由导入的包提供,如果导入的包不提供,则没有导出名。
举例子前的前置知识:在math包中提供一个导出名为Pi
我们接下来将使用小写与大写的输出结果进行对比。
例子1:
package main
import (
"fmt"
"math"
)
func main() {
//输出小写pi
fmt.Println("My favorite number is",math.pi)
}
结果:
例子2:
//对pi修改成Pi
fmt.Println("My favorite number is",math.Pi)
结果:
2 函数
函数定义是以func开头,后接函数名、参数列表、返回值以及方法体。
2.1 函数参数
函数可以接受0个或者 多个(包含1个) 参数。
例子:
package main
import "fmt"
//相加函数,返回传入参数的和
func add(x int,y int) int {
return x+y;
}
func main() {
fmt.Println(add(3,4))
}
ps:func函数定义在最前面 ,函数返回类型在函数名后面,类型在变量名后面.
当函数中传入参数连续两个或者多个类型相同时,除了最后一个必须写参数类型,其他的可以不要写。
例子:
package main
import "fmt"
//函数中存在一个string类型和两个int类型
func add(c string,x,y int) int {
fmt.Println(c)
return x+y
}
func main() {
fmt.Println(add("Go~",3,4))
}
结果:
2.2 函数之多值返回
在函数返回值的时候可以同时返回多个结果。
例子:
package main
import "fmt"
func add(c string,x,y int) (int,int,string) {
fmt.Println(c)
return x+y,y-x,"bbb"
}
func main() {
fmt.Println(add("aaa",3,4))
}
结果:
2.3 函数之命名返回值
Go中函数的返回值可以被命名,返回值的名称应当有一定的意义。
没有参数的return语句将直接返回已命名的返回值。
例子:
package main
import "fmt"
//函数返回值命名为x,y
func swap(sum int) (x,y int) {
x = sum %10
//将y的赋值取消,查看是否会返回,结果会返回默认值0
//y = sum*10
//返回时没有指出具体的返回值
return
}
func main() {
fmt.Println(swap(18))
}
结果:
3. 变量
3.1 变量声明var
变量声明时使用var
来声明。
声明格式(单个变量): var 变量名 变量类型
例子:
package main
import "fmt"
//bool是布尔类型的意思
var c,Java,python bool;
func main() {
var i int;
fmt.Println(i,c,Java,python);
}
结果:
3.2 多个变量同时声明
当有多个变量同时声明时,相同类型可在最后添加类型。
如果变量已存在初始值,变量会通过初始值的类型去获得类型。
例子:
package main
import "fmt"
//声明了两个int类型的变量i和j
var i,j int = 1,99
func main() {
//通过变量的初始值去判断它的类型
var c,java,python = true,1,"python"
fmt.Println(i,j,c,java,python);
}
结果:
3.3短变量声明
在函数内可以使用:=
代替var
,在函数外所有都必须以关键字开头(例如:func
,var
等等),
因此:=
不能再函数外使用。
例子:
package main
import "fmt"
func main() {
//使用 := 进行变量声明
num := 89
fmt.Println(num);
}
3.4 变量的基本类型
bool
string
int int8 int16 int 32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte //uint8的别名
rune //int32的别名 表示一个Unicode码点
float32 float64
complex64 complex128
int,uint和uintptr在32位系统上通常为32位宽,在64位系统上则为64位宽。当需要使用一个整型的时候应该使用int类型。
3.5 变量声明语法块
变量的声明也可以和import语句一样,单独‘分组’成单独的一个语法块。
例子:
package main
//import导入的包块
import (
"fmt"
"math/cmplx"
)
//var声明的变量块
var (
ToBe bool = false
MaxInt uint64 = 1<<64-1
z complex128 = cmplx.Sqrt(-5+12i)
)
func main() {
//%T打印变量类型,%v打印变量内容
fmt.Printf("Type:%T Value:%v\n",ToBe,ToBe)
fmt.Printf("Type:%T Value:%v\n",MaxInt,MaxInt)
fmt.Printf("Type:%T Value:%v\n",z,z)
}
结果:
3.6 零值(默认值)
没有明确初始值的变量会赋予一个默认的零值。
零值是:
- 数值类型是0.
- 布尔类型是false
- 字符串是""(空字符串)
例子:
package main
import (
"fmt"
)
func main() {
var intS int
var stringS string
var boolS bool
var float64S float64
fmt.Printf("%v %v %v %q\n",intS,boolS,float64S,stringS)
}
结果:
3.7 变量的类型转换
表达式T(v)
将值v
转变成类型T
。
GO在不同类型项之间赋值时需要显示转换,如果没有显示转换则会报错。
例子:
package main
import (
"fmt"
"math"
)
func main() {
//变量类型转换
x,y:=3,4
//int转flat64
f := math.Sqrt(float64(x*x+y*y))
//float64转int
z := int(f)
fmt.Println(x,y,z)
}
3.8 变量类型推导
当声明一个变量既不给类型也不给初始值,则会根据使用时右值的类型推导出该变量的值。
package main
import (
"fmt"
)
func main() {
//变量类型推导
var name string= "123"
sample1 := name
sample2 := 123
fmt.Printf("sample1的Type是%T\n",sample1)
fmt.Printf("sample2的Type是%T",sample2)
}
4 常量
4.1 常量的声明
- 常量的声明与变量类似,但是使用的关键字是
const
。 - 常量可以是字符、字符串、布尔值或者数值。
- 常量不能使用
:=
语法声明。
例子:
package main
import "fmt"
func main() {
//常量使用
const name = "世界"
const guess = true
const num = 3.14
fmt.Println("hello,",name)
fmt.Println("Guess?",guess)
fmt.Println("优秀数字:",num)
}
结果
4.2 高精度的数值常量
数值常量是高精度的值。
一个没有指定类型的常量是由使用它的上下文来决定它的类型的。
例子:
package main
import "fmt"
const (
//1左移100位
Big = 1<<100
//Big右移99位
Small = Big>>99
)
func needInt(num int) int {
return num*10+1
}
func needFloat(num float64) float64 {
return num/10
}
func needComplex128(num complex128) complex128 {
return num+5i
}
func main() {
//常量根据使用变更类型
fmt.Println(needInt(Small))
fmt.Println(needFloat(Small))
fmt.Println(needComplex128(Big))
}
结果: