1.名称
函数、变量、常量、类型、语句标签和包名遵循规则:名称的开头是一个字母或下划线,后面可以跟任意数量的字符、数字和下划线,并且区分大小写
注:还有部分关键字等和其他语言类似不能使用,在此暂时忽略.
2.声明
四种主要声明:变量(var),常量(const),类型(type)和函数(func)
package main
import "fmt"
// 声明常量
const PI float64 = 3.1415926
// 声明类型
// 声明摄氏温度类型
type celsius float64
// 声明摄氏温度类型
type fahrenheit float64
func main() {
// 声明变量
var str string = "hello world"
//调用方法
print(str)
}
// 声明方法
func print(s string) {
fmt.Println(s)
}
3.变量
声明方式有下面几种:
var name type = expressionname:= expression
需要注意的是第二种,这种方式类型会根据expression自动推导出来,不是没有类型一说.Go语言是与JAVA等语言一样,属于强类型语言.
3.1指针
变量储存的地方.指针的值是一个变量的地址.并不是所有值都有地址,但是所有的变量都有.
Go指针.jpg
3.2new函数
使用new(T)函数创建变量,T代表类型.创建一个初始化为T类型的零值,并返回其地址(地址类型为*T)
package main
import "fmt"
func main() {
//使用内置函数new创建变量
i := new(int)
//打印i的类型和值
fmt.Printf("i type is:%T,value is:%d\n", i, *i)
}
打印的结果为:i type is:*int,value is:0
3.3变量的生命周期
- 包变量:整个程序的执行时间.
- 局部变量:每次执行声明语句时创建一个新的实例,一直生存到不可访问
4.赋值
赋值语句时用来更新变量所指的值.它由赋值符=,以及符号左边的变量和右边的表达式组成
x = 1 //有名称的变量
*p = true //间接变量
person.name = "bob" //结构体成员
count[x] = count[x] * scale //数组或slice或者map的元素
4.1多重赋值
允许多个变量一次性被赋值.
package main
import "fmt"
//声明
func main() {
// 同时给i,j,k赋值
i, j, k := 1, 2, 3
fmt.Printf("i=%d,j=%d,k=%d\n", i, j, k)
// 可以同时给不同类型的变量赋值
number, str := 0, "hello world"
fmt.Printf("number = %d,str = %s\n", number, str)
// 交换i和j的值,不需要借助第三个临时变量
i, j = j, i
fmt.Printf("i=%d,j=%d\n", i, j)
}
运行结果如下:
i=1,j=2,k=3
number = 0,str = hello world
i=2,j=1
4.2可赋值性
左边的变量和右边的值类型相同时才能赋值.nil可以被赋值给任何接口变量类型或者引用类型.
5.类型声明
变量或者表达式的类型定义这些值应有的特征.例如温度可以使用float64来表示,但是温度分为华氏和摄氏,华氏的30和摄氏的30所表达的温度值虽然一样,但是并不相同.
type声明定义一个新的命名类型,它和某个已有类型使用同样的底层类型.命名类型提供了一种方式来区分底层类型的不同或者不兼容使用,这样在使用时就不会混用.
type name underlying-type
package main
// 类型声明
type Celsius float64
// 声明摄氏温度类型
type Fahrenheit float64
// 声明多个常量
const (
//绝对零度
AbsoluteZeroC Celsius = -273.15
//结冰温度
FreezingC Celsius = 0
//沸腾温度
BoilingC Celsius = 100
)
// 摄氏温度转华氏温度
func CToF(c Celsius) Fahrenheit {
return Fahrenheit(c*9/5 + 32)
}
// 华氏温度转摄氏温度
func FToC(f Fahrenheit) Celsius {
return Celsius((f - 32) * 5 / 9)
}
6.包和文件
在Go中包的作用与其他语言的库或者模块类似,用于支持模块化,封装,编译隔离和重用.
每一个包给它的命名提供独立的命名空间.例如在image包中,Decode标识符和unicode/utf16包中的标识符一样,但是关联了不同的函数.在包外使用,需要明确修饰符标识符来指明是image.Decode或者unicode.Decode
包让我们可以通过控制变量在包外面的可见性或导出情况来隐藏信息. 导出的标识符以大写字母开头
文件src/study/ch1/customerunit/length.go如下所示:
package customerunit
// 声明千米类型
type KM float64
// 声明米类型
type M float64
// 声明厘米类型
type CM float64
// 进制 小写字母开头 对外不可见
var base float64 = 1000
// km 转换 m
func KM2M(k KM) M {
return M(k * KM(base))
}
// km 转 cm 小写字母开头 对外不可见
func kM2CM(k KM) CM {
return CM(k * KM(base*base))
}
文件src/study/ch1/packageDemo.go如下所示:
package main
import (
"fmt"
"study/ch1/customerunit"
)
func main() {
// 定义1千米
var distance customerunit.KM = 1
cm := customerunit.KM2M(distance)
fmt.Println(cm)
//在包外无法访问base
//fmt.Println(customerunit.base)
//在包外无法调用kM2CM
//customerunit.kM2CM(distance)
}
6.1导入
在Go中每一个包通过导入路径的唯一字符串来标识唯一的包.使用方式如下:
import "导入路径"
或者
import (
"导入路径1"
"导入路径2"
)
6.2包初始化
包的初始化从初始化包级别的变量开始.这些变量按照声明顺序初始化,在依赖已完毕的情况下,根据依赖顺序进行.
import "fmt"
var a = b + c //3.最后初始化a
var b = f() //2.通过调用f初始化b
var c = 1 //1.首先初始化c
func main() {
fmt.Printf("a=%d,b=%d,c=%d\n", a, b, c)
}
func f() int {
return c + 1
}
上面这种方式在其他语言,例如JAVA中是不被允许的.
如果包由多个.go文件组成,初始化按照编译器收到文件的顺序进行:go工具会在调用编译器前将.go文件排序
对于一些复杂的变量,可以通过init函数初始化.任何文件可以包含任意数量的init函数,该函数不能被调用或者被引用.
文件src/study/ch1/customerunit/initTest.go如下所示:
package customerunit
import "fmt"
var A = f()
var B int
func init() {
fmt.Println("customerunit init start")
fmt.Printf("A = %d,B = %d\n", A, B)
B = 2
fmt.Println("customerunit init over")
}
func f() int {
fmt.Println("A init")
return 1
}
文件src/study/ch1/packageInit2.go如下所示:
package main
import (
"fmt"
"study/ch1/customerunit"
)
func init() {
fmt.Println("packageInit2 init")
}
func main() {
fmt.Printf("customerunit.B : %d\n", customerunit.B)
}
最后运行结果如下所示:
A init
customerunit init start
A = 1,B = 0
customerunit init over
packageInit2 init
customerunit.B : 2
从中可以看出以下几点:
- 包变量会在
init()函数前初始化 -
mian在最后初始化.
网友评论