高性能高并发，不需要第三方库，使用标准库即可
语法简单
完善的工具链：测试等
静态链接，编译迅速，（缺点，占内存）
跨平台（路由器什么的，垃圾回收
变量
类型：字符串，整型，浮点型，布尔型
变量声明
//自动推导类型
var name=“”
//显式声明
var b,c int =1,2
//不使用var
f:=float32(e) //e是一个已声明变量，这里有一个强制类型转换
常量声明
golang里常量没有确定的类型，根据上下文自行确定类型
//使用const
const s string=“shd”
const h=5000
条件语句
if - else
//最大区别是没有括号
if 7%i==0{
fmt.Println("shf")
}else{
fmt.Println("shqdf")
}
循环（只有for
//死循环
for{
fmt.Println("shf")
}
//经典循环
for j:=7;j<9;j++{
fmt.Println("shf")
}
//相当于while
for i<=3{
fmt.Println("shf")
i=i+1
}
switch
也是不加括号，整体长得相似
与C++不同是：进入一个case分支后，就不会再进入其他分支了，例如运行完13行之后，就会跳转到24行
golang case的条件更加多样，各种类型，也可以是判断语句
数组
var a [5]int
但因其长度固定，所以很少用数组，更多的是用切片
切片
slice是长度、容量、指向数组的指针三元组
make来创建切片，使用append来添加元素（需要重新赋值原元素，因为又可以指向数组的指针改变了
package main
import "fmt"
func main() {
s := make([]string, 3)
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 = append(s, "e", "f")
fmt.Println(s) // [a b c d e f]
c := make([]string, len(s))
copy(c, s)
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]
}
map
遍历时是完全无序的
func main() {
//使用make来声明 【key】value
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")
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
fmt.Println(m2, m3)
}
range
遍历时使用
//两个变量承接，一个idx，一个值
for i, num := range nums {
sum += num
if num == 2 {
fmt.Println("index:", i, "num:", num) // index: 0 num: 2
}
}
// 一个变量，返回key
for k := range m {
fmt.Println("key", k) // key a; key b
}
函数
func 函数名（参数列表）返回值{
}
参数列表 ： 函数名 返回类型[，函数名 返回类型]
返回值可为空，可谓多个值，为多个值时，需要使用括号，可写明函数返回值的变量名
指针
func add2(n int) {
n += 2
}
func add2ptr(n *int) {
*n += 2
}
func main() {
n := 5
add2(n)
fmt.Println(n) // 5
add2ptr(&n)
fmt.Println(n) // 7
}
说是很多功能受限，不能使用
结构体
type 结构体名 struct{
成员变量
}
应该都是public，使用名称.成员变量访问
字段的可见性取决于字段名的首字母大小写。首字母大写的字段是公开的，可以在其他包中访问，而首字母小写的字段是私有的，只能在当前包中访问。
结构体方法
声明为成员函数，与普通函数类似，不同的是在func和函数名之间，加一个（结构体对象 结构体名）
func (u user) checkPassword(password string) bool {
return u.password == password
}
错误处理
主要用于函数返回，多返回一个值，为 err errorreturn 时使用error.New("错误信息")即可
字符串
一些字符串函数，这时候需要记忆一下
a := "hello"
fmt.Println(strings.Contains(a, "ll")) // true
fmt.Println(strings.Count(a, "l")) // 2
fmt.Println(strings.HasPrefix(a, "he")) // true
fmt.Println(strings.HasSuffix(a, "llo")) // true
fmt.Println(strings.Index(a, "ll")) // 2
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
fmt.Println(strings.Repeat(a, 2)) // hellohello
fmt.Println(strings.Replace(a, "e", "E", -1)) // hEllo
fmt.Println(strings.Split("a-b-c", "-")) // [a b c]
fmt.Println(strings.ToLower(a)) // hello
fmt.Println(strings.ToUpper(a)) // HELLO
fmt.Println(len(a)) // 5
b := "你好"
fmt.Println(len(b)) // 6 中文
input = strings.Trim(input, "\r\n") //剔除输入字符串中的回车符(\r)和换行符(\n)。
Json序列化与反序列化
序列化一个json：构造json结构体，调用json.Marshal(结构体)
我的理解噢，从能看懂的变成不能看的
底下这应该是序列化之后的
Java是一种面向对象编程语言，而JSON是一种键值对格式的数据，因此在Java中，需要将Java对象转换为JSON字符串，或者将JSON字符串转换为Java对象。这个过程就是JSON的序列化和反序列化。
