变量
第一种，指定变量类型，声明后若不赋值，使用默认值0
package main
import "fmt"
func main() {
var a int //第一种，指定变量类型，声明后若不赋值，使用默认值0。
fmt.Printf(" a= %d\n", a)
}打印
第二种，根据值自行判定变量类型
package main
import "fmt"
func main() {
var a = 33 //第二种，根据值自行判定变量类型
fmt.Printf("a= %d\n", a)
}打印
第三种，直接定义 变量需首次定义之前不可以为已用过的变量
package main
import "fmt"
func main() {
c := 3 //第三种，直接定义 变量需首次定义之前不可以为已用过的变量
fmt.Printf(" a= %d\n", c)
}打印
const
常量
package main
import "fmt"
func main() {
const LENGTH int = 3
const WIDTH int = 10
var area int
const a, b, c = 1, false, "str" //多重赋值
area = LENGTH * WIDTH
fmt.Printf("面积为 : %d\n", area)
println(a, b, c)
}
这里和Java的常量定义是相同的
打印
多重定义枚举
const (
Unknown = 0
Female = 1
Male = 2
)iota
它简化了常量用于增长数字的定义，给以上相同的值以准确的分类。
package main
import "fmt"
const (
One int = 1 + iota // 1+0
Two // 1+1
Three // 1+2
Four // 1+3
Five // 1+4
Six // 1+5
)
func main() {
fmt.Println(One)
fmt.Println(Two)
fmt.Println(Three)
fmt.Println(Four)
fmt.Println(Five)
fmt.Println(Six)
}
打印
用于常量定义中，常量组中仅仅有一个标示符在一行的时候，它将使用增长的iota取得前面的表达式并且再运用它
if
if语句和Java里的if相同
for循环
package main
import "fmt"
func main() {
//常规for循环类似于Java 对比少了for(i := 0; i < 10; i++)少了括号
for i := 0; i < 10; i++ {
fmt.Println(i)
}
}
打印
类似于Java里while的for循环
如下for循环实现当value=10的时候退出for循环
package main
import "fmt"
func main() {
value := 0
for {
value += 1
fmt.Println(value)
if value == 10 {
break
}
}
}
打印
import和init
import导包和Java的import 差不多
目录结构
fun1
package fun1 //这里的包名最好和目录名保持相同
import (
"fmt"
)
func init() {
fmt.Println("fun1")
}
func TestFun1() {
fmt.Println("testFun1")
}
fun2
package fun2 //这里的包名最好和目录名保持相同
import "fmt"
func init() {
fmt.Println("fun2")
}
func TestFun2() {
fmt.Println("testFun2")
}
主函数
package main
import (
"fmt"
"githup.com/kanyu/moudles_test/basic/fun1"
"githup.com/kanyu/moudles_test/basic/fun2"
)
func main() {
fun1.TestFun1()
fun2.TestFun2()
fmt.Println("main")
}
打印
详细执行流程
1，主函数导入依赖
2，依赖函数再次判断有无依赖，有依赖再重复导入无依赖执行函数的init函数
3，执行其它的函数
指针
go语言中和C语言相同 用*来表达变量的地址 用&来取指针指向的数值
函数值传递与指针传递
值传递，即在函数传参的过程中，原来的参数不会被调用函数的行为所改变值
在传递参数的时候会把值复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 go默认值传递
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
stra := "字符串a"
strb := "字符串b"
fmt.Println("交换之前打印")
fmt.Println(stra, strb)
a, b := swap(stra, strb)
fmt.Println("交换之后打印")
fmt.Println(a, b)
}
打印
指针传递
//引用传递
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int= 200
fmt.Printf("交换前 a 的值为 : %d\n", a )
fmt.Printf("交换前 a 的地址值为 : %d\n", &a )
fmt.Printf("交换前 b 的值为 : %d\n", b )
fmt.Printf("交换前 b 的地址值为 : %d\n", &b )
/* 调用 swap() 函数
* &a 指向 a 指针，a 变量的地址
* &b 指向 b 指针，b 变量的地址
*/
swap(&a, &b)//调用时候传入地址值
fmt.Printf("交换后，a 的值 : %d\n", a )
fmt.Printf("交换后 a 的地址值为 : %d\n", &a )
fmt.Printf("交换后，b 的值 : %d\n", b )
fmt.Printf("交换后 b 的地址值为 : %d\n", &b )
}
func swap(x *int, y *int) {//指针参数变量 这里的交换指的把对应指针指向的值给交换了 所以a和b的地址未变化
var temp int
temp = *x /* 保存 x 地址上的值 */
*x = *y /* 将 y 值赋给 x */
*y = temp /* 将 temp 值赋给 y */
}打印
defer
延迟函数，defer在rerurn之后再执行延迟函数 用于如打开/关闭文件、获取/释放锁、连接/断开连接等，确保资源被适当地释放，即使在发生错误或提前返回的情况下也能保证执行
package main
import "fmt"
func deferFunc() int {
fmt.Println("defer func called")
return 0
}
func returnFunc() int {
fmt.Println("return func called")
return 0
}
func returnAndDefer() int {
defer deferFunc()
return returnFunc()
}
func main() {
returnAndDefer()
}打印
参考