基础语法

hello world

package main //程序入口文件

import "fmt" //标准库文件，用于输入输出格式化字符串

func main(){
    fmt.Println("hello world") //输出
}

变量

常见变量类型：字符串、整数、浮点型、布尔型

两种方法声明变量

1、var 变量名 = 值

可自动推导变量类型，也可以自己写出类型

var a = "abc"
var b,c int =1,2

2、变量名 := 值

f := float32(e)

常量

把var改成const即可

const s string = "constant"

注意go语言中常量会根据上下文自动定义类型

if else

类似c/c++，要注意if后面判断语句不用括号

if 7%2 == 0 {
    fmt.Println("..")
}
else {
    fmt.Println("...")
}

循环

只有for循环

一、死循环

for{
    fat.Println("")
    break
}

二、经典循环

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

可以用continue来继续循环，也可以用break来跳出循环

switch

类似c/c++，变量名不需要括号

注意：go语言里面switch不需要在每个case后面加break

a := 2
switch a{
case 1:
    fmt.Println("1")
case 2:
    fmt.Println("2")
default:
    fmt.Println("other")
}

可以使用任意变量类型，如字符串、结构体等

也可以取代if else语句，在switch后面不加任何变量而在case后面加分支

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

数组

具有编号且长度固定的元素序列

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

并不常用，更多使用切片

切片

可变长度的数组，可在任意时刻更改长度

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"

输出切片长度

fmt.Println(len(s))

可使用append追加元素

注意：append必须将新数组赋值给原数组

s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s) //[a b c d e f]

可使用copy拷贝数据

c := make([]string, len(s))
copy(c, s)

输出切片的值

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]

map

哈希

m := make(map[string]int)

string为key，int为value

创建与删除

m["one"] = 1
delete(m, "one")

判断key值是否有元素

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

遍历map时会按随机顺序遍历

range

用于快速遍历

两个值：一个索引，一个对应位置的值

nums := []int{2, 3, 4}
for i, num :=rage nums{
    fmt.Println("index:", i, "num:", num)
}
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
    fmt.Println{k, v}
}

函数

变量类型后置，函数支持返回多个值，一般业务逻辑中第一个值返回结果、第二个值返回错误信息

func add(a int, b int) int {
    return a + b
}

func exists(m map[string]string, k string) (v string, ok bool) {
    v, ok :=m[k]
    return v, ok
}

指针

对传入的参数进行修改

func add2(n *int) {
    *n += 2
}

结构体

带类型的字段的集合

type user struct {
    name string
    password string
}

下面四种方法都可以初始化结构体，没有定义时会初始化为空值

func main(){
    a := user{name: "wang", password: "1024")
    b := user{"wang", "1024")
    c := user{name: "wang"}
    c.password = "1024"
    var d user
    d.name = "wang"
    d.password = "1024"
}

指针也可以对结构体实现修改

结构体方法

go语言可以给结构体自定义方法，类似于成员函数，这样可以用结构体直接调用函数

func(u user) checkPassword(password string) bool {
    return u,password == password
}
fmt.Println(a.checkPassword("2048"))

实现结构体方法时也可以带指针，这样可以对结构体进行修改

错误处理

可以在函数的返回值类型里面加error，这就代表这个函数可能会返回错误，在函数实现时需要return两个值。

在调用函数时也需要两个值来调用，调用后需要判断error是否存在

func finduser (users []user, name string) (v *user, err error){
    for _, u := range users{
        ...
        return &u, nil
    }
    return nil, erroes.New("not found")//出现错误时返回
}

u, err := finduser([]user{{"wang", "1024"}}, "wang")

字符串操作

判断一个字符串中是否包含另一个字符串

string.Contains(a, "ll")

字符串计数

string.Count(a, "l")

查找某个字符串的位置

string.Index(a, "ll")

连接多个字符串

string.Join([]string{"he","llo"}, "-")//he-llo

重复多个字符串

string.Re("hello", 2) //hellohello

获取字符串长度

len(a)

字符串格式化

打印多个变量并且换行

fmt.Println()

也可以使用Printf

fmt.Printf(s=%v\n", s) // s=hello

在go语言中对于任意变量都可以使用%v来打印，而不需要区分类型

使用%+v可以得到详细结构，%#v则是更加详细

利用%.2f可以控制打印浮点数的小数点位数

json处理

只需要保证结构体内所有字段的第一个字母是大写，就可以使用json.Marshal进行数列化，数列化后会成为一个数组,在输出时需要用到强制类型转换

buf, err := json.Marshal(a)

也可以使用json.Unmarshal进行反数列化

err = json.Unmarshal(buf, &b)

时间处理

最常用的时间处理

now := time.Now() //快速获取当前时间

时间戳

fmt.Println(now.Unix())

数字解析

解析字符串

f, _ := strconv.ParseFloat("1.234", 64) // 字符串，精度
fmt.Println(f) //1.234

n, _ :=strconv.ParseInt("111", 10, 64) // 字符串，进制，精度
fmt.Println(n) //111

n, _ := strconv.Atoi("123") // 快速将字符串转为十进制，也可以将数字转为字符串
fmt.Println(n)

进程信息

获取进程信息

fmt.Println(os.Args) //获取运行时命令行的参数

fmt.Println(os.Getenv("PATH")) //获取路径写入环境变量

buf, err := exec.Command("grep", "127.0.0.1", "/etc/bosts").CombinedOutput() //快速启动子进程并且获取输入输出