一、函数
1、函数基本用法
函数的参数与返回值
//定义一个无参无返回值的函数
func sss() {
fmt.Println("今天小仙女超级超级开心呀！")
}
//定义一个有参无返回值的函数
func aaa(a string, b, c int, d float64) {
fmt.Printf("姓名:%s\n年龄：%d\n开心指数；%d\n爆表指数：%f\n", a, b, c, d)
}
//定义一个不定参数的函数
func bbb(g ...int) {
//输出不定参数的长度
fmt.Println("len(g)=", len(g))
//输出不定参数
for i := 0; i <= len(g)-1; i++ {
fmt.Printf("g[%d]=%d\n", i, g[i])
}
//使用foreach语句遍历输出各元素
for i, j := range g {
fmt.Printf("g[%d]=%d\n", i, j)
}
}
//定义一个无参有返回值的函数
func ggg() (int, int, int) { //返回值无名字
return 1, 2, 3
}
func hhh() (d string, e string, f string) { //定义返回值的名字
d = "小仙女今天没有课哈哈！"
e = "小仙女今天中午吃饭啦！"
f = "小仙女今天中午睡午觉啦！"
return
}+
//定义一个有参有返回值的函数
//max min 是返回值名称，其顺序和返回值顺序一样
//g h 是形参
func iii(g, h int) (max, min int) {
if g > h {
max = g
min = h
} else {
max = h
min = g
}
return
}
不定参数的传递
//不定参数传递
//参数的全部传递
func ddd(s ...string) {
//将ddd全部参数传递给ccc
ccc(s...)
}
func ccc(s ...string) {
//输出参数长度
fmt.Println("len(s)=", len(s))
//输出不定参数
for i := 0; i <= len(s)-1; i++ {
fmt.Printf("s[%d]=%s\n", i, s[i])
}
//用foreach语句遍历输出各元素
for i, j := range s {
fmt.Printf("s[%d]=%s\n", i, j)
}
}
//参数的部分传递
func eee(h ...string) {
//将eee不定参数的前几位传递过去给fff
fff(h[:2]...) //传递h[0]~h[2](不包括h[2])
//将不定参数的后面几位传递过去
fff(h[2:]...) //传递h[2]之后的全部参数(包括h[2])
}
func fff(h ...string) {
//输出参数长度
fmt.Println("len(h)=", len(h))
//用foreach语句遍历输出各元素
for i, j := range h {
fmt.Printf("h[%d]=%s\n", i, j)
}
}
2、函数类型
递归函数
package main
import (
"fmt"
)
//实现1到100的求和
func C() {
var sum int
for i := 1; i <= 100; i++ {
sum += i
}
fmt.Printf("sum=%d\n", sum)
}
//递归函数求1到100的和
func A(i int) int {
if i == 100 {
return 100
}
return i + A(i+1)
}
func B(i int) int {
if i == 1 {
return 1
}
return i + B(i-1)
}
//Fibonacci数列
func D(i int) int {
if i == 1 || i == 2 {
return i - 1
}
return D(i-1) + D(i-2)
}
func main() {
sum := A(1)
fmt.Println(sum)
sum = B(100)
fmt.Printf("sum=%d\n", sum)
C()
fmt.Println("*****************************************")
var h int
fmt.Printf("请输入一个正整数：")
fmt.Scan(&h)
result := D(h)
fmt.Printf("result=%d\n", result)
}
回调函数
//函数也是一种数据类型，通过type给一个函数类型起名
//没有函数名字，没有{}
type FuncType func(int,int) int
//实现求和
func sum(a,b int) int {
return a+b
}
//回调函数 函数有一个参数是函数类型
func aaa(a,b int , c FuncType) int {
return c(a,b)
}
func main() {
e := aaa(7,9,sum)
fmt.Println("result=",e)
}
package main
import (
"fmt"
)
type FuncType func(int, int) int
//类型别名
// type long int
// type char byte
//返回值没有定义名称，return后直接写返回的表达式
func X(a int, b int) int {
return a + b
}
func Y(a, b int) int {
return a - b
}
func Z(a, b int) int {
return a * b
}
func main() {
var s FuncType
s = X
g := s(1, 2)
fmt.Printf("result=%d\n", g)
s = Y
g = s(1, 2)
fmt.Printf("result=%d\n", g)
s = Z
g = s(1, 2)
fmt.Printf("result=%d\n", g)
fmt.Println("------------------------------------")
g = qqq(2, 3, 4, a)
fmt.Printf("result=%d\n", g)
g = qqq(2, 3, 4, b)
fmt.Printf("result=%d\n", g)
g = qqq(2, 3, 4, c)
fmt.Printf("result=%d\n", g)
}
//回调函数
type hhh func(int, int, int) int
func qqq(x int, y int, z int, m hhh) int {
fmt.Println("@@@@")
return m(x, y, z)
}
func a(x int, y int, z int) int {
return x * y * z
}
func b(x int, y int, z int) int {
return x + y + z
}
func c(x int, y int, z int) int {
return x*y + z
}
匿名函数
package main
import (
"fmt"
)
func main() {
a := 7
str := "小仙女"
func (){
a = 9
str = "嘿嘿嘿"
fmt.Println(a,str)
}()
fmt.Println(a,str)
//匿名函数,没有函数名字
//用变量f1接收函数
f1 := func (){
fmt.Printf("a=%d\nstr=%s\n",a,str)
}
f1()//函数的调用
//给函数起一个别名(sss)然后调用
type sss func()
//声明一个函数类型的变量f2
var f2 sss
//将f1赋值给f2
f2 = f1
//调用函数
f2()
//定义匿名函数，同时调用
func (){
fmt.Printf("a=%d\nstr=%s\n",a,str)
}() //()代表调用此匿名函数
//函数必须调用 否则报错 或者可以找变量接收 如f1
//带参数的匿名函数
f3 := func (i, j int){
fmt.Printf("result = %d\n",i+j)
}
f3(10,20)
func (i,j int){
fmt.Printf("result = %d\n",i*j)
}(10,20)
//带参数有返回值的匿名函数
c,d:=func (m,n int) (max,min int){
if m>n{
max = m
min = n
}else{
max = n
min = m
}
return
}(10,20)
fmt.Println(c,d)
f4:= func (x,y string) string {
fmt.Println(x,y)
return x+y
}
f4("可可爱爱","开开心心")
//给函数起一个别名并调用
type ggg func(string,string)string
var f5 ggg
f5 = f4
f5("阳光很暖","微风正好")
}
3、defer的用法(先入后出)
func main() {
a := 10
b := 20
defer func(){
fmt.Println(a,b) //a=7 b=9
}()
a = 7
b = 9
fmt.Println(a,b)
x := 2
y := 3
defer func(x,y int){
fmt.Println(x,y) //x=2 y=3 参数先传过 然后等待执行
}(x,y)
x = 5
y = 6
fmt.Println(x,y)
}
4、闭包与匿名函数
package main
import "fmt"
func main() {
fmt.Println(aaa()) //1
fmt.Println(aaa()) //1
fmt.Println(aaa()) //1
// 将调用bbb()返回的函数赋给变量f
f := bbb()
//调用返回的函数
fmt.Println(f()) //1
fmt.Println(f()) //4
fmt.Println(f()) //9
//直接一次性调用bbb()和返回的函数
fmt.Println((bbb())()) //1
fmt.Println((bbb())()) //1
fmt.Println((bbb())()) //1
}
func aaa() int{
//函数被调用时 x才分配空间 初始化为0
var x int //没有初始化 值为0
x++
return x*x //函数调用完毕 x 自动释放
}
//返回值为一个匿名函数[fnuc() int] 返回一个函数类型
func bbb() func() int{
var x int
i:= func() int{
x++
return x*x
}
return i
}
二、指针变量
package main
import "fmt"
func main(){
var a int = 123
fmt.Printf("a = %d\n",a)//变量的内存
fmt.Printf("&a = %v\n",&a)//变量的地址
//保存某个变量的地址 需要指针类型 *int 保存 int 的地址, **int 保存 *int 的地址
//定义一个变量p 类型为*int
var p *int
// 指针变量指向谁 就把谁的地址赋给变量
p = &a
fmt.Printf("p = %v,a &a = %v\n",p,&a)
//*p操作的不是p的内存 是p指向的内存 即a
*p = 111 //a=111
fmt.Printf("*p = %v,a = %v\n",*p,a)
fmt.Println("****************************************8")
x,y:=10,20
//变量本身传递，即值传递
swap1(x,y)
fmt.Printf("x = %d , y = %d\n",x,y)
//变量地址传递，即址传递
swap2(&x,&y)
fmt.Printf("x = %d , y = %d\n",x,y)
}
func swap1(x,y int){
x,y = y,x
fmt.Printf("x = %d , y = %d\n",x,y)
}
func swap2(p1,p2 *int){
*p1,*p2=*p2,*p1
}
三、数组与切片
1、数组
package main
import "fmt"
func main(){
//声明一个数组
var arr1 [3]int
//方法一 给数组各元素赋值
k:=0
for i:=0;i<3;i++ {
k++
arr1[i] = k
}
fmt.Println("arr1 = ",arr1)
//方法二 给数组各元素赋值
for i := 0;i<len(arr1);i++{
arr1[i]=i+3
}
fmt.Println("arr1 = ",arr1)
//用forrange语句遍历输出各元素
for m,n := range arr1{
fmt.Printf("arr[%d]=%d\n",m,n)
}//[3,4,5] 就近原则
//声明一个数组并完成初始化
arr2 := [3]int{1,2,3}
for i:=0;i<3;i++{
fmt.Printf("arr2[%d]=%d\n",i,arr2[i])
}
//数组的部分初始化 没有初始化的默认为0
arr3 := [3]int{0:7,2:9}
for i:=0;i<3;i++{
fmt.Printf("arr3[%d]=%d\n",i,arr3[i])
}
//数组的比较 只比较各元素是否相等
arr4 := [5]int{1,2,3,4,5}
arr5 := [5]int{1,2,3,4,5}
arr6 := [5]int{2,3,4,5,7}
fmt.Println("arr4==arr5",arr4==arr5) //true
fmt.Println("arr5==arr6",arr5==arr6) //false
//二维数组
//有多少个[]就用多少各循环
var a [3][5]int
q := 0
for i:=0;i<3;i++{
for j := 0;j<5;j++{
q++
a[i][j] = q
//输出第一行的元素
fmt.Printf("a[%d][%d] = %d ",i,j,a[i][j])
}
//换行
fmt.Printf("\n")
}
fmt.Println("a = ",a)
//多维数组的初始化
s := [3][4]int {{1,2,3,4},{5,6,7,8},{9,10,11,12}}
fmt.Println("s=",s)
2、切片
package main
import(
"fmt"
)
//数组做函数参数 是值传递
//实参数组的每个元素给形参数组拷贝一份
//形参数组是实参数组的复制品
func sss(a [5]int){
a[0] = 7
fmt.Println("a1 = ",a)
}
func main() {
a := [5]int{1,2,3,4,5}
sss(a)
fmt.Println("a2 = ",a) //[7,2,3,4,5]
array := [...]int{1,2,3,4,5,6,7,8,9}
slice := array[0:3:5]
//此切片是从数组array的第0个元素开始取（3-0）个元素 长度为（3-0=3） 容量为（5-0=5）
//[low : high : max]
//low 下标的起点
//high 下标的终点(不包括此下标) [a[low],a[high]]左闭右开
//长度：len = high-low 容量: cap = max-low
fmt.Println("array = ",array)
fmt.Println("len(array) = ",len(array))
fmt.Println("cap(array) = ",cap(array))
fmt.Println("slice = ",slice)
fmt.Println("len(slice) = ",len(slice))
fmt.Println("cap(slice) = ",cap(slice))
b := array[2:7:9]//从第3个元素[下标为2]开始取5个元素 长度为5 容量为7
fmt.Println("b = ",b)
fmt.Println("len(b) = ",len(b))
fmt.Println("cap(b) = ",cap(b))
e := b[:]//[0:len(b):len(b)] 不指定容量和长度一样
fmt.Println("e = ",e)
fmt.Printf("len(e) = %d,cap(e) = %d\n",len(e),cap(e))
//append函数 给slice末尾添加数据 返回新的slice对象
//添加一个元素
b = append(b,999)
fmt.Println("b = ",b)
//添加两个元素
b = append(b,666,777)
fmt.Println("b = ",b)
//copy函数
x :=[]int{3,4}
y :=[]int{6,7,8,9,0}
copy(y,x)//后面的代替前面的
fmt.Println("y = ",y) //[3,4,8,9,0]
//自动推导类型 同时初始化
c := []int {6,7,8,9}
fmt.Println("c = ",c)
//make函数 格式 make(切片类型，长度，容量)
d := make([]int,4,4)
fmt.Println("d = ",d)
fmt.Printf("len(d) = %d,cap(d) = %d\n",len(d),cap(d))
//操作某个元素
f := c[1]
fmt.Println("f = ",f)
g := c[1:4:4]
fmt.Println("g = ",g)
fmt.Printf("len(g) = %d,cap(g) = %d\n",len(g),cap(g))
//从0开始取2个元素
h :=c[:2] //[6,7]
fmt.Println("h = ",h)
fmt.Printf("len(h) = %d,cap(h) = %d\n",len(h),cap(h))
//从下标为2（即第三个元素）开始取到末尾
i :=c[2:]
fmt.Println("i = ",i)
fmt.Printf("len(i) = %d,cap(i) = %d\n",len(i),cap(i))
aa :=[]int{1,2,3,4,5,6,7}
//新切片
bb :=aa[1:4] //从aa[1]开始取3个元素 即[2,3,4,]
bb[1] =333
fmt.Println("bb = ",bb) //[2,333,4]
fmt.Println("aa = ",aa) //[1,2,333,4,5,6,7]
//另外新切片
cc :=aa[4:7]//从aa[4]开始取3个元素 即[5,6,7]
cc[1]=666
fmt.Println("cc = ",cc) //[5,666,7]
fmt.Println("aa = ",aa) //[1,2,333,4,5,666,7]
//
}
随机数
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//设置种子，只需一次
//如果种子参数一样，每次运行程序产生的随机数都一样
//rand.Seed(777)
rand.Seed(time.Now().UnixNano())//以当前系统时间作为种子参数
for i :=0;i<5;i++ {
//产生随机数
//fmt.Println("rand = ", rand.Int())//产生的随机数很大
fmt.Println("rand = ",rand.Intn(100))//限制在100以内
}
}
四、map
package main
import "fmt"
func main() {
//定义一个类型为 map[int]string 的变量
var a map[int]string
//a[1] = "ggg" 错误 没有初始化故不能赋值
//对于map 只有len(len=0) 没有cap
fmt.Println("len(a) = ",len(a))
fmt.Println("a = ",a)
//用make创建一个map
b := make(map[int]string)
//可以赋值
b[1] = "aaa"
b[2] = "bbb"
b[3] = "ccc"
fmt.Println("len(b) = ",len(b))
fmt.Println("b = ",b)
//声明一个map并进行初始化
c :=map[int]string{1:"ggg",2:"sss",3:"hhh"}
fmt.Println("c1 = ",c)
c[1] = "iii" //修改原来的值
fmt.Println("c2 = ",c)
c[4] = "yyy" //增加一个值 自动扩容
fmt.Println("c3 = ",c)
//遍历输出 (map 的输出是无序的 所以每次输出的结果不一定相同)
for i,j := range c{
fmt.Printf("%d ==========> %s\n",i,j)
}
//判断一个key值是否存在
//第一个返回值为key所对应的value 第二个返回值是bool类型的 值存在即true 不存在即false
j,m := c[1]
if m == true{
fmt.Println("c[1] = ",j)
}else{
fmt.Println("key值不存在")
}
//删除某个值 delete
s :=map[int]string{1:"ggg",2:"sss",3:"hhh",4:"kkk"}
fmt.Println("s = ",s)
delete(s,2)
fmt.Println("s = ",s)
//map做函数参数传递
test(s) //函数内部删除某个值
fmt.Println("s = ",s) //在外部同样删除了
}
func test(s map[int]string){
delete(s,1)
}
五、结构体
package main
import (
"fmt"
)
func main() {
//顺序初始化 必须每个成员都初始化 否则报错
var s1 Student = Student{"hhh",3,1,12345,"北京"}
fmt.Println("s1 = ",s1)
//指定成员初始化 未初始化的成员自动赋值为0
s2 := Student{name:"hhh",addr:"北京"}
fmt.Println("s2 = ",s2)
//指针
var p1 *Student = &Student{"hhh",3,1,12345,"北京"}
fmt.Println("*p1 = ",*p1)
p2 := &Student{name:"hhh",addr:"北京"}
fmt.Println("*p2 = ",*p2)
//单独操作构体变量
var s Student
//s := new (Student) 用new为s分配一片空间
s.name = "hhh"
s.age = 3
s.sex = 1
s.id = 12345
s.addr = "北京"
fmt.Println("s = ",s)
//指针有合法指向后 才能操作成员
var g Student
var p3 *Student
p3 = &g
p3.name = "hhh"
(*p1).age = 3
p3.sex = 1
p3.id = 12345
p3.addr = "北京"
fmt.Println("*p3 = ",*p3)
//结构体比较
a1 := Student{"hhh",3,1,12345,"北京"}
a2 := Student{"hhh",3,1,12345,"北京"}
a3 := Student{"hhh",7,1,12345,"北京"}
fmt.Println("a1==a2",a1==a2)
fmt.Println("a1==a3",a1==a3)
//同类型的结构体可以相互赋值
var a4 Student
a4 = a3
fmt.Println("a4 = ",a4)
//函数作为参数的传递
test01(a4) //值传递
fmt.Println("a4 = ",a4) // 拷贝一份儿过去 故原来的值不改变
test02(&a4) //地址传递
fmt.Println("a4 = ",a4) //创建一个指针指向原来的地址 故值会改变
}
//定义一个结构体类型 存放学生变量
type Student struct{
name string
age int
sex int
id int
addr string
}
func test01(s Student){
s.name = "ggg"
fmt.Println("s = ",s)
}
func test02(p *Student){
p.name = "kkk"
}
1、结构体中指针的应用
package main
import(
"fmt"
)
func main() {
//g := Student{Person{"hhh",3,1},12345,"beijing"}}
//fmt.Println("g = ",g)
//定义一个变量
var x long = 2 // long为int的别名
//变量名.方法名(参数)
result := x.add(3)
fmt.Println("result = ",result)
}
type Person struct{
name string
age int
sex int
}
type Student struct{
Person
id int
addr string
}
//类型别名
type long int
//方法
func (a long)add(b long)long{ //(a = 2 b = 3)
return a+b
}
2、匿名字段
package main
import "fmt"
func main() {
//顺序初始化
var s1 Student = Student{Person{"hhh",3,1,},12345,"北京"}
fmt.Println("s1 = ",s1)
//自动推导类型
s2 := Student{Person{"hhh",3,1,},12345,"北京"}
fmt.Printf("s2 = %+v\n",s2) //%+v 使输出的s2更详细
//指定成员初始化 没有初始化的自动赋值为0
s3 := Student{Person:Person{name:"ggg"},addr:"上海"}
fmt.Printf("s3 = %+v\n",s3)
}
type Person struct{
name string
age int
sex int
}
type Student struct{
Person //只有类型 没有名字 匿名字段 继承了Person的成员
id int
addr string
}
