Đếm lượt xem Next.js và Supabase mà không theo dõi người đọc
Đếm lượt xem Next.js với Supabase: mỗi bài mỗi ngày một con số, lọc robot và lượt lướt, không lưu IP hay cookie. Kèm SQL và code của blog này.
Để đếm lượt xem Next.js với Supabase, bạn lưu mỗi bài mỗi ngày một con số và tăng nó bằng một hàm SQL, thay vì ghi từng lượt truy cập. Trình duyệt chờ vài giây rồi mới báo lên, máy chủ chỉ nhận bài đã đăng. Cùng mình làm nhé.
Mình cần biết gì về người đọc, và không cần biết gì?
Bài trước mình làm cho mỗi bài có ảnh chia sẻ riêng. Blog đã đẹp hơn khi dán vào Facebook hay Zalo, nhưng có một câu hỏi mình chưa trả lời được: bài nào đang được đọc? Viết xong mười bài mà không biết bài nào có người đọc thì rất khó quyết định bài tiếp theo nên viết gì.
Trước khi làm, mình ngồi liệt kê cái mình thật sự cần. Câu trả lời ngắn đến bất ngờ: mình chỉ cần biết bài X ngày Y có khoảng bao nhiêu lượt đọc. Mình không cần biết người đọc là ai, ở đâu, dùng máy gì, hay hôm qua họ đã đọc bài nào. Một con số cho mỗi bài mỗi ngày là đủ để vẽ danh sách "đọc nhiều" và để mình biết nên viết tiếp theo hướng nào.
Điều đó nghe hiển nhiên, nhưng cách làm đầu tiên mà hầu như ai cũng nghĩ tới lại ghi nhiều hơn mức cần thiết rất nhiều. Cùng xem nó hỏng ở đâu.
Cách làm đầu tiên: ghi nhật ký từng lượt truy cập
Ý tưởng tự nhiên nhất là tạo một bảng, mỗi lần có người mở bài thì thêm một dòng gồm địa chỉ IP, trình duyệt và bài đã mở. Muốn đếm thì count(*). Mình mô phỏng cách đó bằng một ngày truy cập giả của blog.
Bạn cần Node.js 22.18 trở lên (từ bản đó Node chạy thẳng file .ts). Tạo thư mục blog-luot-doc như sau:
blog-luot-doc/
package.json
nhat-ky-tho.ts
chay.ts
src/views.ts
src/su-kien.ts
src/dem-luot-doc.ts{
"name": "blog-mini-11-luot-doc",
"private": true,
"type": "module",
"scripts": { "test": "node --test src" }
}File đầu tiên là nguồn dữ liệu. su-kien.ts sinh ra một ngày truy cập giả với những kiểu người truy cập mà blog nào cũng gặp: 90 người đọc thật (có người lướt qua dưới 5 giây, có người tải lại trang, có người mở cùng một bài ở hai tab), 40 lượt của trình duyệt tự động, 20 lượt xem thử trên bản preview, và 30 lệnh gọi thẳng vào máy chủ với slug bịa hoặc bài chưa đăng. Mọi số liệu đều giả và sinh từ một hạt giống cố định, nên bạn chạy lại sẽ ra đúng kết quả trong bài. IP thì dùng khối 203.0.113.0/24, khối địa chỉ dành riêng cho ví dụ trong tài liệu.
// Sinh một ngày truy cập GIẢ của blog (không phải số liệu thật): người đọc, trình duyệt tự động, trang xem thử và các lệnh gọi thẳng vào máy chủ.
// IP dùng khối 203.0.113.0/24, khối dành riêng cho ví dụ trong tài liệu.
export type MoTrang = {
loai: "mo-trang";
nguoi: number; // số thứ tự người đọc thật (0 với trình duyệt tự động)
tab: string; // một tab trình duyệt; sessionStorage chỉ sống trong một tab
ip: string;
trinhDuyet: string;
slug: string;
giayOLai: number;
webdriver: boolean;
trangThat: boolean; // false = bản xem thử (preview) hoặc chạy trên máy
};
export type GoiTruc = { loai: "goi-truc"; slug: string }; // ai đó gọi thẳng server action, không qua trình duyệt
export type SuKien = MoTrang | GoiTruc;
export const BAI_DA_DANG = ["git-co-ban", "debug-breakpoint", "viet-test-dau-tien", "zod-validation", "rag-la-gi", "seo-nextjs"];
export const BAI_NHAP = "bai-dang-viet-do";
function sinhSo(hat: number): () => number {
let a = hat;
return () => {
a = (a + 0x6d2b79f5) | 0;
let t = Math.imul(a ^ (a >>> 15), 1 | a);
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
};
}
const TRINH_DUYET = ["Chrome/Windows", "Safari/iPhone", "Chrome/Android", "Firefox/Linux", "Safari/macOS"];
export function sinhNgayTruyCap(hat = 11): SuKien[] {
const r = sinhSo(hat);
const ds: SuKien[] = [];
const chon = <T>(mang: T[]) => mang[Math.floor(r() * mang.length)];
// 90 người đọc thật. Mỗi người đọc 1 đến 3 bài; 30% lượt mở là "lướt" (rời trong dưới 5 giây);
// 25% bài được tải lại một hai lần trong cùng tab; 10 người mở cùng một bài ở hai tab khác nhau.
for (let nguoi = 1; nguoi <= 90; nguoi++) {
const ip = `203.0.113.${nguoi}`;
const trinhDuyet = chon(TRINH_DUYET);
const soBai = 1 + Math.floor(r() * 3);
for (let b = 0; b < soBai; b++) {
const slug = chon(BAI_DA_DANG);
const tab = `tab-${nguoi}-${b}`;
const giayOLai = r() < 0.3 ? 1 + Math.floor(r() * 4) : 8 + Math.floor(r() * 170);
const moLai = r() < 0.25 ? 1 + Math.floor(r() * 2) : 0;
for (let k = 0; k <= moLai; k++) ds.push({ loai: "mo-trang", nguoi, tab, ip, trinhDuyet, slug, giayOLai, webdriver: false, trangThat: true });
if (nguoi <= 10 && b === 0) ds.push({ loai: "mo-trang", nguoi, tab: `${tab}-tab-hai`, ip, trinhDuyet, slug, giayOLai: 60, webdriver: false, trangThat: true });
}
}
// 40 lượt của trình duyệt tự động (kiểm thử, robot đọc trang có chạy JavaScript).
for (let i = 0; i < 40; i++) ds.push({ loai: "mo-trang", nguoi: 0, tab: `bot-${i}`, ip: `203.0.113.${200 + (i % 20)}`, trinhDuyet: "HeadlessChrome", slug: chon(BAI_DA_DANG), giayOLai: 30, webdriver: true, trangThat: true });
// 20 lượt xem thử trên bản preview của Vercel.
for (let i = 0; i < 20; i++) ds.push({ loai: "mo-trang", nguoi: 91, tab: `preview-${i}`, ip: "203.0.113.91", trinhDuyet: "Chrome/Windows", slug: chon(BAI_DA_DANG), giayOLai: 40, webdriver: false, trangThat: false });
// 30 lệnh gọi thẳng: slug bịa, bài nháp, và chuỗi lạ.
const SPAM = ["bai-khong-ton-tai", BAI_NHAP, "../../etc/passwd", "A", "x".repeat(150)];
for (let i = 0; i < 30; i++) ds.push({ loai: "goi-truc", slug: i % 3 === 0 ? `bai-bia-${i}` : chon(SPAM) });
return ds;
}Script nhat-ky-tho.ts là cách làm đầu tiên: mỗi lượt mở trang thành một dòng nhật ký. Sau đó nó thử làm điều mà ai có bảng này cũng làm được, tức là nhóm theo IP.
// Cách làm đầu tiên: ghi MỖI lượt mở trang vào một bảng nhật ký. Chạy: node nhat-ky-tho.ts
import { sinhNgayTruyCap } from "./src/su-kien.ts";
const nhatKy = sinhNgayTruyCap().flatMap((sk) => (sk.loai === "mo-trang" ? [{ ip: sk.ip, trinhDuyet: sk.trinhDuyet, slug: sk.slug }] : []));
console.log(`Bảng nhật ký có ${nhatKy.length} dòng. Ba dòng đầu:`);
for (const dong of nhatKy.slice(0, 3)) console.log(` ${JSON.stringify(dong)}`);
// Chỉ cần nhóm theo IP là dựng lại được lịch sử đọc của một người.
const theoIp = new Map<string, Set<string>>();
for (const { ip, slug } of nhatKy) theoIp.set(ip, (theoIp.get(ip) ?? new Set()).add(slug));
const [ipDau, baiDoc] = [...theoIp].find(([, bai]) => bai.size >= 3) ?? [...theoIp][0];
console.log(`\nIP ${ipDau} đã đọc: ${[...baiDoc].join(", ")}`);
console.log(`Số dòng đếm được: ${nhatKy.length}. Số người thật trong ngày: 90 (cộng ~40 robot và 20 lượt xem thử).`);node nhat-ky-tho.tsBảng nhật ký có 329 dòng. Ba dòng đầu:
{"ip":"203.0.113.1","trinhDuyet":"Chrome/Android","slug":"zod-validation"}
{"ip":"203.0.113.1","trinhDuyet":"Chrome/Android","slug":"zod-validation"}
{"ip":"203.0.113.1","trinhDuyet":"Chrome/Android","slug":"git-co-ban"}
IP 203.0.113.2 đã đọc: viet-test-dau-tien, debug-breakpoint, git-co-ban
Số dòng đếm được: 329. Số người thật trong ngày: 90 (cộng ~40 robot và 20 lượt xem thử).Có hai vấn đề hiện ra cùng lúc. Thứ nhất là riêng tư: chỉ với một dòng group by, mình dựng lại được lịch sử đọc của một địa chỉ IP, mà đó có thể là một người thật. Bạn không có lý do gì cần dữ liệu đó để làm danh sách "đọc nhiều", nhưng giờ bạn phải giữ nó an toàn, phải lo chuyện ai được xem, và nếu ai đó hỏi dữ liệu của họ thì phải tìm và xóa. Dữ liệu không lưu thì không bao giờ bị lộ.
Thứ hai là độ chính xác: 329 dòng, nhưng chỉ có 90 người thật. Bạn nhìn lại ba dòng đầu, người đầu tiên đã sinh hai dòng giống hệt chỉ vì tải lại trang. Cộng thêm robot, lượt xem thử của chính mình, và những người chỉ lướt qua một giây rồi đóng, con số 329 gần như vô nghĩa.
Mình không phải luật sư nên không bàn về luật bảo vệ dữ liệu cá nhân ở đây. Mình chỉ chọn nguyên tắc đơn giản: thứ gì không cần cho câu hỏi của mình thì không lưu.
Một bảng, mỗi bài mỗi ngày một con số
Giải pháp là bảng post_views của chính blog này, với khóa chính là cặp (bài, ngày) và một cột đếm. Không có cột nào về người đọc. Đây là migration thật (file supabase/migrations/20261104123913_post_views.sql trong repo của blog), mình dán đủ để bạn chép được:
create table public.post_views (
slug text not null,
day date not null default ((now() at time zone 'Asia/Ho_Chi_Minh')::date),
views integer not null default 0 constraint post_views_non_negative check (views >= 0),
primary key (slug, day)
);
create index post_views_day_idx on public.post_views (day);
alter table public.post_views enable row level security;
create policy "Authors can read post views" on public.post_views for select to authenticated
using ((select auth.jwt() -> 'app_metadata' ->> 'role') = 'author');
revoke all on public.post_views from anon, authenticated;
grant select on public.post_views to authenticated;
create or replace function public.record_post_view(p_slug text)
returns void
language plpgsql
security definer
set search_path = ''
as $$
begin
-- Only real, visible posts: random slugs cannot fill the table.
if not exists (
select 1 from public.posts where slug = p_slug and status = 'published' and published_at <= now()
) then
return;
end if;
insert into public.post_views (slug, day, views)
values (p_slug, (now() at time zone 'Asia/Ho_Chi_Minh')::date, 1)
on conflict (slug, day) do update set views = public.post_views.views + 1;
end;
$$;
revoke all on function public.record_post_view(text) from public;
grant execute on function public.record_post_view(text) to anon, authenticated;(File thật còn thêm một hàm popular_posts cho danh sách "Đọc nhiều" ở trang chủ và các dòng chú thích, mình lược ở đây vì bài này chỉ cần phần ghi. Bạn xem lại nó ở mục cuối.)
Có bốn quyết định trong đoạn SQL này, và mỗi quyết định có lý do.
Người đọc không bao giờ chạm vào bảng. Mình thu hồi toàn bộ quyền của anon trên post_views (dòng revoke all), nên khách ẩn danh không đọc được, cũng không ghi thẳng được. Họ chỉ có thể gọi hàm record_post_view, và hàm đó chạy với quyền của chủ (security definer) nên ghi được dù người gọi không có quyền. Chỉ tác giả (có vai trò author trong token) đọc được các dòng, để vẽ bảng điều khiển.
Hàm kiểm tra bài có thật không trước khi đếm. Dòng if not exists (select 1 from public.posts ...) là lớp chặn ở máy chủ: slug bịa hay bài còn là bản nháp đều bị bỏ qua. Nếu thiếu dòng này, bất kỳ ai cũng gọi được hàm với một triệu slug khác nhau và làm đầy bảng.
Việc tăng số dùng insert ... on conflict ... do update set views = views + 1. Cách nghe có vẻ tự nhiên hơn là đọc con số hiện tại, cộng một, rồi ghi lại, nhưng nếu hai người mở bài cùng lúc, cả hai cùng đọc 10 và cùng ghi 11, mất một lượt. Một câu lệnh upsert nguyên tử thì Postgres lo thứ tự giúp bạn.
Cuối cùng là set search_path = ''. Một hàm security definer chạy với quyền cao, nên nếu nó tìm bảng theo đường dẫn mặc định thì kẻ khác có thể tạo bảng trùng tên ở một schema khác để đánh lừa nó. Đặt đường dẫn rỗng và viết đầy đủ public.posts là cách phòng. Tài liệu của PostgreSQL về CREATE FUNCTION cũng khuyên đặt search_path cho hàm kiểu này. Mình có viết 9 phép kiểm pgTAP cho toàn bộ hành vi này (chạy bằng npx supabase test db, cần cả stack Supabase chạy trên máy nên mình không chạy lại trong bài này).
Phía trình duyệt: chờ vài giây rồi mới báo
Hàm SQL lo phần "đúng hay sai" ở máy chủ. Còn việc quyết định một lượt mở trang có đáng tính không thuộc về trình duyệt, nơi biết người đọc có thực sự ở lại hay không. Component ViewBeacon của blog làm việc đó:
"use client";
import { useEffect } from "react";
import { recordView } from "@/app/[lang]/(site)/view-actions";
import { shouldCountView, VIEW_SESSION_PREFIX } from "@/lib/views";
/** Counts one read per browser session, a few seconds after the article opens (skims don't count). */
export function ViewBeacon({ slug, enabled }: { slug: string; enabled: boolean }) {
useEffect(() => {
const key = `${VIEW_SESSION_PREFIX}${slug}`;
let alreadyCounted = false;
try {
alreadyCounted = window.sessionStorage.getItem(key) === "1";
} catch {}
if (!shouldCountView({ enabled, webdriver: navigator.webdriver === true, alreadyCounted })) return;
const timer = window.setTimeout(() => {
try {
window.sessionStorage.setItem(key, "1");
} catch {}
void recordView(slug).catch(() => {});
}, 5000);
return () => window.clearTimeout(timer);
}, [slug, enabled]);
return null;
}Đọc từ trên xuống, nó có ba bộ lọc. Bộ lọc đầu là sessionStorage: sau khi báo một lần, trình duyệt ghi "1" vào đó, nên tải lại trang trong cùng tab không đếm thêm. sessionStorage chỉ nằm trong trình duyệt của người đọc và mất khi đóng tab, không bao giờ gửi lên máy chủ. Bộ lọc thứ hai là navigator.webdriver: các trình duyệt tự động (Playwright, Selenium, nhiều robot) đặt cờ này, nên bài test end-to-end của mình không làm tăng số lượt. Bộ lọc thứ ba là đồng hồ 5 giây (setTimeout): hàm clearTimeout ở cuối hủy báo nếu người đọc rời trang trước đó, nên những người lướt qua không bị tính.
Hàm shouldCountView mình tách riêng vì nó là logic thuần, dễ test: nhận ba cờ, trả true hoặc false. Bản demo của mình có đủ logic này cùng vài hàm khác (không có phần riêng của Next.js):
// Các hàm thuần của việc đếm lượt đọc, cùng ý với src/lib/views.ts của blog Tech Notes (bản demo bỏ phần riêng của Next.js).
export const GIAY_CHO_TRUOC_KHI_TINH = 5; // người đọc ở lại trang ít nhất chừng này giây thì mới tính một lượt đọc
const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
export const isPostSlug = (value: unknown): value is string => typeof value === "string" && value.length <= 120 && SLUG.test(value);
/** Có nên tính một lượt đọc cho trình duyệt này không: chỉ trên trang thật, không phải trình duyệt tự động, và chưa tính trong phiên này. */
export function shouldCountView({ enabled, webdriver, alreadyCounted }: { enabled: boolean; webdriver: boolean; alreadyCounted: boolean }) {
return enabled && !webdriver && !alreadyCounted;
}
export type ViewRow = { slug: string; day: string; views: number };
/** Tổng theo slug trong `days` ngày gần nhất (tính cả hôm nay), nhiều nhất trước. */
export function totalsSince(rows: ViewRow[], today: string, days = 30): Map<string, number> {
const cutoff = new Date(`${today}T00:00:00Z`);
cutoff.setUTCDate(cutoff.getUTCDate() - (days - 1));
const from = cutoff.toISOString().slice(0, 10);
const totals = new Map<string, number>();
for (const row of rows) {
if (row.day < from || row.day > today) continue;
totals.set(row.slug, (totals.get(row.slug) ?? 0) + row.views);
}
return new Map([...totals].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])));
}
/** Ngày hôm nay theo giờ Việt Nam (UTC+7), dùng làm khóa của bảng đếm. */
export function vnToday(now: Date = new Date()): string {
return new Date(now.getTime() + 7 * 60 * 60 * 1000).toISOString().slice(0, 10);
}Phần cuối là server action recordView, cầu nối giữa trình duyệt và hàm SQL:
"use server";
import { getSupabaseEnv } from "@/lib/supabase/env";
import { createPublicClient } from "@/lib/supabase/public";
import { isPostSlug } from "@/lib/views";
/** Adds one read to today's count. Only the production deployment counts (previews share the DB). */
export async function recordView(slug: string): Promise<void> {
if (process.env.VERCEL_ENV !== "production" || !isPostSlug(slug)) return;
const env = getSupabaseEnv();
if (!env) return;
await createPublicClient(env).rpc("record_post_view", { p_slug: slug });
}Dòng quan trọng là điều kiện VERCEL_ENV !== "production". Các bản preview của Vercel dùng chung cơ sở dữ liệu với production, nên nếu không chặn thì mỗi lần mình xem thử một bài trên preview là một lượt đọc giả. Và isPostSlug kiểm tra dạng slug lần nữa ở máy chủ, vì tài liệu Next.js nói rõ Server Function có thể bị gọi thẳng bằng yêu cầu POST, không nhất thiết qua giao diện của bạn (xem trang mutating data). Kiểm tra ở trình duyệt chỉ để tiện, kiểm tra ở máy chủ mới là rào chắn thật.
Chạy thử: mỗi quy tắc loại bao nhiêu lượt?
Giờ nối hai nửa lại. File dem-luot-doc.ts mô phỏng đúng thứ tự trên: trình duyệt lọc trước (xem thử, robot, rời trước 5 giây, cùng tab), rồi máy chủ lọc (slug sai dạng, không phải bài đã đăng), và cuối cùng tăng một con số cho mỗi (bài, ngày). Nó cũng đếm lại mỗi quy tắc đã loại bao nhiêu.
// Mô phỏng hai nửa của việc đếm lượt đọc, theo đúng thứ tự của blog thật:
// 1. Trình duyệt (view-beacon.tsx): chờ 5 giây, kiểm tra shouldCountView, mỗi tab một lần cho mỗi bài, rồi gọi máy chủ.
// 2. Máy chủ (hàm SQL record_post_view): chỉ đếm bài ĐÃ ĐĂNG, mỗi (bài, ngày) một dòng, tăng thêm 1.
import type { SuKien } from "./su-kien.ts";
import { GIAY_CHO_TRUOC_KHI_TINH, isPostSlug, shouldCountView, type ViewRow } from "./views.ts";
export type LyDoLoai = "xem thử, không phải trang thật" | "trình duyệt tự động" | "rời trước 5 giây" | "cùng tab đã tính" | "slug sai dạng" | "không phải bài đã đăng";
export type KetQuaDem = { bang: ViewRow[]; loai: Map<LyDoLoai, number>; soLenhGoi: number };
export function demLuotDoc(suKien: SuKien[], baiDaDang: string[], ngay: string): KetQuaDem {
const bang = new Map<string, number>(); // khóa "slug|ngày" -> số lượt, giống bảng post_views
const loai = new Map<LyDoLoai, number>();
const tuChoi = (lyDo: LyDoLoai) => loai.set(lyDo, (loai.get(lyDo) ?? 0) + 1);
const daTinhTrongTab = new Set<string>(); // thay cho sessionStorage: "tab|slug"
let soLenhGoi = 0;
// Nửa máy chủ: chỉ nhận slug đúng dạng và là bài đã đăng.
const ghiLuotDoc = (slug: string) => {
soLenhGoi++;
if (!isPostSlug(slug)) return tuChoi("slug sai dạng");
if (!baiDaDang.includes(slug)) return tuChoi("không phải bài đã đăng");
const khoa = `${slug}|${ngay}`;
bang.set(khoa, (bang.get(khoa) ?? 0) + 1);
};
for (const sk of suKien) {
if (sk.loai === "goi-truc") {
ghiLuotDoc(sk.slug); // không qua trình duyệt, nên chỉ máy chủ chặn được
continue;
}
const khoaTab = `${sk.tab}|${sk.slug}`;
if (!sk.trangThat) { tuChoi("xem thử, không phải trang thật"); continue; }
if (sk.webdriver) { tuChoi("trình duyệt tự động"); continue; }
if (sk.giayOLai < GIAY_CHO_TRUOC_KHI_TINH) { tuChoi("rời trước 5 giây"); continue; } // đồng hồ 5 giây chưa kịp chạy
if (!shouldCountView({ enabled: sk.trangThat, webdriver: sk.webdriver, alreadyCounted: daTinhTrongTab.has(khoaTab) })) { tuChoi("cùng tab đã tính"); continue; }
daTinhTrongTab.add(khoaTab);
ghiLuotDoc(sk.slug);
}
const rows = [...bang].map(([khoa, views]) => ({ slug: khoa.split("|")[0], day: khoa.split("|")[1], views }));
return { bang: rows, loai, soLenhGoi };
}Script cuối chạy cả ngày, in số lượt bị loại theo từng quy tắc, rồi so với số cặp (người, bài) thật sự có đọc:
// Đếm lượt đọc bằng các quy tắc, rồi nói rõ mỗi quy tắc loại bao nhiêu. Chạy: node chay.ts
import { demLuotDoc } from "./src/dem-luot-doc.ts";
import { BAI_DA_DANG, sinhNgayTruyCap } from "./src/su-kien.ts";
import { totalsSince, vnToday } from "./src/views.ts";
const suKien = sinhNgayTruyCap();
const ngay = vnToday(new Date("2026-11-18T03:00:00Z"));
const kq = demLuotDoc(suKien, BAI_DA_DANG, ngay);
const moTrang = suKien.filter((s) => s.loai === "mo-trang").length;
console.log(`Trong ngày ${ngay}: ${moTrang} lượt mở trang và ${suKien.length - moTrang} lệnh gọi thẳng vào máy chủ.\n`);
console.log("Số lượt bị loại, theo từng quy tắc:");
for (const [lyDo, soLuong] of kq.loai) console.log(` ${String(soLuong).padStart(3)} ${lyDo}`);
const tong = kq.bang.reduce((t, d) => t + d.views, 0);
console.log(`\nSố lượt đọc được ghi: ${tong}`);
// Số "người đọc thật" tính theo (người, bài) khác nhau, ở lại từ 5 giây trở lên.
const nguoiBai = new Set(suKien.flatMap((s) => (s.loai === "mo-trang" && s.nguoi >= 1 && s.nguoi <= 90 && s.trangThat && s.giayOLai >= 5 ? [`${s.nguoi}|${s.slug}`] : [])));
console.log(`Số cặp (người, bài) thật sự có đọc: ${nguoiBai.size} -> đếm dư ${tong - nguoiBai.size} vì một người mở cùng bài ở hai tab`);
console.log("\nĐọc nhiều nhất:");
for (const [slug, views] of totalsSince(kq.bang, ngay)) console.log(` ${String(views).padStart(3)} ${slug}`);
console.log(`\nBảng lưu ${kq.bang.length} dòng, mỗi dòng chỉ có: ${Object.keys(kq.bang[0]).join(", ")}`);node chay.tsTrong ngày 2026-11-18: 329 lượt mở trang và 30 lệnh gọi thẳng vào máy chủ.
Số lượt bị loại, theo từng quy tắc:
45 cùng tab đã tính
89 rời trước 5 giây
40 trình duyệt tự động
20 xem thử, không phải trang thật
16 không phải bài đã đăng
14 slug sai dạng
Số lượt đọc được ghi: 135
Số cặp (người, bài) thật sự có đọc: 122 -> đếm dư 13 vì một người mở cùng bài ở hai tab
Đọc nhiều nhất:
36 git-co-ban
26 zod-validation
22 viet-test-dau-tien
20 rag-la-gi
16 debug-breakpoint
15 seo-nextjs
Bảng lưu 6 dòng, mỗi dòng chỉ có: slug, day, viewsHãy nhìn khối giữa. Từ 329 lượt mở trang và 30 lệnh gọi lạ, chỉ còn 135 lượt đọc được ghi. Quy tắc loại nhiều nhất là "rời trước 5 giây" (89 lượt), tức khoảng một phần tư lượt mở trang là người lướt qua, một con số mà cách ghi nhật ký ở trên coi là lượt đọc. 40 robot và 20 lượt xem thử cũng bị loại ngay ở trình duyệt, còn 30 lệnh gọi thẳng đều bị máy chủ chặn (16 vì bài chưa đăng hoặc không tồn tại, 14 vì slug sai dạng) và không để lại dòng nào.
Dòng cuối mới là thứ mình muốn bạn nhìn: sau cả ngày, bảng chỉ có 6 dòng (6 bài, một ngày), mỗi dòng gồm slug, day, views. Không IP, không trình duyệt, không mã người đọc. Muốn dựng lại lịch sử của ai đó thì không còn dữ liệu nào để dựng.
Con số này đúng được đến đâu?
Mình không muốn bạn tin con số 135 như một sự thật tuyệt đối. Dòng "đếm dư 13" trong kết quả là một giới hạn có thật: 122 cặp (người, bài) thật sự đọc, nhưng bảng ghi 135. sessionStorage chỉ nhớ trong một tab, nên một người mở cùng bài ở hai tab (hoặc đọc trên điện thoại rồi sang máy tính) bị đếm hai lần. Trong mô phỏng mình cố tình cho 10 người làm vậy, và vài người khác tình cờ chọn trùng bài, nên ra 13.
Con số cũng không nói gì về người đọc duy nhất. Muốn biết "tháng này có bao nhiêu người khác nhau" thì phải nhận ra từng người, mà đó chính là thứ mình đã chọn không làm. Mình chấp nhận: với một blog cá nhân, "bài nào được đọc nhiều hơn bài nào" là câu hỏi đủ dùng, và con số lệch vài phần trăm không làm đổi thứ hạng.
Cũng cần nói thẳng một điều: không ghi vào bảng của mình không có nghĩa là không có dấu vết ở đâu cả. Yêu cầu tới máy chủ vẫn đi qua nhà cung cấp hạ tầng như Vercel và có thể nằm trong log của họ theo cấu hình của họ. Phần mình kiểm soát được là bảng của mình, và ở đó không có thông tin gì về người đọc.
Ngoài ra, bảng này không cho biết người đọc từ đâu tới (Google, Facebook hay gõ thẳng địa chỉ). Câu hỏi đó có công cụ khác trả lời được, ví dụ Search Console cho lượt hiển thị và từ khóa trên Google, còn mình để nguyên vì đó là một câu hỏi khác.
Dùng con số: danh sách "Đọc nhiều" và bảng điều khiển
Bảng đếm xong thì dùng ở hai chỗ. Trang chủ có danh sách "Đọc nhiều" lấy từ hàm popular_posts (cộng số lượt 30 ngày gần nhất rồi sắp xếp), và mình chủ động ẩn danh sách đó khi chưa có ít nhất ba bài có lượt đọc, vì xếp hạng ba bài với vài lượt đọc chỉ là nhiễu. Trong repo, hằng số đó là MIN_POPULAR = 3 trong src/lib/views.ts. Còn trang quản trị của tác giả có thẻ "Đọc nhiều 30 ngày qua", đọc thẳng các dòng của post_views (chỉ tác giả mới có quyền) bằng hàm totalsSince ở trên.
Mình cũng viết test cho các hàm thuần, vì đó là nơi dễ âm thầm hỏng nhất: slug đúng dạng, shouldCountView với ba cờ, vnToday phải trả ngày giờ Việt Nam (lúc 18:30 UTC ngày 4/11 đã là ngày 5/11 ở Hà Nội), và totalsSince đúng cửa sổ 30 ngày. Bản demo có thêm test cho từng quy tắc loại và một test ghi lại giới hạn hai tab. Bạn chạy bằng node --test src/dem-luot-doc.test.ts (file test nằm trong repo demo, bài này mình không dán).
Dữ liệu đã có, nhưng người đọc đến rồi lại đi
Đến đây blog trả lời được câu hỏi ban đầu: bài nào được đọc, đọc bao nhiêu mỗi ngày, mà không biết ai đọc. Nhưng nhìn bảng sáu dòng kia, mình thấy một điều khác: những người đọc xong rồi đi thường không quay lại, vì blog chưa có cách nào để họ ở lại nhận bài mới. Giữ liên lạc với họ theo cách vừa tôn trọng họ vừa không tốn tiền là việc của các bài viết sau.
Bạn theo dõi cả hành trình ở Xây blog với Next.js và Supabase. Bài Row Level Security trong Supabase giải thích vì sao bảng này khóa quyền như vậy, và các câu hỏi về web nằm trong ngân hàng câu hỏi phỏng vấn.