go-redis

引入核心包

1
2
3
4
5
6
7
import (
    "context"
    "encoding/json"
    "fmt"
    "github.com/go-redis/redis"
    "time"
)
设置全局连接变量
1
2
3
// 全局redis连接变量
var rdb *redis.Client
var ctx = context.Background()

初始化redis连接

1
2
3
4
5
6
7
8
9
10
11
12
13
func initClient() error {
    rdb = redis.NewClient(&redis.Options{
        Addr: "localhost:6379", // redis地址
        Password: "password", // redis密码
        DB: 0, // redis数据库编号
    })
    // ping连接
    _,err := rdb.Ping(ctx).Result()
    if err != nil {
        return err
    }
    return nil
}

GetDemo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func setDemo() {
    val := struct {
        Name string `json:"name"`
        Age int `json:"age" `
    }{"Tom",12}
    
    str,err := json.Marshal(val)
    if err != nil {
        return
    }
    fmt.Println("待序列化数据:",str)
    err = rdb.Set(ctx,"mykey",str ,0).Err()
    if err != nil {
        fmt.Println("设置错误",err)
    }
}
1
2
3
4
5
6
7
func setDemo2()  {
    // 设置3秒过期
    err := rdb.Set(ctx,"key2","hello world",3*time.Second).Err()
    if err != nil {
        fmt.Println("设置值错误,err = ",err)
    }
}

GetDemo

1
2
3
4
5
6
7
8
func getDemo() {
    val,err := rdb.Get(ctx,"mykey").Result()
    if err != nil {
        fmt.Println("获得数据失败")
        return
    }
    fmt.Println("mykey = ",val)
}
1
2
3
4
5
6
7
8
func getDemo2()  {
    val,err := rdb.Get(ctx,"key2").Result()
    if err != nil {
        fmt.Println("获得数据失败",err)
        return
    }
    fmt.Println("key2 = ",val)
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
func main() {
    // 初始化
    initClient()
    // 第一组测试
    setDemo()
    getDemo()
    // 第二组测试
    setDemo2()
    getDemo2()
    // 等待4秒后再次获得
    time.Sleep(4*time.Second)
    getDemo2()
}
结果
1
2
3
4
待序列化数据: [123 34 110 97 109 101 34 58 34 84 111 109 34 44 34 97 103 101 34 58 49 50 125]
mykey =  {"name":"Tom","age":12}
key2 =  hello world
获得数据失败 redis: nil

展开全文 >>

go-mysql

golang连接mysql数据库简单demo

引入相关依赖包

1
2
3
4
5
6
import (
  "database/sql"
  "fmt"

  _ "github.com/go-sql-driver/mysql"
)

初始化连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var db *sql.DB

func initDB() (error) {
  dsn := "user:password@(127.0.0.1:3306)/dbname?charset=utf8"
  var err error
  //db,err := sql.Open("mysql",dsn)会出现作用域覆盖导致空指针
  // 创建新的指针会把全局的db指针给覆盖掉
  db, err = sql.Open("mysql", dsn)
  if err != nil {
    return err
  }
  err = db.Ping()
  if err != nil {
    return err
  }
  return nil
}

数据库表结构映射

1
2
3
4
5
type User struct {
  id   int64
  name string
  age  int
}

添加数据DEMO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func InsertRowDemo() {
  sqlStr := "insert into user(name,age) value (?,?)"
  ret, err := db.Exec(sqlStr, "王五", 23)
  if err != nil {
    fmt.Printf("insert failed ,err :%v\n", err)
    return
  }
  theID, err := ret.LastInsertId()
  if err != nil {
    fmt.Printf("get lastinsert ID failed ,err :%v \n", err)
    return
  }
  fmt.Printf("insert success,the id is %d.\n", theID)
}

删除数据DEMO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func DeleteRowDemo(){
  sqlStr := "Delete FROM user where id = ?"
  ret,err := db.Exec(sqlStr,3)
  if err != nil {
    fmt.Printf("Delete failed ,err :%v\n",err)
    return
  }
  n,err := ret.RowsAffected()
  if err != nil {
    fmt.Printf("get RowAffected failed ,err :%v\n",err)
    return
  }
  fmt.Printf("delete success ,affect rows : %d\n",n)
}

更改数据DEMO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func UpdateRowDemo(){
  sqlStr := "update user set age=? where id = ?"
  ret,err := db.Exec(sqlStr,33,2)
  if err != nil {
    fmt.Printf("update failed,err : %v\n",err)
    return
  }
  // 更新影响的行数
  n,err := ret.RowsAffected()
  if err != nil {
    fmt.Printf("get RowAffected failed,err:%v\n",err)
    return
  }
  fmt.Printf("update success,affected rows : %d\n",n)
}

查询数据DEMO

查询单条数据
1
2
3
4
5
6
7
8
9
10
func QueryRowDemo() {
  sqlStr := "select id,name,age from user where id = ?"
  var u User = User{}
  err := db.QueryRow(sqlStr, 1).Scan(&u.id, &u.name, &u.age)
  if err != nil {
    fmt.Printf("scan failed,err:%v\n", err)
    return
  }
  fmt.Printf("user:%v", u)
}
查询多条数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func QueryMultiDemo(){
  sqlStr := "select id,name,age from user where id > ?"
  rows,err := db.Query(sqlStr,1)
  if err != nil {
    fmt.Printf("query failed,err :%v\n",err)
    return
  }
  defer rows.Close()

  for rows.Next(){
    var u User
    err := rows.Scan(&u.id,&u.name,&u.age)
    if err != nil {
      fmt.Printf("Scan failed,err:\v\n",err)
      return
    }
    fmt.Printf("u:%v",u)
  }
}
带预处理的查询
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
func PrepareQueryDemo()  {
  sqlStr := "Select id,name,age from user where id > ?"
  stmt,err := db.Prepare(sqlStr)
  if err != nil {
    fmt.Printf("Prepare failed,err :%v \n",err)
    return
  }
  defer stmt.Close()
  // 放置参数
  rows,err := stmt.Query(0)
  if err != nil {
    fmt.Printf("prepare failed,err :%v\n",err)
    return
  }
  defer rows.Close()
  for rows.Next(){
    var u User
    err := rows.Scan(&u.id,&u.name,&u.age)
    if err != nil {
      fmt.Printf("Scan failed ,err: %v\n",err)
      return
    }
    fmt.Printf("user: %v\n",u)
  }

}

gorm使用

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
package main

import (
    "fmt"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)
type UserTb struct {
    Account string `gorm:"column:account;primary_key"`
    Password string `gorm:"column:password"`
}
var (
    db *gorm.DB
)
func (u *UserTb) TableName() string  {
    // 返回的值是数据库中数据库表名
    return "usertb"
}

func InsertDemo() {
    insertUser := UserTb{
        Account:  "testUserAccount",
        Password: "testPassword",
    }
    // 判断主键是否为空
    // 只是对值进行非空(零值)判断,并不会涉及数据库查询
    //
    re := db.NewRecord(insertUser)
    if re {
        // 插入数据
        if err := db.Create(&insertUser).Error;err == nil{
            fmt.Println("insert success")
        }
    }
    
}

func SelectDemo(){
    user := UserTb{}
    db.Where("account=?","testUserAccount").Find(&user)
    fmt.Println(user)
}
func UpdateDemo(){
    user := UserTb{Account: "testUserAccount"}
    db.Where("account=?","testUserAccount").First(&user)
    fmt.Println("find : ",user)
    user.Password = "testUserPasswordUpdate"
    // db.Save(&user)
    db.Model(&user).Update("password","testUserPasswordUpdate2")
    //
    fmt.Println("update")
    fmt.Println(user)
    //
    fmt.Println("find : ")
    db.Where("account","testUserAccount").First(&user)
    fmt.Println(user)
}
func DeleteDemo() {
    user := UserTb{Account: "testUserAccount"}
    db.Delete(&user)
    fmt.Println("Delete success")
}
func main() {
    var err error
    db,err = gorm.Open("mysql","root:root1234@(localhost:3306)/gamedb?charset=utf8mb4&parseTime=True&loc=Local")
    if err!= nil{
        panic(err)
    }
    defer db.Close()
    usr := UserTb{}
    db.First(&usr)
    fmt.Println(usr)
    users := []UserTb{}
    db.Find(&users)
    fmt.Println(users)
    InsertDemo()
    SelectDemo()
    UpdateDemo()
    DeleteDemo()
}

展开全文 >>

go笔记(一)

go安装

在https://golang.google.cn/dl/下载对应的版本之后解压要想要的文件夹
配置环境变量:

  • GOROOT: go编译器所在的文件夹
  • GOPATH: go三方src所在的文件夹,如果不用go mod的话,所有的项目都要在GOPATH的src目录下编程.
  • GOPROXY: go的代理,国内一般设置为https://goproxy.io,direct"
    将GOPATH的bin文件夹加入PATH环境,以便于能够通过命令行访问。
    linux:的profile文件配置如下
    1
    2
    3
    4
    5
    # golang
    export GOROOT=/work/soft/go
    export GOPATH=/work/soft/dev/gopath
    export GOPROXY=https://goproxy.io,direct
    export PATH=$PATH:$GOROOT/bin
    Windows配置类似。

go get 无法使用问题解决办法

使用第三方包gopm
设置代理。windows需要设置相应的环境变量
1
2
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.io,direct

匿名函数

  • 普通函数变量

    1
    2
    3
    anon := func(a int,b int)int{
      return a + b
    }

    anon是一个函数变量。

  • 函数返回函数

    1
    2
    3
    4
    5
    6
    7
    annof := func() func(int,int) int{
      return func(a1 int, b1 int) int{
        return a1 + b1
      }
    }
    anon2 := annof()
    }

    anon2 也是一个匿名函数，该函数是返回一个函数。

  • 自启动。并且传参

    1
    2
    3
    4
    5
    6
    anon3 := func(param string)func(int,int) int {
      fmt.Println("param",param)
      return func(a1 int,b1 int) int{
        return a1 + b1
      }
    }("Hello World!")

  • 函数别名

    1
    2
    3
    4
    5
    6
    type returnFunctionType func(int,int) int
    anon4 := func() returnFunctionType {
      return func(a1 int, b1 int) int{
        return a1 + b1
      }
    }()

  • 调用函数

    1
    2
    3
    4
    fmt.Println("anon func =",anon(1,2))
    fmt.Println("anon func2 = ",anon2(1,2))
    fmt.Println("anon func3 = ",anon3(1,2))
    fmt.Println("anon func4 = ",anon4(1,2))

  • 调用结果

    1
    2
    3
    4
    5
    param Hello World!
    anon func = 3
    anon func2 =  3
    anon func3 =  3
    anon func4 =  3

闭包

  • 累加器
    1
    2
    3
    4
    5
    6
    7
    8
    func addUper() func(int)int {
      base := 10
      return func(n1 int) int{
        res := base + n1
        base ++
        return res
      }
    }

说明 改函数不依赖外部的数据实现累加。返回的func(int)int中含有一个base变量。该变量会自增。不会因为被调用而初始化。

  • 图片后缀
    1
    2
    3
    4
    5
    6
    7
    8
    9
    func suffixImage(s string) func(string)string {
      return func(path string) string {
        if strings.HasSuffix(path,s) {
          return path
        }else{
          return path + s
        }
      }
    }

说明 该函数返回一个闭包。能够识别是否拥有对应的后缀。没有就自己添加。

闭包总结

闭包等价于函数，但是该函数和普通的函数不一样的是，函数内部有一个不受外部影响而变化的变量。外部调用该函数时并不会重置该闭包内的数据。

接口和类型断言

1、接口

接口作为一种规范。接口是对继承的补充,并且通过接口可以实现上转型和下转型。golang的所有变量类型都是实现空接口,意味着可以将golang的各种类型上转成接口,然后再通过类型断言下转成具体类型。golang的空接口类似于java中的Object

1.1 接口的声明
1
2
3
4
type Usb interface {
    Start()
    Stop()
}

和java的接口一样,接口是作为一种规范，一个模板。没有具体的实现方式

1.2 接口的实现

和java不同的是,golang的接口实现不用显示的绑定,完全松耦合。只要一个类型或者变量实现了某个接口中定义的函数。即函数一样,就可以说该变量或者类型实现了该接口

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
type Phone struct{
    name string
}
func (p Phone) Start() {
    fmt.Println("手机开始工作。。。。")
}
func (p Phone) Stop() {
    fmt.Println("手机停止工作....")
}
func (p Phone) Call() {
    fmt.Println("手机打电话...")
}

type Camera struct{
    name string
}
func (c Camera) Start() {
    fmt.Println("相机开始工作。。。。")
}
func (c Camera) Stop() {
  fmt.Println("相机停止工作")
}
func (c Camera) Photography(){
  fmt.Println("拍照....")
}

类型Phone和Camera实现了Usb接口。但是看起来这两个类型没有和Usb这个接口联系起来。根本没有任何的绑定，java至少有implement来说明绑定的接口。唯一能和接口联系上的就是这两个类型都有Start()和Stop()函数。通过函数一样来绑定接口。

1.3 接口的使用

接口可以赋值,用具体实现类来赋值。这个和java的接口一致。可以使用接口类型来承接具体的类型

1
2
3
4
var usb Usb = Phone{name: "apple"}
fmt.Println(usb)
usb = Camera{name: "尼康"}
fmt.Println(usb)

usb的接口变量可以接收具体的实现类,接口会隐藏掉具体实现类中其它的特征,Phone中的Call()函数被隐藏了。

2、类型断言

类型断言类似于下转型,通过类型断言可以将接口下转成具体的实现类。实现接口的类型和断言的类型一致才会转换成功。
value,ok := i.(Phone)转换失败由第二个参数接收,转换成功由第一个参数接收转换后的具体实现类。

2.1 类型断言的使用(一)
1
2
3
4
5
6
7
8
9
10
11
12
13
type Computer struct{
}
func (c Computer) Working(usb Usb) {
    usb.Start()
    // 使用类型断言
    if v,flag := usb.(Phone);flag{
        v.Call()
    }
    if v, flag := usb.(Camera); flag {
        v.Photography()
    }
    usb.Stop()
}

computer的Working(usb Usb)函数使用了,usb接口类型,如果传进来的实现类是Phone就调用Call()方法。如果是Camera就调用Photography()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var usbArr [3]Usb = [3]Usb{
      0:Phone{
          name: "vivo",
      },
      1:Camera{
          name: "尼康",
      },
      2:Phone{
          name: "meizu",
      },
  }
var computer Computer
for _,v := range usbArr{
    computer.Working(v)
    fmt.Println()
}

输出

1
2
3
4
5
6
7
8
9
10
11
手机开始工作。。。。
手机打电话...
手机停止工作....

相机开始工作。。。。
拍照....
相机停止工作

手机开始工作。。。。
手机打电话...
手机停止工作....
2.2 类型断言的使用(二)

使用一个类型判断函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
func TypeJudge(item... interface{}){
  for index,v := range item{
    switch v.(type) {
      case bool:
          fmt.Printf("第%v参数 bool类型,值为:%v\n",index,v)
      case float32:
          fmt.Printf("第%v参数 float32类型,值为:%v\n",index,v)
      case float64:
          fmt.Printf("第%v参数 float64类型,值为:%v\n",index,v)
      case int, int32, int64:
          fmt.Printf("第%v参数 int 类型,值为:%v\n",index,v)
      case string:
          fmt.Printf("第%v参数 string类型,值为:%v\n",index,v)
      case Phone:
          fmt.Printf("第%v参数 Phone类型,值为:%v\n",index,v)
      case Camera:
          fmt.Printf("第%v参数 Camera类型,值为:%v\n",index,v)
      default:
          fmt.Printf("第%v参数 未知类型,值为:%v\n",index,v)
      }
  }
}

调用函数

1
TypeJudge(1,"stringvalue",1.1,Phone{"phone"},Camera{"camera"},computer)

控制台输出

1
2
3
4
5
6
第0参数 int 类型,值为:1
第1参数 string类型,值为:stringvalue
第2参数 float64类型,值为:1.1
第3参数 Phone类型,值为:{phone}
第4参数 Camera类型,值为:{camera}
第5参数 未知类型,值为:{}

panic

捕获函数panic的defer必须在调用函数之前才能捕获。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func TestPanic() {
    //defer func() {
    //   if err := recover();err!= nil{
    //       fmt.Println("Function Catch Panic ",err)
    //   }
    //}()
    // 抛出panic
    panic(errors.New("Test Panic"))
}
func main() {
   // TestPanic() //无法捕获
    // defer必须在TestPanic之前才能捕获
    defer func() {
        if err := recover();err!= nil{
            fmt.Println("Main catch Panic ",err)
        }
    }()
    TestPanic()
    fmt.Println("over")
}

测试

当一个go文件以_test.go作为后缀的时候不会参与build.使用go test命令会执行里面的测试函数

  • 测试函数:以Test开始的函数，入参为(t *testing.T)
  • 基准测试:以Benchmark做前缀的函数,入参为(t *testing.B)
  • 示例函数:以Example做前缀的函数。入参为空。需要有注释//Output:作为输出结果。
    例子
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    // 测试函数
    func TestHelloWorld(t *testing.T) {
        fmt.Println("Function Test Hello world")
    }

    func BenchmarkHello(t *testing.B)  {
        fmt.Println("Benchmark Test Hello")
       
    }

    func ExampleHello()  {
        //fmt.Println(false)
        fmt.Println(true)
        // Output:
        // true
        // false
    }
    命令行执行:go test就会执行测试函数。
    添加-bench参数，启动bench测试。
    go test -bench=.

golang学习路线

golang基础、进阶、大师。

展开全文 >>

python aria2 rpc

添加新的下载任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def addDownloadTask(url,dir,out):
    postdata = {
        "jsonrpc": "2.0",
        "id": "QXJpYU5nXzE1NDgzODg5MzhfMC4xMTYyODI2OTExMzMxMzczOA=="
    }
    rpc_request = postdata
    rpc_request["method"] = "aria2.addUri"
    # rpc 的选项，去掉--就可以了
    options = {
        "dir":dir,
        "out":out,
        "allow-overwrite":"true"
    }
    rpc_request["params"] = [[url],options]
    response = requests.post(url=rpc_url, json=rpc_request)
    if response.status_code == 200:
        result = response.json().get("result", [])
        print("gid: {}".format(result))
        return result
    else:
        log("无法调用aria2")

查询当前的状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def download_status(gid):
    postdata = {
        "jsonrpc": "2.0",
        "id": "QXJpYU5nXzE1NDgzODg5MzhfMC4xMTYyODI2OTExMzMxMzczOA=="
    }
    rpc_request = postdata
    rpc_request["method"] = "aria2.tellStatus"
    rpc_request["params"] = [gid]
    response = requests.post(url=rpc_url,json=rpc_request)
    if response.status_code == 200:
        result = response.json().get("result","")
        if result != "":
            status = result.get("status")
            if status != "":
                return status
    return None

下载

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
def download(url,dir,out):
    log("开始下载:{}".format(url))
    gid = addDownloadTask(url,dir,out)
    status = download_status(gid)
    error = False
    while True and not error:
        if status == "active":
            time.sleep(3)
            print("下载中.....\n")
            status = download_status(gid)
        if status == "complete":
            break
        elif status == "waiting":
            log("下载队列已满")
            time.sleep(4)
        elif status == "paused":
            log("暂停下载")
            break
        elif status == "error":
            log("下载错误")
            error = True
            break
        elif status == "removed":
            log("已经从下载队列中移除")
            break
    if error:
        log("下载:{}出错".format(url))
        return -1
    else:
        log("下载{}成功".format(url))
        return 0
日志函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
day = datetime.datetime.now().strftime('%Y%m%d')
log_file = day+"_log.txt"
def log(value,print_flag = True):
    logfile = open(log_file, 'a', encoding='utf-8')
    if logfile.writable():
        now_data = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        log_message = "时间:{} : log : {}\n".format(now_data, value)
        if print_flag:
            print(log_message)
        logfile.write(log_message)
    try:
        logfile.close()
    except IOError:
        print("写入日志错误")
    else:
        return

展开全文 >>

下载bing首页图片 

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
function getUrl(){
    // console.log("geturl");
    var bgurl = document.getElementById("bgImgProgLoad").getAttribute("data-ultra-definition-src");
    var bgDivUrl = document.getElementById("bgDiv").style.backgroundImage;
    if(bgDivUrl != undefined || bgDivUrl != ""){
        bgurl = bgDivUrl.replace("url(\"","").replace("\")","");
       }
    return bgurl;
}
(function() {
    'use strict';
    // add download btn
    var downloadButton = document.createElement("button");
    downloadButton.style.borderRadius="6px";
    downloadButton.style.zIndex="99";
    downloadButton.style.borderWidth="thin";
    downloadButton.style.height = "55px";
    downloadButton.style.marginLeft="20px";
    downloadButton.innerText = "下载图片";
    downloadButton.addEventListener("click",function(){
        var bgurl = getUrl();
        var xhr = new XMLHttpRequest();
        xhr.open("get",bgurl,true);
        xhr.responseType = "blob";
        xhr.onload = function(){
           if (this.status == 200) {
               var blob = this.response;
               var downloadElement = document.createElement('a');
               var href = window.URL.createObjectURL(blob); //创建下载的链接
               downloadElement.href = href;
               downloadElement.download = name; //下载后文件名
               document.body.appendChild(downloadElement);
               downloadElement.click(); //点击下载
               document.body.removeChild(downloadElement); //下载完成移除元素
               window.URL.revokeObjectURL(href); //释放掉blob对象
          }else{
              alert("下载失败");
          }
       }
       xhr.send();
    });
    var sbox = document.getElementById("sbox");
    sbox.appendChild(downloadButton);
    // Your code here...
})();
效果

效果

新版的bing首页壁纸下载脚本

由于bing搜索的页面变更,同步更新

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
// ==UserScript==
// @name         Bing首页图片下载
// @namespace    http://tampermonkey.net/
// @version      0.1
// @description  下载bing首页壁纸的脚本!
// @author       风兮木落
// @match        https://cn.bing.com/*
// @grant        none
// ==/UserScript==
function getUrl(){
    var bgurl =document.querySelectorAll("#bgImgProgLoad")[0].getAttribute("data-ultra-definition-src");
    //var bgurl =document.querySelector("#bgLink").href;
    console.log(`geturl:$(bgurl)`);
    return "https://cn.bing.com/" + bgurl;
}
(function() {
    'use strict';
    // add download btn
    var downloadButton = document.createElement("button");
    downloadButton.style.borderRadius="6px";
    downloadButton.style.zIndex="99";
    downloadButton.style.borderWidth="thin";
    downloadButton.style.height = "55px";
    downloadButton.style.marginLeft="20px";
    downloadButton.innerText = "下载图片";
    downloadButton.addEventListener("click",function(){
        var bgurl = getUrl();
        var xhr = new XMLHttpRequest();
        xhr.open("get",bgurl,true);
        xhr.responseType = "blob";
        xhr.onload = function(){
           if (this.status == 200) {
               var blob = this.response;
               var downloadElement = document.createElement('a');
               var href = window.URL.createObjectURL(blob); //创建下载的链接
               downloadElement.href = href;
               downloadElement.download = name; //下载后文件名
               document.body.appendChild(downloadElement);
               downloadElement.click(); //点击下载
               document.body.removeChild(downloadElement); //下载完成移除元素
               window.URL.revokeObjectURL(href); //释放掉blob对象
          }else{
              alert("下载失败");
          }
       }
       xhr.send();
    });
    var sbox = document.getElementById("sbox");
    sbox.appendChild(downloadButton);
    // Your code here...
})();

展开全文 >>

windows创建外部进程

引入头文件

1
2
3
4
5
#include<string>
#include<windows.h>
#include<winerror.h>
#include<Psapi.h>
#include<iostream>

重定向输入输出流

将外部进程的输入输出流重定向到文件，具体是从文件读取输入流，进程产生的输出重定向到文件中。启动进程的父进程只是进行监控。注意重定向到文件需要配置安全配置。

  • 安全配置
    1
    2
    3
    4
    5
    SECURITY_ATTRIBUTES saAttr;
    memset(&saAttr,0,sizeof(saAttr));
    saAttr.nLength = sizeof(SECURTIY_ATTRIBUTES);
    saAttr.bInheritHandle = TRUE;
    saAttr.lpSecurityDescriptor = NULL;
  • 文件句柄
    1
    2
    3
    4
    5
    // 设置读取文件内容的句柄
    fileReadHandle = (HANDLE)CreateFile(input_path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, &saAttr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    // 输出写入文件的句柄
    fileWriteHandle = (HANDLE)CreateFile(output_path, GENERIC_WRITE, FILE_SHARE_WRITE | FILE_SHARE_READ, &saAttr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    SetFilePointer(fileWriteHandle, NULL, NULL, FILE_BEGIN);
  • 子进程配置
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
    // 标准错误重定向到输出文件
    si.hStdError = fileWriteHandle;
    // 标准错误重定向到输出文件
    si.hStdOutput = fileWriteHandle;
    // 标准输入重定向到输入文件
    si.hStdInput = fileReadHandle;
    si.dwFlags |= STARTF_USESTDHANDLES;
    ZeroMemory(&pi, sizeof(pi));
  • 启动进程
    1
    CreateProcess(NULL, run_cmd, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, 0, &si, &pi

Judge的全部代码文件

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
// WinJudge.cpp : 定义控制台应用程序的入口点。
//
// 跟踪程序,主要记录程序执行占用的内存和运行的时间
// 
//

#include "stdafx.h"
#include<string>
#include<windows.h>
#include<winerror.h>
#include<Psapi.h>
#include<iostream>

using namespace std;

#define AC 0
#define PE 1
#define TLE 2
#define MLE 3
#define WA 4
#define RE 5
#define OLE 6
#define CE 7
#define SE 8

#define DEBUG false

struct result {
    int status;
    int timeUsed;
    int memoryUsed;
};

__int64 processStartTime = 0;

std::wstring s2ws(const std::string& s)
{
    int len;
    int slength = (int)s.length() + 1;
    len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
    wchar_t* buf = new wchar_t[len];
    MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);
    std::wstring r(buf);
    delete[] buf;
    return r;
}
LPWSTR ConvertToLPWSTR(const std::string& s)
{
    LPWSTR ws = new wchar_t[s.size() + 1]; // +1 for zero at the end
    copy(s.begin(), s.end(), ws);
    ws[s.size()] = 0; // zero at the end
    return ws;
}

/*
monitor the user process
*/
void monitor(PROCESS_INFORMATION pi, int timeLimit, int memoryLimit, struct result *rest) {
    // 等待进程执行完毕
    DWORD waitStatus;
    waitStatus = WaitForSingleObject(pi.hProcess, timeLimit);
    switch (waitStatus)
    {
    case WAIT_ABANDONED:
        if (DEBUG) {
            cout << "waiteStatus:" << waitStatus << endl;
        }
        rest->status = RE;
        return;
    case WAIT_TIMEOUT:
        rest->status = TLE;
        // 超时强制退出,避免死循环
        if (DEBUG) {
            cout << "waiteStatus: "<<"TIMEOUT" << waitStatus << endl;
        }
        TerminateProcess(pi.hProcess, 1);
        return;
    case WAIT_OBJECT_0:
        break;
    default:
        return;
    }
    // 获得进程的信息
    PROCESS_MEMORY_COUNTERS pmc;
    if (GetProcessMemoryInfo(pi.hProcess, &pmc, sizeof(pmc)))
    {
        // 时间 计算时间占用
        LARGE_INTEGER large_integer;
        QueryPerformanceCounter(&large_integer);
        __int64 processEndTime = large_integer.QuadPart;
        QueryPerformanceFrequency(&large_integer);
        double div = 1.0;
        div = large_integer.QuadPart;
        // 转换为ms
        rest->timeUsed = (processEndTime - processStartTime) * 1000 / div;
        // 计算内存占用
        long memory_peak_use = pmc.PeakWorkingSetSize;
        rest->memoryUsed = (memory_peak_use / 1024);
        // 获得退出的状态码
        DWORD exitCode;
        GetExitCodeProcess(pi.hProcess, &exitCode);
        // 外部进程正常结束 return为0
        if (exitCode != 0) {
            // 查看错误代码
            DWORD last_error = GetLastError();
            switch (last_error)
            {
            case ERROR_INVALID_SEGMENT_NUMBER:
                if (rest->memoryUsed > memoryLimit) {
                    rest->status = MLE;
                }
                else {
                    if (DEBUG) {
                        cout << "无效段:exitCode:" << exitCode << endl;
                    }
                    rest->status = RE;
                }
                break;
            case ERROR_SEM_TIMEOUT:
                rest->status = TLE;
                break;
            case ERROR_STACK_OVERFLOW:
                rest->status = MLE;
                if (DEBUG)
                {
                    cout << "栈溢出" << endl;
                }
                break;
            default:
                if (int(exitCode) == int(3221225725))
                {
                    if (DEBUG) {
                        cout << "stack overflow: exitCode:" << hex << exitCode << endl;
                    }
                    rest->status = MLE;
                }
                else {
                    if (DEBUG) {
                        cout << "other problem: exitCode:" <<hex<< exitCode << endl;
                    }
                    rest->status = RE;
                } 
                break;
            }
        }
        else {
            // 正常退出
            if (rest->timeUsed > timeLimit)
            {
                // 超时
                rest->status = TLE;
                TerminateProcess(pi.hProcess, 1);
            }
            else if (rest->memoryUsed > memoryLimit) {
                // 超内存
                rest->status = MLE;
                TerminateProcess(pi.hProcess, 1);
            }
            else {
                // 正常执行完毕
                rest->status = AC;
            }
        }
    }
    else {
        // 无法获得内存信息,返回RE
        if (DEBUG)
        {
            cout << "无法获得内存信息" << endl;
        }
        rest->status = RE;
    }
}

void runProccess(string cmd, int timeLimit, int memoryLimit, string inputPath, string outputPath) {
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    // 子进程的输出管道句柄
    SECURITY_ATTRIBUTES saAttr;

    // 输入输出文件的句柄
    // 读取文件的句柄
    HANDLE fileReadHandle = NULL;
    // 写入文件的句柄
    HANDLE fileWriteHandle = NULL;

    memset(&saAttr, 0, sizeof(saAttr));
    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
    saAttr.bInheritHandle = TRUE;
    saAttr.lpSecurityDescriptor = NULL;

    std::wstring ipath = s2ws(inputPath);
    wstring opath = s2ws(outputPath);
    LPCWSTR input_path = ipath.c_str();
    LPCWSTR output_path = opath.c_str();
    LPWSTR run_cmd = ConvertToLPWSTR(cmd);

    // LPCWSTR input_path = L"D:\\C\\TestInputOutput\\Debug\\input.txt";
    // LPCWSTR output_path = L"D:\\C\\TestInputOutput\\Debug\\output.txt";
    // LPWSTR run_cmd = ConvertToLPWSTR("python D:\\GraduationProject\\WinJudge\\Debug\\test.py");

    // 设置读取文件内容的句柄
    fileReadHandle = (HANDLE)CreateFile(input_path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, &saAttr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    // 输出写入文件的句柄
    fileWriteHandle = (HANDLE)CreateFile(output_path, GENERIC_WRITE, FILE_SHARE_WRITE | FILE_SHARE_READ, &saAttr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    
    if (NULL == fileReadHandle)
    {
        cerr<<("Can't open input file\n");
        return;
    }
    if (fileWriteHandle == NULL) {
        cerr <<("Can't open output file \n");
        return;
    }
    SetFilePointer(fileWriteHandle, NULL, NULL, FILE_BEGIN);
    memset(&si, 0, sizeof(si));
    // si.cb = sizeof(si);
    si.cb = memoryLimit * 1024;
    si.hStdError = fileWriteHandle;
    si.hStdOutput = fileWriteHandle;
    si.hStdInput = fileReadHandle;
    si.dwFlags |= STARTF_USESTDHANDLES;
    ZeroMemory(&pi, sizeof(pi));
    // Start the child process. 
    if (!CreateProcess(NULL, run_cmd, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, 0, &si, &pi))
    {
        cerr << ("CreateProcess failed (%d).\n", GetLastError());
        return;
    }
    // 开始计时
    LARGE_INTEGER large_integer;
    QueryPerformanceCounter(&large_integer);
    processStartTime = large_integer.QuadPart;
    struct result rest;
    rest.status = RE;
    rest.timeUsed = -1;
    rest.memoryUsed = -1;
    CloseHandle(fileWriteHandle);
    CloseHandle(fileReadHandle);
    // 监控进程
    monitor(pi, timeLimit, memoryLimit, &rest);
    printf("{\"status\":%d,\"timeUsed\":%d,\"memoryUsed\":%d}", rest.status, rest.timeUsed, rest.memoryUsed);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
}

int main(int argc, char ** argv)
{
    if (argc == 6)
    {
        string cmd(argv[1]);
        int replaceIndex = cmd.find("@");
        while(replaceIndex != -1)
        {
            cmd.replace(replaceIndex, 1, " ");
            replaceIndex = cmd.find("@");
        }
        int timeLimit = NULL;
        int memoryLimit = NULL;
        timeLimit = atoi(argv[2]);
        memoryLimit = atoi(argv[3]);
        string inputPath(argv[4]);
        string outputPath(argv[5]);
        if (DEBUG)
        {
            cout << "====info====" << endl;
            cout << "cmd:" << cmd << endl;
            cout << "timeLimit" << timeLimit << endl;
            cout << "memoryLimit" << memoryLimit << endl;
            cout << "input: " << inputPath << endl;
            cout << "output:" << outputPath<<endl;
            cout << "===========" << endl;
        }
        runProccess(cmd, timeLimit, memoryLimit, inputPath, outputPath);
    }
    else {
        // struct result rest;
        // rest.status = SE;
        // rest.memoryUsed = -1;
        // rest.timeUsed = -1;
        // printf("{\"status\":%d,\"timeUsed\":%d,\"memoryUsed\":%d}", rest.status, rest.timeUsed, rest.memoryUsed);
        cerr << "error params" << endl;
    }
    if (DEBUG) {
        // system("pause");
    }
    return 0;
}

Windows内存泄漏检查工具VLD使用

https://kinddragon.github.io/vld/

安装之后,将对应的lib和dll和头文件加到项目中。并且引用

1
#include "vld.h"

便可以引入了

展开全文 >>

右键更换壁纸

python文件

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
import win32api
import win32gui
import win32con
import os
import datetime
import random


day = datetime.datetime.now().strftime('%Y%m%d')
log_filename = day+"_log.txt"
def log(value,print_flag = True):
    log_path = os.getcwd() + "\\log"
    if not os.path.exists(log_path) :
        os.mkdir(log_path)
    log_file_path = log_path + "\\" + log_filename
    logfile = open(log_file_path, 'a', encoding='utf-8')
    if logfile.writable():
        now_data = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        log_message = "时间:{} : log : {}\n".format(now_data, value)
        if print_flag:
            print(log_message)
        logfile.write(log_message)
    try:
        logfile.close()
    except IOError:
        print("写入日志错误{}".format(IOError))
    else:
        return


def setWallPaper(wallpaper):
    try:
        key = win32api.RegOpenKeyEx(win32con.HKEY_CURRENT_USER,
                                    "Control Panel\\Desktop", 0, win32con.KEY_SET_VALUE)
        win32api.RegSetValueEx(key, "WallpaperStyle", 0, win32con.REG_SZ, "2")
        win32api.RegSetValueEx(key, "TileWallPaper", 0, win32con.REG_SZ, "0")
        win32gui.SystemParametersInfo(win32con.SPI_SETDESKWALLPAPER, wallpaper, 1 + 2)
        return True
    except EnvironmentError:
        log("except:{}错误".format(EnvironmentError))
        return False


"""
过滤图片文件
"""
def image_filter(file_list):
    image_list = []
    # 图片后缀
    image_suffix = ["jpg","png","bmp"]
    for file in file_list:
        if file.split(".")[-1] in image_suffix:
            image_list.append(file)
    return image_list


if __name__ == '__main__':
    image_dir = os.getcwd() + "\images"
    if os.path.exists(image_dir):
        file_list = os.listdir(image_dir)
        print(file_list)
        image_list = image_filter(file_list)
        print(image_list)
        if len(image_list) > 0:
            wallpaper_path = image_dir + "\\" + random.choice(image_list)
            if os.path.exists(wallpaper_path):
                if setWallPaper(wallpaper_path):
                    log("设置壁纸成功:path = {}".format(wallpaper_path))
                else:
                    log("设置壁纸失败,详情查看日志。path = {}".format(wallpaper_path))
            else:
                log("无效路径:{}".format(wallpaper_path))
        else:
            log("文件夹中没有图片文件:path = {}".format(image_dir))
    else:
        log("不存在路径:{}".format(image_dir))

启动文件

1
2
3
4
5
6
7
8
9
set curdir=%~dp0
cd /d %curdir%

@echo off
if "%1" == "h" goto begin
start mshta vbscript:createobject("wscript.shell").run("%~nx0 h",0)(window.close)&&exit
:begin

python main.py

设置右键项的

设置右键图片

展开全文 >>

windows右键添加项

1、进入注册列表

运行regedit.注册列表编辑器

2、定位

\HKEY_CLASSES_ROOT\Directory\Background\shell

3、新建一个子项

名称为右键所看见得项

4、在新建子项下面添加command项

command项为固定项。项的数据便是命令行。当你点击的时候便会运行该数据

截图

步骤
结果

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

正在成长中<br>请多多指教