二、Go基础语法

1.Go语言结构

package main

import "fmt"

func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}

仅声明与其他编程语言不同的点。

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

  • 当标识符(包括常量、变量、类型、函数名、结构字段等等)以一个大写字母开头,如:Group1,那么使用这种形式的标识符的对象就可以被外部包的代码所使用(客户端程序需要先导入这个包),这被称为导出(像面向对象语言中的 public);标识符如果以小写字母开头,则对包外是不可见的,但是他们在整个包的内部是可见并且可用的(像面向对象语言中的 protected )。

  • { 不能单独放在一行,否则会报错。

2.Go数据类型和基础语法

与其他编程语言几乎一样,不展开。

3.Go语言变量和常量

变量

共有三种声明变量的方法。

  1. 指定变量类型,声明后若不赋值,使用默认值。

    var v_name v_type
    v_name = value
    
  2. 根据值自行判定变量类型

    var v_name = value
    
  3. 省略var, 注意 :=左侧的变量不应该是已经声明过的,否则会导致编译错误。该命名方法只能用在方法内。

    func main(){
        a := 10
    }
    

常量

使用const声明常量。

  • 显式类型定义: const b string = "abc"
  • 隐式类型定义: const b = "abc"

iota

iota,特殊常量,可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前),const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值:

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

4.Go 条件判断

if语句

与java的条件判断语句基本相同,但是条件表达式不需要用 ()。

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

if 布尔表达式 1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式 2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}

switch

switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是唯一的,从上直下逐一测试,直到匹配为止。

一个case 后面可以跟两个条件,用,分割。

switch 语句执行的过程从上至下,直到找到匹配项,匹配项后面也不需要再加break。

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}
Type switch

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:      
         fmt.Printf(" x 的类型 :%T",i)                
      case int:      
         fmt.Printf("x 是 int 型")                       
      case float64:
         fmt.Printf("x 是 float64 型")           
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )       
      default:
         fmt.Printf("未知型")     
   }   
}

select

select是Go中的一个控制结构,类似于用于通信的switch语句。每个case必须是一个通信操作,要么是发送要么是接收。

select随机执行一个可运行的case。如果没有case可运行,它将阻塞,直到有case可运行。一个默认的子句应该总是可运行的。

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s); 
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}
  • 每个case都必须是一个通信
  • 所有channel表达式都会被求值

  • 所有被发送的表达式都会被求值

  • 如果任意某个通信可以进行,它就执行;其他被忽略。

  • 如果有多个case都可以运行,Select会随机公平地选出一个执行。其他不会执行。

    否则:

    1. 如果有default子句,则执行该语句。
    2. 如果没有default字句,select将阻塞,直到某个通信可以运行;Go不会重新对channel或值进行求值。

5.Go语言循环

for循环

主要有3种用法

1.与C语言的for循序一样:

for init; condition; post { }

for a = 1; a 

2.与C语言的while一样:

for condition { }

for true{
     //dosomething
}

3.和 C 的 for(;;) 一样:

for {
    //dosomething
}
//跟for true其实一样

嵌套循环的用法与其他语音一样。

for [condition |  ( init; condition; increment ) | Range]
{
   for [condition |  ( init; condition; increment ) | Range]
   {
      statement(s);
   }
   statement(s);
}

range的用法

类似于Python。

循序控制语句

break

用于循环语句中跳出循环,并开始执行循环之后的语句。

continue

跳过当前循环执行下一次循环语句。

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

goto语句通常与条件语句配合使用。可用来实现条件转移, 构成循环,跳出循环体等功能。

但是,在结构化程序设计中一般不主张使用goto语句, 以免造成程序流程的混乱,使理解和调试程序都产生困难。

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* 循环 */
   LOOP: for a 

文章来源于互联网,如有雷同请联系站长删除:二、Go 基础语法

发表评论