一、指针类型
1、普通类型,变量存的就是值,也叫值类型。指针类型存的是地址
2、获取变量的地址,用&,比如:var a int, 获取a的地址 &a
3、指针类型,变量存的是一个地址,这个地址存的才是值
4、获取指针类型所指向的值,使用:* ,比如:var p *int,使用*p获取p指向的变量的值
var a int = 5
var p *int = &a 0xefefefe 指向变量a的值是 5
5、指针类型的变量初始话有两种:
5.1、直接给指针赋值其他变量的地址
func test3(){
var p *int //默认初始化nil
var a int
p = &a
*p = 200
fmt.Println(a)
}
5.2、使用new分配
func test4(){
var p *int
p = new(int)
*p = 2000
fmt.Println(*p)
}
6、练习题
6.1、练习1:写一个程序,获取一个变量的地址,并打印到终端
package main
import (
"fmt"
)
func test1(){
var a int = 5
var p *int = &a
fmt.Printf("a的地址是:%p\\n",p)
fmt.Printf("a的值是:%d",*p)
}
func main(){
test1()
}
运行打印的结果如下:
6.2、练习2:写一个函数,传入一个int类型的指针,并在函数中修改所指向的值
func modify(x *int){ //传入的变量x类型是指针 *int代表指针是整形的指针
*x = 200 //给x指针指向的值重新赋值为200
}
func test2(){
var a int = 5 //定义一个整形的变量a,初始值是5
var p *int = &a //定义一个指针p,指向的是a
fmt.Println("变量a的初始值是",a) //打印a的初始值
modify(p) //修改p指针指向的a的值
fmt.Println("p指针指向的a变量的改变值是",a) //打印a的值改变的结果
}
func main(){
test2()
}
执行打印的结果如下:
二、内置函数
1、close:主要用来关闭channel
2、len:用来求长度,比如string、array、slice、map、channel
3、new:用来分配内存,主要用来分配值类型,比如int、struct。返回的是指针。示例可以看上面一的5.2,
4、make:用来分配内存,主要用来分配引用类型,比如channel、map、slice
5、append:用来追加元素到数组、slice中
6、panic和recover:用来做错误处理
7、new和make的区别
7.1、内建函数 new 用来分配内存,它的第一个参数是一个类型,不是一个值,它的返回值是一个指向新分配类型零值的指针
7.2、内建函数 make 用来为 slice,map 或 chan 类型分配内存和初始化一个对象(注意:只能用在这三种类型上),跟 new 类似,第一个参数也是一个类型而不是一个值,跟 new 不同的是,make 返回类型的引用而不是指针,而返回值也依赖于具体传入的类型,具体说明如下:
Slice: 第二个参数 size 指定了它的长度,它的容量和长度相同。
你可以传入第三个参数来指定不同的容量值,但必须不能比长度值小。
比如 make([]int, 0, 10)
Map: 根据 size 大小来初始化分配内存,不过分配后的 map 长度为 0,如果 size 被忽略了,那么会在初始化分配内存时分配一个小尺寸的内存
Channel: 管道缓冲区依据缓冲区容量被初始化。如果容量为 0 或者忽略容量,管道是没有缓冲区的
7.3、总结:
new 的作用是初始化一个指向类型的指针(*T),make 的作用是为 slice,map 或 chan 初始化并返回引用(T)。
三、函数
1、声明语法:func 函数名(参数列表)[(返回值列表)]{}
func add(){
}
func add(a int,b int){
}
func add(a int, b int) int {
}
func add(a int, b int) (int , int){
}
func add(a , b int) (int , int){
}
2、golang函数的特点:
a、不支持重载,一个包不能有两个名字一样的函数;
b、函数是一等公民,函数也是一种类型,函数也可以赋值给变量
c、匿名函数
d、多返回值
示例:
type add_func func(int, int)int
func oprator(op add_func,a int,b int)int {
//使用传进来的函数op,进行操作
return op(a,b)
}
func add(a,b int) int {
return a + b
}
func main(){
c:=add
fmt.Println(c)
sum := oprator(c,100,200)
}
3、函数参数传递方式:
3.1、值传递
3.2、引用传递
注意1:无论是值传递,还是引用传递,传递给函数的都是变量的副本。值传递是值的拷贝,一般来说地址拷贝更高效。值拷贝取决于拷贝的对象的大小,对象越大,性能越低。
注意2:map、slice、channel、指针、interface默认以引用的方式传递
func reduce(a , b int)(c int){
c = a - b
return
}
//重命名多个返回值
func calc(a,b int)(sum int,avg int){
sum = a + b
avg = sum/2
return
}
// _ 忽略返回值
func main(){
sum,_ := calc(100,200)
}
5、可变参数:
多个参数
func test11(arg...int) int{
}
一个或多个参数
func test11(a int ,arg...int) int{
}
二个或多个参数
func test11(a int,b int ,arg...int) int{
}
注意:其中arg是一个slice,我们可以通过arg[index]来获取多个参数
通过len(arg)来判断传递参数的个数
6、练习题示例
package main
import (
"fmt"
)
//练习题一:写一个函数add,支持1个或多个int相加,并返回结果
func add(a int,arg...int)int{
var sum int
//当只有一个参数时
if len(arg)==0{
sum = a
}
//当参数大于一个时
if len(arg)>0{
for i:=0;i<len(arg);i++{
//注意这里但arg里面只有一个参数时,i是等于0即arg[0]
if i == 0 {
sum = a + arg[0]
}
//当arg参数大于一个时
if i >0 {
sum+=arg[i]
}
}
}
return sum
}
//练习题二:写一个函数concat,支持1个或多个string相拼接,并返回结果
func concat(a string,arg...string)string{
var str string
if len(arg)==0{
str = a
}
if len(arg)>0{
for i:=0;i<len(arg);i++{
if i == 0 {
str = a + arg[0]
}
if i >0 {
str+=arg[i]
}
}
}
return str
}
func main(){
fmt.Println(add(-22,23,555))
fmt.Println(concat("aaa","bbbbb","ccccccc"))
}
7、defer的特点和用途
7.1、当函数返回时,执行defer语句。因此可以用来做资源清理
7.2、多个defer语句,按先进后出的方式执行
示例:
func a(){
fmt.Println("defer from a")
i:=0
defer fmt.Println(i) //defer语句中的变量,在defer声明时就决定
i++
}
func f(){
fmt.Println("defer from f")
for i:=0;i<5;i++{
defer fmt.Println(i)
}
}
func main(){
//练习三
a()
f()
}
打印的结果:
7.3、defer语句中的变量,在defer声明时就决定了
7.4、defer用途:关闭文件句柄,锁资源释放,数据库连接释放
四、递归函数
1、一个函数调用自己,就叫递归函数
2、斐波那契数
//斐波那契数列示例:
func fb( n int)int{
if n <=1{
return 1
}
return fb(n-1)+fb(n-2)
}
func main(){
for i:=0;i<10;i++{
n := fb(i)
fmt.Println(n)
}
}
3、递归的设计原则
3.1、一个大问题能够分解成相似的小问题
3.2、定义好出口条件(即结束递归循环的条件)
五、闭包
一个函数和与其相关的引用环境的组合成的实体
//示例一:
func Adder() func(int)int{
var x int
return func(delta int)int{
x +=delta
return x
}
}
//示例2:
func makeSuffixFunc(suffix string) func(string)string{
return func(name string)string{
if !strings.HasSuffix(name ,suffix){
return name + suffix
}
return name
}
}
func main(){
//练习五:闭包
//示例1:
// var f = Adder()
// fmt.Println(f(1))
// fmt.Println(f(10))
// fmt.Println(f(100))
//示例2:
func1 := makeSuffixFunc(".jpg")
func2 := makeSuffixFunc(".txt")
fmt.Println(func1(func1("test")))
fmt.Println(func2("test"))
}
六、数组和切片
1.1、排序和查找操作
排序操作主要都在sort包中,导入就可以使用
sort.Ints对整数进行排序, sort.Strings对字符串串进⾏行行排序, sort.Float64s对 浮点数进⾏行行排序.
sort.SearchInts(a []int, b int) 从数组a中查找b,前提是a 必须有序
sort.SearchFloats(a []float64, b float64) 从数组a中查找b,前提是a 必须有序
sort.SearchStrings(a []string, b string) 从数组a中查找b,前提是a 必须有序