Go 语言1

1.Go语言基础语法

 (1)注释

// 单行注释

/*

多行注释

*/

(2)关键字

    ·var和const:变量和常量的声明

    ·var varName type 或者 varName := value

    ·package and import:导入

    ·func:用于定义函数和方法

    ·return:用于从函数返回

    ·defer someCode:在函数退出之前执行

    ·go:用于并行

    ·select:用于选择不同类型的通讯

    ·interface:用于定义接口

    ·struct:用于定义抽象数据类型

    ·break、case、continue、for、fallthrough、else、if、switch、goto、default流程控制

    ·chan用于channel通讯

    ·type用于声明自定义类型

    ·map用于声明自定义类型

    ·range用于读取slice,map, channel数据

(3)格式化字符串

Go 可以使用 fmt.Sprintf 来格式化字符串,格式如下:

fmt.Sprintf(格式化样式, 参数列表…)

注:多个参数以逗号分隔,个数必须与格式化样式中的个数一一对应,否则运行时会报错

Go 字符串格式化符号:

格  式描  述
%v按值的本来值输出
%+v在 %v 基础上,对结构体字段名和值进行展开
%#v输出 Go 语言语法格式的值
%T输出 Go 语言语法格式的类型和值
%%输出 % 本体
%b整型以二进制方式显示
%o整型以八进制方式显示
%d整型以十进制方式显示
%x整型以十六进制方式显示
%X整型以十六进制、字母大写方式显示
%UUnicode 字符
%f浮点数
%p指针,十六进制方式显示

2.数据类型

 (1)数字类型

序号类型和描述
1uint8
无符号 8 位整型 (0 到 255)
2uint16
无符号 16 位整型 (0 到 65535)
3uint32
无符号 32 位整型 (0 到 4294967295)
4uint64
无符号 64 位整型 (0 到 18446744073709551615)
5int8
有符号 8 位整型 (-128 到 127)
6int16
有符号 16 位整型 (-32768 到 32767)
7int32
有符号 32 位整型 (-2147483648 到 2147483647)
8int64
有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

(2)浮点型

序号类型和描述
1float32
IEEE-754 32位浮点型数
2float64
IEEE-754 64位浮点型数
3complex64
32 位实数和虚数
4complex128
64 位实数和虚数

(3)其他数字类型

序号类型和描述
1byte
类似 uint8
2rune
类似 int32
3uint
32 或 64 位
4int
与 uint 一样大小
5uintptr
无符号整型,用于存放一个指针

3.变量

(1)变量声明

第一种

指定变量类型,如果没有初始化,则变量默认为零值。

第二种:

根据值自行判定变量类型。

第三种:

如果变量已经使用 var 声明过了,再使用 := 声明变量,就产生编译错误。

(2)多变量声明

//类型相同多个变量, 非全局变量
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
)

(3)简短形式,使用 := 赋值操作符

我们知道可以在变量的初始化时省略变量的类型而由系统自动推断,声明语句写上 var 关键字其实是显得有些多余了,因此我们可以将它们简写为 a := 50 或 b := false。

a 和 b 的类型(int 和 bool)将由编译器自动推断。

这是使用变量的首选形式,但是它只能被用在函数体内,而不可以用于全局变量的声明与赋值。使用操作符 := 可以高效地创建一个新的变量,称之为初始化声明。

4.常量

(1)

常量的定义格式:

const identifier [type] = value

你可以省略类型说明符 [type],因为编译器可以根据变量的值来推断其类型。

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

多个相同类型的声明可以简写为:

const c_name1, c_name2 = value1, value2c

例子:

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5  
   var area int
   const a, b, c = 1, false, "str" //多重赋值

   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d", area)
   println()
   println(a, b, c)  
}

运行结果:

面积为 : 50
1 ​false str

(2)iota

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

5.Go语句

(1)switch语句

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

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

switch 默认情况下 case 最后自带 break 语句,匹配成功后就不会执行其他 case,如果我们需要执行后面的 case,可以使用 fallthrough 。

package main

import "fmt"

func main() {
   var grade string
   var marks int = 90

    //switch语句第1种写法
   switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }

    //switch语句第2种写法
   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 );      
}

运行结果:

优秀!
你的等级是 A

(2)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("未知型")    
   }  
}

运行结果:

x 的类型 :<nil>

(3)select语句

1、select 语句随机执行一个可运行的 case。

2、每个case都必须是一个通信

3、如果没有 case 可运行,且没有default语句,它将阻塞,直到有 case 可运行。

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

否则:

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

import "fmt"

func main() {
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
      case i1 = <-c1:
         fmt.Printf("received ", i1, " from c1\n")
      case c2 <- i2:
         fmt.Printf("sent ", i2, " to c2\n")
      case i3, ok := (<-c3):  // same as: i3, ok := <-c3
         if ok {
            fmt.Printf("received ", i3, " from c3\n")
         } else {
            fmt.Printf("c3 is closed\n")
         }
      default:
         fmt.Printf("no communication\n")
   }    
}

运行结果:

no communication
 

6.Go循环语句

(1)for循环

第一种(类似于C的for):

package main

import "fmt"

func main() {
        sum := 0
        for i := 0; i <= 10; i++ {
                sum += i
        }
        fmt.Println(sum)
}

运行结果:

55

第二种(类似于C的while):

package main

import "fmt"

func main() {
        sum := 1
        for ; sum <= 10; {
                sum += sum
        }
        fmt.Println(sum)

        // 这样写也可以,更像 While 语句形式
        for sum <= 10{
                sum += sum
        }
        fmt.Println(sum)
}

运行结果:

16
16

第三种(for change):

package main
import "fmt"

func main() {
        str := []string{"google", "qpple"}
        for i, s := range str {
                fmt.Println(i, s)
        }


        num := [6]int{1, 2, 3, 5}
        for i,x:= range num {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

运行结果:

0 google
1 qpple
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0
 

(2)循环控制语句

goto语句:

实例:

在变量 a 等于 15 的时候跳过本次循环并回到循环的开始语句 LOOP 处

package main

import "fmt"

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

   /* 循环 */
   LOOP: for a < 20 {
      if a == 15 {
         /* 跳过迭代 */
         a = a + 1
         goto LOOP
      }
      fmt.Printf("a的值为 : %d\n", a)
      a++    
   }  
}


运行结果:

a的值为 : 10
a的值为 : 11
a的值为 : 12
a的值为 : 13
a的值为 : 14
a的值为 : 16
a的值为 : 17
a的值为 : 18
a的值为 : 19

(3)无限循环

如果循环中条件语句永远不为 false 则会进行无限循环,我们可以通过 for 循环语句中只设置一个条件表达式来执行无限循环:

package main

import "fmt"

func main() {
    for true  {
        fmt.Printf("这是无限循环。\n");
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值