标签：pac   ref   fun   关键字   import   必须   pre   指定   int   

补充: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:任何语言都一样

GO ---- 函数 包 判断 循环

标签：pac   ref   fun   关键字   import   必须   pre   指定   int   

原文地址：https://www.cnblogs.com/lddragon1/p/12571872.html