Go语言与c语言细节语法对比20210818

本文链接：https://blog.csdn.net/Narutolxy/article/details/119777596

Switch

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
   
}

init函数

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

}