Posts on Creedowl https://blog.creedowl.com/posts/ Recent content in Posts on Creedowl Hugo -- gohugo.io zh-hans This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License. Wed, 03 Mar 2021 15:10:56 +0800 Ocaml Heap https://blog.creedowl.com/posts/ocaml-heap/ Wed, 03 Mar 2021 15:10:56 +0800 https://blog.creedowl.com/posts/ocaml-heap/ 简介 本次课设我实现的数据结构是堆（heap)，堆是一种非常重要的数据结构，分为大顶堆和小顶堆，可以快速地获取其中优先级最高的元素。若是满足以 简介

本次课设我实现的数据结构是堆（heap)，堆是一种非常重要的数据结构，分为大顶堆和小顶堆，可以快速地获取其中优先级最高的元素。若是满足以下特性，即可称为堆：“给定堆中任意节点P和C，若P是C的母节点，那么P的值会小于等于（或大于等于）C的值”。若母节点的值恒小于等于子节点的值，此堆称为最小堆（min heap）；反之，若母节点的值恒大于等于子节点的值，此堆称为最大堆（max heap）。所以堆又称作优先队列。

原理

完全二叉树

堆的实现方式通常是完全二叉树，采用数组进行模拟。完全二叉树的特点是较为对称，查找时时间复杂度较为稳定，可以通过数组进行模拟，而不需要实际构建一棵二叉树。

以数组 [1, 2, 3, 4, 5, 6, 7] 为例，可以构建出如下一棵完全二叉树。

p1

对于每个节点都满足值大于父节点，所以这是一个小顶堆。对比数组和二叉树，可以发现：

  1. 对于节点 i ，它的两个子节点在数组中的索引为 2*i 和 2*i+1
  2. 两个子节点的大小对于堆的性质并没有影响，这点和二叉搜索树不一样

其中的核心操作是 shiftUp 和 shiftDown

分析其时间复杂度，有：

  • 获取堆顶元素：$O(1)$
  • 插入元素：$O(logn)$
  • 删除元素：$O(logn)$
  • 合并堆：$O(n)$

不过采用完全二叉树并不能方便地进行合并操作，需要转换成对一个堆的插入操作

但在函数式语言中要如何实现一个堆呢？对于纯函数式语言，是不允许有副作用的。虽然 Ocaml 支持命令式操作，也支持传统的数组，但依然采用数组模拟的话和普通的命令式语言就没有太多区别，而且会产生副作用，这是不推荐的。那么如果用 List 来模拟数组操作呢？

Ocaml 中的 List 是通过链表实现的，这就意味着 List 只能进行顺序访问，无法随机访问，也就无法像上面那样构建出一个虚拟的树形结构，而要全部转换成遍历操作。虽然可以通过计算和记录确定节点的位置，但会导致访问的时间复杂性大大提高。还有别的办法吗？

既然用数组模拟完全二叉树的方法在函数式语言中有很大的限制，那我们手动模拟一棵二叉树试试。我们可以定义出以下的数据结构：

type 'a heap = 
	| Leaf
	| Node of 'a * 'a heap * 'a heap

该结构参考了书上的内容，一个节点由自身的值和左右子节点构成，空节点为叶子节点。

对于插入操作，传统的数组模拟方式将元素插入数组尾部，再调用 shiftUp 操作将元素移动到正确的位置，如图所示：

p2

但在树状结构中，我们很难找到最后一个元素的位置，或者说时间复杂度太高，不具备可行性，也就无法采用 shiftUp 的思想。而我们的树结构只保存了根节点的位置，也就意味着只能自顶向下想想办法。

p3

首先比较 1 和 4 ，1 比 4 小，应该继续向下，但应该走左边还是右边呢？堆能保持高效性的原因之一就是结构比较对称，即左右子树的深度大致相等。必须要找到一个规则来解决这个问题。

堆的另一个重要操作是删除，即删除最顶端节点。这时我们发现如果删掉了根节点，我们会得到两个二叉树：

p4

在数组模拟的方式中我们将数组的最后一个元素（也就是完全二叉树的最后一个节点）移动到原本根节点的为止，再采用 shiftDown 操作将它移动到正确的位置。但同上面的问题一样，无法快速定位到最后一个节点，因此问题变成了如何合并两个堆。这时再看插入操作，发现也可以当成合并堆解决，即将目标堆和由待插入元素构成的只有一个节点的堆进行合并。可见堆的核心操作都转换成了堆合并，这就需要找到一个可以高效地进行堆合并的方法。

左偏树

搜索后发现，虽然大部分算法教程和书中堆都是采用数组模拟完全二叉树，但也有其它数据结构可以实现堆，就是左偏树。查看维基百科中的定义：

左偏树是一种可并堆的实现。左偏树是一棵二叉树，它的节点除了和二叉树的节点一样具有左右子树指针（left, right）外，还有两个属性： 键值和距离（英文文献中称为s-value）。键值用于比较节点的大小。距离的定义如下： 当且仅当节点 i 的左子树或右子树为空时，节点被称作外节点（实际上保存在二叉树中的节点都是内节点，外节点是逻辑上存在而无需保存。把一颗二叉树补上全部的外节点，则称为extended binary tree）。节点i的距离是节点 i 到它的后代中的最近的外节点所经过的边数。特别的，如果节点 i 本身是外节点，则它的距离为0;而空节点的距离规定为 -1。

光看定义比较复杂，但其实很简单，只需要在上面定义的树中加入一个距离（rank）即可，一个节点距离的值为到最右叶子节点的长度，如图所示：

p5

rank 是用来比较左右子树的长度的，在左偏树中，所有节点的左子树 rank 值一定大于等于右子树。因此每次进行合并操作时我们选择右子树，重复进行直到叶子节点或正确的位置，最后更新路径上的 rank 值，如果出现右子树的 rank 值大于左子树，则交换左右子树以保证左偏树的定义成立。

作为左偏树的核心操作，合并（merge）操作的流程如下：

  1. 合并 t1 ，t2 两个树 merge t1 t2
  2. 比较两个树根节点的值，如果 v1 < v2 则交换两个树（即 merge t2 t1 ），这样做的目的是保证左边树的值小于右边，便于操作。实际比较操作是通过函子中的 compare 函数进行，可以根据该函数设置大顶堆或小顶堆
  3. 由于左边树（ t1 ）根节点的值小于右边树（ t2 ），v1 保持不变作为新的根节点
  4. 由于 t1 的右子树 r 一定是最短的，开始合并 r 和 t2 （即 merge r t2 ）
  5. 当任一子树是叶子节点时，只需要直接返回另一个子树，并开始向上更新每个节点的 rank 值
  6. 更新完毕后还要比较左右子树的 rank 值以确定是否需要交换左右子树

看一个合并子树的例子：

p6

分析其时间复杂度，有：

  • 获取堆顶元素：$O(1)$
  • 插入元素：$O(logn)$
  • 删除元素：$O(logn)$
  • 合并堆：$O(logn)$

代码

完全二叉树

这部分代码是我一开始研究学习时写的测试代码，比较混乱，也采用了很多命令式语言的思维，比如有大量的副作用，对对象的操作都是在一个对象本身等。这里保留在这来和下面纯函数式的写法做一个对比

binary_heap.ml

(* Input signature of the functor *)
module type OrderedType = sig
  (* the type of the heap elements *)
  type t

  (* compare function used to determine the order of elements *)
  val compare : t -> t -> int
end

module Make (Ord : OrderedType) = struct
  type elt = Ord.t

  type tree = { mutable elements : elt array; mutable size : int }

  let create n default = { size = 0; elements = Array.make n default }

  let insert v t =
    let d = t.elements in
    let rec shiftUp i =
      let fi = (i - 1) / 2 in
      if i > 0 && Ord.compare d.(fi) v > 0 then (
        d.(i) <- d.(fi);
        shiftUp fi )
      else d.(i) <- v
    in
    shiftUp t.size;
    t.size <- t.size + 1

  let deleteTop t =
    if t.size <= 0 then failwith "empty"
    else
      let n = t.size - 1 in
      t.size <- n;
      let d = t.elements in
      let x = d.(n) in
      let rec shiftDown i =
        let ci = (2 * i) + 1 in
        if ci < n then
          let j =
            let k = ci + 1 in
            if k < n && Ord.compare d.(k) d.(ci) < 0 then k else ci
          in
          if Ord.compare d.(j) x < 0 then (
            d.(i) <- d.(j);
            shiftDown j )
          else d.(i) <- x
        else d.(i) <- x
      in
      shiftDown 0

  let getTop t = if t.size <= 0 then failwith "empty" else t.elements.(0)

  let rec toList t =
    if t.size <= 0 then []
    else
      let top = getTop t in
      deleteTop t;
      top :: toList t

  let rec fromList n default = function
    | [] -> create n default
    | hd :: tl ->
        let t = fromList n default tl in
        insert hd t;
        t
end

binary_heap.mli

(* Input signature of the functor *)
module type OrderedType = sig
  (* the type of the heap elements *)
  type t

  (* compare function used to determine the order of elements *)
  val compare : t -> t -> int
end

module Make : functor (Ord : OrderedType) -> sig
  type elt = Ord.t

  type tree

  (* create an empty heap, with only a leaf *)
  val create : int -> elt -> tree

  (* insert an element into a heap, just like merge two heap *)
  val insert : elt -> tree -> unit

  (* delete the top element of a heap, just merge two children trees *)
  val deleteTop : tree -> unit

  (* get the top element of a heap *)
  val getTop : tree -> elt

  (* generate a list from a heap *)
  val toList : tree -> elt list

  (* create a heap from list *)
  val fromList : int -> elt -> elt list -> tree
end

左偏堆

这里的左偏堆采用了纯函数式的写法，包括采用联合体构建一棵二叉树，所有操作都无副作用，返回一个新的对象等。和上面命令式的写法相比，也更加简练，通过递归和迭代就实现了复杂的操作逻辑

heap.ml

(* Input signature of the functor *)
module type OrderedType = sig
  (* the type of the heap elements *)
  type t

  (* compare function used to determine the order of elements *)
  val compare : t -> t -> int
end

module Make (Ord : OrderedType) = struct
  type elt = Ord.t

  (* heaps are represented by leftist tree *)
  type tree =
    (* leaf node *)
    | Leaf
    (* left child, value of node, right child, rank of node *)
    | Node of tree * elt * tree * int

  (* create an empty heap, with only a leaf *)
  let create () = Leaf

  (* create a node contains only v *)
  let singleton v = Node (Leaf, v, Leaf, 1)

  (* get the rank of a node *)
  let getRank = function Leaf -> 0 | Node (_, _, _, r) -> r

  (* merge to heap, the most important function in leftist heap *)
  let rec merge t1 t2 =
    match (t1, t2) with
    | Leaf, t | t, Leaf -> t
    | Node (l, v1, r, _), Node (_, v2, _, _) ->
        (* switch two heap if the tree on the left have a bigger key *)
        if Ord.compare v1 v2 > 0 then merge t2 t1
          (* the order is determined by the compare function *)
        else
          (* merge with the right tree *)
          let merged = merge r t2 in
          let leftRank = getRank l and rightRank = getRank merged in
          (* compare the rank of both tree *)
          if leftRank >= rightRank then Node (l, v1, merged, rightRank + 1)
            (* switch left and right since left tree is shorter *)
          else Node (merged, v1, l, leftRank + 1)

  (* insert an element into a heap, just like merge two heap *)
  let insert v t =
    match t with
    | Leaf -> singleton v
    | Node (_, _, _, _) -> merge t (singleton v)

  (* get the top element of a heap *)
  let getTop = function Leaf -> failwith "empty" | Node (_, v, _, _) -> v

  (* delete the top element of a heap, just merge two children trees *)
  let deleteTop = function
    | Leaf -> failwith "empty"
    | Node (l, _, r, _) -> merge l r

  (* generate a list from a heap *)
  let rec toList t =
    match t with Leaf -> [] | _ -> getTop t :: toList (deleteTop t)

  let rec fromList = function
    | [] -> create ()
    | hd :: tl -> insert hd (fromList tl)
end

heap.mli

(* Input signature of the functor *)
module type OrderedType = sig
  (* the type of the heap elements *)
  type t

  (* compare function used to determine the order of elements *)
  val compare : t -> t -> int
end

module Make : functor (Ord : OrderedType) -> sig
  type elt = Ord.t

  type tree

  (* create an empty heap, with only a leaf *)
  val create : unit -> tree

  (* merge to heap, the most important function in leftist heap *)
  val merge : tree -> tree -> tree

  (* insert an element into a heap, just like merge two heap *)
  val insert : elt -> tree -> tree

  (* get the top element of a heap *)
  val getTop : tree -> elt

  (* delete the top element of a heap, just merge two children trees *)
  val deleteTop : tree -> tree

  (* generate a list from a heap *)
  val toList : tree -> elt list

  (* create a heap from list *)
  val fromList : elt list -> tree
end

test.ml

测试文件，对所写的堆向外提供的函数进行测试。创建了一个带 int 类型的函子，采用自定义的排序函数实现大顶堆。还创建了一个 String 类型的函子

(* int 型函子，带比较函数 *)
module E = struct
  type t = int

  let compare a b = -compare a b
end

(* int 型大顶堆，采用左偏树 *)
module H_int = Heap.Make (E)

let t = H_int.create ()

(* 测试基本的插入、删除等操作 *)
let () =
  let t =
    H_int.insert 3 t |> H_int.insert 5 |> H_int.insert 1 |> H_int.insert 4
    |> H_int.insert 2
  in
  assert (H_int.getTop t = 5);
  assert (H_int.deleteTop t |> H_int.deleteTop |> H_int.getTop = 3);
  List.iter (Printf.printf "%d ") (H_int.toList t);
  print_newline ()

(* 测试从 list 构建和生成 list *)
let () =
  let l = H_int.toList (H_int.fromList [ 4; 2; 1; 5; 6; 7; 2; 0 ]) in
  assert (l = [ 7; 6; 5; 4; 2; 2; 1; 0 ]);
  List.iter (Printf.printf "%d ") l;
  print_newline ()

(* 测试合并两个堆 *)
let () =
  let t =
    H_int.merge
      (H_int.fromList [ 1; 3; 5; 7; 9 ])
      (H_int.fromList [ 2; 4; 6; 8 ])
  in
  let l = H_int.toList t in
  assert (l = [ 9; 8; 7; 6; 5; 4; 3; 2; 1 ]);
  List.iter (Printf.printf "%d ") l;
  print_newline ()

(* string 型小顶堆 *)
module H_string = Heap.Make (String)

let t = H_string.create ()

(* 测试基本的插入、删除等操作 *)
let () =
  let t =
    H_string.insert "asdf" t |> H_string.insert "qwer" |> H_string.insert "zz"
  in
  assert (H_string.getTop t = "asdf");
  assert (
    H_string.toList
      (H_string.deleteTop t |> H_string.deleteTop |> H_string.insert "bb")
    = [ "bb"; "zz" ] )

(* 测试 string 类型上的操作 *)
let () =
  let l =
    H_string.toList
      (H_string.merge
         (H_string.fromList [ "Z"; "Y"; "X" ])
         (H_string.fromList [ "y"; "z"; "x" ]))
  in
  assert (l = [ "X"; "Y"; "Z"; "x"; "y"; "z" ]);
  List.iter (Printf.printf "%s ") l;
  print_newline ()

(* int 型大顶堆，采用数组模拟完全二叉树 *)
module B_H_int = Binary_heap.Make (E)

let t = B_H_int.create 20 0

(* 测试基本的插入、删除等操作 *)
let () =
  B_H_int.insert 1 t;
  B_H_int.insert 3 t;
  B_H_int.insert 2 t;
  B_H_int.insert 4 t;
  assert (B_H_int.getTop t = 4);
  B_H_int.deleteTop t;
  assert (B_H_int.getTop t = 3);
  B_H_int.deleteTop t;
  assert (B_H_int.getTop t = 2);
  B_H_int.insert 6 t;
  assert (B_H_int.getTop t = 6);
  B_H_int.deleteTop t;
  B_H_int.deleteTop t;
  assert (B_H_int.getTop t = 1)

let t = B_H_int.create 20 0

(* 测试生成 list *)
let () =
  B_H_int.insert 1 t;
  B_H_int.insert 3 t;
  B_H_int.insert 2 t;
  B_H_int.insert 4 t;
  List.iter (Printf.printf "%d ") (B_H_int.toList t);
  print_newline ()

(* 测试从 list 构建 *)
let () =
  let t = B_H_int.fromList 20 0 [ 1; 3; 5; 7; 9; 2; 4; 6; 8; 0 ] in
  assert (B_H_int.toList t = [ 9; 8; 7; 6; 5; 4; 3; 2; 1; 0 ])

(* 测试两种堆实现的结果一致 *)
let () =
  let t1 = H_int.fromList [ 1; 3; 5; 7; 9; 2; 4; 6; 8; 0 ]
  and t2 = B_H_int.fromList 20 0 [ 1; 3; 5; 7; 9; 2; 4; 6; 8; 0 ] in
  assert (H_int.toList t1 = B_H_int.toList t2)

项目采用 make 进行构建

.PHONY:	all clean byte native profile debug test run

OCB_FLAGS = -tag bin_annot
OCB = 		ocamlbuild $(OCB_FLAGS)

all: native byte

clean:
	$(OCB) -clean

native:
	$(OCB) main.native

byte:
	$(OCB) main.byte

profile:
	$(OCB) -tag profile main.native

debug:
	$(OCB) -tag debug main.byte

run: native
	./main.native

心得体会

第一次用纯函数式语言写一个算法，和之前上课时在 toplevel 中测试还是有较大的区别，包括如何实现多文件编译，如何配置编译，如何编写模块等都困扰了我很久。最后依靠文档、手册、github上的一些项目等学会了如何构建一个 Ocaml 项目。

此外，Ocaml 标准库也给了我很大的帮助，里面的标准库如 Set 等都写得很清晰，有很详细的注释，我写的堆的模块结构、函子等都是参考 Set 库的处理方式。

对于函数式语言，特别是纯函数式的思想我也有了更深刻的理解。一开始我还是以命令式的思维来编写代码，认为不使用 for 、while 语句就是函数式，代码中还是存在很多 mutable 、ref 等内容，即存在副作用，也就导致了函数操作还是对一个“对象”进行操作，而不是每次返回一个新的结果。后来参考各种项目、教程，才发现了纯函数式“无副作用”的核心思想及处理方式。

我认为，纯函数式语言更贴近数学模型，可以用非常简练的语句写出算法，其核心是递归和迭代，例如我的堆通过短短几十行语句就实现了，通过一些精巧的递归就实现了命令式语言要写大量循环命令才能实现的功能。但这些简洁也带来了一些问题，比如代码抽象程度较高，理解起来较为困难；大量递归对栈上空间造成很大压力，性能降低了的同时也难以进行大量的计算，需要花费很大的力气去消除尾递归（但通常很难实现）；不允许副作用造成时间、空间的浪费；思维在两种思想中的转换较为困难等。但总的来说，函数式语言还是有很好的前景，从近年来越来越多的语言都开始支持函数式的写法（如 lambda 表达式等）可以看出。如 C++ 、Python 、Java 等都有函数式的写法，我在平时编写代码的过程中也会用到函数式语句来简化代码。函数式语言和命令式语言在未来可能会越走越近，取长补短，最后融为一体。

]]> GPG使用笔记 https://blog.creedowl.com/posts/gpg/ Thu, 02 Apr 2020 14:47:31 +0800 https://blog.creedowl.com/posts/gpg/ Why GPG? GPG 是一个密码学软件，用于加密、签名通信内容及管理非对称密码学的密钥，具体历史、介绍可以在wiki中看到，官网 而我使用 GPG 的缘由是，在 Github 上提 Why GPG?

GPG 是一个密码学软件，用于加密、签名通信内容及管理非对称密码学的密钥，具体历史、介绍可以在wiki中看到，官网

而我使用 GPG 的缘由是，在 Github 上提交时，如果使用 GPG 对提交进行签名，会有一个Verified标识看起来很nb

UTOOLS1585795152275.png

当然使用 GPG 不仅是为了好看，它能确保你提供的信息是由你自己发布的，无法被别人篡改、冒充，前提是保护好自己的 GPG 私钥

安装

这边以 MacOS 为示例进行操作

强烈建议 MacOS 用户使用 GPG Suite 进行操作，可以避免一些奇奇怪怪的问题

brew cask install gpg-suite

仅安装 GPG 本体

# deprecated
brew install gpg

生成密钥

GPG 采用非对称加密，一切的操作都需要有密钥。网上一些教程中的操作与我使用的 GPG 版本 gpg (GnuPG/MacGPG2) 2.2.17 有点出入，以下操作都在我所使用的版本下进行

有两个命令用于生成密钥，为gpg --gen-key和gpg --full-gen-key，区别是前者采用默认的配置不可更改，后者能自定义配置。我们采用后一种，首先选择密钥类型，默认的1就可以了

$ gpg --full-gen-key
gpg (GnuPG/MacGPG2) 2.2.17; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

请选择您要使用的密钥类型：
   (1) RSA 和 RSA （默认）
   (2) DSA 和 Elgamal
   (3) DSA（仅用于签名）
   (4) RSA（仅用于签名）
您的选择是？ 1

接着选择密钥长度，默认2048即可

RSA 密钥的长度应在 1024 位与 4096 位之间。
您想要使用的密钥长度？(2048) 2048

然后设定密钥的有效期限，我们没有特殊需求，设置永不过期即可

请设定这个密钥的有效期限。
         0 = 密钥永不过期
      <n>  = 密钥在 n 天后过期
      <n>w = 密钥在 n 周后过期
      <n>m = 密钥在 n 月后过期
      <n>y = 密钥在 n 年后过期
密钥的有效期限是？(0) 0

确认上述设置后，依次输入姓名、邮箱和注释，这里我使用随机信息用于演示

GnuPG 需要构建用户标识以辨认您的密钥。

真实姓名： naive
电子邮件地址： naive@test.com
注释： too young too simple
您选定了此用户标识：
    “naive (too young too simple) <naive@test.com>”

更改姓名（N）、注释（C）、电子邮件地址（E）或确定（O）/退出（Q）？

确定后，需要设定密钥的密码，如果你采用了 GPG Suite ，会出现一个窗口，在此输入密码

UTOOLS1585796741624.png

如果没使用GPG Suite，则会在你当前终端弹出一个全屏终端窗口，同样是输入密码。

注意，在 mac 终端环境下，如果语言是中文的话，这个终端窗口可能会乱码，但不影响使用，也可以临时设置语言为英文解决这个问题LANGUAGE=en gpg --full-generate-key。但千万不要用ctrl-c结束这个进程，这会破坏当前终端环境，后面的输入会变得很奇怪，而且后台进程不会结束，会占满你的CPU

我们需要生成大量的随机字节。在质数生成期间做些其他操作（敲打键盘
、移动鼠标、读写硬盘之类的）将会是一个不错的主意；这会让随机数
发生器有更好的机会获得足够的熵。
gpg: 密钥 4C26D2E451FFDAF1 被标记为绝对信任
gpg: 目录‘/Users/creedowl/.gnupg/openpgp-revocs.d’已创建
gpg: 吊销证书已被存储为‘/Users/creedowl/.gnupg/openpgp-revocs.d/0B3C52F1EF07B14EA7C45C9A4C26D2E451FFDAF1.rev’
公钥和私钥已经生成并被签名。

pub   rsa2048 2020-04-02 [SC]
      0B3C52F1EF07B14EA7C45C9A4C26D2E451FFDAF1
uid                      naive (too young too simple) <naive@test.com>
sub   rsa2048 2020-04-02 [E]

这样，密钥就生成完成，其中4C26D2E451FFDAF1就是你的密钥名，后续操作都需要通过这个密钥名选择密钥，但也可以通过之前设置的姓名或邮箱代替操作

GPG 常用操作

GPG 最基础的操作就是对文件等信息进行加密、签名，首先创建一个测试文件test.txt

echo test > test.txt

加密

gpg --recipient creedowl --output test.txt.gpg --encrypt test.txt

其中--recipient指定接收者，简写为-r，设定接受者时需要你本地有接收者的公钥，可以用密钥名、姓名或者邮箱进行指定。--output指定输出文件名，可省略。--encrypt指定待加密的文件，简写为-e。这样在你当前目录下会生成一个test.txt.gpg即加密后的文件，你就可以把这个文件发送给接受者，不必担心文件内容被第三方读取

注意这里生成加密文件为二进制格式，有时候（如通过邮件发送）不便于操作，可以加上--armor参数（简写为-a）生成文本格式的密文，如

gpg -r creedowl -ae test.txt

生成的加密文件为test.txt.asc

-----BEGIN PGP MESSAGE-----

hQEMA9KmvDhAMTGrAQf+KITqx4HTpWsevIEfRFlw5g+jt8l8ol3fuww0gBoMEPBG
KaqxCmjIpHZdGmaXwBSKadmeieZGLsm1CYuf4gbv4FpdWgveVWnLvB/HmwuvnmJt
YhTtapNgkQ++mwPbH4WKeOFQ58U5dZ7C+R8rrucRRYQBRTH6AJQY82aV1KXTqyF1
D8c/2ANW7aCWr8W/ogCbEqH47VE3foP+aSD+JMPtdnaYWIPzyr5x5lw6ASwxD4hB
ikOUcJTxp+GyFLTd3n1zCvSP9ZQzvolur7soqZVP8t4hxlALGL+KYN4YgubcPt5y
bucMYWkbLlZM+AuAYzSCLaSmkgkiYUFEkwKJWdLr+NJGAY5Mk+bnEP2k/kKxl9vo
/LVsloiYbg9M184LxUNfZRBnKcI9vKw/C6uU2Ee5wKUMsy3Epnp60Fe5u5fj5yn7
0JjMBmY+gQ==
=8K/i
-----END PGP MESSAGE-----

解密

有了密文就要对其进行解密得到原文。注意要进行解密，你必须有接受者的私钥。公钥是公开的，任何人都可以查看、使用，而私钥是私有的，一定要保管好，如果泄露了这个 GPG 密钥就等同于失效了，需要吊销。这就是非对称加密

	gpg --decrypt test.txt.asc --output out.txt

其中--decrypt声明该命令进行解密，简写为-d，--output指定输出文件，默认输出到终端。注意解密时需要输入你密钥的密码，所以也一定要保管好密码

签名

有的时候不需要对文件进行签名，只需要确保文件是由本人发出的，这个时候就可以用到签名

gpg --sign test.txt

会生成二进制的签名文件test.txt.gpg，如果想生成文本类型的签名，使用

gpg --clearsign test.txt

会生成文本类型的签名文件test.txt.asc

注意以上两种方式原文和签名是在同一个文件中，查看test.txt.asc

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256

test
-----BEGIN PGP SIGNATURE-----

iQFDBAEBCAAtFiEECzxS8e8HsU6nxFyaTCbS5FH/2vEFAl6FX+cPHG5haXZlQHRl
c3QuY29tAAoJEEwm0uRR/9rxGNsH/AmjJiT19q5caq9Pe8tMRnR2yvZIGWbMD3Ch
UTkyGMkSPMIo6XRpYPlANe2/dddBT2l7EAPy2lAxaa8LcjsxtRhJG4GxMaCcujik
M6MX3IOfa1m9aDP1IY3Sh2U07j3t+8dawahR8EUF2D+rtvx24ybnwpWpKbDVsGyp
Mt06BI3pWC3opMRYPCl21IBhPhaPPnvXF7X8DMP+2VqZye2juX2oG1KMkZWQuiBb
/D7DYlx6/ainu0cJw6UL8YXHag7tkUeKtTPQbBpCsszOuxJZ74gduIUzDcokayCB
DM9qB/GpUyVOOTwfLMBta6JP5BO8ppPaPdPX46kKDqLKG7eh4bQ=
=Q4/W
-----END PGP SIGNATURE-----

因为是签名，不会对内容进行加密，所以直接显示原文。如果想把原始文件分离出来，使用

gpg --output out.txt -d test.txt.gpg

分离的同时还顺便校验了签名。注意这里test.txt.gpg是上面生成的二进制签名文件，也可以用test.txt.asc

如果每次都要分离，就很麻烦，而且没有安装 GPG 的用户就无法使用源文件了。所以更好的方式是分离源文件和签名文件

gpg --detach-sign --armor test.txt

这样会生成一个单独的、文本类型的签名文件test.txt.sig

注意：如果有多个私钥，可以用-u参数选择

签名校验

收到文件和签名文件后，需要对签名进行校验

gpg --verify test.txt.sig test.txt

如果签名校验成功，会显示

gpg: 签名建立于 四  4/ 2 11:49:35 2020 CST
gpg:               使用 RSA 密钥 34B368EFC6FA8941B4A096CFFA4C884FBE8164D7
gpg: 完好的签名，来自于 “creedowl <creedowl@gmail.com>” [绝对]

导入导出

当你需要与他人交换数据时，需要导出自己的公钥，同时导入他人的公钥；而如果你更换电脑，就需要导出自己的私钥。这就涉及到了密钥的导入导出

gpg -a --output public_key.txt --export naive

上述命令用于导出公钥，相关参数在上文都有介绍。接着你就可以把public_key.txt发布给他人

gpg -a --output private_key.txt --export-secret-keys naive

上述命令用于导出私钥，一定要保管好，建议在脱机情况下进行操作

gpg --improt [密钥文件]

上述命令用于导入密钥，不区分公钥私钥

查看所有密钥

gpg -k

生成吊销证书

当你的私钥泄露或者更换时，需要吊销失效的密钥，这时就需要使用吊销证书

gpg --gen-revoke naive

接着选择吊销原因，就能生成吊销证书

sec  rsa2048/4C26D2E451FFDAF1 2020-04-02 naive (too young too simple) <naive@test.com>

要为这个密钥创建一个吊销证书吗？(y/N) y
请选择吊销的原因：
  0 = 未指定原因
  1 = 密钥已泄漏
  2 = 密钥被替换
  3 = 密钥不再使用
  Q = 取消
（也许您会想要在这里选择 1）
您的决定是什么？ 1
请输入描述（可选）；以空白行结束：
>
吊销原因：密钥已泄漏
（未给定描述）
这样可以吗？ (y/N) y
已强行使用 ASCII 字符封装过的输出。
-----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: This is a revocation certificate

****
-----END PGP PUBLIC KEY BLOCK-----
已创建吊销证书。

请把这个文件转移到一个您可以藏起来的介质上；如果坏人获取到了这
份证书的话，那么他就能使用它并让您的密钥无法继续使用。把此证书
打印出来再存放到安全的地方也是很好的方法，以免您的保存媒体变得
不可读。但是千万小心：您机器上的打印系统可能会在打印过程中储存
这些数据，并使得其他人看到！

只需要保存中间的吊销证书，当密钥泄露时将其发送到公钥服务器，就可以吊销旧密钥

编辑密钥

有时候需要对密钥进行编辑，如修改信任度，生成子密钥等，使用以下命令

gpg --edit-key naive

接着就会进入交互模式等待命令，输入help可以查看所有操作

gpg (GnuPG/MacGPG2) 2.2.17; Copyright (C) 2019 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

私钥可用。

sec  rsa2048/4C26D2E451FFDAF1
     创建于：2020-04-02  有效至：永不       可用于：SC
     信任度：绝对        有效性：绝对
ssb  rsa2048/A86AB46BDC677F8F
     创建于：2020-04-02  有效至：永不       可用于：E
[ 绝对 ] (1). naive (too young too simple) <naive@test.com>

gpg>

使用 GPG 签名 Git Commit

这就是我使用 GPG 的原因，下面开始配置，首先配置 git

# 设置全局默认密钥
git config --global user.signingkey <密钥ID>

# 设置强制使用GPG签名
git config --global commit.gpgsign true

之后在提交时，只需要带上-S参数，就能对提交进行签名

git commit -S -m "xxx"

查看 git 日志时，带上--show-signature参数就能看到签名信息

git log --show-signature

最后一步，需要把你的公钥提交到 github，否则它怎么知道这个签名是你的呢？将之前生成的文本类型的公钥public_key.txt提交到 github，之后你的提交在 github 上就有像开头那样的绿色小勾了

FAQ

解决git提交时出现error: gpg failed to sign the data

以下是原始解决方案，虽然能解决问题，但体验不好，在 IDE 中提交时难以输入密码，建议 MacOS 用户采用上面说的 GPG Suite进行操作，它可以接管密码输入操作，弹出一个独立窗口用于输入，还能将密码添加到 iCloud 钥匙串中，避免重复输入密码。如果你已经在使用GPG Suite，但仍然遇到了这个问题，可以尝试重装GPG Suite

  1. 导出密钥（私钥）重要

  2. 卸载 GPG

    brew uninstall gnupg gnutls
   
brew cask uninstall gpg-suite

  3. 删除 gpg 文件夹，请确认已经导出密钥

    rm -rf ~/.gnupg

  4. 重新安装GPG Suite，不需要手动安装 GPG

    brew cask install gpg-suite

  5. 导入密钥

这时 GPG Suite应该已经可以正常工作了

原始方案

首先测试gpg工作是否正常

echo "test" | gpg --clearsign

如果出现下面的错误

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256

test
gpg: 签名时失败： Inappropriate ioctl for device
gpg: [stdin]: clear-sign failed: Inappropriate ioctl for device

说明gpg无法打开输入密码的窗口。在生成gpg key时，如果指定了密码，在签名时就需要输入。而这时gpg不知道从哪里读取输入，所以可以用以下的命令指定tty

export GPG_TTY=$(tty)

这样就可以正常弹出输入密码的窗口。

但我不喜欢这个全屏窗口，主要是在mac上gpg语言为中文时，这个窗口会乱码，所以用另一个方法解决。编辑~/.gnupg/gpg.conf，添加以下内容

use-agent 
pinentry-mode loopback

再编辑~/.gnupg/gpg-agent.conf，添加以下内容

allow-loopback-pinentry

最后输入echo RELOADAGENT | gpg-connect-agent重启agent就生效了，这样可以直接在终端输入密码

source

]]> 重新开始 https://blog.creedowl.com/posts/renew/ Thu, 19 Mar 2020 21:28:13 +0800 https://blog.creedowl.com/posts/renew/ 突然发现距上一篇blog发布已经过去了快一年的时间，原先的blog也疏于打理，只有寥寥几篇文章，图床基本失效。主要因为我比较懒，认真整理一篇 突然发现距上一篇blog发布已经过去了快一年的时间，原先的blog也疏于打理，只有寥寥几篇文章，图床基本失效。主要因为我比较懒，认真整理一篇blog也是费时费力的事情。但自己整理一些文章是很有意义的事情，能记录下自己的学习历程，总结知识，再次遇到相同的问题也可以回头参考。

blog一直没更新有个诱因是微博图床开启了防盗链，导致blog中许多图片都无法访问了老王背锅，又懒得修复。同时看上了hugo这个框架，正好也在学习golang，就想从hexo更换到hugo。但这两个框架有个很大的区别我觉得，就是hexo是一堆前端工程师搞的，而hugo是一堆后端工程师搞的，这就导致了hugo没有啥好看的主题，也就一直鸽下去了。

去年年中的时候就打算和@queensferry写一个Hugo主题verse，立项的时候很多想法，但做起来就不想动了。摸完页面框架后就鸽了，一方面实在不会设计，另一方面调各种样式是真的蛋疼。鸽了半年又捡起来虽然我没写啥，不过渐渐也有点样子了。但今天发现了一个很棒的主题hermit，几乎就是我想要的，里面很多设计就是我当初构想的内容，马上捡起了blog。

这一年来也计划整理个人笔记软件，在尝试了数个软件后，有印象笔记，为知笔记，有道云笔记，onenote及一堆开源笔记应用，都不太满足我的需求。最后发现了notion这个东西贼香（主要对学生免费了），最后就选择了它。不过这也导致我手上一堆笔记分散在各处，打算后面整理清楚水几篇blog出来。

]]> Vue.js 从入坑到入土 https://blog.creedowl.com/posts/vue-demo-instruction/ Tue, 23 Apr 2019 21:25:25 +0800 https://blog.creedowl.com/posts/vue-demo-instruction/ Vue.js 从入坑到入土 近年来前端领域发展飞速，从最早的直接写html, js, css 到使用jQuery快速开发，再到近年来使用Vuejs，Reactjs 实现工 Vue.js 从入坑到入土

近年来前端领域发展飞速，从最早的直接写html, js, css 到使用jQuery快速开发，再到近年来使用Vuejs，Reactjs 实现工程化开发，也就短短十几年。虽然前端项目结构越来越复杂，但也越来越规范，清晰，更加工程化。当前较为流行的前端框架有Vuejs、Reactjs、Angularjs 等，而Vuejs由于其灵(zhong)活(wen)轻(wen)便(dang)，较为流行。虽然Vuejs有完善的中文文档，但文档主要在介绍其用法，缺少如何实现一个完整项目的指导，本文就介绍如何用Vuejs创建一个完整的前端项目，并与后端进行交互。

本文基于Vuejs@2.x及VueCLI@3.x

  1. 所需技术栈：html, javascript, css基础知识，其中js建议了解ES2015标准，特别要掌握promise的使用
  2. 使用的工具：宇宙第一编辑器 VSCode —— 现在对vue项目的支持已经很好了，可以自动安装vue项目需要的插件

0x0 安装

推荐使用yarn代替npm作为包管理器

安装VueCLI

VueCLI是Vuejs官方推出的项目脚手架工具，可以方便的创建、管理Vue项目，还提供优雅的web管理界面

全局安装VueCLI

yarn global add @vue/cli

安装Vue-devtools

Vue-devtools 是vue官方的浏览器开发插件，可以方便的在浏览器中调试vue应用

Vue-devtools 提供多平台的浏览器插件可以直接安装使用

installation

0x1 新建项目

使用 vue create vue_demo 创建新项目，接下来会出现一个交互式命令行帮你配置项目。

注意此处不要使用默认的配置！具体配置参考下图

坑x1 默认的配置十分简单，新手经常不知道怎么写多页面，弄不明白项目怎么组织的，所以需要自定义配置，添加vue-router插件实现多页面跳转

asciicast

0x2 项目框架

此时项目已经创建成功，如果你按照提示启动项目就能看到经典的vue启动页

image

当前的项目结构如下

.                     项目根目录
├── README.md 
├── babel.config.js
├── package.json      项目主配置文件
├── public            公共资源文件夹
│   ├── favicon.ico
│   └── index.html    入口html
├── src               源码根目录
│   ├── App.vue       入口文件
│   ├── assets        资源文件夹
│   │   └── logo.png
│   ├── components    组件文件夹
│   │   └── HelloWorld.vue 
│   ├── main.js       入口配置文件
│   ├── router.js     路由文件
│   ├── store.js      状态管理
│   └── views         页面文件夹
│       ├── About.vue
│       └── Home.vue
└── yarn.lock         依赖文件

在下面的章节具体介绍各个文件、文件夹的用处和如何组织项目。

0x3 项目结构

用vue开发的项目一般是SPA(单页应用)，通过动态重写当前页面来与用户交互，而不会重新加载整个新页面。所以要组织多页面就要通过vue-router来组织页面，而vuex用来保存状态。

作为单页应用，当然需要一个入口html文件，也就是 public/index.html :

public/index.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width,initial-scale=1.0">
    <link rel="icon" href="<%= BASE_URL %>favicon.ico">
    <title>vue_demo</title>
  </head>
  <body>
    <noscript>
      <strong>We're sorry but vue_demo doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
    </noscript>
    <div id="app"></div>
    <!-- built files will be auto injected -->
  </body>
</html>

这是默认生成的 index.html ，而编译好的文件（网页内容）会被自动注入到 `` 中，也就意味着要使用vue开发的应用，浏览器必须支持js。

而#app所绑定的vue实例，则位于 src/main.js

src/main.js

import Vue from 'vue'
import App from './App.vue'
import router from './router'
import store from './store'
Vue.config.productionTip = false
new Vue({
  router, // 使用vue-router插件
  store, // 使用vuex插件
  render: h => h(App) // 渲染页面
}).$mount('#app') // 绑定到 index.html -> div#app

其中渲染的页面位于 src/App.vue

xxx.vue 是vue中的单文件组件，将 html css javascript 集合在同一个文件，便于组织管理

src/App.vue

<template>
  <div id="app">
    <div id="nav">
      <router-link to="/">Home</router-link>
      <router-link to="/about">About</router-link>
    </div>
    <router-view/>
  </div>
</template>
<style>
#app {
  font-family: 'Avenir', Helvetica, Arial, sans-serif;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  text-align: center;
  color: #2c3e50;
}
#nav {
  padding: 30px;
}
#nav a {
  font-weight: bold;
  color: #2c3e50;
}
#nav a.router-link-exact-active {
  color: #42b983;
}
</style>

其中 是页面的 `html` 元素，`style` 是样式元素，还可以添加一个 `javascript` 为js元素。其中 是路由组件，会被自动渲染成当前路由对应的页面

src/router.js

import Vue from 'vue'
import Router from 'vue-router'
import Home from './views/Home.vue'
Vue.use(Router)
export default new Router({
  mode: 'history',
  base: process.env.BASE_URL,
  routes: [
    {
      path: '/',
      name: 'home',
      component: Home
    },
    {
      path: '/about',
      name: 'about',
      // route level code-splitting
      // this generates a separate chunk (about.[hash].js) for this route
      // which is lazy-loaded when the route is visited.
      component: () => import(/* webpackChunkName: "about" */ './views/About.vue')
    }
  ]
})

如 http://localhost:8080/ 下 被渲染成 `home` 页面，`http://localhost:8080/about` 下 被渲染成 about 页面。

技巧 这里加载组件使用函数加载，就可以实现懒加载以优化性能。

src/views/ 则是保存页面文件，例如

src/views/Home.vue

<template>
  <div class="home">
    <img alt="Vue logo" src="../assets/logo.png">
    <HelloWorld msg="Welcome to Your Vue.js App"/>
  </div>
</template>
<script>
// @ is an alias to /src
import HelloWorld from '@/components/HelloWorld.vue'
export default {
  name: 'home',
  components: {
    HelloWorld
  }
}
</script>

这就是路由 home 对应的页面，其中用到了 HelloWorld 组件，需要在js中引入。

src/components/ 里面保存可复用的组件，例如上面的 `` 就是一个独立的组件（component）

src/components/HelloWorld.vue

<template>
  <div class="hello">
    <h1>{{ msg }}</h1>
    <p>
      For a guide and recipes on how to configure / customize this project,<br>
      check out the
      <a href="https://cli.vuejs.org" target="_blank" rel="noopener">vue-cli documentation</a>.
    </p>
  </div>
</template>
<script>
export default {
  name: 'HelloWorld',
  props: {
    msg: String
  }
}
</script>
<!-- Add "scoped" attribute to limit CSS to this component only -->
<style scoped>
h1 {
  margin: 40px 0 0;
}
</style>

这就是一个典型的组件，结构就是一个正常的单文本组件，说明组件就是把一部分页面逻辑抽出来组成一个文件。这样的好处是分离与页面无关的组件，使页面逻辑更加清晰，同时也便于复用组件。如果有以下情况，我建议把部分代码分离成独立的组件：

  1. 需要多次复用的组件，如基础按钮、表单等
  2. 较为复杂但与页面逻辑无关的，如页面的Header、Footer等

技巧 在 style 表情上添加 scoped 属性可以限制CSS生效范围为该组件，不会影响其他元素，在编译时vue解释器会给这些css属性加上随机的hash保证唯一

vue还提供了一个状态管理模式 vuex，可以很方便的管理所有组件的状态。对应文件 src/store.js

src/store.js

import Vue from 'vue'
import Vuex from 'vuex'
Vue.use(Vuex)
export default new Vuex.Store({
  state: {
  },
  mutations: {
  },
  actions: {
  }
})

由于我还没用过 vuex 所以自己看文档吧

对于简单的应用也可以不用 vuex ，一个简单的 store 模式 就足够了

0x4 开发指引

有了上面的基础，我们就可以开始写代码了，这里以添加一个 Foo 页面展示从远端获得的数据为例

1. 给页面添加一个 Tab

Tab 属于与页面逻辑无关，但又处处要使用的元素，所以我们将其独立成为一个组件

src/components/Tab.vue

<template>
  <div id="tab">
    <div class="item" @click="router('/')">
      <span>home</span>
    </div>
    <div class="item" @click="router('/about')">
      <span>about</span>
    </div>
    <div class="item" @click="router('/foo')">
      <span>foo</span>
    </div>
  </div>
</template>
<script>
export default {
  name: 'Tab',
  methods: {
    router (url){
      this.$router.push(url)
    }
  }
}
</script>
<style scoped>
#tab {
  display: flex;
  justify-content: space-around;
  align-items: center;
  bottom: 0px;
  position: fixed;
  height: 65px;
  left: 0px;
  width: 100%;
  background-color: aquamarine;
}
.item {
  padding-top: 5px;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  height: 50px;
}
</style>

在这里我们创建了一个底部导航栏，有三个 Tab ，并且对应跳转到不同的页面

2. 创建 Foo.vue 相关逻辑并与后端交互

因为我们需要从远端API获取数据并进行展示，就涉及网络请求。在vue中，官方推荐使用 axios 发起请求。axios 是一个基于 promise 的异步网络请求库，相关用法可参考文档或网上教程

安装 axios

yarn add axios

接着在 src/main.js 中加入以下语句启用 axios

import Axios from 'axios'
// 把axios添加到原型链
Vue.prototype.$axios = Axios

现在就可以在vue实例中用 this.$router 来访问路由了

接着来创建 Foo.vue

src/views/Foo.vue

<template>
  <div id="foo">
    <p>{{ result }}</p>
    <button @click="bar()">bar</button>
  </div>
</template>
<script>
export default {
  name: 'Foo',
  data(){
    return {
      result : 'naive'
    }
  },
  methods: {
    bar(){
      /* eslint-disable */
      this.result = 'loading...'
      this.$axios.post('http://httpbin.org/post')
        .then(res => {this.result = res})
        .catch(res => {console.error(res)})
    }
  }
}
</script>
<style>
</style>

具体实现代码里面很清楚了 这个文件的作用就是请求 http://httpbin.org/get 并把结果显示在界面上

注意前后端分离的项目会有跨域(CORS)问题，这个问题比较复杂，巨坑，网上也有较多解决的文章咕咕咕

0x5 技巧及坑们

这里介绍一些我写vue项目遇到的坑和使用的技巧

data methods computed props 的区别

TODO

vue中存储数据有几种方式——data、

0x6 结语

到此，一个简单的vue项目就完成了，对于如何组织项目，前后端如何交互应该已经有了初步了解。本文也会持续更新，欢迎关注我的blog

本文的实例请访问github

]]> 南航校园网OpenWRT配置IPv6 NAT6 https://blog.creedowl.com/posts/ipv6_and_nat6_in_nuaa/ Thu, 04 Apr 2019 23:29:39 +0800 https://blog.creedowl.com/posts/ipv6_and_nat6_in_nuaa/ 当前IPv6越来越流行，不但解决了IPv4地址不够用的问题，还能给接入的设备提供公网访问的支持。但由于校园网的特殊性，虽然很早就有了IPv6

当前IPv6越来越流行，不但解决了IPv4地址不够用的问题，还能给接入的设备提供公网访问的支持。但由于校园网的特殊性，虽然很早就有了IPv6支持，大部分学校在IPv6地址分配上却有剧毒，无法向下游设备分配独立的IPv6地址（正常家庭网络环境中路由器及下游设备都能自动分配独立的公网IPv6地址），以南航为例，OpenWRT上虽然获取到了2001开头，/64结尾的公网IPv6地址，但下游设备却无IPv6访问权限。本文介绍南航校园网环境下如何在OpenWRT下获取IPv6并配置NAT6使下游设备拥有IPv6访问权限。

0：软硬件需求

硬件：支持OpenWRT固件的路由器或软路由（推荐使用软路由，性能更好，支持启用更多服务，且不需要考虑太多兼容性问题，x86版本OpenWRT一把梭）

软件：较新版本的OpenWRT或其衍生版本（lede，pandorabox等，但原版OpenWRT最佳）

OpenWRT内核需高于3.7， linux kernel在3.7版本开始支持NAT6

内核版本不够高且无法升级可以尝试早年由北邮大佬开发的NAT66项目，但不推荐

所需软件包：

ip6tables kmod-ipt-nat6 kmod-ip6tables kmod-ip6tables-extra luci-proto-ipv6 iputils-traceroute6

较新版本已经自带IPv6支持，老版本需要自己安装相关软件包，但兼容性较差，或者内核版本不足，建议找较新版本或者自行编译。

1：OpenWRT配置获取IPv6

IPv6_setting_1

1. 修改IPv6 ULA前缀为fd开头（默认为dd开头）

2. 修改wan6口配置（如下图所示）

IPv6_setting_2

3. 修改lan口DHCP服务器配置（如下图所示）

IPv6_setting_3

IPv6_setting_4

此时稍等片刻，在概况中应该就能看到获取到的IPv6地址及下游设备DHCPv6分配内网IPv6地址

IPv6_setting_5

IPv6_setting_6

现在你的路由器已经可以使用IPv6了，但下游设备并不行，就需要配置NAT6。

2：配置NAT6

虽然NAT6并不符合IPv6的设计哲学，但却能解决一些问题，如安全隔离，或者像我们这样通过单一地址转发给多个设备使用。

1. 修改防火墙

IPv6_setting_7

加入以下自定义规则

WAN6=pppoe-wan
LAN=br-lan
ip6tables -t nat -A POSTROUTING -o $WAN6 -j MASQUERADE
ip6tables -A FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
ip6tables -A FORWARD -i $LAN -j ACCEPT

注意这里WAN6和LAN要改为外网IPv6和内网网卡名字，在终端使用ifconfig查看

IPv6_setting_8

2. 配置网关

在终端执行 ip -6 r 查看默认网关（default开头），如果是类似

default from 2001:xxxx:xxxx:xxxx::/64 via fe80::ded2:fcff:fe98:64f7 dev pppoe-wan proto static metric 512 pref medium

这样蛋疼的网关，需要去掉from 2001:xxxx:xxxx:xxxx::/64 这段再添加默认网关，例如

ip -6 route add default via fe80::ded2:fcff:fe98:64f7 dev pppoe-wan proto static metric 512

可以建立一个/etc/hotplug.d/iface/99-ipv6实现自动配置

#!/bin/sh
[ "$ACTION" = ifup ] || exit 0
iface=wan6
[ -z "$iface" -o "$INTERFACE" = "$iface" ] || exit 0
ip -6 route add `ip -6 route show default|sed -e 's/from [^ ]* //'`
logger -t IPv6 "Add IPv6 default route."

最后别忘了修改权限

chmod +x /etc/hotplug.d/iface/99-ipv6

重启路由器就可以愉快的玩耍了。

本来还想折腾IPv6端口转发，但一直无法配置成功。后来突然发现南航校园网下没有对IPv4做严格隔离（除了80端口基本上都能直接访问），就直接做IPv4端口转发配合DDNS，连接校园WIFI（nuaa.portal，付费版本）就可以直接使用，速度还挺快。。。就真香了。。不过配置IPv6端口转发还是有意义，比如可以从非校园网访问，校园网访问IPv6无需认证（不要充钱了），相关教程有空再补上（咕咕咕）有需求可以参考ipv6 NAT后配置端口转发

参考资料

清华OpenWRT 路由器作为 IPv6 网关的配置

]]> PostgreSQL 简介与常用命令 https://blog.creedowl.com/posts/postgres-handbook/ Sun, 03 Feb 2019 18:32:39 +0800 https://blog.creedowl.com/posts/postgres-handbook/ PostgreSQL 简介与常用命令 PostgreSQL，简称postgres，是继mysql被收购之后极为热门的开源关系型数据库，这篇文章简单记录一些使用过程 PostgreSQL 简介与常用命令

PostgreSQL，简称postgres，是继mysql被收购之后极为热门的开源关系型数据库，这篇文章简单记录一些使用过程中的基本用法。

安装

为了保证宿主机环境的纯净，这里使用docker来安装postgres

docker run --name postgres -p 5432:5432 -e POSTGRES_PASSWORD=password -d postgres

常用环境变量

POSTGRES_USER: 数据库用户，缺省postgres

POSTGRES_PASSWORD: 数据库密码 ps. 若从localhost连接则默认trust，不需要填写

POSTGRES_DB: 数据库名，缺省postgres

更多docker相关内容参考postgres官方docker镜像页面

常用命令

连接数据库

psql -U user -d database -h host -p port

导入数据

psql database < db.sql

控制台命令

\h：查看SQL命令的解释，比如\h select。

?：查看psql命令列表。

\l：列出所有数据库。

\c [database_name]：连接其他数据库。

\d：列出当前数据库的所有表格。

\d [table_name]：列出某一张表格的结构。

\du：列出所有用户。

\e：打开文本编辑器。

\conninfo：列出当前数据库和连接的信息。

数据库操作

采用基本sql语法

# 建表
CREATE TABLE IF NOT EXISTS user (
	id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

# 插入
INSERT INTO user (name) VALUES ('username');

# 选择
SELECT * FROM user;

# 更新
UPDATE user SET name = 'qwer' WHERE id = 1;

# 删除
DELETE FROM user WHERE id = 1;

# 添加栏位
ALTER TABLE user ADD gender VARCHAR(2);

# 更新表结构
ALTER TABLE user ALTER COLUMN gender SET NOT NULL;

# 字段更名
ALTER TABLE user RENAME COLUMN name TO username;

# 删除字段
ALTER TABLE user DROP COLUMN gender;

# 表名更改
ALTER TABLE user RENAME TO users;

# 删除表格
DROP TABLE users;

相关链接

PostgreSQL新手入门

]]> var和let声明变量的区别 https://blog.creedowl.com/posts/js-differences-between-var-and-let/ Sat, 26 Jan 2019 21:59:14 +0800 https://blog.creedowl.com/posts/js-differences-between-var-and-let/ var和let声明变量的区别 今天因为全局变量重复声明的问题被let坑了好久，就研究了一下var和let的区别 var var是最早的变量标识符（但在 var和let声明变量的区别

今天因为全局变量重复声明的问题被let坑了好久，就研究了一下var和let的区别

var

var是最早的变量标识符（但在js中声明变量也不一定要标识符。。），兼容性也是最好的，但也存在一些问题，如

  1. 变量提升，即函数和变量的声明都将被提升到函数的最顶部。但初始化并不会提升
{
    // 变量a未声明
    console.log(a) // error: Uncaught ReferenceError: a is not defined
}

{
    // 变量声明提升，但未初始化
    console.log(a) // undefined
    var a = 2 // 初始化a
    console.log(a) // 2
}
  1. 可重复声明
var a = 2
var a = '3'
  1. 没有局部变量，变量作用域都是全局容易导致

let

为了解决var的一些奇奇怪怪的问题，es6新增了let命令用于声明变量。与var相比，let更像其他语言（如c艹）

  1. 不存在变量提升，所以类似上面的写法会抛出未定义的错误
{
    console.log(a) // error: Uncaught ReferenceError: a is not defined
    let a = 2 // 初始化a
    console.log(a) // 2
}
  1. 不可重复声明
let a = 1
let a = 2 // SyntaxError: Identifier 'a' has already been declared
  1. 有块级作用域等特性，所以如循环变量等局部变量等不会影响外部的变量
]]> decorator 装饰器 https://blog.creedowl.com/posts/python-decorator/ Sat, 03 Nov 2018 16:24:59 +0800 https://blog.creedowl.com/posts/python-decorator/ decorator 装饰器 普通装饰器 有个计算a+b的函数 def add(a, b): return a+b 现在想要在函数执行前后进行操作，可以用装饰器 from functools import wraps def log(func): @wraps(func) # 避免原函数的__name__等属 decorator 装饰器

普通装饰器

有个计算a+b的函数

def add(a, b):
    return a+b

现在想要在函数执行前后进行操作，可以用装饰器

from functools import wraps

def log(func):
    @wraps(func) # 避免原函数的__name__等属性发生变化
    def wrapper(*args, **kwargs)
        print('before func')
        func(*args, **kwargs) # 执行原函数，若不调用则不执行原函数
        print('after func')
    return wrapper
    
@log # @:装饰器语法糖
def add(a, b):
    return a+b
    
'''
add(1, 2)
output: 
before func
3
after func
'''

带参数的装饰器

要实现带参数的装饰器，只需要再用一个函数包装普通装饰器就行

from functools import wraps

def log(text):
    def decorator(func):
        @wraps(func) # 避免原函数的__name__等属性发生变化
        def wrapper(*args, **kwargs)
            print(text)
            func(*args, **kwargs) # 执行原函数，若不调用则不执行原函数
            print('after func')
        return wrapper
    return decorator
    
@log('log') # @:装饰器语法糖
def add(a, b):
    return a+b
    
'''
add(1, 2)
output: 
log
3
after func
'''
]]>