邯郸网站设计怎么做,网站建设方案合同,虚拟主机哪里好,网站建设岗位职责a : 10str : mike//匿名函数#xff0c;没有函数名字 形成一个闭包,函数定义#xff0c;还没有调用f1 : func() { //:自动推到类型fmt.Println(a , a)fmt.Println(str , str)}f1()//给一个函数类型起别名 这个写法不推荐type FuncType …
a : 10str : mike//匿名函数没有函数名字 形成一个闭包,函数定义还没有调用f1 : func() { //:自动推到类型fmt.Println(a , a)fmt.Println(str , str)}f1()//给一个函数类型起别名 这个写法不推荐type FuncType func() //函数没有参数内推返回值//声明变量var f2 FuncTypef2 f1f2()//定义匿名函数,同时调用func() {fmt.Printf(a %d, str %s\n, a, str)}() //后面的()代表此匿名函数//带参数的匿名函数f3 : func(i, j int) {fmt.Printf(i %d , j %d\n, i, j)}f3(1, 2)//定义匿名函数同时调用func(i, j int) {fmt.Printf(i %d , j %d\n, i, j)}(10, 20)//匿名函数有参有返回值x, y : func(i, j int) (max, min int) {if i j {max imin j} else {max jmin i}return}(10, 20)fmt.Printf(x %d, y %d\n, x, y)//闭包捕获外部变量的特点a : 10str : mikefunc() {//闭包以引用方式a 666str gofmt.Printf(内部a %d, str %s\n, a, str)}() //()外部直接调用fmt.Printf(外部a %d, str %s\n, a, str) //外部同步//内部a 666, str go// 外部a 666, str go它不关心这些捕获了的变量和常量是否已经超出作用域所以只有闭包还在使用它这些变量就还会存在
// 函数的返回值是一个匿名函数返回一个函数类型
func testUnKoun() func() int {var x int //没有初始化值为0return func() int {xreturn x * x //函数调用完毕 x自动释放}
}f : testUnKoun()
fmt.Println(f()) //1
fmt.Println(f()) //4
fmt.Println(f()) // 9
fmt.Println(f()) // 16我们看到的声明周期不由它的作用域决定变量x仍然隐式的存在于f中
函数调用定义
// 无参无返回值
func MyFunc() {a : 666fmt.Println(a , a)
}// 有参无返回值
// 参数传递只能由实参传递给形参不能反过来单向传递
func MyFunc1(a int) { //定义函数在()中定义的参数叫形参//a 111fmt.Println(aa , a)
}func MyFunc2(a int, b int) { //定义函数在()中定义的参数叫形参 简单写法func MyFunc2(a,b int)//a 111fmt.Printf(a %d, b %d \n, a, b)
}func MyFunc3(a int, b string, c float64) {fmt.Printf(a%d, b %s,c %f\n, a, b, c)
}// 不定参数类型 ...type 不定参数只能放在形参中的最后一个参数
func MyFunc4(args ...int) { //传递的实参可以是0或者多个fmt.Println(len(args) , len(args)) //获取用户传递参数的个数for i : 0; i len(args); i {fmt.Printf(args[%d] %d\n, i, args[i])}
}
func main01() {MyFunc()MyFunc1(11) //实参MyFunc2(666, 777)MyFunc3(11, aaa, 3.14)MyFunc4(1, 2, 3)
}// 固定参数一定要传参不定参数根据需求传参 不定参数类型 ...type 不定参数只能放在形参中的最后一个参数
func MyFunc5(a int, args ...int) { //传递的实参可以是0或者多个}func myFunc01(tmp ...int) {for _, data : range tmp {fmt.Println(data , data)}
}
func myFunc02(tmp ...int) {for _, data : range tmp {fmt.Println(data , data)}
}// 不定参数的传递
func test(args ...int) {//全部元素传递给myFunc01myFunc01(args...)fmt.Println()//只想把后2个参数传递给另外一个函数使用myFunc02(args[:2]...) //0~2(不包括数字2),触底传递过去 1 2myFunc02(args[2:]...) //从args[2]开始(包括本身),把后面所有元素传递过去 3 4
}// 无参有返回值 只有一个返回值
// 有返回值的函数需要通过return中断函数通过return返回
func myfunc01() int {return 666
}// 给返回值起一个变量名go推荐写法 常用写法
func myfunc02() (result int) {//return 666result 666return
}// 多个返回值
func myfunc03() (int, int, int) {return 1, 2, 3
}// go官方推荐写法
func myfunc04() (a int, b int, c int) {a, b, c 111, 222, 333return
}// 有参有返回值
func MaxAndMin(a, b int) (max, min int) {if a b {max amin b} else {max bmin a}return
}func funcb() (b int) {b 222fmt.Println(funcb b , b)return
}// 普通函数的调用流程
func funca() (a int) {a 111b : funcb()fmt.Println(funca b , b)//调用另外一个函数fmt.Println(funca a , a)return
}main()
//MyFunc5(111, 1, 2, 3)//test(1, 2, 3, 4)//var a int//a myfunc01()//fmt.Println(a , a)//b : myfunc01()//fmt.Println(b , b)////c : myfunc02()//fmt.Println(c , c)////a, b, c myfunc03()//fmt.Println(a, b, c)////a, b, c myfunc04()//fmt.Println(a, b, c)//max, min : MaxAndMin(10, 20)//fmt.Println(max, min)/**main funcfuncb b 222funca b 222funca a 111main a 111*///fmt.Println(main func)//a : funca()//fmt.Println(main a , a)递归函数实现
// 函数递归调用的流程
func testRecursion(a int) { //函数调用终止调用的条件非常重要if a 1 {fmt.Println(a , a)return}//函数调用自身testRecursion(a - 1)fmt.Println(a , a)
}// 数字累加
func InteragerSum() (sum int) {for i : 0; i 100; i {sum i}return
}func InteragerSum1(i int) int {if i 1 {return 1}return i InteragerSum1(i-1)}main方法
//testRecursion(3)//var sum int
sum InteragerSum()
//sum InteragerSum1(100)
//fmt.Println(sum , sum)回调函数
// 起别名
type funcType func(int, int) int// 实现加法
func Add(a, b int) int {return a b
}func Minus(a, b int) int {return a - b
}func Mul(a, b int) int {return a * b
}// 回调函数函数参数是函数类型这个函数就是回调函数
// 计算器可以进行四则运算 多态多种形态 调用同一个接口不同的表现可以实现不同表现加减乘除
func Calc(a, b int, fTest funcType) (result int) {fmt.Println(Calc)result fTest(a, b) // 这个函数还没有实现//result Add(a,b) // Add必须定义后才能调用return
}main方法
//a : Calc(1, 1, Add)
//fmt.Println(a , a)// 形成了一个独立的空间
func testClouse() int {//函数被调用时x才分配空间才初始化为0var x int //没有初始化值为0xreturn x * x //函数调用完毕 x自动释放
}// 函数的返回值是一个匿名函数返回一个函数类型
func testUnKoun() func() int {var x int //没有初始化值为0return func() int {xreturn x * x //函数调用完毕 x自动释放}
}main方法
//返回值为一个匿名函数返回一个函数类型通过f来调用返回的匿名函数f来调用闭包函数
f : testUnKoun()
fmt.Println(f()) //1
fmt.Println(f()) //4
fmt.Println(f()) // 9
fmt.Println(f()) // 16defer调用
/**defer作用关键字defer用户延迟一个函数或者方法(或者当前所创建的匿名函数)的执行。注意defer语句只能出现在函数或方法的内部。*///defer 延迟调用 main函数结束前调用defer fmt.Println(bbbbbbbbbb)fmt.Println(aaaaaaaaaa)//aaaaaaaaaa//bbbbbbbbbb多个defer执行顺序
如果一个函数中有多个defer语句它们会以LIFO(后进先出)的顺序执行哪怕函数或某个延迟调用发生错误这些调用依旧会被执行。
/*
*
defer语句经常被用于处理成对的操作如打开关闭连接断开连接
加锁释放锁。通过defer机制不论函数逻辑多复杂都能保证在任何执行路径下
资源被释放。释放资源的defer应该直接跟在请求资源的语句后。
*/func test(x int) {sum : 100 / xfmt.Println(sum)
}func main() {bbbbbbbbbbbaaaaaaaaaaa//defer fmt.Println(aaaaaaaaaaa)//defer fmt.Println(bbbbbbbbbbb)调用一个函数导致内存出问题//test(0) //这个会先调用//defer fmt.Println(ccccccccccc)//ccccccccccc//bbbbbbbbbbb//aaaaaaaaaaadefer fmt.Println(aaaaaaaaaaa)defer fmt.Println(bbbbbbbbbbb)//调用一个函数导致内存出问题defer test(0) //defer fmt.Println(ccccccccccc)
}defer和匿名函数结合使用
package mainimport fmtfunc main01() {a : 10b : 20defer func() {fmt.Println(a, b)}()a 111b 222fmt.Println(a, b) /// 111 222
}func main() {a : 10b : 20defer func(a, b int) {fmt.Println(a, b)}(a, b) // 10 20 把参数传递过去 已经先传递参数只是没有调用a 111b 222fmt.Println(a, b) /// 111 222
}获取命令行参数
package mainimport (fmtos
)// 获取命令行参数
func main() {//接收用户传递的参数都是以字符串方式传递的list : os.Argsn : len(list)fmt.Println(n , n)for i : 0; i n; i {fmt.Printf(list[%d] %s\n, i, list[i])}for i, data : range list {fmt.Printf(list[%d] %s\n, i, data)}
}局部变量
package mainimport fmtfunc test() {a : 10fmt.Println(a , a)
}func main() {//定义在{}里面的变量就是局部变量只能在{}里面有效// 执行执行到定义变量那句话才开始分配空间离开作用域自动释放//作用域变量起作用的范围{i : 10fmt.Println(i , i)}
}全局变量
package mainimport fmtfunc test() {fmt.Println(test , a)
}// 定义在函数外部的变量是全局变量 全部变量在任何地方都能使用
var a int// a : 10 没有这样的写法
func main() {//全局变量a 10fmt.Println(a , a)test()
}不同作用域的同名变量
package mainimport fmtvar a byte //全局变量func main() {//不同作用域的同名变量//不同作用域允许定义同名变量//使用变量的原则就近原则var a int //局部量fmt.Printf(%T\n, a) //int{var a float32fmt.Printf(2: %T\n, a) //float32}test()
}func test() {fmt.Printf(3: %T\n, a) //uint8
}工作区介绍
导入包
import fmt //1
import . fmt //2
import io fmt //给包名起别名
import(
fmt
os
)
import _ fmt //忽略此包工程管理
1 分文件编程(多个源文件)必须放在src目录 2 设置GOPATH环境变量
init函数
import _“fmt” _操作其实是引入该包而不直接使用包里面的函数而是调用了该包里面的init函数
