Go语言课外学习了解

1 对于独立运行的可执行文件必须是package main

2 Go语言里如果想把多条语句放在一行书写，则必须要用封号“;”隔开。

3 多个var声明可以成组，const和import同样允许这么做，要用圆括号()，如下

import (
   "fmt"
   "reflect"
)
const (
   A string = "bac"   // 显式类型
   B  int = 2         // 显式类型
)
const (
   C = 12             // 隐式类型
   D = "122"          // 隐式类型
)
var (
   x int
   b bool
)

4 多个变量同行声明赋值

a , b := "12",12    // a为string类型，b为int类型

5 Go语言里int类型是根据硬件条件决定长度，在32位机器上是32位，在64位上是64位。uint同样的情况。要明确长度，可以使用int8，int16，int32，int64和byte，uint8，uint16，uint32，uint64。

6 特别注意int和int32，int64不是同个类型，如下

var a int
var b int32
a = 15
b = a + 14    // illegal , cannot use a + 14 (type int) as type int32 in assignment
c := 15       // c被系统默认推导为int类型

7 字符串在Go语言中是UTF-8的由双引号(")包裹的字符序列。用单引号(')则表示一个字符。

8 字符串是不可变的变量，一旦赋值不能改变

9 多行字符串，有2种方法

用双引号加上加号，加号必须是放上一行的最后面

     s := "abcddf"    // illegal，加号另起一行了
          + "dddd"
     s2 := "abcd" +   // ok
          "dddd"

用反引号( ` )作为原始字符串号，但它会包含换行符，即s3会两行显示

    s3 := `dafdfdsf
           dsfdfsd`

10 rune是int32的别名，用UTF-8进行编码。如需要遍历字符串中的字符。可以循环每个字节（仅在使用US ASCII编码字符串时与字符等价，而它们在Go语言中不存在）因此为了获得实际的字符，需要使用rune类型。

11 Go支持复数，有complex128(64位虚数部分)，complex64(32位虚数部分)，如下

var c complex64 = 5+5i
fmt.Printf("Value is: %v",c)

输出 Value is: (5+5i)

12 Go语言不支持运算符重载和函数重载

13 Go语言的保留字：break，default，func，interface，select，case，defer，go，map，struct，chan，else，goto，package，switch，const，fallthrough，if，range，type，continue，for，import，return，var

14 goto使用例子

func myfunc(){
   i := 0
   Here:
      fmt.Println(i)
      i++
      goto Here
}

15 Go语言的for循环有三种形式

for init ; condition ; post { } // 和C的for一样
for condition { } // 和while循环一样
for { } // 和C的for( ; ; )一样

例子如下

sum := 0
for i:=0;i<10;i++{
   sum += i
}
fmt.Println(sum," ,i = ",i)   // 会报错，i的变量区域只在for循环里，i在for循环声明故结束后i变量就被回收
j := 0
for j<10 {      // 第二种for循环形式，类似while循环
   j ++
   fmt.Println(j)
}
for i,j:=0,10;i<j;i,j=i+1,j-1{   // 平行赋值
   // todo
}

16 break后面可以指定标签，用标签决定哪个循环被终止

J:
   for i:=0;i<10;i++{
      for j:=0;j<10;j++{
         if j > 5{
            break J      // 终止的是J，而不是j循环
         }
         fmt.Println(j)
      }
   }

17 range可用于循环。可以在slice，array，string，map和channel。range是个迭代器，当被调用时从它循环的内容中返回一个键值对

list := []string{"a","b","c"}
for k,v := range list {
   fmt.Println("string ",v," is at position ",k)
}

输出

        string a is at position 0
        string b is at position 1
        string c is at position 2

18 Go语言的switch非常灵活，表达式不必是常量或整数，也可以没有表达式。它不会匹配失败后自动向下尝试，但可以使用fallthrough使其这么做

c := '3'
switch  {       // 可以没有表达式
case '0' <= c && c <= '1':
   // todo
case '1' <= c:
   // todo
}

switch c {
case '1','2','3':    // 多个分支可以用逗号隔开
   //todo
default:
   //todo
}

19 数组是值类型，将一个数组赋值给另一个数组，会复制所有元素。当向函数内传递一个数组时，函数会生成数组的副本，而不是数组的指针

a := [3]int{1,2,3}
b := [...]int{4,5,6}
c := [2][2]int{[2]int{1,2},[2]int{3,4}}
d := [2][2]int{[...]int{1,2},[...]int{3,4}}
f := [2][2]int{{1,2},{3,2}}
var e [3]int

20 数组切片slice，是引用类型，有三种方式创建数组切片

s1 := make([]int,10)   
s2 := []int{9,1}
a := [100]int{}
s3 := a[0:10]

21 数组切片扩展，可以使用append()或copy()。copy()有点特别，它是从源数组切片src复制到目标数组切片dst，并且返回复制的元素个数，即len(src)和len(dst)中的最小值

s0 := []int{0,0}
s1 := append(s0,2)    // s1 = []int{0,0,2}
s2 := append(s1,3,5,7)  // s2 = []int{0,0,2,3,5,7}
s3 := append(s2,s0...)   // s3 = []int{0,0,2,3,5,7,0,0}

var a = [...]int{0,1,2,3,4,5,6}
var s = make([]int,6)
n1 := copy(s,a[0:])    // n1=6，s=[]int{0,1,2,3,4,5} 
n2 := copy(s,s[2:])    // n2=4，s=[]int{2,3,4,5,4,5}

Go语言课外学习了解

猜你喜欢