【go】学习笔记之语言结构、基础语法、函数形式、切片、map、并发

1.go的优点

• 简洁、快速、安全
• 并行、有趣、开源
• 内存管理、数组安全、编译迅速
• 对于高性能分布式系统领域而言，Go 语言无疑比大多数其它语言有着更高的开发效率。

2.语言结构

2.1基础组成部分

包声明、引入包、函数、变量、语句 & 表达式、注释。第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。例子：

package main

import "fmt"

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

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

※ { 大括号的左半边，不能单独在一行。

2.2运行程序

两种方式：

1）进入到hello.go所在目录中，运行如下命令

$ go run hello.go

2）先生成二进制文件，再运行二进制文件

$ go build hello.go 
$ ls
hello    hello.go
$ ./hello 

3.基础语法

Go 标记：Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。也即是一行代码中能拆分出来的内容。

标识符：标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。这点同c语言。

数据类型：用于声明函数和变量。数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。

序号	类型和描述
1	布尔型 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
2	数字类型 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
3	字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
4	派生类型: 包括： (a) 指针类型（Pointer） (b) 数组类型 (c) 结构化类型(struct) (d) Channel 类型 (e) 函数类型 (f) 切片类型 (g) 接口类型（interface） (h) Map 类型

语言变量：变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。声明变量的一般形式是使用 var 关键字，这点同scala。

//格式
var identifier type
//例子
var a string = "Runoob"

※：1.指定变量类型，如果没有初始化，则变量默认为零值。数值类型（包括complex64/128）为 0，布尔类型为 false，字符串为 ""（空字符串）。

※：2.根据值自行判定变量类型。eg：var v_name = value

※：3.省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误。也就是说，要用：=，就不要使用var。

值类型和引用类型：

像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值。当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝。

你可以通过 &i 来获取变量 i 的内存地址，例如：0xf840000040。值类型的变量的值存储在栈中。一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。

使用 := 赋值操作符：如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明。如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误。但是全局变量是允许声明但不使用的。 同一类型的多个变量可以声明在同一行。

语言常量：常量是一个简单值的标识符，在程序运行时，不会被修改的量。常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

//格式
const identifier [type] = value
//例子
显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"

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

    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
    )
//运行结果
0 1 2 ha ha 100 100 7 8

go语言条件语句：

   /* 定义局部变量 */
   var a int = 10
 
   /* 使用 if 语句判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" )
   }

Go 语言循环语句：for循环

语法：Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

//格式
for init; condition; post { }
//例子
package main

import "fmt"

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

和 C 的 while 一样：

        // 这样写也可以，更像 While 语句形式
        for sum <= 10{
                sum += sum
        }

和 C 的 for(;;) 一样：

        sum := 0
        for {
            sum++ // 无限循环下去
        }

           for-each range 循环：这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

package main
import "fmt"

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

        //[6]int{1, 2, 3, 5} 表示数组长度是6，类型是int，初始化了前4个元素为{1,2,3,5}
        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

输出：
0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

4.Go 语言函数

Go 语言最少有个 main() 函数。

Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}

例子，两个数比较大小，返回大的数：

/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
   /* 声明局部变量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result
}

例子，多个返回值的函数，返回值用()括起来：

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}

Go 语言数组：具有相同唯一类型的一组已编号且长度固定的数据项序列。

声明数组：Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

//格式
var variable_name [SIZE] variable_type
//例子
var balance [10] float32
//初始化数组
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
//如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。eg:   Element[0] = 100

Go 语言指针：

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：

格式
var var_name *var-type
例子
var ip *int        /* 指向整型*/

如何使用指针？指针使用流程：定义指针变量，为指针变量赋值，访问指针变量中指向地址的值。在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。当一个指针被定义后没有分配到任何变量时，它的值为 nil。

Go 语言结构体

在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

定义结构体：结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

eg：
variable_name := structure_variable_type {value1, value2...valuen}

访问结构体成员：如果要访问结构体成员，需要使用点号 . 操作符。

Go 语言切片(Slice)

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片：var identifier []type，切片不需要说明长度。或使用make()函数来创建切片:slice1 := make([]type, len)。

初始化切片：

s :=[] int {1,2,3 } #[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3
s := arr[:] #初始化切片s,是数组arr的引用
s := arr[startIndex:endIndex] #将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片
s := arr[startIndex:] #默认 endIndex 时将表示一直到arr的最后一个元素
s := arr[:endIndex] #默认 startIndex 时将表示从arr的第一个元素开始
s :=make([]int,len,cap) #通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片

make()函数的使用方法：make([]T, length, capacity)，T是数组，length 是数组的长度并且也是切片的初始长度，capacity是切片的最大容量。

len() 方法获取长度。

cap() 可以测量切片最长可以达到多少。

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。拷贝切片的 copy 方法，向切片追加新元素的 append 方法。

func main() {
   var numbers []int
   printSlice(numbers)
   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)
   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
}
输出：
len=0 cap=0 slice=[]
len=1 cap=1 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=6 slice=[0 1 2 3 4]

语言范围(Range)：Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。例子：

package main
import "fmt"
func main() {
    //这是我们使用range去求一个slice的和。使用数组跟这个很类似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)
    //在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的键值对上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

Go 语言Map(集合)：Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

定义 Map：可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "巴黎"

    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap [country])
    }

delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下：delete(countryCapitalMap, "France")

Go 语言类型转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换基本格式如下：

type_name(expression)   #type_name 为类型，expression 为表达式。
例子：
package main
import "fmt"
func main() {
   var sum int = 17
   var count int = 5
   var mean float32
   
   mean = float32(sum)/float32(count)
   fmt.Printf("mean 的值为: %f\n",mean)
}

输出
mean 的值为: 3.400000

Go 错误处理：Go 语言通过内置的错误接口提供了非常简单的错误处理机制。

我们可以在编码中通过实现 error 接口类型来生成错误信息。函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息：

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

Go 并发

只需要通过 go 关键字来开启 goroutine 即可。goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。goroutine 语法格式：

go 函数名( 参数列表 )
eg：
go f(x, y, z)

Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间。

通道（channel）：用来传递数据的一个数据结构。

通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v

声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

ch := make(chan int)

注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。

#以下实例通过两个 goroutine 来计算数字之和，在 goroutine 完成计算后，它会计算两个结果的和：
package main

import "fmt"

func sum(s []int, c chan int) {
        sum := 0
        for _, v := range s {
                sum += v
        }
        c <- sum // 把 sum 发送到通道 c
}

func main() {
        s := []int{7, 2, 8, -9, 4, 0}

        c := make(chan int)
        go sum(s[:len(s)/2], c)
        go sum(s[len(s)/2:], c)
        x, y := <-c, <-c // 从通道 c 中接收

        fmt.Println(x, y, x+y)
}
输出
-5 17 12

通道缓冲区

通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：  ch := make(chan int, 100)

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

注意：如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

package main

import "fmt"

func main() {
    // 这里我们定义了一个可以存储整数类型的带缓冲通道
        // 缓冲区大小为2
        ch := make(chan int, 2)

        // 因为 ch 是带缓冲的通道，我们可以同时发送两个数据
        // 而不用立刻需要去同步读取数据
        ch <- 1
        ch <- 2

        // 获取这两个数据
        fmt.Println(<-ch)
        fmt.Println(<-ch)
}
输出结果
1
2

Go 遍历通道与关闭通道：

Go 通过 range 关键字来实现遍历读取到的数据，类似于与数组或切片。格式如下：

v, ok := <-ch

如果通道接收不到数据后 ok 就为 false，这时通道就可以使用 close() 函数来关闭。

go方法和接口

方法：

Go 没有类。不过你可以为结构体类型定义方法。方法就是一类带特殊的 接收者 参数的函数。方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。在此例中，Abs 方法拥有一个名为 v，类型为 Vertex 的接收者。

package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	x, y float64
}

func (v Vertex) Abs() float64 {
	return math.Sqrt(v.x * v.x + v.y + v.y) 
}

func main() {
	b := Vertex{3, 4}
	fmt.Println(b.Abs())
}

方法即函数

记住：方法只是个带接收者参数的函数。现在这个 Abs 的写法就是个正常的函数，功能并没有什么变化。

package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func Abs(v Vertex) float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	v := Vertex{3, 4}
	fmt.Println(Abs(v))
}

接口

接口类型 是由一组方法签名定义的集合。接口类型的变量可以保存任何实现了这些方法的值。

 

 

参考：

1.网页资料：https://www.runoob.com/go/go-program-structure.html

2.go的练习场地，包括语法和可以运行的环境：https://tour.go-zh.org/list