Go语言基础（一）

Go语言具有支持高并发、语法简洁等特点

变量

Go语言中变量的定义可以直接定义，不需要基本数据类型，这些会自动帮你定义。但是你也可以写出变量的类型，放在变量的后面。还有一种是直接使用 := 来定义变量

var a = "initial"

	var b, c int = 1, 2

	var d = true

	var e float64

	f := float32(e)

	g := a + "foo"

	fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
	fmt.Println(g)                // initialapple

常量

其中，常量的定义没有确定的类型，它会根据上下文来自动确定类型

const s string = "constant"
	const h = 500000000
	const i = 3e20 / h
	fmt.Println(s, h, i, math.Sin(h), math.Sin(i))  //其中math.Sin()是求其值的正弦值

if else

Go语言中，if-else后面直接 接判断条件，无需加括号，即使加了，编译器编译的时候也会给你去除掉。并且Go中if-else后面必须加大括号，不能像C、C++一样写在同一行

package main

import "fmt"

func main() {

	i := 1
	for {
		fmt.Println("loop")
		break
	}
	for j := 7; j < 9; j++ {
		fmt.Println(j)
	}

	for n := 0; n < 5; n++ {
		if n%2 == 0 {
			continue
		}
		fmt.Println(n)
	}
	for i <= 3 {
		fmt.Println(i)
		i = i + 1
	}
}

if语句中，检查多个条件和C++是一样的，“!”非、“&&”与、“||”或

循环

Go语言中只有for一种循环,和if-else一样没有括号

常见的类型

for idx , item := range list{

package main

import "fmt"

func main() {

	i := 1
	for { //不加break，就是典型的死循环
		fmt.Println("loop")
		break
	}
	for j := 7; j < 9; j++ {  //第一个初值 ， 第二个范围 ， 第三个自增或自减
		fmt.Println(j)
	}

	for n := 0; n < 5; n++ {
		if n%2 == 0 {
			continue
		}
		fmt.Println(n)
	}
	for i <= 3 {  //也可以当成while来使用
		fmt.Println(i)
		i = i + 1
	}
}

switch-case

go中switch循环可以不加break，默认退出.

也可以在case后面不加常量，写表达式也可以；可以使用任意的变量类型（结构体、任意变量类型）；甚至switch后面不加变量，直接在case后面加表达式做条件.

package main

import (
	"fmt"
	"time"
)

func main() {

	a := 2
	switch a {
	case 1:
		fmt.Println("one")
	case 2:
		fmt.Println("two")
	case 3:
		fmt.Println("three")
	case 4, 5:
		fmt.Println("four or five")
	default:
		fmt.Println("other")
	}

	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("It's before noon")
	default:
		fmt.Println("It's after noon")
	}
}

数组

Go中定义数组的方式有三种

第一种定义方式：

var list [5] string
fmt.println(list)

第二种定义方式：

var list2  = [5] string{"a","b","c","d","e"}
fmt.println(list2)

第三种定义方式：

list3 := [5]string{"a" , "b" , "c" , "d" , "e"}
fmt.println(list3)

package main

import "fmt"

func main() {

	var a [5]int
	a[4] = 100
	fmt.Println("get:", a[2])
	fmt.Println("len:", len(a))

	b := [5]int{1, 2, 3, 4, 5}
	fmt.Println(b)

	var twoD [2][3]int
	for i := 0; i < 2; i++ {
		for j := 0; j < 3; j++ {
			twoD[i][j] = i + j
		}
	}
	fmt.Println("2d: ", twoD)
}

切片

切片是相同类型元素的可变长度的集合，通常用type[]表示。

切片由三部分组成：

• 指向底层数组中某个元素的指针：指向数组的第一个从切片访问的元素，但是这个元素并不一定是数组的第一个元素。

  1、 一个底层数组可以对应多个切片。

  2、 这些切片可以引用数组的任何位置。

  3、 彼此之间的元素可以重叠。

• 长度（length/len）：切片中的元素个数。

• 容量（capacity/cap）：为切片分配的存储空间。

切片类型的初始化值是nil，没有对应的底层数组，并且长度和容量都为0。可以使用len(s) == 0 来判断切片是否为空。

创建切片

package main

import "fmt"

func main() {

	s := make([]string, 3)  //使用内置函数make创建切片
	s[0] = "a" 
	s[1] = "b"
	s[2] = "c"
	fmt.Println("get:", s[2])   // c  访问切片，直接 切片名称[索引]
	fmt.Println("len:", len(s)) // 3

	s = append(s, "d")   //s切片后面增加了d
	s = append(s, "e", "f")  //s切片后面增加了e和f
	fmt.Println(s) // [a b c d e f]

	c := make([]string, len(s))
	copy(c, s)   //内置函数 copy() 可以将一个数组切片复制到另一个数组切片中
	fmt.Println(c) // [a b c d e f]

	fmt.Println(s[2:5]) // [c d e]  从第二个位置开到第五个位置
	fmt.Println(s[:5])  // [a b c d e]  从最开始的位置一直到第五个位置
	fmt.Println(s[2:])  // [c d e f]  从第二个位置一直最后一位

	good := []string{"g", "o", "o", "d"}  //直接创建切片
	fmt.Println(good) // [g o o d]
}

切片长度：就是包含的元素个数

切片容量：从它的第一个元素开始数，到其底层数组元素末尾的个数

内置函数

make([]T , len , cap)

• []T:表示类型，这个T可能是int型、string型，或者是自定义的一种类型。

• len（长度）：切片元素的个数，不能超过切片的容量。切片有自己的长度。

• cap（容量）：从切片的起始元素到最后一个元素之间的个数，它就是底层数组的长度

删除切片

定义一个切片

var word = []string{"a" , "b" , "c" , "d" , "e"}

例如要删除“c” ， 它的索引是2，即word[2:]

第一步：找到待删除元素前面的切片

第二步：找到待删除元素后面的切片

第三步：把这两个切片组合起来，即可达到删除元素的目的

word2 := append(word[:1] , word[2:]...) //这里的（...），因为在使用方法append时，需要添加具体的每个单独的元素，而word是一个切片，所以Go语言用（...)把一个切片打散成单独的元素，这样就可以使用方法append了
fmt.Println(word2)

工程代码中，一般很少使用数组，主要使用切片

Map

Map中一个键值（K）对应一个值T。

定义：

ms := map[K]T  //map容量使用的是默认值
ms := map[K]T , len)  //map的容量使用给定的len值

K:key 来快速检索数据，key 类似于索引，指向数据的值

T:T是指类型

package main

import "fmt"

func main() {
	m := make(map[string]int)
	m["one"] = 1
	m["two"] = 2
	fmt.Println(m)           // map[one:1 two:2]
	fmt.Println(len(m))      // 2
	fmt.Println(m["one"])    // 1
	fmt.Println(m["unknow"]) // 0

	r, ok := m["unknow"]
	fmt.Println(r, ok) // 0 false

	delete(m, "one")  //用于删除集合的元素，参数为map和它的key

	m2 := map[string]int{"one": 1, "two": 2}
	var m3 = map[string]int{"one": 1, "two": 2}
	fmt.Println(m2, m3)
}

range

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

package main

import "fmt"

func main() {
	nums := []int{2, 3, 4}
	sum := 0
	for i, num := range nums {
		sum += num
		if num == 2 {
			fmt.Println("index:", i, "num:", num) // index: 0 num: 2
		}
	}
	fmt.Println(sum) // 9

	m := map[string]string{"a": "A", "b": "B"}
	for k, v := range m {
		fmt.Println(k, v) // b 8; a A
	}
	for k := range m {
		fmt.Println("key", k) // key a; key b
	}
}