做网站如何挣钱_设计之家官网效果图_香港旺道旺国际集团_上海网站排名seo公司哪家好

此文章只做总结，以记住语法为准，学习go的同学应该都不是第一次学习编程语言了，既然玩了go，就要以生产实践为主。

包

导入

import “fmt”

起别名

import f “fmt”

批量导入，使用()来表示

import ( "fmt" "math" )

只导入不调用

import ( "fmt" _ "math" )

在go中禁止循环导入，无论直接还是间接，编译无法通过

导出

该规则适用于整个Go语言：对外暴露，首字母大写；不对外暴露，首字母小写

私有

go中约定，一个包内名为internal包为私有包，其他的包将无法访问私有包中的任何东西

数据类型

bool

true & false
在go中，整数0并不代表假值，非零整数也不能代表真值，即数字无法代替布尔值进行逻辑判断，两者是完全不同的类型

整型

uint8、uint16、uint32、uint64
int8、int16、int32、int64
uint、int
uintptr 等价于无符号64位整型

浮点型

float32、float64

字符类型

byte 等价于uint8表示ANSCII字符
rune 等价于int32表示Unicode字符
string 字节序列，可以转换为[]byte类型即字节切片

派生类型

数组 [5]int，长度为5的整型数组
切片 []float64，64位浮点数切片
映射表 map[string]int ,键为字符串类型、值为整型的映射表
结构体 type Gopher struct{} Gopher结构体
指针 *int 一个整型指针
函数 type f func(),一个参数，没有返回值的函数类型
接口 type Gopher interface{}，Gopher接口
通道 chan int，整型通道

零值

数字类型 0
布尔类型 false
字符串类型 “”
数组 固定长度对应类型的零值集合
结构体 内部字段都是零值的结构体
切片、映射表、函数、接口、通道、指针 nil

常量

const 修饰的必须初始化的字面量、常量表达式

变量

var 修饰的

声明

只声明不赋值，则为零值

简单声明

var intNum int

同时声明相同的数据类型

var numA,numB,numC int

同时声明多个变量

var (
name string
age int
)


赋值

先声明再赋值

var name string
name = “jack”

声明直接赋值

var name string = “jack”

同时赋值多个变量

var name string
var age int
name,age = “jack”,1

语法糖

a := 1

特殊情况，允许编译通过

func main() {a := 1a, b := 2, 2fmt.Println(a)fmt.Println(b)
}

交换

func main() {num1, num2 := 10, 20num1, num2 = num2, num1fmt.Println(num1)fmt.Println(num2)
}

匿名变量

a, b, _ := 1, 2, 3

比较

类型必须相同
minVal := min(1, 2, -1, 1.2)

数组

go中的数组是值类型，而非引用，并不是指向头部元素的指针

初始化

// 声明
var nums [5]int
// 元素初始化
nums := [5]int{1,2,3}
// new函数获取一个指针
nums := new([5]int)

使用

fmt.Println(nums[0])
nums[0] = 1
// 元素数量
len(nums)
// 数组容量
cap(nums)

切割

左闭右开

nums :=[5]{1,2,3,4,5}
nums[1:]
nums[:5]
nums[2:3]

切片

初始化

var nums []int // 值
nums := []int{1,2,3} // 值
nums := make([]int,0,0) // 值
nums := new([]int) // 指针

使用

切片的使用和数组完全一样

append

package mainimport "fmt"func main() {nums := make([]int, 0, 0)nums = append(nums, 1, 2, 3, 4, 5, 6, 7, 8, 9)fmt.Println(len(nums), cap(nums))
}

插入元素

头插入

func main() {nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}nums = append([]int{-1, 0}, nums...)fmt.Println(nums)
}

中间插入
例如在i的位置插入

nums = append(nums[:i+1], append([]int{999, 999}, nums[i+1:]…)…)


尾部插入
nums = append(nums,99,100)

删除元素

从头部删除n个元素

nums = nums[n:]
fmt.Println(nums) //n=3 [4 5 6 7 8 9 10]


从尾部删除n个元素

nums = nums[:len(nums)-n]
fmt.Println(nums) //n=3 [1 2 3 4 5 6 7]

从中间指定下标i位置开始删除n个元素

nums = append(nums[:i], nums[i+n:]…)
fmt.Println(nums)// i=2，n=3，[1 2 6 7 8 9 10]

删除所有元素

nums = nums[:0]
fmt.Println(nums) // []


拷贝

copy

clear

clear会将切片内所有的值置为零值

清空切片

func main() {s := []int{1, 2, 3, 4}s = s[:0:0]fmt.Println(s)
}

字符串

在Go中，字符串本质上是一个不可变的只读的字节数组，也是一片连续的内存空间

字面量

普通字符串

支持转义、不支持多行书写

"这是一个普通字符串\n"
"abcdefghijlmn\nopqrst\t\\uvwxyz"

原生字符串

支持多行书写，不支持转义

访问

func main() {str := "hello world"fmt.Println(str[0])fmt.Println(str[0:4])
}

不支持修改

str[0]=‘a’

转换

func main() {str := "this is a string"// 字符串转切片bytes := []byte(str)fmt.Println(bytes)// 切片转字符串fmt.Println(string(bytes))
}

字符串的内容是只读的不可变的，无法修改，但是字节切片是可以修改的

func main() {str := "this is a string"// 字符串转切片bytes := []byte(str)fmt.Println(bytes)bytes = append(bytes, 96, 97, 98)// 切片转字符串fmt.Println(string(bytes))
}

提示：两种类型之间的转换都需要进行数据拷贝，其性能损耗会随着长度的增加而增长。

长度

字符串的长度，并不是字面量的长度，而是字节数组的长度

func main() {str := "中国人"fmt.Println(len(str))
}

拷贝

本质是字节切片的拷贝

func main() {var dst, src stringsrc = "this is a string"desBytes := make([]byte, len(src))copy(desBytes, src)dst = string(desBytes)fmt.Println(src)fmt.Println(dst)
}

也可以使用string.clone函数，本质内部实现差不多

func main() {var dst, src stringsrc = "this is a string"dst = strings.Clone(src)fmt.Println(src, dst)
}

拼接

+ 拼接

转为字节使用append添加

package mainimport "fmt"func main() {var str string = "hello world"bytes := []byte(str)bytes = append(bytes, "您好 世界"...)fmt.Println(string(bytes))
}

strings.Builder

以上两种的性能都很差，如果对性能有要求，使用strings.Builder

package mainimport ("fmt""strings"
)func main() {builder := strings.Builder{}builder.WriteString("hello world")builder.WriteString("hello world")fmt.Println(builder.String())
}

遍历

func main() {str := "hello world 您好世界"for _, r := range str {fmt.Printf("%c", r)}
}

rune 本质上是int32的别名

映射表

一般来说，映射表数据结构实现通常有两种，哈希表和搜索树，区别在于前者无序，后者有序，在Go中，map的实现是基于哈希通，所以也是无序的

初始化

字面量

func main() {mp := map[int]string{0: "a",1: "b",2: "c",3: "d",}fmt.Println(mp)
}

make

func main() {mp := make(map[string]int, 8)mp["a"] = 1fmt.Println(mp)
}

访问

不存在，返回对应的零值

func main() {mp := make(map[string]int, 8)mp["a"] = 1fmt.Println(mp["b"])
}

访问方式

func main() {mp := make(map[string]int, 8)//mp["a"] = 1fmt.Println(mp["b"])if val, exist := mp["a"]; exist {// 如果存在fmt.Println(val)} else {// 如果不存在fmt.Println("mp['a'] not exist")}
}

删除

delete(mp,"a")

遍历

func main() {mp := map[string]int{"a": 1,"b": 2,"c": 3,"d": 4,}for k, v := range mp {fmt.Println(k, v)}
}

清空

clear(mp)

Set

Set是一种无序的，不包含重复元素的集合，Go中并没有提供类似的数据结构的实现，但是map的键正是无序且不能重复的，所以也可以使用map来替代set

func main() {set := make(map[int]struct{}, 10)for i := 0; i < 10; i++ {set[rand.Intn(100)] = struct{}{}}fmt.Println(set)
}

提示：一个空的结构体不会占用内存

并发安全

map并不是一个并发安全的数据结构，Go团队认为大多数情况下map的使用并不涉及高并发的场景，引入互斥锁会极大的降低性能，map内部有读写检测机制，如果冲突会触发fatal error
在这种情况下，需要使用sync.Map来替代。

指针

Go保留了指针，在一定程度上保证了性能，同时为了更好的GC和安全考虑，又限制了指针的使用

创建

func main() {num := 2p := &numfmt.Println(p)
}

解引用符号

1. 访问指针所指向元素
2. 声明一个指针

func main() {num := 2p := &numfmt.Println(*p)var numPtr *intnumPtr = &numfmt.Println(*numPtr)}

指针声明初始化

func main() {var numPtr *int = new(int)fmt.Println(*numPtr)numPtr1 := new(int)fmt.Println(*numPtr1)}

new 和 make

• new

1. 返回值是类型指针
2. 接收参数是类型
3. 专用于给指针分配内存空间

• make

1. 返回值是值，不是指针
2. 接收的第一个参数是类型，不定长参数根据传入类型的不同而不同
3. 专用于给切片，映射表，通道分配内存

结构体

Go中抛弃了类与继承，同时抛弃了构造方法，刻意弱化了面向对象的功能，Go并非是一个OOP的语言，但是Go依旧有着OOP的影子，通过结构体和方法可以模拟出一个类。结构体可以存储一组不同类型的数据，是一种复合类型

声明

type Person struct {name stringage int
}

对于相同类型的字段，如下声明

type Rectangle struct {height, width float32
}

注意：在声明结构体字段时，字段名和方法名不应该重复

创建

package mainimport "fmt"type Programmer struct {Name     stringAge      intJob      stringLanguage string
}func main() {programmer := Programmer{Name:     "jack",Age:      42,Job:      "bash",Language: "python",}fmt.Println(programmer)}

组合

在Go中，结构体之间的关系是通过组合来表示的，可以显式组合，也可以匿名组合，后者使用起来更类似于继承

import "fmt"type Person struct {name stringage  int
}type Student struct {p      Personschool string
}type Employee struct {p   Personjob string
}func main() {student := Student{p:      Person{name: "jack", age: 18},school: "lili school",}fmt.Println(student.p.name)
}

type Person struct {name stringage  int
}type Student struct {Personschool string
}type Employee struct {Personjob string
}func main() {student := Student{Person: Person{name: "jack",age: 18},school: "lili school",}fmt.Println(student.name)
}

指针

对于结构体而言，不需要解引用就可以直接访问结构体的内容

type Person struct {name stringage  int
}func main() {p := &Person{name: "jack",age:  18,}fmt.Println(p.age)
}

标签

结构体标签是一种元编程的形式，结合反射可以做出很多奇妙的功能
标签是一种键值对的形式，使用空格进行分隔。
结构体的容错性很低，如果没能按照正确的格式书写结构体，那么将导致无法正常读写，但是编译时不会有任何报错

type Programmer struct {Name string `json:"name"`Age  int `json:"age"`
}

空间结构体

空间结构体没有字段，不占用内存空间，可以通过unsafe.SizeOf函数计算占用字节大小

func main() {type Empty struct {}fmt.Println(unsafe.Sizeof(Empty{}))
}

应用：例如 将map作为set来使用