VSCode配置Go开发环境

blog.csdn.net/weixin_4276…

总结： 1.下载官方sdk，配置环境变量；【可以使用go version和go env进行验证】 2.下载vscode，安装go插件，安装开发工具包；

Go语言基础语法（一）

1.包、函数、变量、常量

1.1 包

• 每个 Go 程序都是由包构成的，程序从 main 包开始运行。
• 导包：

import (
	"fmt"
	"math"
)

等价于

import "fmt"
import "math"

1.2 函数

• 定义：

func split(sum int) (x, y int) {
	x = sum * 4 / 9
	y = sum - x
	return
}

• 类型省略：

x int, y int

等价于

x , y  int

• 返回值可以有多个且可以命名，变量名作为文档使用；

1.3 变量

• 声明：

var 变量名,变量名 类型 = 初始值，初始值

var (

变量名 类型 = 初始值

变量名 类型 = 初始值

)

package main

import "fmt"

var i, j int = 1, 2
var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
	var c, python, java = true, false, "no!"
	fmt.Println(i, j, c, python, java)
}
输出结果：
1 2 true false no!

• 短变量声明：

• 在函数内部，可以使用：=的方式代替var关键字，比如c, python, java := true, false, "no!"等价于var c, python, java = true, false, "no!"；
• 注意：短变量声明无法在函数外部使用；

• 类型：

• 布尔值：bool
• 整数： int int8 int16 int32【rune】 int64 uint uint8【byte】 uint16 uint32 uint64 uintptr
• 浮点数： float32 float64 complex64 complex128
• 字符串：string

• 类型转换：表达式 T(v) 将值 v 转换为类型 T。

var i int = 42
var f float64 = float64(i)

i := 42
f := float64(i)

1.4 常量

• 声明

• 常量的声明与变量类似，只不过是使用 const 关键字。
• 常量可以是布尔值、数值、字符、字符串。
• 常量不能用 := 语法声明。

2. for、if else、switch 、defer

2.1 for

• go语言中只有for循环，没有while和do while；
• 省略了初始化语句、条件判断语句、后置语句的（），若三个语句都不写表示一个死循环；
• {}不可以省略；

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

2.2 if else

• （）可以省略，{}不可以省略；
• 可以在判断语句前添加短语句，短语句的变量可以在if和else中使用；

2.3 switch

• 与C#相比省略了条件的（）与break子语句；
• switch可以不带条件变量，相当于switch true，作用与if then else相同；

2.4 defer

• defer可以将函数压入栈中，等外层函数返回值后再按照先进后出的顺序进行调用；

3. 指针、结构体、数组、切片、映射map、range

3.1 指针

• 定义：使用*T来表示指向类型T的指针 var p *int
• 赋值：&，使用&可以将值的内存地址赋值给指针
• 取值：* ，使用* 可以取出指针指向的值

3.2 结构体

• 定义：type 结构体名称 struct {字段定义}
• 访问：结构体名称.字段

3.3 数组

• 定义和声明：类型 [n]T 表示拥有 n 个 T 类型的值的数组。

var a [2]int
var a = [2]int{1,2}
a  := [2]int{1,2}

3.4 切片

• 定义：类型 []T 表示一个元素类型为 T 的切片。

var s []int

• 声明：一个切片是半开区间，下方示例代码表示切片s包含 primes 中下标从 1 到 3 的元素；

primes := [6]int{2, 3, 5, 7, 11, 13}
var s []int = primes[1:4]

primes := [6]int{2, 3, 5, 7, 11, 13}
s := primes[1:4]

s := []int {1,2,3}

• 长度和容量：

• 切片的长度就是它所包含的元素个数。
• 切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
• 切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	printSlice(s)

	// 截取切片使其长度为 0
	s = s[:0]
	printSlice(s)

	// 拓展其长度
	s = s[:4]
	printSlice(s)

	// 舍弃前两个值
	s = s[2:]
	printSlice(s)
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}
输出：
len=6 cap=6 [2 3 5 7 11 13]
len=0 cap=6 []
len=4 cap=6 [2 3 5 7]
len=2 cap=4 [5 7]

• nil切片：切片的零值是 nil，nil 切片的长度和容量为 0 且没有底层数组。
• 使用make创建切片：

• b := make([]int, 0, 5)

• 注意：
• 切片是一段数组的引用，不存储值，但是更改切片的数值也会更改原先数组的值；
• 切片默认的下界是0，默认的上界是切片长度；

3.5 映射map

• 定义：

/* 使用 make 函数 */
map_variable := make(map[KeyType]ValueType, initialCapacity)

/* 使用 map 关键字 */
// 使用字面量创建 Map
m := map[string]int{
    "apple": 1,
    "banana": 2,
    "orange": 3,
}

• 在映射 m 中插入或修改元素：

m[key] = elem

• 获取元素：

elem = m[key]

• 删除元素：

delete(m, key)

• 通过双赋值检测某个键是否存在：

elem, ok = m[key]

3.6 range

• 定义：range通过如下格式，对array、slice、map等进行遍历； for i,v := 遍历值名称 {处理语句}

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 将传入索引和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。  
    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)  
    }  
}
输出：
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111