目录
补充:go变量定义推荐使用驼峰,文件名命名推荐使用下划线
函数
定义函数基本格式:
// func关键字 + 函数名 + (参数1,参数2,参数3) + {函数体内容}
package main
import "fmt"
// 这个位置不能写逻辑代码,只能变量和常量的定义
func main(){
// 调用函数
myFunc()
}
// 自定义函数 myFunc
func myFunc(){
fmt.Priltln("函数体执行内容")
}
1 函数基本定义(放在main前后都可以)
func test() {
fmt.Println("我是函数test")
}
2 带参数的函数
// 参数可以指定类型
func test(a int,b int) {
fmt.Println(a+b)
}
// 带参数的函数,两个参数类型相同，可以省略
func test(a ,b int,c string) {
fmt.Println(a+b) //a,b是int， c是string
}
3 带返回值(需要指定返回值类型是什么)
// 在参数后加类型即可
func test(a ,b int) int {
return a+b
}
// 多返回值（python中可以 返回的是元祖）,我们这里返回两个int类型
func test(a ,b int) (int,int) {
return a+b,b*a
}
4 可变长参数
// 可变长，接收任意长度的参数 (参数1 + ... + 类型)
func test(a ...int){
fmt.Println(a)
}
// go中只有位置参数，没有关键字参数一说,没有默认参数
5 匿名函数
匿名函数:（没有名字的函数）,一定要定义在函数内部
func test() {
//匿名函数直接加括号
func (){
fmt.Println("我是匿名函数")
}() // 注意这里加了括号执行了
}
func test() {
//赋值给一个变量
var a func()
a =func (){
fmt.Println("我是匿名函数")
}
a() // 执行
//a是个什么类型
fmt.Printf("%T",a) // func()
}
6 函数这个类型,它的参数，返回值，都是类型的一部分
var a func()
var b func(a,b int)
var c func(a,b int)int
var d func(a,b int)(int,string)
// 以上的类型都不相同
7 闭包
定义: 定义在函数内部 , 对外部作用域有引用
# python代码
def index():
def func():
print("hello")
return func
a = index()
a()
// go代码闭包
func test() func() {
// 变量接收函数
a := func() {
fmt.Println("我是内层函数")
}
// 返回a 但是返回值需要定义类型 我们可以打印下a的类型
fmt.Printf("%T",a) // 我们发现a的类型是func()
// 那么我们就返回类型为func()
return a
}
// 如果内层函数有参数
func test2() func(x,y int) string {
//只是一个内层函数
a:= func(x,y int) string {
fmt.Printf("我是内层函数")
return "我是内层函数的返回值"
}
return a
}
// 这里的返回值 他怎么定义的就需要怎么返回 包括放回值 func(x,y int) string
//闭包函数，闭包函数，就是多了一种函数传参的方式
8 给函数类型重命名
// 因为每一次放回都特别多特别麻烦所以可以给函数的类型重命名
type Myfunc func (z int) int
//给 函数类型 重命名
type Myfunc func(z int)int
func test(x,y int) Myfunc {
//只是一个内层函数
a:= func(z int)int {
fmt.Println(x+y+z)
return x+y+z
}
return a
}
9 返回值默认值
//返回值默认值
func test()(a int,b string) {
// a和b不需要定义，直接使用
// return的时候，不需要指定了
a=0
b="ok"
return
}
func test() {
//这样写，有没有返回值
return
fmt.Printf("xxx")
}
10 补充
匿名空接口（目前不用看）
//补充Println函数可以传任意的数据类型
fmt.Println(1,"lqz",3.45)
//interface{} 应该是所有类型的鼻祖，int，string，float32都属于interface{}类型
//接口，匿名空接口
包
package main
import "s12_day02/mypacakge" //导包的时候，是从gopath的src路径下开始导
import "fmt"
//同一个文件夹下只能有一个包，也就是package 后面 的名字都要一致 默认就跟文件夹名字一样即可
//同一个包下有两个名字相同的函数是不行的
//使用包，需要导入
func main() {
mypackage.MyPackageTest()
//以大写字母开头表示导出（外部包可以使用），小写字母开头，外部包不能使用，只能再包内部适应
mypackage.test()
fmt.Println("xxx")
}
总结：
1 新建一个文件夹（包），包下新建任意多个go文件，但是包名都必须一致（建议就用文件夹名）
2 在包内定义的函数，大写字母开头，表示外部包可以使用，小写字母开头，表示只能再内部使用,直接使用即可
3 在其他包中使用，要先导入（goland有自动提示）
-import "s12_day02/mypacakge"
-包名.函数（）
4 公有和私有 就是大小写区分的
5 所有的包必须在gopath的src路径下，否则找不到
if-else语句
package main
import "fmt"
func main() {
//1 语法
if 条件 {
//符合上面条件的执行
}
else if 条件{
//符合上面条件的执行
}else {
// 不符合上面的条件执行这个
}
}
package main
import "fmt"
func main() {
var a =10
if a<9{
fmt.Println("小于9")
}else if a==10{
fmt.Println("10")
}else {
fmt.Println("都不符合")
}
}
package main
import "fmt"
func main() {
//作用域范围不一样
if a:=10;a<9{
fmt.Println("小于9")
}else if a==10{
fmt.Println("10")
}else {
fmt.Println("都不符合")
}
}
循环
package main
//循环：go中，没有while循环，只有一个for循环，for可以替代掉while
func main() {
//1 语法,三部分都可以省略
/*
for关键字 初始化;条件;自增自减{
循环体的内容
}
*/
}
// 示例 从0 打印到9
for i:=0;i<10;i++{
fmt.Println(i)
}
break continue:任何语言都一样