Go语言速推

go语言

一、 变量

1.使用关键词var

func main() {
   var a, b int = 1, 2
   var st string = "dddd" + "caonima"
   fmt.Println(a, b)
   fmt.Print(st)
}

2.“:=” 声明法

intVal := 1 等于

var intVal int 
intVal =1 

3.括号声明法：

var ( *// 这种因式分解关键字的写法一般用于声明全局变量*
  a int
  b bool
)

4.若未初始化，则默认为0

5.常量用关键词const

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)  
}

二、运算

1.条件运算

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

2.for循环语句

for init; condition; post { }

3.range范围

自动给出键值对，其中键为自动生成的从零开始的自然数

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	slice := data[:]
	for index, value := range slice {
		fmt.Printf("inde : %v , value : %v\n", index, value)
	}

三、函数

包括函数声明func, 函数名称， 参数列表，返回类型

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)
}

四、数组

1.普通数组

数组拥有cap, len两个属性，其中cap指的是数组人为限制的最大容量，len指的是当前容量

balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

以下情况下，默认 初始化为 nil：len=0 cap=0 slice=[]之所以为 nil ，是因为 没有分配存储空间。

var identifier []type

2.特殊数组（结构体）

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

variable_name := structure_variable_type {value1, value2...valuen}
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

3.slice切片

（1）声明一个拥有初始长度或规定容量的切片（可以指定切片的长度和容量），可以使用 make() 函数来创建切片:

var slice1 []type = make([]type, length, capacity)

// 也可以简写为

slice1 := make([]type, length, capacity)

s1 := []int{0, 1, 2, 3, 8: 100} // 通过初始化表达式构造，可使用索引号。
fmt.Println(s1, len(s1), cap(s1))

（2）双层切片

data := [][]int{             //[]int类型的切片
		[]int{1, 2, 3},          //初始化值
		[]int{100, 200},
		[]int{11, 22, 33, 44},
	}

(3) 结构体切片

d := [5]struct { //结构体数组
		x int
	}{}             //未初始化

	s := d[:]       //切片

	d[1].x = 10
	s[2].x = 20

	fmt.Println(d)
	fmt.Printf("%p, %p\n", &d, &d[0])
 

(4) append追加(这种操作能扩容cap)

var a = []int{1, 2, 3}
	fmt.Printf("slice a : %v\n", a)
	var b = []int{4, 5, 6}
	fmt.Printf("slice b : %v\n", b)
	c := append(a, b...)
	fmt.Printf("slice c : %v\n", c)
	d := append(c, 7)
	fmt.Printf("slice d : %v\n", d)
	e := append(d, 8, 9, 10)
	fmt.Printf("slice e : %v\n", e)

五、指针

使用&和*

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

六、并发

1.使用关键词go开启并发

package main

import (
        "fmt"
        "time"
)

func say(s string) {
        for i := 0; i < 5; i++ {
                time.Sleep(100 * time.Millisecond)
                fmt.Println(s)
        }
}

func main() {
        go say("world")
        say("hello")
}

2.通道

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

以下实例通过两个 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)
}