函数高级
// 函数
1 没有参数没有返回值 fun 函数名(){}
2 有参数没有返回值 fun 函数名(a int){}
3 多个参数同一种类型,可以简写 fun 函数名(a,b int){}
4 多个参数同一种类型,有返回值可以简写 fun 函数名(a,b int)int{ retrun a+b}
5 多个返回值fun 函数名(a,b int)(int,string){ retrun a+b,'成功'}
// 函数高级
1 匿名函数,定义在函数内部,没有名字
var f func()=func(){}
头等函数
一等公民
2 闭包函数
定义在函数内部,对外部作用域有引用
3 函数也是一种类型,参数和返回值都是类型的一部分
4 一个函数可以返回另一个函数
package main
import "fmt"
// 1 函数的参数和返回值都是类型的一部分,函数可以赋值给一个变量
// test3 函数,接收一个参,参数是函数类型:没有参数没有返回值
// test 有返回值,返回值是个函数:函数有两个参数,一个返回值
//func test3(a func()) func(int, int) int {
// a()
// return func(x, y int) int {
// return x + y
// }
//}
// 2 类型重命名
// 可以给类型重命名
// 如果 type Myint int 相当于我们新定义了一个类型,叫Myint
// 如果 type Myint = int 只是重命名,没有新定义类型
type MyFunc func(int, int) int
type Myint = int
func test3(a func()) MyFunc {
a()
return func(x, y int) int {
return x + y
}
}
// 3 函数可变长参数
// 可以传任意长度的int类型参数
func test4(a ...int) {
fmt.Println(a) //[3 4 5 6 7 7 8 89 9 99] 切片
fmt.Printf("%T", a) // 类型是 int类型切片 []int
}
// 4 defer 关键字
func main() {
//var a Myint = 9
//var b int = 19
//fmt.Println(a + b)
//fmt.Println(6,3,4,5,5,6,76,7,8)
// 完整定义
//var f MyFunc = test3(func() {
// fmt.Println("被传入的函数")
//})
//res := f(10, 19)
//fmt.Println(res)
// 3 可变长参数
//test4(3, 4, 5, 6, 7, 7, 8, 89, 9, 99)
// 4 defer 延迟调用, 当前函数所有代码都执行完了,再执行defer的内容,先注册,后调用 ,先写的defer后来执行
//var a = 10
//defer func(i int) {
// fmt.Println(i)
// fmt.Println("我很帅")
//
//}(a)
defer fmt.Println("我很帅")
defer fmt.Println("我很帅222")
//a = 99
fmt.Println("我不觉得")
fmt.Println("我也不觉得")
}
包的使用
# python 模块和包
模块是一个py文件
包是一个文件夹 有 __init__
# go 包 ---》包是在一个文件夹下,这个文件夹下所有go文件的第一行要声明包
一堆go文件的组合
# 使用步骤
新建文件夹,写多个go文件,包名必须一致
# 注意点:
'''
// 1 包内部,大写开头,表示导出 变量,函数。。。
// 2 包内部的变量函数,只能定义一次
// 3 包内部的所有东西,在包内部直接使用
// 4 包名可以跟文件夹名不一样,但是一个文件夹下只能有一个包
// 5 导入包,按路径导入,如果不重命名,就是文件夹必须跟包名一样
//如果文件夹跟包名不一样,要重命名,可以命名成任意的,但是我们叫了包名 import lqz "go_day03/utils"
//可以命名成任意的 import qqq "go_day03/utils"
// 以后使用包名. 调用即可
// 6 包内的init函数,可以定义多次,只要导入包,就会依次执行init
// 7 导入包,必须使用,不使用就报错,现在就不用,只想执行init, import _ "go_day03/utils"
// 8 一个文件夹下可以再建文件夹建新的包,各个文件夹直接没有必然联系,只是文件夹层级关系
// 9 使用的go mod模式,从1.11后都是这种模式,项目根路径下会有一个go.mod
'''
# 之前有个go path模式,已经弃用了,它的包导入,不是从项目路径下开始导入,而是从go path 的src路径下路径下开始导入
# gosdk内置包,自定义包和第三方包
gin:开一个web服务
安装第三方包
# 使用gin
配置代理:七牛云
局部:goland中:GOPROXY=https://goproxy.cn,direct
全局:改全局go env
安装: go get github.com/gin-gonic/gin
写代码:
package main
import "github.com/gin-gonic/gin"
func main() {
r := gin.Default()
r.LoadHTMLGlob("templates/*")
r.GET("/", func(c *gin.Context) {
c.JSON(200, gin.H{
"code": "100",
"message": "成功",
})
})
r.GET("/index", func(c *gin.Context) {
c.HTML(200, "index.html", gin.H{"name": "刘清政", "age": 19})
})
r.Run() // listen and serve on 0.0.0.0:8080
}
if-else
#基本格式
if 条件{
}else if 条件{
}else{
}
//示例:
package main
import (
"fmt"
)
// if-else
func main() {
score := 55
if score >= 90 {
fmt.Println("优秀")
} else if score >= 80 && score < 90 {
fmt.Println("良好")
} else if score >= 60 {
fmt.Println("及格")
} else {
fmt.Println("不及格")
}
}
循环
// python while for
// go 只有 for循环
// java while ,for do while
// go的for循环能实现while循环的功能
package main
// 循环
func main() {
// 1 基本语法 for关键字 定义变量i=0;i<10;i++{} 三部分都可以省略,但是一般会保留第二部分,第二部分是条件
//// 2 循环打印0--9
//for i := 0; i < 10; i++ {
// fmt.Println(i)
//}
//fmt.Println(i) // i的作用域范围只在for内部有效
// 3 循环打印0--9 省略掉第一部分 分号不能省
//i := 0
//for ; i < 10; i++ {
// fmt.Println(i)
//}
//fmt.Println(i) // 10
// 4 循环打印0--9 第三部分 分号不能省
//for i := 0; i < 10; {
// fmt.Println(i)
// i++
//}
// 5 循环打印0--9 省略第一部分和第三部分 分号能省略
//i := 0
//for i < 10 {
// fmt.Println(i)
// i++
//}
// 6 for 条件 {} while 循环
//for true {
// fmt.Println("llll")
//}
// 死循环
//for {
// fmt.Println("llll")
//}
//7 上面是基于索引的循环,这个案例是基于迭代的
s := "lqz国中"
//for i, v := range s {
// fmt.Println(i)
// fmt.Println(string(v))
//}
//for i := 0; i < len(s); i++ {
// fmt.Println(string(s[i]))
//}
}
switch
switch 是一个条件语句,用于将表达式的值与可能匹配的选项列表进行比较,并根据匹配情况执行相应的代码块,优雅的替换掉else-if
package main
import "fmt"
func main() {
// 1 switch 基本使用
//score := 90
//switch score {
//case 90:
// fmt.Println("我是90")
//case 80:
// fmt.Println("我是80")
//case 70:
// fmt.Println("我是70")
//}
//// 2 default 的使用
//score := 99
//switch score {
//case 90:
// fmt.Println("我是90")
//case 80:
// fmt.Println("我是80")
//case 70:
// fmt.Println("我是70")
//default:
// fmt.Println("不知道")
//}
// 3 多表达式判断
//score := 66
//switch score {
//case 90, 91, 92, 98, 99:
// fmt.Println("我是90")
//case 80, 88:
// fmt.Println("我是80")
//case 70:
// fmt.Println("我是70")
//default:
// fmt.Println("不知道")
//}
// 4 无表达式
//score := 66
//switch {
//case score > 90:
// fmt.Println("我是90")
//case score > 80 && score < 90:
// fmt.Println("我是80")
//case score >= 60:
// fmt.Println("大于60")
//default:
// fmt.Println("不知道")
//}
//5 Fallthrough 默认情况下,每个条件之间完,默认加break,但是也不用加,其他语言要加,其他语言去掉break,会无条件执行下一个case
// 要无条件执行下一个case,需要使用fallthrough
score := 99
switch {
case score > 90:
fmt.Println("我是90")
case score > 80 && score < 90:
fmt.Println("我是80")
fallthrough // 无条件执行下一个case
case score >= 60 && score <= 80:
fmt.Println("大于60")
fallthrough
default:
fmt.Println("不知道")
}
}
数组
// 数组是同一类型元素的集合。例如,整数集合 5,8,9,79,76 形成一个数组。
// Go 语言中不允许混合不同类型的元素,例如包含字符串和整数的数组
// 数组是连续存储,存储同一个类型的数据结构
标签:case,int,fmt,else,Println,switch,score,func,go
From: https://www.cnblogs.com/xm15/p/17356997.html