linux查看ip 

1
2
ip addr 查看ip分配情况
ip addr show xxx 查看xxx的ip分配情况
1
ifconfig 查看ip分配情况
1
arp -a 查看本地地址解析协议缓存的内容

linux查看内存 

1
2
以MB为单位显示系统的内存使用情况
free -m
1
2
查看cpu和内存使用情况
htop
1
2
查看cpu和内存使用情况
top
1
2
查看内核实时生成的占用
cat /proc/meminfo

linux查看存储空间 

1
2
3
4
5
6
7
8
9
10
11
查看全部的空间占用情况，-h表示人类可读性，df是disk free
df -h
df --human-readable
查看文件夹的占用情况，-s表示--summarize，-h表示--human-readable，du表示disk usage
du -sh
列出所有可用的存储块设备以及它们的分区
lsblk
查看或修改磁盘分区表
sudo fdisk -l
查看磁盘的S.M.A.R.T信息，判断磁盘健康状态
sudo smartctl -a /dev/sda

byte数字转可读文字Python 

1
2
3
4
5
6
7
8
str = "10 6 100 97 109 105 110 103 16 18"
str_list = str.split(" ")
# 列表推导式
int_list = [int(num) for num in str_list]
# 使用map函数和lambda表达式
int_list = list(map(lambda num: int(num), str_list))
str_byte = bytes(int_list)
print(str_byte.decode("utf-8"))

yaml的横杠 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
requests:
  - method: 
        GET
    path:
        - '{{fBaseURL}}'
        - '{{fBaseURL}}'
        
{
  "requests": [
    {
      "path": [
        "{{fBaseURL}}", 
        "{{fBaseURL}}"
      ], 
      "method": "GET"
    }
  ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
requests:
  - method: 
        GET
  - path:
        - '{{fBaseURL}}'
        - '{{fBaseURL}}'
        
        
{
  "requests": [
    {
      "method": "GET"
    }, 
    {
      "path": [
        "{{fBaseURL}}", 
        "{{fBaseURL}}"
      ]
    }
  ]
}

golang mysql 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "log"
)

func main() {
    // 数据库连接信息
    db, err := sql.Open("mysql", "username:password@tcp(127.0.0.1:3306)/database_name")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 查询数据库中的第一条数据
    var (
        id   int
        name string
    )
    err = db.QueryRow("SELECT id, name FROM table_name LIMIT 1").Scan(&id, &name)
    if err != nil {
        log.Fatal(err)
    }

    // 打印查询结果
    fmt.Printf("ID: %d, Name: %s\n", id, name)
}

golang rpc 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// server
package main

import (
	"fmt"
	"net"
	"net/rpc"
)

type Hello struct{
}
// bind func to Hello type
func (this Hello) SayHello(req string, res *string) error {
	*res = "你好，" + req
	return nil
}

func main() {
	// registe rpc service name
	err := rpc.RegisterName("hello",new(Hello))
	if err != nil{
		fmt.Println(err)
	}
	
	listener, err2 := net.Listen("tcp", "127.0.0.1:8001")
	if err2 != nil{
		fmt.Println(err2)
	}
	defer listener.Close()

	for{
		fmt.Println("开始建立服务")
		conn, err3 := listener.Accept()
		if err3 != nil{
			fmt.Println(err3)
		}
		rpc.ServeConn(conn)
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// client
package main

import (
	"fmt"
	"net/rpc"
)

func main() {
	conn, err := rpc.Dial("tcp","127.0.0.1:8001")
	if err != nil{
		fmt.Println("Dial err:",err)
		return
	}
	defer conn.Close()

	var reply string

	// call the rpc service's func
	err = conn.Call("hello.SayHello", "David", &reply)

	if err != nil{
		fmt.Println("Call err:",err)
	}

	fmt.Println(reply)
}

golang ws 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package main

import (
	"log"
	"net/http"

	"github.com/gorilla/websocket"
)
 
var upgrader = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
	CheckOrigin: func(r *http.Request) bool {
		return true // 允许所有源，生产环境中应根据需要设置更严格的CORS策略
	},
}
 
func serveWs(w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Println("Failed to set up WebSocket connection:", err)
		return
	}
	defer conn.Close()
 
	for {
		// 读取客户端发送的消息
		msgType, msg, err := conn.ReadMessage()
		if err != nil {
			log.Println("Failed to read WebSocket message:", err)
			break
		}
 
		log.Printf("Received message from client: %s", msg)
 
		err = conn.WriteMessage(msgType, []byte("receive message successfully"))
		if err != nil {
			log.Println("Failed to send WebSocket message:", err)
			break
		}
	}
}
 
func main() {
	http.HandleFunc("/ws", serveWs)
	log.Println("Starting WebSocket server on :8080...")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		log.Fatal("Error starting server:", err)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main
 
import (
	"github.com/gorilla/websocket"
	"log"
	"net/url"
)
 
func main() {
	u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/ws"}
	log.Printf("Connecting to %s", u.String())
 
	c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
	if err != nil {
		log.Fatal("Failed to connect to WebSocket server:", err)
	}
	defer c.Close()
 
	err = c.WriteMessage(websocket.TextMessage, []byte("Hello from client!"))
	if err != nil {
		log.Println("Failed to send message:", err)
		return
	}
 
	_, msg, err := c.ReadMessage()
	if err != nil {
		log.Println("Failed to receive message:", err)
		return
	}
 
	log.Printf("Received message from server: %s", msg)
}

git 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
初始化项目
git init
拉取项目
git clone
查看项目状态
git status
拉取远程分支到本地
git pull origin mian
	拉取到本地仓库并合并工作区
	pull=fetch+merge
	拉取到本地仓库
    git fetch
    将本地仓库的合并到工作区
    git merge
查看历史版本
git log
以简化形式查看历史版本
git log --pretty=oneline
以极简化形式查看历史版本
git log oneline
回退版本，切换版本
git reset --hard xxx(哈希)
回退^个版本，版本数量取决于^的数量
git reset --hard HEAD^
回退n个版本
git reset --hard HEAD~n
    --soft参数：仅仅在本地库移动HEAD指针
    --mixed参数：在本地库移动HEAD指针，重置暂存区
    --hard参数：在本地库移动HEAD指针，重置暂存区，重置工作区
创建分支xxx
git branch xxx
查看分支
git branch -v
切换分支
git checkout xxx
推送暂存区的文件到远程库origin的main分支
git push origin main
在本地多次修改后查看修改记录
git reflog
在本地多次修改后回退修改版本
git reset HEAD@{index}
修改刚刚提交的commit信息
git commit --amend
1
2
工作区：能看到的文件
暂存区：提交到本地暂存区的文件

commit错误的分支补救，转到其他分支

1
2
3
4
5
6
7
8
9
# 撤回这次提交，但保留改动的内容
git reset HEAD~ --soft
git stash
# 现在切到正确的那个分支去
git checkout name-of-the-correct-branch
git stash pop
git add . # 或者你可以添加指定的文件
git commit -m "your message here";
# 现在你的改动就在正确的分支上啦
1
2
3
4
5
6
git checkout name-of-the-correct-branch
# 抓取 master 分支上最新的那个 commit
git cherry-pick master
# 然后删掉 master 上的那个 commit
git checkout master
git reset HEAD~ --hard

提交commit后，需要修改部分文件内容

1
2
3
4
5
# 再次修改文件
git add . # 或者你可以添加指定的文件
git commit --amend --no-edit
# 你这次的改动会被添加进最近一次的 commit 中
# 警告: 千万别对公共的 commit 做这种操作

commit错误的分支补救，转到新分支

1
2
3
4
5
6
# 基于当前 master 新建一个分支
git branch some-new-branch-name
# 在 master 上删除最近的那次 commit
git reset HEAD~ --hard
git checkout some-new-branch-name
# 只有在这个新分支上才有你最近的那次 commit 哦

git diff没有内容

1
2
将文件add之后，diff没有内容可以使用以下命令比较
git diff --staged

回到以前的commit

1
2
3
4
5
6
7
8
9
10
# 先找到你想撤销的那个 commit
git log
# 如果在第一屏没找到你需要的那个 commit，可以用上下
# 箭头来滚动显示的内容，找到了以后记下 commit 的
# hash 值
git revert [刚才记下的那个 hash 值]
# 这个操作会新建一次提交，不会修改原有的提交，reset则会删除提交
# git 会自动修改文件来抵消那次 commit 的改动，并创
# 建一个新的 commit，你可以根据提示修改这个新 commit
# 的信息，或者直接保存就完事了

将某个文件回退到某个commit的版本

1
2
3
4
5
6
7
8
# 找到文件改动前的那个 commit
git log
# 如果在第一屏没找到你需要的那个 commit，可以用上下
# 箭头来滚动显示的内容，找到了以后记下 commit 的
# hash 值
git checkout [刚才记下的那个 hash 值] -- path/to/file
# 改动前的文件会保存到你的暂存区
git commit -m "这样就不需要通过复制粘贴来撤回改动啦"