Go语言学习笔记

运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

优先级 运算符
5 * / % << >> & &^
4 + – | ^
3 == != < <= > >=
2 &&
1 ||

变量类型转换

string转成int：
int, err := strconv.Atoi(string)
string转成int64：
int64, err := strconv.ParseInt(string, 10, 64)
int转成string：
string := strconv.Itoa(int)
int64转成string：
string := strconv.FormatInt(int64,10)

设置环境变量

添加变量名：GOPATH Go的安装路径
GOPATH在系统环境变量有默认值 windows是C:/Users/用户名/Go

编译arm linux

GOARM=7 GOARCH=arm GOOS=linux go build

1.window下编译linux/arm ,linux/386 ...
   cmd到c:\go\src 目录 
   set GOOS=linux
   set GOARCH=arm
    执行all.bat
    结果：在C:\Go\pkg\tool\windows_386目录产生5a ,5l ,5c 5g ,8a ..等文件
   编译windows/amd64
   set GOOS=windows
   set GOARCH=amd64
   make.bat
CubiBoard板子 
2.linux下交叉编译
     bash到$GOROOT/src 
     GOARCH=386 GOOS=windows ./all.bash 
   或者 
    GOARCH=386 GOOS=windows ./make.bash
     GOARCH=arm GOOS=linux  ./make.bash

获取版本号

go version

配置工程文件夹

src
pkg

bin

项目结构

bin
pkg
src

• 包名 – 作者 – 项目名 – 模块

将bin目录添加到PATH环境变量的后边

获取Go路径相关信息
go env

运行go

编译go

并行编译

相关资料

json解析详解：https://segmentfault.com/a/1190000019787975

常用json库

import {
"fmt"
"encoding/json"
"net/http"
}

数组

//声明数组
a:= [3]int
a:= [3]int{1,2,3}
//给数组赋值
a[0] = 1
//将数组赋值给切片
b:= a[1:]
//数组遍历
for k,v := range team {
    fmt.Println(k,v) //k表示数组索引，v表示值
}

切片

//定义切片
a= make([]int, 3);
//为切片赋值
a[0] = 1
a[1] = 2
a[2] = 3

结构体

//定义结构体
type Battery struct{
Capacity int
}

//结构体赋值
battery := Battery{
    Capacity : 3000,
}

为结构体定义方法

type Bag struct{
    items []int
}

//将一个物品放入背包的过程 （面向过程的实现方式）
func Insert(b *Bag, itemid int){
    b.items = append(b.items, itemid);
}

//面向对象的实现方式
func (b *Bag) Insert(itemid int){
    b.items = append(b.items, item.id);
}

接口定义与实现

//声明接口
type Writer interface{
    Write(p []byte) (n int, err error)
}

type Closer interface{
    Close() error
}

//实现接口
type Socket struct{

}

func (s *Socket) Write(p []byte) (n int, err error){
    return 0, nil
}

func (s *Socket) Close() error{
    return nil
}

匿名函数

package main

import {
    "fmt"
}

// 遍历切片的每个元素， 通过给定函数进行元素访问
func visit(list []int, f func(int)){
    for _,v := range list {
        f(v)
    }
}

func main() {
    //使用匿名函数打印切片内容
    visit([]int{1,2,3,4}, func(v int){
        fmt.Println(v)
    })
}

json的解析与生成

package main

import (
        "fmt"
        "encoding/json"
        "time"
        "flag"
)

type  JSONObject struct{
 Action string `json:"action"`
 Msg string `json:"msg"`
 Code int `json:"code"`
 Data string `json:"data"`
}

//测试json创建
func test_json_create(){
   var jsonObject = JSONObject{Action:"test", Msg:"this is test", Data:"data",Code:200}
   output,error := json.MarshalIndent(&jsonObject,"","\t\t")
   if error != nil{
      fmt.Println("error:",error)
   }
   fmt.Println("json",string(output[:]))
}

type Server struct {
    ServerName string
    ServerIP   string
}
type Serverslice struct {
    Servers []Server
}
//测试json解析
func test_json_parse(){
     var s Serverslice

    // 模拟传输的Json数据
    str := `{
                "servers": [
                    {
                        "serverName": "Shanghai_VPN",
                        "serverIP": "127.0.0.1"
                    }, {
                        "serverName": "Beijing_VPN",
                        "serverIP": "127.0.0.2"
                    }
                ]
            }`

    // 解析字符串为Json
    json.Unmarshal([]byte(str), &s)
    for key,value := range s.Servers {
     fmt.Println("key:",key)
     fmt.Println("value",value)
    }
}

通道

线程

WebSocket服务端实现

WebSocket客户端实现

base64编码 url编码 字符串编码转换

···

//使用simplifiedchinese将string转byte[]
import (
"fmt"
"golang.org/x/text/encoding/simplifiedchinese"
)

// 字符串GBK2312编码方式解码方法
func str2gbk(text string) []byte{
TextBuff, err := simplifiedchinese.GBK.NewEncoder().String(text)
if err != nil {
fmt.Println(err)
}
return TextBuff
}

//使用mahonia进行编码转换
import (
"fmt"
"github.com/axgle/mahonia"
)

// 字符串GBK2312编码方式解码方法
func str2gbk(text string) []byte{
enc:=mahonia.NewEncoder("gbk")
TextBuff := []byte(enc.ConvertString(text))
if err != nil {
fmt.Println(err)
}
return TextBuff
}

编码转换原文链接：https://blog.csdn.net/weixin_43919745/article/details/97525828

// base64编解码
package main

import (
"encoding/base64"
"fmt"
)

func main() {
str := "Man"
fmt.Println("原字符串是：", str)
enStr := Base64EncodeString(str)
fmt.Println("编码后字符串是：", enStr)
deStrBytes, deStr := Base64DecodeString(enStr)
fmt.Printf("解码后字符串：字符串%s 字节%v\n", deStrBytes, deStr)

}

// Base64EncodeString 编码
func Base64EncodeString(str string) string {
return base64.StdEncoding.EncodeToString([]byte(str))
}

// Base64DecodeString 解码
func Base64DecodeString(str string) (string, []byte) {
resBytes, _ := base64.StdEncoding.DecodeString(str)
return string(resBytes), resBytes
}

//url编码解码
import (
"fmt"
"net/url"
)
测试代码：

urltest := "http://www.baidu.com/s?wd=自由度"
fmt.Println(urltest)
encodeurl:= url.QueryEscape(urltest)
fmt.Println(encodeurl)
decodeurl,err := url.QueryUnescape(encodeurl)
if err != nil {
    fmt.Println(err)
}
fmt.Println(decodeurl)

输出结果：

http://www.baidu.com/s?wd=自由度
http%3A%2F%2Fwww.baidu.com%2Fs%3Fwd%3D%E8%87%AA%E7%94%B1%E5%BA%A6
http://www.baidu.com/s?wd=自由度

···

字符串与byte[]互转

    var param string = "hell world"

    // string to []byte
    b := []byte(param)
    fmt.Println(b)

    // []byte to string
    s := string(b)
    fmt.Println(s)

变量类型判断

···
// 输出变量类型
v1 := "123456"
v2 := 12

    fmt.Printf("v1 type:%T\n", v1)
    fmt.Printf("v2 type:%T\n", v2)

// 输出变量类型 方法2
v1 := "123456"
v2 := 12
// reflect
fmt.Println("v1 type:", reflect.TypeOf(v1))
fmt.Println("v2 type:", reflect.TypeOf(v2))

// switch 判断变量类型
type-switch 流程控制的语法或许是Go语言中最古怪的语法。 它可以被看作是类型断言的增强版。它和 switch-case 流程控制代码块有些相似。 一个 type-switch 流程控制代码块的语法如下所示：
switch t := areaIntf.(type) {
case Square:
fmt.Printf("Type Square %T with value %v\n", t, t)
case Circle:
fmt.Printf("Type Circle %T with value %v\n", t, t)
case nil:
fmt.Printf("nil value: nothing to check?\n")
default:
fmt.Printf("Unexpected type %T\n", t)
}

变量类型判断资料：http://c.biancheng.net/view/86.html
···

键值循环 判断键值是否存在

v, ok = scene["route"]
- ok为true表示存在 false表示不存在

//遍历map
scene := make(map[string]int)
scene["route"] = 66
scene["brazi1"] = 4
scene["china"] = 960

for k,v := range scene {
    fmt.Println(k, v)
}

goto语句

// 使用goto语句跳出多层循环
package main
import (
    "fmt"
)

func main() {
    for x:=0; x<10; x++ {
        for y:=0; y<10; y++{
            if y==2 {
                goto breakHere
            }
        }
    }

    breakHere:
        fmt.Println("done")
}

break跳出指定循环

package main

import (
    "fmt"
)

func main(){
    OuterLoop:
        for i:=0; i<2; i++{
            for j:=0; j<5; j++ {
                switch j{
                case 2:
                fmt.Println(i, j)
                break OuterLoop
                case 3:
                fmt.Println(j, j)
                break OuterLoop
                }
            }
        }
}

时间获取，解析与转换

如何获取当前时间
time.now()
如何获取当前的年月日时分秒
now.年月日时分秒
如何按照我们指定的格式生成时间字符串
t := time.Now()
    fmt.Printf("当前的时间是: %d-%d-%d %d:%d:%d\n", t.Year(),
        t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second()) 
或者(装逼时刻)

注意点:任何数字都不能更改
    //str := t.Format("2006-01-02 15:04:05")
    //str := t.Format("2006-01-02")
    //str := t.Format("15:04:05")
    str := t.Format("2006")

相关链接：https://www.jianshu.com/p/1b56a082b677

http数据获取

一个简单的http服务器

延迟执行语句 defer

定义错误 捕获错误

文件读取

golang创建文本文件

    f,err := os.Create(fileName)

    defer f.Close()

    if err !=nil {

        fmt.Println(err.Error())

    } else {

        \_,err\=f.Write(\[\]byte("要写入的文本内容"))

        checkErr(err)

    }

golang读取文本文件

f, err := os.OpenFile(fileName, os.O\_RDONLY,0600)

    defer f.Close()

    if err !=nil {

        fmt.Println(err.Error())

    } else {

     contentByte,err\=ioutil.ReadAll(f)

        checkErr(err)

fmt.Println(string(contentByte))

    }

OpenFile用法：os.OpenFile(文件名，打开方式，打开模式）

//打开方式  

const (

//只读模式

O\_RDONLY int = syscall.O\_RDONLY // open the file read-only.

//只写模式

O\_WRONLY int = syscall.O\_WRONLY // open the file write-only.

//可读可写

O\_RDWR int = syscall.O\_RDWR // open the file read-write.

//追加内容

O\_APPEND int = syscall.O\_APPEND // append data to the file when writing.

//创建文件,如果文件不存在

O\_CREATE int = syscall.O\_CREAT // create a new file if none exists.

//与创建文件一同使用,文件必须存在

O\_EXCL int = syscall.O\_EXCL // used with O\_CREATE, file must not exist

//打开一个同步的文件流

O\_SYNC int = syscall.O\_SYNC // open for synchronous I/O.

//如果可能,打开时缩短文件

O\_TRUNC int = syscall.O\_TRUNC // if possible, truncate file when opened.

)

//打开模式  

const (

ModeDir FileMode = 1 << (32 - 1 - iota) // d: is a directory 文件夹模式

ModeAppend // a: append-only 追加模式

ModeExclusive // l: exclusive use 单独使用

ModeTemporary // T: temporary file (not backed up) 临时文件

ModeSymlink // L: symbolic link 象征性的关联

ModeDevice // D: device file 设备文件

ModeNamedPipe // p: named pipe (FIFO) 命名管道

ModeSocket // S: Unix domain socket Unix 主机 socket

ModeSetuid // u: setuid 设置uid

ModeSetgid // g: setgid 设置gid

ModeCharDevice // c: Unix character device, when ModeDevice is set Unix 字符设备,当设备模式是设置Unix

ModeSticky // t: sticky 粘性的

// Mask for the type bits. For regular files, none will be set. bit位遮盖.不变的文件设置为none

ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice

ModePerm FileMode = 0777 // Unix permission bits 权限位.

)

golang写入文本文件

f, err := os.OpenFile(fileName, os.O\_WRONLY|os.O\_TRUNC, 0600)

    defer f.Close()

    if err != nil {

        fmt.Println(err.Error())

    } else {

     \_,err\=f.Write(\[\]byte("要写入的文本内容"))

        checkErr(err)

    }

字符串分割 替换 截取

 str := "赵,钱,孙,李,赵"

    //字符串分割, 使用字符分割
    str1 := strings.Split(str, ",")
    fmt.Println(str1[0]) //赵
    fmt.Println(str1[1]) //钱
    fmt.Println(str1[2]) //孙
    fmt.Println(str1[3]) //李
    fmt.Println(str1[4]) //赵

    //字符串替换, -1表示全部替换, 0表示不替换, 1表示替换第一个, 2表示替换第二个...
    str2 := strings.Replace(str, "赵", "钱", -1)
    fmt.Println(str2) //钱,钱,孙,李,钱

    //字符串截取, 一个汉字3个字节, 还有一个逗号
    str3 := str[4 : len(str)-4]
    fmt.Println(str3) //钱,孙,李

StringBuffer BytesBuffer

 var buffer bytes.Buffer
    for i := 0; i < 1000; i++ {
        buffer.WriteString("a")
    }
    fmt.Println(buffer.String())