package main
import (
"fmt"
"os"
)
//从命令行输入参数，在switch中进行处理
func main() {
//c:argc , **argv
//Go: os.Args ==> 直接可以获取命令输入,是一个字符串切片
strcmds := os.Args
for key,cmd := range strcmds{
fmt.Print("key: ",key)
fmt.Print(" cmd: ",cmd)
fmt.Println(" cmds len:",len(cmd))
}
// go bulid xxx.go
// ../xxx.exe
if len(strcmds) < 2{
fmt.Println("请正确输入参数")
}
switch strcmds[1] {
case "hello":
fmt.Println("This is Hello")
// 如下想向下传透需要增加关键字 fallthrough
fallthrough
case "world":
fmt.Println("This is world")
default:
fmt.Println("This is default")
}
}
$ ./Switch_golxy.exe hello world
key: 0 cmd: E:\GO_Space\src\Switch_golxy.exe cmds len: 32
key: 1 cmd: hello cmds len: 5
key: 2 cmd: world cmds len: 5
This is Hello
This is world
package main
import "fmt"
func main() {
// 标签 LABEL1
// goto LABEL1
LABEL_lxy:
for i:=0;i<5;i++{
for j:=0;j<6;j++{
if j == 3{
// goto跳转到标签处i重新从0开始
//goto LABEL_lxy
// continue跳转到标签，会记录运行到的状态，i继续后续取值
// continue LABEL_lxy
//break 直接跳出循环不再进入
break LABEL_lxy
}
fmt.Println("i: ",i," j= ",j)
}
}
fmt.Println("goto over")
// break LABEL1
// continue LABEL1
}
package main
import "fmt"
// 在go语言中没有枚举的类型，但是我们可以使用const+iota
// 常量累加器类进行模拟
// 模拟一个一周的枚举
const (
MONDAY = iota // 0
TUESDAY = iota // 1
WEDNESDAY
THURSDAY
FRIDAY
SATURDAY
SUNDAY
M_C,N_C = iota,iota
)
const (
JAN = iota + 100// 0
FER // 1
)
//1.iota是常量组计数器
//2.iota从零开始,每换行递增1
//3.常量组有个特点如果默认不复制，默认与上一行表达式相同
//4.如果同一行出现两个iota，那么两个iota值相同
//5.每个常量的iota是独立的，如果遇到const iota则会重新清零
func main() {
//var nubmer int
//var name string
//var flag bool
//可以使用变量组来将统一的变量
var(
number int
name string
flag bool
)
number=1
name="name string"
flag = true
fmt.Println("number: ",number," name: ",name," flag: ",flag)
// number: 1 name: name string flag: true
fmt.Println("MONDAY:",MONDAY)
fmt.Println("TUESDAY:",TUESDAY)
fmt.Println("WEDNESDAY:",WEDNESDAY)
fmt.Println("THURSDAY:",THURSDAY)
fmt.Println("FRIDAY:",FRIDAY)
fmt.Println("SATURDAY:",SATURDAY)
fmt.Println("SUNDAY:",SUNDAY)
//MONDAY: 0
//TUESDAY: 1
//WEDNESDAY: 2
//THURSDAY: 3
//FRIDAY: 4
//SATURDAY: 5
//SUNDAY: 6
// 同一行值一样
fmt.Println("M_C:",M_C)
fmt.Println("N_C:",N_C)
//M_C: 7
//N_C: 7
// 在遇到const 重新计数
fmt.Println("JAN:",JAN)
fmt.Println("FER:",FER)
}
package main
import "fmt"
//c:
//struct Person{
//}
type MyInt int
//go语言结构体
//tyoe +struct来处理
type Person struct{
name string
age int
gender string
score float64
}
func main() {
var i,j MyInt
i,j = 10,20
fmt.Println(i+j)
//30
liLei := Person{
name: "lilei",
age: 30,
gender: "女生",
score: 90, // }不同行，最后一个元素后面必须加括号
}
//创建并赋值
liLei2 := Person{
name: "lilei3",
age: 40,
gender: "女生",
score: 80} // 最后一个元素后面不加括号，但是}必须同一行
fmt.Println("lilei:",liLei.name,liLei.age,liLei.gender,liLei.score)
fmt.Println("liLei2:",liLei2.name,liLei2.age,liLei2.gender,liLei2.score)
// lilei: lilei 30 女生 90
// 注意结构体没有->
s1 := &liLei
fmt.Println("s1 lilei:",s1.name,s1.age,s1.gender,s1.score)
// s1 lilei: lilei 30 女生 90
// 对结构体赋值时如果每个字段都赋值，则字段名字可不写；
// 如果只对局部字段进行赋值，必须明确指定变量的名字
liLei3 := Person{
name: "lilei3",
age: 40,
//gender: "女生",
//score: 80 // 最后一个元素后面不加括号，但是}必须同一行
}
liLei3.gender = "男"
liLei3.score = 98
fmt.Println("liLei3:",liLei3.name,liLei3.age,liLei3.gender,liLei3.score)
// liLei3: lilei3 40 男 98
}
C语言中没有init函数，一般需要自己去写init，然后在构造函数中调用
Go语言自带Init函数，每一个包都可以包含一个或多个init函数
这个init会在包引用的时候import进行调用
sub/sub.go
package sub
import "fmt"
// 0.函数包被调用的时候，自动调用包内的所有init函数
// 1.init函数没有参数，没有返回值
// 2.一个保重包含多个init时，调用顺序不一定
// 3.init函数不能显示调用（手工调用）
// 4.有的时候引用一个包，可能只想使用这个包里面的Init函数
//不先使用其他函数，为了防止报错，可以使用_形式处理
func init() {
fmt.Println("first init sub package init start")
}
func init() {
fmt.Println("second init sub package init start")
}
func init() {
fmt.Println("third init sub package init start")
}
//func sub(a ,b int) int {
func Sub(a ,b int) int {
return a -b
}
init函数.go
package main
import (
//"sub"
//import _xxx : _"sub"之后调用init函数，编译还不会报错
_ "sub"
)
func main() {
// ctrl + shift + i 查看函数原型
// 注意函数名大写才是public才能被它包进行调用
//c := sub.Sub(18,8)
//fmt.Println("c:",c)
// "sub" 效果
//first init sub package init start
//second init sub package init start
//third init sub package init start
//c: 10
//_"sub"之后调用init函数，编译还不会报错 效果
//first init sub package init start
//second init sub package init start
//third init sub package init start
}