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