C++回顾

C++回顾

1.可以直接对指针用下标操作，array[2]等价于*(array + 2)

2.对STL容器的迭代器进行封装！例如begin函数，先要判断容器是否为空。

1
2
3
4
template <typename T>
inline T* begin(const vector<T> &vec) {
    return vec.empty() ? 0 : &vec[0];
}

3.遍历数组、vector、list都可以通过指针来实现，但是在list中，因为元素在内存区域中不是按照顺序摆放的，所以不能对指针进行算术运算。但即使这样，我们依然能够在指针上面添加一个抽象层来用这一层操控这些容器。一种最为简单的抽象方式就是将指针当作一个泛型。list的迭代器也不能进行加减！必须传入首尾迭代器！

4.有一种叫做function object的东西，可以代替函数指针，即它帮我们定义了一些简单的运算，例如：less<int>()就可以表示a < b的bool函数。有unary的function object，可以对binary function object的结果进行操作。

5.泛型函数设计的流程一般是先写一个局限比较多的函数，然后考虑哪些参数可以让用户来定制，接着考虑如何应用到不同的类型上，最后改template。

6.Iterator Inserter：类似copy()、unique_copy()等泛型算法会让你提供一个迭代器参数作为复制后的元素放置的位置，如果只是提供一个迭代器，会将这些放置操作变为赋值操作。如果用insertion adapter，就可以将赋值变成插入操作：

1
unique_copy(vec.begin(),vec.end(),back_inserter(result));

Iterator Inserter用于不知道一开始为容器初始化为多大容量的情况。

7.iostream iterator：

1
2
3
4
5
istream_iterator<string> is(cin);
istream_iterator<string> eof;
copy(is,eof,back_inserter(text));
ostream_iterator<string> os(cout," ");
copy(text.begin(),text.end(),os);

将标准输入的字符串存到一个vector中，并用空格隔开输出到标准输出中。不进行初始化就是默认为EOF。

厉害之处在于可以把cin、cout替换为ifstream、ofstream。

8.创建一个class，将class的定义放在同名的.h文件中，如果在class内部定义成员函数，则这些成员函数默认是inline的。如果想在外部定义成员函数，就在同名的.cpp文件中定义。

1
2
3
4
A & A::copy(const A &rhs) {
    ...
    return *this;
}

这里作用域关键字加在函数名前面。

9.成员初始化列表：

1
2
3
4
5
Triangular::Triangular(int len,int bp) : _name("Triangular") {
    _length = len > 0 ? len : 1;
    _beg_pos = bp > 0 ? bp : 1;
    _next = _beg_pos - 1;
}

10.copy constructor：有时候一个类中的成员是动态分配的内存，如果直接采用默认的成员对应赋值的方法，就容易出现多个指针指向共同一片内存区域的问题。可以利用成员初始化列表的方式来定义copy constructor：

1
Matrix::Matrix(const Matrix &rhs) : ...

这里参数必须要是一个常引用。

如果定义了copy constructor，就必须同时定义copy assignment operator。

11.如果定义了一个const reference实例，虽然这里把实例声明为了const的，但是其成员函数还是有可能改变其成员变量的值。这里应该加以限制：对于那些不会改变成员变量的成员函数，应该在形参列表后面加上const关键词，这样const reference是只能够调用有const关键词的成员函数的。同时这类函数不应该把任何可能修改成员变量的接口暴露出去。但是一个const成员函数如果要改变某一个成员变量的信息，并且改变这个成员变量的信息不会破坏抽象概念的常量性，那么可以在这个成员变量前面添加关键词mutable。这样在这个const成员函数中修改这个成员变量的值就没有任何问题了。

12.静态成员变量在其定义前面加上static关键词。对于class而言，static data member只有唯一的一份实体，必须在和类同名的.cpp文件中清楚地定义，并且要在变量名前面加上作用域：

1
vector<int> A::_elems;

在成员函数中访问静态变量就跟访问一般的成员变量一样，不需要加上作用域。

如果成员函数不会用到非静态成员变量，就可以把成员函数定义为静态的。加上static关键词即可。这样在程序代码中使用静态成员函数就只需要在前面加上作用域而不需要通过实例进行调用了。

13.重载运算符：类似成员函数的定义，只需要在运算符名字前面加上operator即可，对于const的运算符，对形参有要求：

1
bool operator == (const A&) const;

前置++和后置++有区别：

1
2
A& operator++();  //前置
A operator++(int);  //后置

前置版本会返回一个引用，后置版本的形参中有一个int，这里不需要真的传入值进去，只是c++为了区分前置和后置用的方法，会自动设置为0。

不可以引入新的运算符，运算符的操作数不可改变，优先级不可改变，不能为内置类型重载运算符。

14.两种友元声明：

1
2
friend int A::operator*();
friend class A;

友元声明可以放在类定义的任何位置，友元声明的函数或者类（相当于类里面的所有成员函数）都可以访问这个类的private部分。第一种方式需要A的定义在当前类前面，第二种方式不需要。

不过替代友元更好的方法是暴露一个public inline函数。

15.重载iostream运算符：

1
2
3
4
ostream& operator<< (ostream &os,const A &rhs) {
    os << "(" << rhs.beg_pos() << "," << rhs.length() << ";";
    return os;
}

iostream运算符第一个形参必须接受iostream引用，并返回，这里的流操作会改变iostream对象，因此不能声明为const的，而且重载运算符不能是成员函数！

16.如果我们要自己定义一个function object，只需要重载()运算符即可。

17.定义一个抽象基类：先找出所有子类共通的操作行为，然后找出哪些操作行为与类型相关，最后每个操作行为的访问层级。private是派生类都不能访问，protect是派生类可以访问。如果一个函数在抽象基类中没有实质性的作用，就把它声明为纯虚函数，类似定义为：

1
virtual int elem(int pos) const = 0;

在后面加上=0即可。

而如果一个类中有虚函数，那么它的析构函数一定要是virtual的，并且最好不要定义为纯虚函数。

任何有纯虚函数的类都不能实例一个完整的对象，派生类必须把纯虚函数完全都定义了才能用来实例化一个完整的对象。

18.在基类中声明一个函数为虚函数后，派生类都不需要加上virtual关键词了，只要基类声明就可以,基类声明虚函数后,会建一张虚函数表。 一旦一个函数被声明为虚函数,从该点之后的继承层次结构中都是虚函数,不管它在有没有再次声明是不是虚函数。

19.C++中的多态只能通过引用和指针来实现。基类的constructor不会调用派生类虚函数！

20.typeid函数可以获得一个对象在运行时的类型。

21.对于泛型类，以后凡是要用到这个类的地方都必须要加上<type>，也就是将后面的类型看作是这个类定义的一部分！

22.泛型类的成员函数的定义比较复杂：

1
2
3
4
5
template <typename elemType>
inline BinaryTree<elemType>::
BinaryTree(const BinaryTree &rhs) {
    copy(_root,rhs._root);
}

在一开始要加上模板参数，后面定义成员函数的时候要先指定其作用域，一旦指定了作用域，那么定义的后半部分就知道了这个函数是定义在类里面的成员函数，也就可以直接用类中的成员信息而不用加作用域了。

23.建议使用初始化列表来初始化泛型类：

1
2
3
4
5
6
template <typename valType>
inline BTnode<valType>::
BTnode(const valType &val) : _val(val) {
    _cnt = 1;
    _lchild = _rchild = 0;
}

这种方式对于泛型val可以避免通过直接赋值的防止来初始化，也就提高了效率。而如果我们用constructor来进行初始化，就会出现_val = val;这种赋值的情况，可能会使程序变慢。

24.如果涉及到递归结构，即类中包含类自己，就要用指针。一般用new来分配内存。需要注意的是，如果我们要改变指针本身（也就是不光可以改变指针指向的值，也可以改变指针指向哪个值），那么参数就要用指针的引用，即：BTnode *& prev，从变量名开始往左边读。

25.表达式也可以作为template参数。例如：

1
2
3
4
template <int len>
class A {
    A() : num_sequence<len>() {}
};

可以用一个表达式作为len的值：

1
A<16> temp;

26.将template参数作为一种设计策略：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template <typename elemType,typename Comp = less<elemType> >
class LessThanPred {
public:
	LessThanPred(const elemType &val) : _val(val){}
    bool operator()(const elemType &val) const {
        return Comp(val,_val);
    }
    void val(const elemType &newval) {
        _val = newval;
    }
    elemType val() const {
        return _val;
    }
private:
    elemType _val;
}

这里用了第二个泛型参数Comp，因为我们不知道传入的泛型是否自己定义了<，所以我们就需要把这个作为泛型处理！

展开全文 >>

数据库存储

数据库存储

存储器介绍

1.cache–>main memory–>flash memory–>magnetic disk–>optical disk–>magnetic tapes，从main memory往上都是volatile的。

2.对于同一层次的存储器，如果支持的协议不同，那么传输数据的速度也不同。例如SSD的NVMe协议比SATA 3协议要快。

3.从main memory往上读写数据都是以字节为单位的，可以进行随机读取。而下面层次的存储器都必须以page/block为单位，一次读取连续一段数据。

4.HDD和SSD与操作系统交互中间层的API相同，也就是说操作系统根本就不知道硬盘是HDD还是SSD。而SSD可以并行执行多个功能。但update有点麻烦，需要先erase掉一整个block的数据（这个block中会包含多个page），然后再来write。而每个block都有erase的次数上限，如果要erase的时候这个block上还有page有数据，就会先将这些page上的数据写到其他的block上。

数据库存储结构

1.数据库分为磁盘型数据库和内存型数据库。对于磁盘型数据库而言，数据最终都要保存在磁盘上，但是如果想要对数据进行操作，就必须先把这些数据放到内存上来。因此在内存上会有一个Buffer Pool对所有pages进行管理。当数据库需要获得信息时，它会向Buffer Pool请求得到ID为x的page，若没有命中则Buffer Pool会从Disk中获得并执行替换策略。

2.Buffer Pool很像操作系统中虚拟内存的实现，但是我们不能直接用mmap，因为数据库对page的掌控更加全面具体。例如如果有多个线程同时对一个page进行读写，如果是数据库来管理这些page，就可以通过添加限制位的方式来解决冲突，而mmap则难以解决这个问题。

文件组织

1.数据库以文件的形式存储在磁盘上。文件内部被逻辑上划分为一个个page。这个文件只有数据库本身可以解析。

2.一个page就是一个固定长度的数据块。这个数据块里面可能有元数据、tuple等等信息，大多数数据库系统在一个page中只会存储一种类型的信息，而有些数据库系统例如Oracle要求一个page要是self-contained的，也就是说我们能够根据这个page中包含的某些信息来恢复这个page的内容。

3.每个page都有一个独特的标识符。DBMS用indirection层来将page id映射到物理区域上。

4.有很多不同种类的page，例如Hardware Page一般都是4kb，还有OS Page和Database Page。而Database Page一般比4kb大，这是为了提高命中率和减少对磁盘的读写。但是这也会产生一些问题：因为4kb也就是Hardware Page一般是最大的系统能够保证不出现错误的读写数据块大小，也就是说可以认为以4kb为大小的读写操作是原子性的，如果我们的Database Page大小超过了4kb，就要用一些其他的措施来保证读写中途不会出现问题。

数据库文件的组织

堆存储

如果用堆来组织存储着records的pages，那么这些pages就是无序的。可以用链表和表目录来实现。

链表

数据库文件维护一个header page在开头来存储两个指针：

1.指向free page list。

2.指向data page list。

那么对于每一个page都需要维护前后两个指针（双向链表）以及所包含的data。这种方式不是经常用到。

表目录

我们可以维护一个header page来保存一个数组，数组的每个元素记录它对应的page上还有多少空间和这个page的位置。这样一旦我们要插入一个record的时候就可以遍历这个数组。为了提高效率，一个数组可以表示连续一大段的page上还有多少空间。

顺序存储

如果对relation指定一个special key，那么就会按照这个key的大小顺序来存储所有的record。删除就直接删，如果要在某个位置插入，但是这个位置的空间不够，就在这个位置存一个指针指向实际存储的区域（也就是新开一个大的区域存储）。这样一段时间后这些records在物理上是不连续的，所以要定期重排。

聚合存储

可以将多个relation的tuple连接到一起，如果他们有公共属性，并且这个公共属性在连接后的tuple中只会出现一次。这样做的好处是如果有多次对多个relation的查询，效率就会高很多，相当于pre-join了。但是每次查询得到的信息会多一些，并且时间会长。可以在DDL的时候指定是否进行聚合存储。

数据库文件中page内部的组织

1.每个page中都会有一个header存储元数据，比如page size，checksum，DBMS Version，Transaction Visibility和Compression Information。

2.page中存储tuple，必须保证这个tuple的大小不超过page的大小，每个tuple都必须在单独一个page中，不能这个tuple的一部分在其中一个page，另一部分在另外一个page中，因此为tuple分配内存需要格外注意，可能会产生内存碎片。

3.用slotted-page structure来存储tuples。在每个header处存slot的数量、未使用空间的末尾位置。Header后面是slot数组，每个slot存它对应的tuple的位置和大小。当要插入一个tuple时，slot从前往后加入，tuple从后往前，当两者相遇时，这个page就满了。而删除操作会产生内存碎片，可以通过定期平移tuples的方式来重排。

4.每个tuple都有一个独特的record identifier，通过page_id + offset/slot来得到。

Tuple组织

1.一个tuple本质上是一堆字节序列，由DBMS来解析。

2.每个tuple都有一个header，用来存visibility info(concurrency control)和表示哪个属性是NULL的Bit Map。大多数情况下属性的值按照定义的schema来顺序存储。

数据表示

1.integer/bigint/smallint/tinyint都用C/C++的表示。

2.float/real用IEEE-754表示，numeric/decimal在数据库中有单独表示方法。对于不定长浮点数，精度上有误差，但是运算速度快，因为CPU有对应的单独一条指令能够执行运算。而定长浮点数运算慢但是可以保证没有误差。

3.varchar/varbinary/text/blob都是用一个header存长度后面跟着数据。

4.如果数据过大，数据库会把这个数据作为Blob类型，在对应属性位置上放一个指针指向External File。这个file是不能被数据库操作的，不能提供持久化保护和事物保护。如果通过操作系统对这些文件进行更改，数据库可能会无法正确处理这些文件。当然如果数据不是特别大，数据库是可以把它放到overflow page上。

SYSTEM CATALOGS

用来存储数据库的元数据，大部分数据库的存储方式是使用另外的数据库来存储。不能用数据库存储有关自己的元数据。通过INFORMATION_SCHEMA这个API来从数据库中得到，但是注意的是这里并不是数据库本身的查询语句！

事务类型

1.分为OLAP和OLTP以及他们的混合HTAP。

2.OLTP一般是和外界交互，即要插入一个tuple、删除/修改一个数据、查询一组数据等等，更多偏向于write，只会涉及到一小部分tuples。

3.OLAP则会涉及到对很多数据进行计算、分析，会涉及到大量的数据。

4.现在的应用一般是用两个数据库，前端数据库负责OLTP，后端数据库负责OLAP。

数据存储模型

1.分为行存储和列存储，前者即把每一行的信息存在一起，后者为把每一个属性值的信息存在一起。

2.如果我们仅仅是想要根据几个属性值来筛选若干个属性值出来，那么用列存储就很容易做到，只需要遍历涉及到的存储属性值的文件即可。而行存储则要读取很多完整的tuple。

3.那么在列存储方式中，我们如何知道一个属性和另外一个属性是不是在同一个tuple中呢？因为每个属性的大小是固定的，我们可以通过计算offset的方式来得到。

4.可以在DDL中指定数据库是行存储还是列存储。

Buffer Pool

1.内存区域被组织为一个定长page的数组，每一个数组条目都被叫作frame。一个叫做page table的数据结构可以跟踪正在内存中的pages，还对每个pages有额外的元数据：Dirty Flag（如果内存上的这个page被修改了就要写回到硬盘上去）和Pin/Reference Counter（用来处理transaction），即如果正在读一个page的数据，则Pin Counter++，其他线程对这个page不能进行写操作。

2.可以设多个Buffer Pool来减少latches。通过Object Id来指定存到哪一个Buffer Pool中或者直接将page id进行hash然后对内存池的个数n进行取模来决定。

3.数据库管理pages优于OS的一点是可以根据一段连续的数据进行预取存或者根据Index进行预取。而在替换策略方面，OS只能根据过去的情况作出预测，而数据库可以根据指令来决定哪些page需要缓存，哪些不需要以此来更换不同策略。例如sort一个relation，不需要将中间数据缓存。

4.如果有两个线程在读取同一张表，其中一个线程先读了一部分，那么可以利用cursor，也就是给每个查询操作一个cursor，当第一个查询操作进行到一半，第二个查询操作刚开始时，可以将第二个查询操作的cursor赋值为第一个查询操作的cursor，这样后面的每个数据就只用读取一次，接着第二个查询操作再来读取前面没有读取到的部分。

5.如果我们从操作系统中读取pages，中间会写入到OS PAGE CACHE中，而数据库是会用direct I/O，即虽然进行了文件读写，但不经过OS PAGE CACHE这一步，除了PostgreSQL。

展开全文 >>

SQL基础

SQL基础

一、SQL的组成

SQL包括以下几个部分：

1.DDL，提供定义relation schemas，删除relations和修改relation schemas的命令。

2.DML，提供在database中增删查改tuples的命令。

3.Integrity，DDL命令会对database加上一些确保Integrity的约束，例如给某些attribute赋予某些属性，主键或外键等等。

4.View definition，相当于可以把一些命令给打包。

5.Transaction control，用于处理一些特殊情况，例如并发读写数据库、阻止某些操作破坏操作的原子性。

6.Authorization，相当于Linux里面的用户组和权限，可以给权限到某些用户组/用户上。读/写/增/删都有对应的权限。

二、SQL数据定义

基本数据类型

1.**char(n)**：一个定长字符串类型，长度为n，是character的缩写。

2.**varchar(n)**：可变长字符串类型，最大长度为n。

3.int：整数类型。

4.smallint：小整数类型。

5.**numeric(p,d)**：固定浮点类型，整个数字的位数为p,小数点后的位数为d。

6.**float(n)**：精度至少为n位的浮点数类型。

对于字符串建议都用varchar，如果不同长度的char进行比较，会对较短的char填充空格。

基本规格定义

1.用create table命令来定义一个relation。

1
2
3
4
5
create table department
		(dept_name varchar(20),
        building varchar(15),
        budget numeric(12,2),
        primary key(dept_name));

在SQL中每个命令的结尾都必须带有分号。

2.主键可以是一个属性的集合，被要求必须是notnull和unique的。

3.外键关联两个relation，声明的形式为：

1
foreign key(A1,A2,...,An) references s

对于定义在relation A中的外键，如果他的外键目标是relation B,那么称A是referring，B为referred。其中A1，A2,…,An的值都必须同时要在A中和B中出现（属性名字可以不相同），并且在B中必须是B的主键。可以通过外键进行Integrity限制。例如要往A中插入的tuple的A1在B中找不到值对应时，这个操作就是不合法的。

基本SQL查询

1
2
3
select (all/distinct) attributes
from tablenames
where conditions;

从表中查询得到的数据也组成一张表，默认情况下是不会去重的，也就是括号里面all的情况，如果要去重就要加上distinct。

2.可以对attributes进行算术运算等。where就是筛选条件。

3.如果指定了多个table，执行顺序是：先将from的表格组成笛卡尔积，然后应用where里面的条件判断，最后选出select中的属性值。

更多SQL基本操作

1.关于rename：

1
2
3
select distinct T.name
from instructor as T,instructor as S
where T.salary > S.salary and S.dept_name = 'Biology'

用as重命名，并且记得加上作用域。

2.关于字符串：在各种SQL的实现版本中，字符串都是用单引号括起来的。引号内可以进行模式匹配：

**%**可以匹配任意字符串；

**_**可以匹配任意单个字符；

**\**放在前面可以表示转义字符。

3.select后加*****可表示选取所有的属性。

4.关于显示数据的顺序：SQL的实现是基于bags的，也就是不考虑顺序和重复问题，如果要按某个属性的顺序输出，则要在查询语句的后面加上：

1
order by attributename (asc/desc);

5.关于集合操作：我们可以把两个query的结果进行集合之间的交、并、补等等，例如：

1
2
3
(select...)
union/intersect/except (all)
(select...);

这些集合操作默认是去重的，原因在于操作的名称为集合操作。

Null

1.这里null应该理解为暂时不知道的数据而不是空值，虽然在很多数据库实现上是被显示为空值。

2.任何和null进行算术运算的结果都是null。

3.和null进行比较的结果都是null。

4.and/or/not等逻辑运算的短路定律依然成立。如果在有null的这些逻辑表达式中不能运用短路定律，则结果为null。

5.因为有null这种结果存在，where成立当且仅当结果为true。

聚合函数

1.有以下几种聚合函数：

avg，min，max，sum，count。

2.使用方法如下：

1
2
3
select avg(salary) as avg_salary
from instructor
where dept_name = 'Comp.sci';
1
2
select count(distinct ID)
...

有几点值的注意的是，这里聚合函数计算的结果最好是重命名，而且最后的输出结果只会有一个tuple，即聚合函数计算的结果。

如果想用count函数来计算有多少个tuple，用count(*)

3.如果在select中使用了聚合函数，那么输出结果只会有一个tuple。如果要输出另外的属性，就必须要进行分组。当然也可以利用分组操作实现对每个组内单独计算聚合函数值到一个tuple中。

1
2
...
group by attributenames

这样凡是在attributenames中的attributes相同的tuples都会被分到同一组中。每个组最后会作为一个tuple输出。而在select中选择的属性要么是聚合函数计算结果，要么是出现在group中的属性，因为一个group只会输出一个tuple，如果一个属性不在group by中，那么就不知道要输出这个组中的哪一个tuple中的属性值了。

4.可以在group by语句后面加上having语句，这里和where语句不同的是，having语句用于对group进行筛选，而where语句是对tuple进行筛选。

完整SQL语句执行顺序

1.from语句首先执行得到一个relation。

2.如果where语句存在，则应用where来筛选得到的每一个tuple。

3.where筛选出来的tuple被group by语句进行分组，如果group by不存在，则所有筛选出来的语句组成一整个group。

4.执行having语句。

5.执行select语句。

嵌套查询

可以在增加子语句在where中，形式如下：

1
2
...
where ... action(...)

其中括号内的是另一条query语句，这里action可以有以下几种：

1.in/not in：是否存在。

2.比较符号+all/some：与查询结果中的一个或所有tuples进行比较，这里比较符号可以为<,<=,>,>=,=,<>.

3.exist：结果的count是否>0。

4.unique：结果中是否有重复的tuple。

增删改

1.删除操作：

1
2
delete from r
while P;

这里一条delete命令只能删除一个relation。

2.插入操作：

有两种形式：

1
2
3
insert into student
		select *
		from student;

或者

1
2
insert into course
		values("1","2")

3.修改操作：

1
2
3
4
5
update instructor
set salary = case
				when salary <= 100000 then salary * 1.05
				else salary * 1.03
		 	 end

CTE

提供了一种在大规模查询中写任意声明的方法。必须命名，可以指定返回参数的名字：

1
2
3
4
WITH cteName (col1,col2) AS (
	SELECT 1,2
)
SELECT col1 + col2 FROM cteName
1
2
3
4
5
WITH cteSource (maxId) As (
	SELECT MAX(sid) FROM enrolled
)
SELECT name FROM student,cteSource
WHERE student.sid = cteSource.maxId

展开全文 >>

如何创建一个新的博客

搭建过程

1.下载node.js

2.npm更换淘宝的源:npm install -g cnpm --registry=https://registry.npm.taobao.org

3.下载hexo:cnpm install -g hexo-cli

4.创建一个blogs文件夹，进入后hexo init

5.启动博客:hexo s

6.创建一篇文章:hexo n "title"，文章在/source/_posts中

7.生成hexo博客:hexo g,然后可以再次启动

8.创建一个github仓库，仓库名字一定为:id.github.io,id是github的名字

9.部署:cnpm install --save hexo-deployer-git

10.更改_config.yml，更改：

1
2
3
4
5
6
7
# Deployment
## Docs: https://hexo.io/docs/one-command-deployment
deploy:
  type: git
  repo: https://github.com/zbtrs/zbtrs.github.io.git
  branch: master

11.hexo d:往远端部署博客

更换博客主题

1.将theme clone到/themes文件夹中

2.改_config.yml，theme后面改主题名

展开全文 >>

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><br>只做了一点微小的工作<br>谢谢大家