Markdown 基本语法

一级标题

二级标题

三级标题

四级标题

五级标题
六级标题

粗体 斜体 粗斜体 正常 删除线

单行块引用

多个段落的块引用

多个段落的块引用

嵌套块引用

嵌套块引用

带有其它元素的块引用

带有其它元素的块引用

带有其它元素的块引用

带有其它元素的块引用

  1. 有序列表
  2. 有序列表
  3. 有序列表
    1. 有序列表
    2. 有序列表
  4. 有序列表
  • 无序列表
  • 无序列表
  • 无序列表
    • 无序列表
    • 无序列表
  • 无序列表

单行代码块 with Both Chines and English Text

分割线


链接

链接(带有标题)

https://www.lynx3.top/

email@example.com

带格式化的链接

图片

内容类 HTML 嵌入

Markdown 扩展语法

表格

左对齐居中对齐右对齐
/叫做斜线
|叫做管道符

任务列表

折叠块

点击展开查看隐藏的惊喜

这是一个原生的 HTML 折叠块,常用于隐藏长代码或剧透内容。 结合 Markdown 语法,内部依然可以正常渲染:

  • 列表项 1
  • 列表项 2

下划线与名词解释

这是 带有下划线的文本,这是 插入的文本。

Hexo
快速、简洁且高效的博客框架
Butterfly
一个基于 Hexo 的高颜值且功能强大的主题

代码框

以下短例取自 Highlight.js 11.12.0 的语言识别测试,用于对照语法着色。Copyright © 2006 Ivan Sagalaev,见完整许可(BSD 3-Clause)。

C++

预处理指令、十六进制数与流运算符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>

int main(int argc, char *argv[]) {

/* An annoying "Hello World" example */
for (auto i = 0; i < 0xFFFF; i++)
cout << "Hello, World!" << endl;

char c = '\n';
unordered_map <string, vector<string> > m;
m["key"] = "\\\\"; // this is an error

return -2e3 + 12l;
}

Java

文档注释、类声明与继承。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
* @author John Smith <john.smith@example.com>
*/
package l2f.gameserver.model;

public abstract strictfp class L2Char extends L2Object {
public static final Short ERROR = 0x0001;

public void moveTo(int x, int y, int z) {
_ai = null;
log("Should not be called");
if (1 > 5) { // wtf!?
return;
}
}
}

Kotlin

注解、可空类型与字符串模板。

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
import kotlinx.serialization.Serializable
import kotlin.random.Random

interface Building

@Serializable
class House(
private val rooms: Int? = 3,
val name: String = "Palace"
) : Building {
var residents: Int = 4
get() {
println("Current residents: $field")
return field
}

fun burn(evacuation: (people: Int) -> Boolean) {
rooms ?: return
if (evacuation((0..residents).random()))
residents = 0
}
}

fun main() {
val house = House(name = "Skyscraper 1")
house.burn {
Random.nextBoolean()
}
}

Python

装饰器、文档字符串与默认参数。

1
2
3
4
5
6
7
8
9
10
11
12
@requires_authorization(roles=["ADMIN"])
def somefunc(param1='', param2=0):
r'''A docstring'''
if param1 > param2: # interesting
print 'Gre\'ater'
return (param2 - param1 + 1 + 0b10l) or None

class SomeClass:
pass

>>> message = '''interpreter
... prompt'''

Bash

变量展开、条件判断与引号。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/bin/bash

###### CONFIG
ACCEPTED_HOSTS="/root/.hag_accepted.conf"
BE_VERBOSE=false

if [ "$UID" -ne 0 ]
then
echo "Superuser rights required"
exit 2
fi

genApacheConf(){
echo -e "# Host ${HOME_DIR}$1/$2 :"
}

echo '"quoted"' | tr -d \" > text.txt

JavaScript

正则表达式、异常处理与对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function $initHighlight(block, cls) {
try {
if (cls.search(/\bno\-highlight\b/) != -1)
return process(block, true, 0x0F) +
` class="${cls}"`;
} catch (e) {
/* handle exception */
}
for (var i = 0 / 2; i < classes.length; i++) {
if (checkCondition(classes[i]) === undefined)
console.log('undefined');
}

return (
<div>
<web-component>{block}</web-component>
</div>
)
}

export $initHighlight;

Stylus

变量、混入与缩进。

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
@import "nib"

// variables
$green = #008000
$green_dark = darken($green, 10)

// mixin/function
container()
max-width 980px

// mixin/function with parameters
buttonBG($color = green)
if $color == green
background-color #008000
else if $color == red
background-color #B22222

button
buttonBG(red)

.blue-button
buttonBG(blue)

#content, .content
font Tahoma, Chunkfive, sans-serif
background url('hatch.png')
color #F0F0F0 !important
width 100%

HTML

标签内嵌的 CSS 和 JavaScript;正文加入中文以对照字形。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!DOCTYPE html>
<title>Title</title>

<style>
body {
width: 500px;
}
</style>

<script type="application/javascript">
function $init() {
return true;
}
</script>

<body>
<p checked class="title" id="title">标题 Title</p>
<!-- here goes the rest of the page -->
</body>

XML

这个独立样例用于区分命名空间、属性、实体与 CDATA。

1
2
3
4
5
<?xml version="1.0" encoding="UTF-8"?>
<log:entry xmlns:log="urn:dragonfly:observations" id="pond-01">
<log:site>池塘 &amp; 溪流</log:site>
<log:note><![CDATA[水温 < 20 °C]]></log:note>
</log:entry>

等宽字体与横向滚动

比较数字和字母、运算符与中英文标点。第二行以一个制表符缩进,第三行以四个空格缩进;最后一行用于测试窄屏横向滚动。

1
2
3
4
0O 1lI | != <= >= => -> ::  中文,。 English,.
Tab → 红蜻 × 13
四个空格 → 碧伟蜓 × 10
01---------|02---------|03---------|04---------|05---------|06---------|07---------|08---------|09---------|10---------|11---------|12---------|13---------|14---------|15---------|16---------| END

长代码块

下面是 LLVM libc++ 18.1.8 的 std::sort 测试(许可证)。

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
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// This test appears to hang with picolibc & qemu.
// UNSUPPORTED: LIBCXX-PICOLIBC-FIXME

// <algorithm>

// template<RandomAccessIterator Iter>
// requires ShuffleIterator<Iter>
// && LessThanComparable<Iter::value_type>
// void
// sort(Iter first, Iter last);

#include <algorithm>
#include <iterator>
#include <numeric>
#include <random>
#include <cassert>
#include <vector>
#include <deque>
#include <utility>

#include "test_macros.h"

std::mt19937 randomness;

template <class Container, class RI>
void
test_sort_helper(RI f, RI l)
{
if (f != l)
{
Container save(l - f);
do
{
std::copy(f, l, save.begin());
std::sort(save.begin(), save.end());
assert(std::is_sorted(save.begin(), save.end()));
assert(std::is_permutation(save.begin(), save.end(), f));
} while (std::next_permutation(f, l));
}
}

template <class T>
void set_value(T& dest, int value)
{
dest = value;
}

inline void set_value(std::pair<int, int>& dest, int value)
{
dest.first = value;
dest.second = value;
}

template <class Container, class RI>
void
test_sort_driver_driver(RI f, RI l, int start, RI real_last)
{
for (RI i = l; i > f + start;)
{
set_value(*--i, start);
if (f == i)
{
test_sort_helper<Container>(f, real_last);
}
if (start > 0)
test_sort_driver_driver<Container>(f, i, start-1, real_last);
}
}

template <class Container, class RI>
void
test_sort_driver(RI f, RI l, int start)
{
test_sort_driver_driver<Container>(f, l, start, l);
}

template <class Container, int sa>
void
test_sort_()
{
Container ia(sa);
for (int i = 0; i < sa; ++i)
{
test_sort_driver<Container>(ia.begin(), ia.end(), i);
}
}

template <class T>
T increment_or_reset(T value, int max_value)
{
return value == max_value - 1 ? 0 : value + 1;
}

inline std::pair<int, int> increment_or_reset(std::pair<int, int> value,
int max_value)
{
int new_value = value.first + 1;
if (new_value == max_value)
{
new_value = 0;
}
return std::make_pair(new_value, new_value);
}

template <class Container>
void
test_larger_sorts(int N, int M)
{
using Iter = typename Container::iterator;
using ValueType = typename Container::value_type;
assert(N != 0);
assert(M != 0);
// create container of length N filled with M different objects
Container array(N);
ValueType x = ValueType();
for (int i = 0; i < N; ++i)
{
array[i] = x;
x = increment_or_reset(x, M);
}
Container original = array;
Iter iter = array.begin();
Iter original_iter = original.begin();

// test saw tooth pattern
std::sort(iter, iter+N);
assert(std::is_sorted(iter, iter+N));
assert(std::is_permutation(iter, iter+N, original_iter));
// test random pattern
std::shuffle(iter, iter+N, randomness);
std::sort(iter, iter+N);
assert(std::is_sorted(iter, iter+N));
assert(std::is_permutation(iter, iter+N, original_iter));
// test sorted pattern
std::sort(iter, iter+N);
assert(std::is_sorted(iter, iter+N));
assert(std::is_permutation(iter, iter+N, original_iter));
// test reverse sorted pattern
std::reverse(iter, iter+N);
std::sort(iter, iter+N);
assert(std::is_sorted(iter, iter+N));
assert(std::is_permutation(iter, iter+N, original_iter));
// test swap ranges 2 pattern
std::swap_ranges(iter, iter+N/2, iter+N/2);
std::sort(iter, iter+N);
assert(std::is_sorted(iter, iter+N));
assert(std::is_permutation(iter, iter+N, original_iter));
// test reverse swap ranges 2 pattern
std::reverse(iter, iter+N);
std::swap_ranges(iter, iter+N/2, iter+N/2);
std::sort(iter, iter+N);
assert(std::is_sorted(iter, iter+N));
assert(std::is_permutation(iter, iter+N, original_iter));
}

template <class Container>
void
test_larger_sorts(int N)
{
test_larger_sorts<Container>(N, 1);
test_larger_sorts<Container>(N, 2);
test_larger_sorts<Container>(N, 3);
test_larger_sorts<Container>(N, N/2-1);
test_larger_sorts<Container>(N, N/2);
test_larger_sorts<Container>(N, N/2+1);
test_larger_sorts<Container>(N, N-2);
test_larger_sorts<Container>(N, N-1);
test_larger_sorts<Container>(N, N);
}

void
test_pointer_sort()
{
static const int array_size = 10;
const int v[array_size] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const int *pv[array_size];
for (int i = 0; i < array_size; i++) {
pv[i] = &v[array_size - 1 - i];
}
std::sort(pv, pv + array_size);
assert(*pv[0] == v[0]);
assert(*pv[1] == v[1]);
assert(*pv[array_size - 1] == v[array_size - 1]);
}

// test_adversarial_quicksort generates a vector with values arranged in such a
// way that they would invoke O(N^2) behavior on any quick sort implementation
// that satisfies certain conditions. Details are available in the following
// paper:
// "A Killer Adversary for Quicksort", M. D. McIlroy, Software-Practice &
// Experience Volume 29 Issue 4 April 10, 1999 pp 341-344.
// https://dl.acm.org/doi/10.5555/311868.311871.
struct AdversaryComparator {
AdversaryComparator(int N, std::vector<int>& input) : gas(N - 1), V(input) {
V.resize(N);
// Populate all positions in the generated input to gas to indicate that
// none of the values have been fixed yet.
for (int i = 0; i < N; ++i)
V[i] = gas;
}

bool operator()(int x, int y) {
if (V[x] == gas && V[y] == gas) {
// We are comparing two inputs whose value is still to be decided.
if (x == candidate) {
V[x] = nsolid++;
} else {
V[y] = nsolid++;
}
}
if (V[x] == gas) {
candidate = x;
} else if (V[y] == gas) {
candidate = y;
}
return V[x] < V[y];
}

private:
// If an element is equal to gas, it indicates that the value of the element
// is still to be decided and may change over the course of time.
const int gas;
// This is a reference so that we can manipulate the input vector later.
std::vector<int>& V;
// Candidate for the pivot position.
int candidate = 0;
int nsolid = 0;
};

void test_adversarial_quicksort(int N) {
assert(N > 0);
std::vector<int> ascVals(N);
// Fill up with ascending values from 0 to N-1. These will act as indices
// into V.
std::iota(ascVals.begin(), ascVals.end(), 0);
std::vector<int> V;
AdversaryComparator comp(N, V);
std::sort(ascVals.begin(), ascVals.end(), comp);
std::sort(V.begin(), V.end());
assert(std::is_sorted(V.begin(), V.end()));
}

template <class Container>
void run_sort_tests()
{
// test null range
using ValueType = typename Container::value_type;
ValueType d = ValueType();
std::sort(&d, &d);

// exhaustively test all possibilities up to length 8
test_sort_<Container, 1>();
test_sort_<Container, 2>();
test_sort_<Container, 3>();
test_sort_<Container, 4>();
test_sort_<Container, 5>();
test_sort_<Container, 6>();
test_sort_<Container, 7>();
test_sort_<Container, 8>();

test_larger_sorts<Container>(256);
test_larger_sorts<Container>(257);
test_larger_sorts<Container>(499);
test_larger_sorts<Container>(500);
test_larger_sorts<Container>(997);
test_larger_sorts<Container>(1000);
test_larger_sorts<Container>(1009);
}

int main(int, char**)
{
// test various combinations of contiguous/non-contiguous containers with
// arithmetic/non-arithmetic types
run_sort_tests<std::vector<int> >();
run_sort_tests<std::deque<int> >();
run_sort_tests<std::vector<std::pair<int, int> > >();

test_pointer_sort();
test_adversarial_quicksort(1 << 20);

return 0;
}

数学

单行公式

F=G=m物g=1kg⋅9.8N/kg=9.8NF=G=m_\textsf{物}g=1kg·9.8N/kg=9.8N

数学文字混杂

让我们尝试证明一个稍微复杂一些的等式:

∑k=0n(nk)=2n\sum_{k=0}^{n} \binom{n}{k} = 2^n

我们可以使用二项式定理证明这个等式。二项式定理表述为:

(a+b)n=∑k=0n(nk)an−kbk(a + b)^n = \sum_{k=0}^{n} \binom{n}{k} a^{n-k} b^k

现在,令 a=1a = 1, b=1b = 1,然后代入:

(1+1)n=∑k=0n(nk)1n−k1k(1 + 1)^n = \sum_{k=0}^{n} \binom{n}{k} 1^{n-k} 1^k

2n=∑k=0n(nk)2^n = \sum_{k=0}^{n} \binom{n}{k}

这证明了 ∑k=0n(nk)=2n\sum_{k=0}^{n} \binom{n}{k} = 2^n。

多行公式与对齐

麦克斯韦方程组(微分形式):

∇⋅E=ρε0∇⋅B=0∇×E=−∂B∂t∇×B=μ0J+μ0ε0∂E∂t\begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \\ \nabla \cdot \mathbf{B} &= 0 \\ \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \\ \nabla \times \mathbf{B} &= \mu_0 \mathbf{J} + \mu_0 \varepsilon_0 \frac{\partial \mathbf{E}}{\partial t} \end{aligned}

分段函数

符号函数 sgn(x)\text{sgn}(x) 的定义如下:

f(x)={1,if x>00,if x=0−1,if x<0f(x) = \begin{cases} 1, & \text{if } x > 0 \\ 0, & \text{if } x = 0 \\ -1, & \text{if } x < 0 \end{cases}

矩阵

带有不同括号的矩阵测试:

(1234)[abcd]{xyzw}∣αβγδ∣\begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} \quad \begin{bmatrix} a & b \\ c & d \end{bmatrix} \quad \begin{Bmatrix} x & y \\ z & w \end{Bmatrix} \quad \begin{vmatrix} \alpha & \beta \\ \gamma & \delta \end{vmatrix}

微积分与极限

求导与积分的排版测试:

lim⁡x→∞(1+1x)x=e\lim_{x \to \infty} \left(1 + \frac{1}{x}\right)^x = e∫−∞∞e−x2dx=π\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}ddx(∫axf(t)dt)=f(x)\frac{d}{dx} \left( \int_{a}^{x} f(t) dt \right) = f(x)

化学方程式专区

基础化学式与离子

分子:HX2O\ce{H2O}, SbX2OX3\ce{Sb2O3}, AgClX2X−\ce{AgCl2-}

离子:HX+\ce{H+}, CrOX4X2−\ce{CrO4^2-}, [AgClX2]X−\ce{[AgCl2]-}

同位素:X90227X2902227ThX+\ce{^{227}_{90}Th+}, X90227X2902227ThX+\ce{^227_90Th+}

复杂结构:KCr(SOX4)X2 ⋅ 12 HX2O\ce{KCr(SO4)2 * 12H2O}

化学反应方程式

基础反应:

COX2+C→2 CO\ce{CO2 + C -> 2 CO}

带有气体与沉淀符号:

SOX4X2−+BaX2+→BaSOX4↓\ce{SO4^2- + Ba^2+ -> BaSO4 v}Zn+2 HX+→ZnX2++HX2↑\ce{Zn + 2H+ -> Zn^2+ + H2 ^}

反应条件与箭头符号

燃烧反应(箭头上方带条件):

2 HX2+OX2→点燃2 HX2O\ce{2H2 + O2 ->[\text{点燃}] 2H2O}

加热条件(使用 \Delta):

CaCOX3→ΔCaO+COX2↑\ce{CaCO3 ->[\Delta] CaO + CO2 ^}

可逆反应与平衡移动:

NX2+3 HX2⇌2 NHX3\ce{N2 + 3H2 <=> 2NH3}A⇄B(等长箭头)\ce{A <--> B} \quad \text{(等长箭头)}A⇌B(平衡正向移动)\ce{A <=>> B} \quad \text{(平衡正向移动)}

有机化学与多行反应

有机物结构简式:

CHX3−CHX2−OH或CHX3=CHX2或A−---B−−---C\ce{CH3-CH2-OH} \quad \text{或} \quad \ce{CH3\bond{=}CH2} \quad \text{或} \quad \ce{A\bond{~}B\bond{~-}C}

核反应方程式:

X92235X2922235U+X01X2021n→X56137X2562137Ba+X3697X236297Kr+2X01n\ce{^{235}_{92}U + ^{1}_{0}n -> ^{137}_{56}Ba + ^{97}_{36}Kr + 2^{1}_{0}n}

渲染器拓展语法测试

这是 被注释文本

上标示例

下标示例

脚注示例 [1]

你知道的太多了!

Butterfly 拓展语法测试 [2]

Note

simple

默认 提示块标签

default 提示块标签

primary 提示块标签

success 提示块标签

info 提示块标签

warning 提示块标签

danger 提示块标签

modern

默认 提示块标签

default 提示块标签

primary 提示块标签

success 提示块标签

info 提示块标签

warning 提示块标签

danger 提示块标签

flat

默认 提示块标签

default 提示块标签

primary 提示块标签

success 提示块标签

info 提示块标签

warning 提示块标签

danger 提示块标签

disable

默认 提示块标签

default 提示块标签

primary 提示块标签

success 提示块标签

info 提示块标签

warning 提示块标签

danger 提示块标签

Tag Hide

哪个英文字母最酷? C,因为西装裤 (C 装酷)

Mermaid [5]

流程图

时序图

甘特图

类图

状态图

饼图

用户体验旅程图

C4 图

Tabs

This is Tab 1.

Button

Butterfly Butterfly Butterfly Butterfly Butterfly Butterfly Butterfly

label

臣亮言:先帝创业未半,而中道崩殂。今天下三分,益州疲敝,此诚危急存亡之秋也!然侍衞之臣,不懈于内;忠志之士,忘身于外者,盖追先帝之殊遇,欲报之于陛下也。诚宜开张圣听,以光先帝遗德,恢弘志士之气;不宜妄自菲薄,引喻失义,以塞忠谏之路也。

宫中、府中,俱为一体;陟罚臧否,不宜异同。若有作奸、犯科,及为忠善者,宜付有司,论其刑赏,以昭陛下平明之治;不宜偏私,使内外异法也。

Timeline

2022

01-02

这是测试页面

ECharts

下面两张图共用一组虚构的池塘观察记录:在三个时段各观察十分钟,分别记录红蜻和碧伟蜓的目击次数。同一只蜻蜓可能被重复看到。

直角坐标系

横轴是观察时刻,纵轴是目击次数。点按图例可以单独查看一个物种,指向数据点可以比较同一时段的两条记录。

饼图

把三个时段相加,红蜻占 23 次目击中的 13 次。环形图展示两者的比例;点按或悬停可查看次数和百分比。

Chart.js

除了计算机编程外,我想不出还有其他让我感兴趣的工作。 我可以无中生有地创造出精美的范式和结构, 在此过程中也解决了无数的小谜团。 I can’t think of any other job other than computer programming that interests me. I can create beautiful paradigms and structures out of nothing, Countless small mysteries are also solved in the process.


  1. 脚注是指附在文章页面的最底端的,对某些东西加以说明的注文。 ↩︎

  2. 代码来自 Butterfly 安裝文檔 (三) 主題配置 -1 | Butterfly,采用 CC-BY-NC-SA 协议授权 ↩︎

  3. 画作由 TysonTan 绘制,采用 CC-BY-SA 协议授权 ↩︎

  4. 图片来自 Butterfly ReadMe,采用 CC-BY-NC-SA 协议授权 ↩︎

  5. 代码来自 Mermaid ReadMe ↩︎