如果你也在用 Hexo + Butterfly,想给博客加一个「最近访客」能力,可以按本文一步步做。做完后会有:

  • 侧栏「最近访客」卡片
  • 独立页面 /visitor/
  • 数据存在 Cloudflare(Worker + D1),免费额度对个人博客通常够用

本文按零基础可读来写:能注册 Cloudflare、会改博客配置即可。全程可用网页操作,不必装 Wrangler 命令行。文末附有完整可复制代码,不依赖作者仓库;示例里的 Database ID、Worker 域名都是假数据,请换成你自己的。

相关:hexo + butterfly 搭建记录

效果说明

  • 读者打开你的博客时,页面会静默「打卡」一次(短时间重复刷新一般不会刷很多条)
  • 首页等页面的侧栏显示大致地区、访问路径、相对时间
  • 导航可进入 /visitor/ 查看更多
  • 不展示完整 IP;默认在文章页不显示该侧栏卡(打卡仍会进行)

原理

三块积木:

  1. 博客前端 JS:告诉接口「当前打开的是哪一页」,并把列表画到侧栏
  2. Cloudflare Worker:小接口程序(打卡写入、查询列表)
  3. Cloudflare D1:SQLite 数据库,存访客记录
1
2
3
4
5
读者打开博客页面
→ visitor.js 发送 POST /visit(body 只带 path)
→ Worker 从请求读取 IP/地区/UA,写入 D1(短时去重)
→ visitor.js 再 GET /visits 拉最近几条
→ 渲染侧栏或 /visitor/ 页

body 只传 path:当前路径只有浏览器知道;IP / 地区 / UA 由 Worker 从请求读取,更准也不易伪造。

GitHub Pages / Netlify 只会部署静态博客,不会自动部署 Worker。接口要在 Cloudflare 控制台单独部署;你本地可把 visitor-api/ 当作源码备份目录。

你需要准备什么

  • 已能跑起来的 Hexo + Butterfly 博客(本地 hexo server 可打开)
  • Cloudflare 账号(邮箱注册即可,个人场景通常不必绑卡)
  • 按文末附录在博客里建好对应文件(复制粘贴即可)

注册并进入 Cloudflare

  1. 打开 https://dash.cloudflare.com ,注册 / 登录。
  2. 左侧找到 「Workers 和 Pages」(Workers & Pages)。
  3. 第一次用可能会提示开通 Workers,按提示同意即可。

创建 D1 数据库

新建库

  1. 左侧进入 Workers 和 Pages。
  2. 打开 D1(在「存储和数据库」或 Workers 相关入口下)。
  3. 点 Create database / 创建数据库。
  4. 名称填:blog-visitors(可自定,后面要一致)。
  5. 数据位置:选「位置」→ 亚太;不要勾「指定管辖权地」。
  6. 点 创建。

建表

  1. 点进库 blog-visitors → Console(查询)。
  2. 粘贴并执行:
1
2
3
4
5
6
7
8
9
10
11
12
CREATE TABLE IF NOT EXISTS visits (
id INTEGER PRIMARY KEY AUTOINCREMENT,
visited_at INTEGER NOT NULL,
path TEXT NOT NULL,
country TEXT,
region TEXT,
city TEXT,
ua_brief TEXT,
ip_hash TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_visits_time ON visits(visited_at DESC);
CREATE INDEX IF NOT EXISTS idx_visits_dedupe ON visits(ip_hash, visited_at);
  1. 再执行:
1
SELECT name FROM sqlite_master WHERE type='table';

能看到 visits 即可。

库名和 Database ID 用在哪

在库的详情页可以看到 Database ID(UUID)。

示例(假数据):

  • 库名:blog-visitors
  • Database ID:00000000-0000-4000-8000-000000000000
字段 用在什么地方
库名 网页绑定 Worker 时下拉选择;wrangler.toml 的 database_name
Database ID 写在 wrangler.toml 的 database_id,给 CLI 部署用。网页绑定一般点选库名即可,仍建议记下 ID

可选自测:

1
2
3
4
INSERT INTO visits (visited_at, path, country, region, city, ua_brief, ip_hash)
VALUES (strftime('%s','now')*1000, '/', 'CN', 'Sichuan', 'Chengdu', 'Chrome / Windows', 'demo-hash-001');

SELECT id, path, city, ua_brief FROM visits ORDER BY visited_at DESC LIMIT 5;

创建并部署 Worker

创建 Hello World

  1. Workers 和 Pages → 创建 → 从 Hello World! 开始(不要选 GitHub / 上传静态文件)。
  2. Worker 名称:blog-visitors-api。
  3. 「使用 Cloudflare Access 保护」保持关闭。
  4. 点 部署。

记下地址,形如(假):https://blog-visitors-api.example.workers.dev(不要末尾 /)。

粘贴正式代码

  1. 进入该 Worker → Edit code / 编辑代码。
  2. 删掉默认代码,粘贴文末附录 「Worker:index.js」 全文。
  3. 把文件开头的 ALLOWED_ORIGINS 改成你自己的博客域名(必须包含本地调试用的 localhost):
1
2
3
4
5
6
const ALLOWED_ORIGINS = [
"https://你的用户名.github.io",
"https://你的站点.netlify.app",
"http://localhost:4000",
"http://127.0.0.1:4000",
];
  1. Save and deploy。

绑定 D1

  1. Worker → Settings → Bindings → Add → D1 database。
  2. Variable name 必须填:DB。
  3. Database 下拉选:blog-visitors。
  4. 保存后再 Deploy 一次。

验证

浏览器打开:

https://blog-visitors-api.example.workers.dev/visits?limit=5

应返回类似 {"visits":[]} 或带数据的 JSON。若报 DB binding missing,检查绑定名是否为 DB 并重新部署。


接到你的 Hexo 博客

下面默认你的博客根目录里有 _config.yml、_config.butterfly.yml、source/ 等常见结构。
请新建这些路径,内容从文末「完整代码」整段复制(路径层级要一致):

路径 说明
visitor-api/src/index.js 与 Cloudflare 里粘贴的 Worker 代码保持一致(方便以后改)
visitor-api/wrangler.toml 可选;把 database_id 换成你的 UUID
source/self/visitor.js 浏览器打卡与渲染
source/self/visitor.css 样式
source/visitor/index.md 生成站点路径 /visitor/
scripts/visitor-config.js 构建时把主题配置写成前端可读文件(必须放在博客根目录的 scripts/)

改 _config.butterfly.yml

菜单:

1
2
menu:
访客: /visitor/ || fas fa-street-view

侧栏配置(api_base 换成你的 Worker 地址):

1
2
3
4
5
6
7
aside:
card_visitor:
enable: true
sort_order: 4
limit: 8
page_limit: 50
api_base: https://blog-visitors-api.example.workers.dev

inject(追加,别删原有项;visitor-config.js 必须在 visitor.js 前):

1
2
3
4
5
6
inject:
head:
- <link rel="stylesheet" href="/self/visitor.css">
bottom:
- <script src="/self/visitor-config.js"></script>
- <script src="/self/visitor.js"></script>

本地验证

1
2
hexo clean
hexo server
  • http://localhost:4000/ 侧栏应有「最近访客」
  • http://localhost:4000/visitor/ 完整列表
  • 打开任意文章页:侧栏不应再出现这张卡

若失败:F12 → Network 看 /visits;检查 CORS、api_base、D1 绑定。

部署

照常部署博客静态站。Worker 有改动时,仍要回 Cloudflare 粘贴部署。


以后怎么改

目的 改哪里
侧栏条数 / 顺序 / 开关 _config.butterfly.yml → aside.card_visitor
接口逻辑 / 去重 / CORS 附录 Worker 代码 → Cloudflare 粘贴部署
看原始数据 D1 Console:SELECT * FROM visits ORDER BY visited_at DESC LIMIT 20;

注意

  • 可与不蒜子 / Vercount 并存。
  • Worker 不要开 Access。
  • CORS 必须包含真实访问域名和本地 localhost。

完整代码(可复制)

以下代码供任意读者直接复制到自己的项目使用。请务必替换:

  • Worker 里的 ALLOWED_ORIGINS → 你的博客域名
  • api_base / 示例 workers.dev 地址 → 你的 Worker 地址
  • database_id → 你在 D1 详情页看到的 UUID

Worker:visitor-api/src/index.js

粘贴到 Cloudflare 编辑器,或保存到本地同名路径(先改 ALLOWED_ORIGINS):

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
/**
* blog-visitors-api
* Cloudflare Worker + D1:访客打卡 / 最近访客列表
*
* Dashboard:Edit code → 全文替换 → Save and deploy
* Settings → Bindings → D1,变量名必须为 DB
*/

const ALLOWED_ORIGINS = [
"https://你的用户名.github.io",
"https://你的站点.netlify.app",
"http://localhost:4000",
"http://127.0.0.1:4000",
];

const DEDUPE_MS = 30 * 60 * 1000;
const MAX_LIMIT = 100;
const BOT_RE =
/bot|spider|crawl|slurp|bingpreview|facebookexternalhit|python-requests|curl|wget|httpclient|headless/i;

function corsHeaders(origin) {
const allow = ALLOWED_ORIGINS.includes(origin) ? origin : ALLOWED_ORIGINS[0];
return {
"Access-Control-Allow-Origin": allow,
"Access-Control-Allow-Methods": "GET, POST, OPTIONS",
"Access-Control-Allow-Headers": "Content-Type",
"Access-Control-Max-Age": "86400",
Vary: "Origin",
};
}

function json(data, status, origin) {
return new Response(JSON.stringify(data), {
status,
headers: {
"Content-Type": "application/json; charset=utf-8",
...corsHeaders(origin),
},
});
}

function normalizePath(raw) {
if (!raw || typeof raw !== "string") return "/";
let p = raw.trim();
try {
if (p.startsWith("http://") || p.startsWith("https://")) {
p = new URL(p).pathname;
}
} catch (_) {}
p = p.split("?")[0].split("#")[0] || "/";
if (!p.startsWith("/")) p = "/" + p;
if (p.length > 200) p = p.slice(0, 200);
return p;
}

function parseUaBrief(ua) {
if (!ua) return "Unknown";
let browser = "Browser";
if (/Edg\//i.test(ua)) browser = "Edge";
else if (/Chrome\//i.test(ua) && !/Chromium/i.test(ua)) browser = "Chrome";
else if (/Firefox\//i.test(ua)) browser = "Firefox";
else if (/Safari\//i.test(ua) && !/Chrome/i.test(ua)) browser = "Safari";

let os = "Unknown";
if (/Windows/i.test(ua)) os = "Windows";
else if (/Android/i.test(ua)) os = "Android";
else if (/iPhone|iPad|iPod/i.test(ua)) os = "iOS";
else if (/Mac OS X/i.test(ua)) os = "macOS";
else if (/Linux/i.test(ua)) os = "Linux";

return `${browser} / ${os}`;
}

function formatLocation(cf) {
if (!cf) return "未知";
const country = cf.country || "";
const region = cf.region || cf.regionCode || "";
const city = cf.city || "";

if (country === "CN" || country === "China") {
const parts = [region, city].filter(Boolean);
return parts.length ? parts.join(" · ") : "中国";
}
if (country && city) return `海外 · ${country} · ${city}`;
if (country) return `海外 · ${country}`;
if (city) return city;
return "未知";
}

async function hashIp(ip, daySalt) {
const data = new TextEncoder().encode(`${ip || "unknown"}|${daySalt}`);
const buf = await crypto.subtle.digest("SHA-256", data);
return [...new Uint8Array(buf)]
.map((b) => b.toString(16).padStart(2, "0"))
.join("");
}

async function handleVisit(request, env, origin) {
if (!env.DB) {
return json({ ok: false, error: "DB binding missing" }, 500, origin);
}

const ua = request.headers.get("user-agent") || "";
if (BOT_RE.test(ua)) {
return json({ ok: true, skipped: "bot" }, 200, origin);
}

let body = {};
try {
body = await request.json();
} catch (_) {
body = {};
}

const path = normalizePath(body.path);
const now = Date.now();
const daySalt = new Date().toISOString().slice(0, 10);
const ip =
request.headers.get("cf-connecting-ip") ||
request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ||
"";
const ipHash = await hashIp(ip, daySalt);
const uaBrief = parseUaBrief(ua);
const cf = request.cf || {};
const country = cf.country || null;
const region = cf.region || cf.regionCode || null;
const city = cf.city || null;

const recent = await env.DB.prepare(
`SELECT id FROM visits
WHERE ip_hash = ? AND visited_at > ?
ORDER BY visited_at DESC LIMIT 1`
)
.bind(ipHash, now - DEDUPE_MS)
.first();

if (recent) {
return json({ ok: true, deduped: true }, 200, origin);
}

await env.DB.prepare(
`INSERT INTO visits (visited_at, path, country, region, city, ua_brief, ip_hash)
VALUES (?, ?, ?, ?, ?, ?, ?)`
)
.bind(now, path, country, region, city, uaBrief, ipHash)
.run();

return json({ ok: true }, 200, origin);
}

async function handleVisits(request, env, origin) {
if (!env.DB) {
return json({ ok: false, error: "DB binding missing" }, 500, origin);
}

const url = new URL(request.url);
let limit = parseInt(url.searchParams.get("limit") || "20", 10);
if (!Number.isFinite(limit) || limit < 1) limit = 20;
if (limit > MAX_LIMIT) limit = MAX_LIMIT;

const { results } = await env.DB.prepare(
`SELECT id, visited_at, path, country, region, city, ua_brief
FROM visits
ORDER BY visited_at DESC
LIMIT ?`
)
.bind(limit)
.all();

const visits = (results || []).map((row) => ({
id: row.id,
visited_at: row.visited_at,
path: row.path,
location: formatLocation({
country: row.country,
region: row.region,
city: row.city,
}),
ua_brief: row.ua_brief,
}));

return json({ visits }, 200, origin);
}

export default {
async fetch(request, env) {
const origin = request.headers.get("Origin") || "";
const url = new URL(request.url);

if (request.method === "OPTIONS") {
return new Response(null, { status: 204, headers: corsHeaders(origin) });
}

try {
if (request.method === "POST" && url.pathname === "/visit") {
return await handleVisit(request, env, origin);
}
if (request.method === "GET" && url.pathname === "/visits") {
return await handleVisits(request, env, origin);
}
if (request.method === "GET" && url.pathname === "/") {
return json(
{
service: "blog-visitors-api",
endpoints: ["POST /visit", "GET /visits?limit=8"],
},
200,
origin
);
}
return json({ error: "not found" }, 404, origin);
} catch (err) {
return json(
{ ok: false, error: err && err.message ? err.message : "server error" },
500,
origin
);
}
},
};

可选:visitor-api/wrangler.toml

1
2
3
4
5
6
7
8
9
# 第一期用网页部署即可;以后若用 npx wrangler deploy 再填真实 database_id
name = "blog-visitors-api"
main = "src/index.js"
compatibility_date = "2024-11-01"

[[d1_databases]]
binding = "DB"
database_name = "blog-visitors"
database_id = "00000000-0000-4000-8000-000000000000"

Hexo 脚本:scripts/visitor-config.js

放在博客根目录 scripts/ 下(与 package.json 同级):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
* 把 _config.butterfly.yml → aside.card_visitor 写成前端可读配置
* 生成:public/self/visitor-config.js
*/
hexo.extend.generator.register("visitor-config", () => {
const cfg =
(hexo.theme.config.aside && hexo.theme.config.aside.card_visitor) || {};
const payload = {
enable: cfg.enable !== false,
sort_order:
cfg.sort_order === 0 || cfg.sort_order ? Number(cfg.sort_order) : 4,
limit: cfg.limit ? Number(cfg.limit) : 8,
page_limit: cfg.page_limit ? Number(cfg.page_limit) : 50,
api_base:
cfg.api_base || "https://blog-visitors-api.example.workers.dev",
};
return {
path: "self/visitor-config.js",
data: `window.__VISITOR_CONFIG__=${JSON.stringify(payload)};`,
};
});

前端:source/self/visitor.js

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
/**
* 访客墙:打卡 + 侧栏 /visitor/ 渲染
* 配置在 _config.butterfly.yml → aside.card_visitor
*/
(function () {
const defaults = {
enable: true,
sort_order: 4,
limit: 8,
page_limit: 50,
api_base: "https://blog-visitors-api.example.workers.dev",
};
const cfg = Object.assign({}, defaults, window.__VISITOR_CONFIG__ || {});
const API_BASE = String(cfg.api_base || defaults.api_base).replace(/\/$/, "");
const ASIDE_ORDER = Number(cfg.sort_order);
const ASIDE_LIMIT = Number(cfg.limit) || defaults.limit;
const PAGE_LIMIT = Number(cfg.page_limit) || defaults.page_limit;
const ASIDE_ENABLE = cfg.enable !== false;

function relativeTime(ts) {
const diff = Math.max(0, Date.now() - Number(ts));
const m = Math.floor(diff / 60000);
if (m < 1) return "刚刚";
if (m < 60) return m + " 分钟前";
const h = Math.floor(m / 60);
if (h < 24) return h + " 小时前";
const d = Math.floor(h / 24);
if (d < 30) return d + " 天前";
return new Date(ts).toLocaleDateString("zh-CN");
}

function escapeHtml(str) {
return String(str)
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;");
}

function renderList(visits, { compact }) {
if (!visits.length) {
return '<p class="visitor-empty">暂无访客记录</p>';
}
const items = visits
.map((v) => {
const loc = escapeHtml(v.location || "未知");
const path = escapeHtml(v.path || "/");
const ua = escapeHtml(v.ua_brief || "");
const time = relativeTime(v.visited_at);
const meta = compact
? `<div class="visitor-meta"><code>${path}</code></div>`
: `<div class="visitor-meta"><code>${path}</code> · ${ua}</div>`;
return `
<li class="visitor-item">
<div class="visitor-avatar" aria-hidden="true"><i class="fas fa-location-dot"></i></div>
<div class="visitor-body">
<div class="visitor-top">
<span class="visitor-loc">${loc}</span>
<span class="visitor-time">${time}</span>
</div>
${meta}
</div>
</li>`;
})
.join("");
return `<ul class="visitor-list">${items}</ul>`;
}

async function fetchVisits(limit) {
const res = await fetch(`${API_BASE}/visits?limit=${limit}`, {
credentials: "omit",
});
if (!res.ok) throw new Error("fetch visits failed");
const data = await res.json();
return Array.isArray(data) ? data : data.visits || [];
}

function checkIn() {
try {
fetch(`${API_BASE}/visit`, {
method: "POST",
headers: { "Content-Type": "application/json" },
credentials: "omit",
body: JSON.stringify({ path: location.pathname || "/" }),
keepalive: true,
}).catch(() => {});
} catch (_) {}
}

function isPostPage() {
const wrap = document.getElementById("body-wrap");
if (wrap && wrap.classList.contains("post")) return true;
if (window.GLOBAL_CONFIG_SITE && window.GLOBAL_CONFIG_SITE.pageType === "post") {
return true;
}
return false;
}

function removeAsideCard() {
const old = document.getElementById("card-visitor");
if (old) old.remove();
}

function ensureAsideCard() {
if (!ASIDE_ENABLE || isPostPage()) {
removeAsideCard();
return null;
}
const aside = document.getElementById("aside-content");
if (!aside) return null;
let card = document.getElementById("card-visitor");
if (card) {
card.style.order = String(ASIDE_ORDER);
return card;
}

card = document.createElement("div");
card.className = "card-widget";
card.id = "card-visitor";
card.style.order = String(ASIDE_ORDER);
card.innerHTML = `
<div class="item-headline">
<i class="fas fa-street-view"></i>
<span>最近访客</span>
</div>
<div class="visitor-card-body">
<p class="visitor-loading">加载中…</p>
</div>`;

const webinfo = aside.querySelector(".card-webinfo");
const sticky = aside.querySelector(".sticky_layout");
if (webinfo && webinfo.parentElement) {
webinfo.parentElement.insertBefore(card, webinfo);
} else if (sticky) {
sticky.appendChild(card);
} else {
aside.appendChild(card);
}
return card;
}

async function mountAside() {
try {
const card = ensureAsideCard();
if (!card) return;
const body = card.querySelector(".visitor-card-body");
const visits = await fetchVisits(ASIDE_LIMIT);
body.innerHTML = renderList(visits, { compact: true });
} catch (e) {
const body = document.querySelector("#card-visitor .visitor-card-body");
if (body) body.innerHTML = '<p class="visitor-empty">访客墙暂时不可用</p>';
console.warn("[visitor]", e);
}
}

async function mountPage() {
const root = document.getElementById("visitor-wall");
if (!root) return;
root.innerHTML = '<p class="visitor-loading">加载中…</p>';
try {
const visits = await fetchVisits(PAGE_LIMIT);
root.innerHTML = renderList(visits, { compact: false });
} catch (e) {
root.innerHTML = '<p class="visitor-empty">访客墙暂时不可用</p>';
}
}

function init() {
checkIn();
mountAside();
mountPage();
}

if (document.readyState === "loading") {
document.addEventListener("DOMContentLoaded", init);
} else {
init();
}
document.addEventListener("pjax:complete", init);
})();

样式:source/self/visitor.css

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
/* —— 访客墙(Cloudflare Worker + D1) —— */

#card-visitor .item-headline {
display: flex;
align-items: center;
gap: 0.35rem;
}

.visitor-list {
list-style: none;
margin: 0;
padding: 0;
display: flex;
flex-direction: column;
gap: 0.65rem;
}

.visitor-item {
display: grid;
grid-template-columns: 36px 1fr;
gap: 0.55rem;
align-items: start;
font-size: 0.85rem;
line-height: 1.35;
}

.visitor-avatar {
width: 36px;
height: 36px;
border-radius: 50%;
display: grid;
place-items: center;
font-size: 0.85rem;
color: var(--text-highlight-color, #49b1f5);
background: color-mix(in srgb, var(--text-highlight-color, #49b1f5) 12%, transparent);
border: 1px solid color-mix(in srgb, var(--text-highlight-color, #49b1f5) 28%, transparent);
flex-shrink: 0;
}

.visitor-body {
min-width: 0;
}

.visitor-top {
display: flex;
justify-content: space-between;
gap: 0.4rem;
align-items: baseline;
}

.visitor-loc {
font-weight: 600;
color: var(--font-color);
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}

.visitor-time {
flex-shrink: 0;
font-size: 0.72rem;
opacity: 0.65;
}

.visitor-meta {
margin-top: 0.15rem;
font-size: 0.75rem;
opacity: 0.7;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}

.visitor-meta code {
font-size: 0.72rem;
padding: 0 0.2rem;
background: transparent;
}

.visitor-empty,
.visitor-loading {
font-size: 0.85rem;
opacity: 0.7;
text-align: center;
padding: 0.5rem 0;
}

#visitor-page {
max-width: 720px;
}

#visitor-page .visitor-notice {
margin-bottom: 1.25rem;
padding: 0.75rem 1rem;
border-left: 3px solid var(--text-highlight-color, #49b1f5);
background: rgba(73, 177, 245, 0.08);
font-size: 0.9rem;
line-height: 1.55;
}

#visitor-page .visitor-list {
gap: 0;
}

#visitor-page .visitor-item {
grid-template-columns: 42px 1fr;
padding: 0.85rem 0.25rem;
border-bottom: 1px dashed rgba(128, 128, 128, 0.25);
}

#visitor-page .visitor-avatar {
width: 42px;
height: 42px;
font-size: 0.95rem;
}

#visitor-page .visitor-meta {
white-space: normal;
}

页面:source/visitor/index.md

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
---
title: 访客记录
date: 2026-11-18 12:00:00
comments: false
aside: true
---

<div id="visitor-page">

<p class="visitor-notice">
这里展示最近访客的大致地区与访问路径,<strong>不展示完整 IP</strong>。<br>
同一访客短时间内重复访问会合并,避免刷屏。
</p>

<div id="visitor-wall">
<p class="visitor-loading">加载中…</p>
</div>

</div>