Title

go基础知识二

1 函数

/*
函数
*/

package main

import "fmt"

func main() {

//1 函数调用
//test()

//2 函数调用
   
   //先定义
//a:=10
//test(a)
   // 或者直接传值
//test(10)

//3 函数调用
//test(10,11)
//test(b=10,a=11) //没有关键字参数

//4 函数调用,接收返回值
//var a int
//a=test(10,11)
   
   //或者这种方式比较常用
//a:=test(100,11)
//fmt.Println(a)

//5 函数调用(有几个返回值,必须用几个值来接收)
//a,b:=test(10,11)
//第二个参数不接收了(跟python中_不一样,python中_就是一个变量)
//a,_:=test(10,11)
////fmt.Println(a,b)
//fmt.Println(a)
////fmt.Println(_)

//6 可变长参数
//fmt.Println(1,"ddd",3.14,4,4,5,6,7,8)
//test(1,2,3,4,4,56,7,7,8,9,9,0)

//7 匿名函数(定义在函数内部,没有名字)
//放在函数内部,有两种处理方案
//1 让它执行
//2 当参数返回
//否则报错
//func (){
// fmt.Println("我是匿名函数")
//}()

//8 函数是一等公民
//test()() 没问题

//var a func()
//a=test()
//a()

//a:=test()
//a()


// 9 闭包函数调用
//a:=test(10)
//fmt.Println(a)
//a()

//10 闭包函数高级

//test(99)(88,77)
//a:=test(99)
//a(88,77)

}

//定义函数
//func关键字 函数名(参数1 类型,参数2 类型){函数体的内容}
//1 定义一个无参数,无返回值的普通函数
//func test() {
// fmt.Println("我是test")
//}

//2 带参数,无返回值

//func test(b int) {
// fmt.Println(b)
//
//}

//3 带多个参数,无返回值(没有默认参数和关键字参数)
//func test(a int,b int) {
//如果两个参数都是同一个类型,就可以简略写
//func test(a ,b int,c string) {
// fmt.Println(a+b)
//}

//4 带多个参数,有一个返回值(指明返回参数类型是什么)
//返回值类型是int类型
//func test(a, b int) int {
// c := a + b
// return c
//}

//5 带多个参数,多返回值(返回值类型,返回值类型。。。)
//func test(a,b int)(int,int) {
// c:=a+b
// d:=a*b
// return c,d
//}
//补充
//func test(a,b int)(){}
//func test(a,b int)(int){}
//func test(a,b int)(int,string,int){}
//func test(a,b int)int{}

//6 可变长参数
//可以传任意长度的int类型
//func test(a ...int) {
// //a是切片
// fmt.Println(a[1])
//}

//7 匿名函数(定义在函数内部,没有名字)


//8 函数是一等公民(头等函数),函数也是一个类型
//在一门语言中,如果函数可以赋值给变量,那函数就叫一等公民,或者叫头等函数(python和go都可以,但是java不行)
//返回值是函数类型(即func()类型)
//func test() func() {
// var a func()=func (){
// fmt.Println("我是内层函数")
// }
// return a
//}
//func test() func() {
// return func (){
// fmt.Println("我是内层函数")
// }
//}


//9 闭包函数(1 定义再函数内部 2 对外部作用域有引用)
// 闭包函数:多了一种函数传参的方式

//func test(b int) func() {
// a:= func() {
// fmt.Println(b)
// }
// return a
//}


//go语言中没有装饰器语法糖,但是可以自己实现装饰器
//@ttt
//func test() {
//}

//10 闭包函数高级
func test(b int) func(x,y int) {
var a func(x,y int)
a= func(x,y int) {
fmt.Println(b+x+y)
}
return a
}



//func test(b func(z int)()) (func(x,y int)(),func()()) {
// var a func(x,y int)
// a= func(x,y int) {
// b(12)
// fmt.Println(x+y)
// }
// return a, func() {
// }
//}




//规范
/*
1 变量:go语言中变量区分大小写,建议用驼峰
var Name="lqz"
var name="lqz"
fmt.Println(Name)
fmt.Println(name)
2 文件名:建议用下划线
3 大写字母开头,表示导出字段(外部包可以使用)

4 先导入第三方包,内置包,自己写的包
5 不像python中缩进代表同一段代码块
var a =10
fmt.Println(a)
  fmt.Println("xxx")

*/

注意:go中全是位置参数, 没有所谓的关键字参数和默认参数,都是按照位置传参

2包

//1 在同一个包下(文件夹下),包名必须一致
//2 以后,包名就是文件夹的名字
//3 同一个包下,同名函数只能有一个(init除外)
//4 一个包(当成一个文件),同一包下的函数,直接调用即可
//5 导包的位置,从src路径开始
//6 包只要在src路径下就可以导入
//7 大写表示导出,在外部包可以使用,小写只能再包内部适应
//8 使用第三方包:https://beego.me/
go get github.com/astaxie/beego  (放到gopath的src路径下)
-python:pip3 install requests
   package main
   import "github.com/astaxie/beego"

   func main() {
     beego.Run()
  }

补充mode模式

//1 包导入 import . "github.com/astaxie/beego"  类似于python中form xx import *
//2 包导入 import _ "github.com/go-sql-driver/mysql" 触发init()初始化的执行,但是不使用包内的函数
//3 包导入 import f "fmt"   重命名,以后直接用f

//4 对比python中__init__.py  
//在代码中导入模块
import xx   实质上触发__init__.py  的执行(在__init__.py中也可以执行其他代码,对应到go中就是init函数)
一般情况下,在__init__.py写from xx import 会使用到的函数,导过来
以后再用 xx.函数()

//5 go mod没有之前,可以设置多个gopath,开发某个项目,切到不同的gopath,类似于虚拟环境

//6 go env
-GO111MODULE="off"  表示go mod模式是关闭的,用gopath
-一旦开启了go mod模式,代码不需要放在src路径下(任意位置都可以)
   开启命令:set GO111MODULE=on  (windows)
export GO111MODULE=on  (linux)

-在项目路径下要有 go.mod 文件(文件里记录了,go版本,项目依赖的包,包的版本)(可以手动建也可以自动生成,自动生成命令:go mod init 项目名)
-写代码,建自己的包即可
-一般情况下,项目有一个main.go  内部是main包,main函数,整个程序的入口

一般go项目目录(mvc架构)

3 if-else语句

//if-else
package main

func main() {
//a:=9
//1 基本使用
//if a>10{
// fmt.Println("大于10")
//}else {
// fmt.Println("小于等于10")
//}

//2 if -else if -else
//if a>10{
// fmt.Println("大于10")
//}else if a==10 {
// fmt.Println("等于10")
//}else {
// fmt.Println("小于10")
//}

//3 不能换行(go语言每一行结尾,需要加一个; ,因此go每当换行,会自动加;)
//if a>10{
// fmt.Println("大于10")
//}else if a==10 {
// fmt.Println("等于10")
//}else
//{
// fmt.Println("小于10")
//}

//4 条件里可以进行初始化操作(有作用域范围的区别,写在外面可以全局,写在里面是局部)
//a:=10;
//if a<10{
   //可以初始化a
//if a:=10;a<10{
// fmt.Println("xxx")
//}else {
// fmt.Println("yyyy")
//}
//fmt.Println(a)

//fmt.Println(a)
}

 

4 循环

//循环(只有for循环,没有while ,do while)
package main

func main() {
//1 基本语法
//for 初始化;条件判断;自增/自减{ 循环体内容 }   三部分都可以省略
// 打印0--9
//for i:=0;i<10 ;i++ {
// fmt.Println(i)
//}

//2 省略第一部分(初始化),作用域范围不一样
//i:=0
//for ;i<10 ; i++ {
// fmt.Println(i)
//}

//3 省略第三部分
//for i:=0;i<10 ; {
// i++
// fmt.Println(i)
//}

//4 省略第一和第三部分
//i := 0
//for ; i < 10; {
// i++
// fmt.Println(i)
//}
//5 这不就是while循环吗?
//for 条件 {}
//i := 0
//for i < 10 {
// i++
// fmt.Println(i)
//}
//for true{
// fmt.Println(1)
//}

//6 死循环(三部分都省略)
//for {
// fmt.Println(1)
//}

//7 break和continue(不讲了)
//for {
// fmt.Println(1)
// //break
// continue
//}
}

 

5 switch语句

//switch
package main

func main() {
// 1 switch 基本使用(如符合a=10,则打印)
//a:=10
//switch a {
//case 1:
// fmt.Println("1")
//case 2:
// fmt.Println(2)
//case 9:
// fmt.Println(9)
//case 10:
// fmt.Println("10")
//}

//2 default (若都不符合,执行default)
//a:=15
//switch a {
//case 1:
// fmt.Println("1")
//case 2:
// fmt.Println(2)
//case 9:
// fmt.Println(9)
//case 10:
// fmt.Println("10")
//default:
// fmt.Println("不知道")
//}

//3 多条件(只要满足任意一个即可)
//a:=3
//switch a {
//case 1,2,3:
// fmt.Println("1")
//case 4,5,6:
// fmt.Println(2)
//case 7,9:
// fmt.Println(9)
//case 10,16:
// fmt.Println("10")
//default:
// fmt.Println("不知道")
//}


//4 无表达式(|| 表示或)
//a:=3
//switch {
//case a==1 || a==3:
// fmt.Println("1")
//case a==4||a==5:
// fmt.Println(2)
//default:
// fmt.Println("不知道")
//}

//5 fallthrough,无条件执行下一个case
//a:=1
//switch {
//case a==1 || a==3:
// fmt.Println("1")
// //fallthrough //fallthrough 会无条件执行下一个case
//case a==4||a==5:
// fmt.Println(2)
// fallthrough
//default:
// fmt.Println("不知道")
//}
}


我们把使用switch语句的过程规律想象成坐电梯(大家都有坐电梯的经历),每个case语句后面的标号相当于一个按钮,你要在哪一层下去,就按那一层按钮,就可以在这一层下去。 比如一共24层,你要去第几层,比如我要到第十层下去,那么你的第十层后面肯定要加个break语句,意义是到这一层就结束了,退出这个switch语句了,我要离开电梯了。 如果说每一层都有人下去,那么每一层都有一个break语句。 再如果说每一层都不下,我就从1层做到24层,那你就要把break语句都要取消,不写break语句,一直执行到default语句后面的 } ,最后到顶层了,出电梯吧,退出switch语句。

posted @ 2020-04-22 15:19  Mr江  阅读(154)  评论(0编辑  收藏  举报