【Go语言】基本的语法

　　昨天花了几个小时的时间把Go的语法过了一遍，发现Go语言的语法核心和大部分编程语言的规则还是挺相近的，差别的就是不同的书写规范。还有就是前天安装VScode编译器那个插件把人弄得恶心了，总是安装不成功，找了各种办法(包括FQ)还是没能解决。最后也没有过于执着的继续弄了。

程序结构

　　最简单的例子：　

package main           # 包申明

import "fmt"           # 导入的包，和py挺像的，只不过go需要用”“括起来

func main() {          # 函数入口，就像c语言中的main函数一样， 另外{不能单独另起一行，会报错。
   fmt.Println("Hello, World!")         # 打印字符， 一行代表一个语句的结束，不用向c一样需要；符号，虽然Go也可以多条语句一行(加；号)，但是并不推荐这种用法。
}

　　package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

　　import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。

　　func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

　　fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。

　　注释规则第一种是 // ，第二种是 /* */

数据类型

变量声明

　 在Go语言中声明的变量必须得到使用，否则会报错。

　　第一种声明变量的方式

var  变量名 类型      // 如果没有给定初始化的值的话，系统会设置为0
变量名 =  值
package main
import "fmt"
func main() {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
//result
0 0 false ""

　　第二种根据赋的值自动判断类型

var 变量名 = 值

　　第三种方法是省略 var 使用变量名 := 值来定义新的变量。但是如果变量名已经声明过了会报错。

var  变量名 := 值

var intVal int 

intVal :=1 // 这时候会产生编译错误

intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句， 前面的intval相当于一个赋值操作。

　　多个变量申明方式

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误
// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

常量

　　常量是一个简单值的标识符，在程序运行时，不会被修改的量。常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。这个和c语言中的常量是一个意思，当被定义之后就不能被修改，不然会报错。

const  变量名  类型(可选) = 值      # 单个常量
const  变量1， 变量2 = 值1，值2     # 多个常量赋值

　　iota是一个特殊的常量，也可以认为是一个可以被编译器修改的常量。iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

package main
import "fmt"
func main() {
    const (
            a = iota    //0
            b             //1
            c              //2
            d = "ha"    //独立值，iota += 1
            e               //"ha"   iota += 1
            f = 100      //iota +=1
            g               //100  iota +=1
            h = iota     //7,恢复计数
            i                //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

以上实例运行结果为：
0 1 2 ha ha 100 100 7 8

　运算符

　　和c语言的运算符一样， +、-、*、/、%、++、--、==、!=、>、<、>=、<=、&&、||、！、>>、<<另外还有赋值运算符 +=、-=、/=等等。

条件选择语句

　　一、if ...else if .... else 语句格式

package main

import (
	"fmt"
)
func main()  { 
	a := -1
	if a > 0{
		fmt.Println("11111")
	}else if a == 0{
		fmt.Println("2222")
	}else{
		fmt.Println("333")
	}
}

　　二、switch语句：用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。

package main
import "fmt"
func main() {
   var grade string = "B"

   switch {
      case grade == "A" :
         fmt.Printf("优秀!\n" )     
      case grade == "B", grade == "C" :
         fmt.Printf("良好\n" )      
      case grade == "D" :
         fmt.Printf("及格\n" )      
      case grade == "F":
         fmt.Printf("不及格\n" )
      default:
         fmt.Printf("差\n" );
   }
   fmt.Printf("你的等级是 %s\n", grade );      
}

　　当使用fallthrough时会强制执行后面的 case 语句，不会判断下一条 case 的表达式结果是否为 true。

package main
import "fmt"
func main() {
   var grade string = "B"

   switch {
      case grade == "A" :
         fmt.Printf("优秀!\n" )     
      case grade == "B", grade == "C" :
         fmt.Printf("良好\n" )
         fallthrough      
      case grade == "D" :
         fmt.Printf("及格\n" ) 
         fallthrough     
      case grade == "F":
         fmt.Printf("不及格\n" )
      default:
         fmt.Printf("差\n" );
   }

 fmt.Printf("你的等级是 %s\n", grade );      
}

// 运行结果
  良好
  及格
  不及格
  你的等级是 B

　　三、select语句是(待续)

【Go语言】基本的语法

猜你喜欢