GO语言二

1 函数

package main

//函数


//这个位置不能写逻辑代码，只能变量和常量的定义
//fmt.Println("xxx")
//var a =10
//const name  = "lqz"


func main() {
	//test()

	//test(1,2)

	//test(1,2,"xx")

	//var a int=test(3,4)
	////var a =test(2,3)
	////a :=test(2,3)
	//fmt.Println(a)

	//python中可以用一个值来接收，go不允许，返回几个值，就用几个值来接收
	//var a,b int
	//a,b =test(2,3)
	//fmt.Println(a)
	//fmt.Println(b)
	//a,b,c :=test(2,3)
	//忽略掉b，不接收了  _  下划线  （跟python不一样，python中_也是一个变量，go中没有就是没有）
	//a,_,c :=test(2,3)
	//fmt.Println(a,c)   //Println这个函数可以接收任意长度的参数
	//fmt.Println(_)

	//test(1,2,3,4,5,6,6,7,8,9,90,0)

	//test(1,"lqz")

	//test()
	
	//定义一个a 是 函数类型
	//var a func()= test()
	//a()

	//a:=test(2,3)
	//
	//a()  //闭包函数不需要再传参，它引用了外部作用域的参数

	//var a Myfunc =test(1,2)

	//var a =test()
	//fmt.Printf(a)

}

//0 函数定义格式
/*
func关键字 函数名(参数1 类型，参数2 类型){
	函数体内容
}
*/
//1 函数基本定义(放在main前后都可以)
//func test()  {
//	fmt.Println("我是函数test")
//}

////2 带参数的函数
//func test(a int,b int)  {
//	fmt.Println(a+b)
//}

//2 带参数的函数,两个参数类型相同，可以省略
//func test(a ,b int)  {
//func test(a ,b int,c string)  {   //a,b是int， c是string
//	fmt.Println(a+b)
//}

//3 带返回值(需要指定返回值类型是什么)
//func test(a ,b int) int {
//	return a+b
//}

//4 多返回值（python中可以）,返回两个int类型
//func test(a ,b int) (int,int) {
//func test(a ,b int) (int,int,string) {
//	return a+b,a*b,"ok"
//}

//5 可变长，接收任意长度的参数

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

//6 go中只有位置参数，没有关键字参数一说,没有默认参数

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

//7 匿名函数（没有名字的函数）,一定要定义在函数内部

//func test()  {
//	//匿名函数直接加括号
//	//func (){
//	//	fmt.Println("我是匿名函数")
//	//}()
//	//赋值给一个变量
//	var a func()
//	
//	a =func (){
//		fmt.Println("我是匿名函数")
//	}
//	a()
//	//a是个什么类型
//	fmt.Printf("%T",a)
//
//}

//8 函数这个类型,它的参数，返回值，都是类型的一部分
//var a func()
//var b func(a,b int)
//var c func(a,b int)int
//var d func(a,b int)(int,string)




//8 闭包  ---》  1 定义在函数内部 2 对外部作用域有引用

//func test() func() {
//	//只是一个内层函数
//	a:= func() {
//		fmt.Printf("我是内层函数")
//	}
//	return a
//}d
// 如果内层函数有参数
//func test() func(x,y int)string {
//	//只是一个内层函数
//	a:= func(x,y int)string {
//		fmt.Printf("我是内层函数")
//		return "我是内层函数的返回值"
//	}
//	return a
//}

//闭包函数，闭包函数，就是多了一种函数传参的方式
//go中没有装饰器语法糖，用go实现装饰器

//func test(x,y int) func() {
//	//只是一个内层函数
//	a:= func() {
//		fmt.Println(x+y)
//	}
//	return a
//}

//给 函数类型 重命名
//type Myfunc  func(z int)int
//
////func test(x,y int) 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
//}

//返回值默认值
//func test()(a int,b string)  {
//	//a和b不需要定义，直接使用
//	//return的时候，不需要指定了
//	a=0
//	b="ok"
//	return
//}
//func test()(int,string)  {
//	a:=0
//	b:="ok"
//	return a,b
//}

//func test()  {
//	//这样写，有没有返回值
//	return
//	fmt.Printf("xxx")
//}

3 包

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路径下，否则找不到

// 类似于python中的包 包名叫 lqz   文件夹下有个__init__.py
	__init__.py 写 文件夹下py文件
import lqz
lqz.能点出来的都在__init__.py中注册过
//go 中 包名.函数名，只要是大写开头的，都能点出来

4 if-else语句

package main

import "fmt"

//if else

func main() {
	//1 语法
	/*
	if 条件 {
		//符合上面条件的执行
	}
	else if 条件{
		//符合上面条件的执行
	}else {
		// 不符合上面的条件执行这个
	}
	*/

	//var a =10
	//if a<9{
	//	fmt.Println("小于9")
	//}else if a==10{
	//	fmt.Println("10")
	//}else {
	//	fmt.Println("都不符合")
	//}
	//作用域范围不一样
	if a:=10;a<9{
		fmt.Println("小于9")
	}else if a==10{
		fmt.Println("10")
	}else {
		fmt.Println("都不符合")
	}


}

5 循环

package main

//循环：go中，没有while循环，只有一个for循环，for可以替代掉while

func main() {
	//1 语法,三部分都可以省略
	/*
	for关键字 初始化;条件;自增自减{
		循环体的内容
	}
	 */
	//2 示例 从0 打印到9
	//for i:=0;i<10;i++{
	//	fmt.Println(i)
	//}
	//3 省略第一部分  从0 打印到9,把i的定义放在for外面
	//i:=0
	//for ;i<10;i++{
	//	fmt.Println(i)
	//}

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

	//5 第二部分省略,条件没了，死循环
	//i:=0
	//for ;;{
	//	fmt.Println(i)
	//	i++
	//}

	//6 全省略的简略写法，死循环
	//for {
	//	fmt.Println("xxxx")
	//}

	//7 第一部分和第三部分都省略的变形
	//i:=0
	//for i<10 {
	//	fmt.Println(i)
	//	i++
	//}
	//for 条件{  就是while循环
	//
	//}

	//8 break continue:任何语言都一样


	// python  垃圾回收 --》同一时刻其实只有一个线程在执行  单核的时候  出现了多核
	// 多进程 开进程

}