---
title: "Таблица рекордов: сортировка, ничьи и почему счёт на клиенте можно подделать"
description: "Как устроить таблицу рекордов браузерной игры: компаратор с числом, а не true/false, ничья по порядку установления результата, вставка и обрезка до N мест без потери чужой строки и почему сервер не должен верить счёту, который прислал клиент. Модель на JavaScript, проверенная в Node.js 24: семь ловушек с цифрами прогона — от sort() без компаратора до подписи HMAC с ключом из клиентского кода."
slug: tablica-rekordov-sortirovka-nichi-i-pochemu-schet-na-kliente-mozhno-poddelat
date: 2026-11-18
updated: 2026-11-18
scheduled_at: "2026-11-18T19:00:00+03:00"
rubric: logika-i-arhitektura
tags: ["javascript", "ochki-i-rekordy", "arhitektura-igry", "brauzernye-igry", "razrabotchikam"]
reading_time: 23
draft: false
summary: "Таблица рекордов держится на одном правиле порядка и одной функции вставки: больше очков — выше, при равенстве выше тот, кто установил результат раньше, причём «раньше» определяет номер, который выдаёт тот, кто ведёт таблицу, а не время с клиента; вставка сначала сортирует всё вместе с новой строкой, потом обрезает до N мест. В нашем прогоне на таблице из 8 мест sort() без компаратора опустил 12 000 очков на 7-е место, компаратор true/false не пустил в таблицу 11 000, а обрезка до сортировки вписала 100 очков вместо 5000. Правильная сортировка не защищает общую таблицу: сервер, который верит числу, ставит 999 999 на 1-е место, подпись с ключом из клиентского JS подделывается за одну строку, а пересчёт по ленте ввода отсекает невозможное, но не идеальную подделку в пределах правил."
---

## Коротко

Таблица рекордов — это одно правило порядка и одна функция вставки: больше очков — выше, при равном счёте выше тот, кто установил результат раньше, а вставка сначала сортирует таблицу вместе с новой строкой и только потом обрезает её до N мест. Номер «кто раньше» выдаёт тот, кто ведёт таблицу, а не клиент, иначе ничью можно купить одним полем в запросе. Правильная сортировка не защищает общую таблицу: счёт, присланный браузером, — это заявка, и сервер, который ей верит, в нашем прогоне ставит 999 999 очков на 1-е место даже с подписью HMAC, потому что ключ подписи лежит в том же клиентском коде. Сервер должен получать ленту раунда и пересчитывать счёт сам: так отсекается невозможное, но не идеальная подделка в пределах правил.

## Содержание

1. Что должна гарантировать таблица рекордов
2. Модель: «Ловец комет» и таблица на 8 мест
3. Код на JavaScript и проверка в Node.js
4. Что показал прогон: семь ловушек
5. Правило порядка: два ключа и одна вставка
6. Почему счёт с клиента — заявка, а не результат
7. Что сервер может проверить и чего не может
8. Практический сценарий: общая таблица «Ловца комет»
9. Когда вам это не подойдёт

## Что должна гарантировать таблица рекордов

Таблица рекордов должна давать один и тот же порядок из одних и тех же данных, никогда не отнимать место у того, кто набрал результат раньше, и показывать только результаты, набранные в игре. Первые два свойства — задача сортировки и вставки, третье — задача того, кто принимает результат: аккуратно отсортированная таблица выглядит честной, даже если в первой строке число, которое никто не набирал.

Как считать сами очки — за что их давать, как множить серию, когда её сбрасывать и как показать игроку «не хватило N очков», — разобрано в статье об [очках, множителях серии и рекордах](/blog/ochki-mnozhiteli-serii-i-rekordy-kak-schitat-nagradu). Там же есть правило «при равном счёте новый игрок встаёт ниже старого». Здесь мы его не повторяем как совет, а проверяем прогоном: что будет, если его нарушить, и почему его не спасает одна только стабильная сортировка.

Где хранить таблицу в браузере и как пережить смену формата, — тема статьи о [сохранениях в браузерной игре](/blog/sohraneniya-v-brauzernoj-igre-localstorage-indexeddb). Здесь хранилище — просто строка JSON: нас интересует порядок при чтении и правка этой строки руками.

| Свойство | Что его ломает | Где в прогоне |
|---|---|---|
| Порядок по числу, а не по тексту | `sort()` без компаратора | ловушка 1 |
| Порядок вообще есть | компаратор `true`/`false` | ловушка 2 |
| Ничья не отнимает место | вставка в начало, ничья по имени, порядок чтения | ловушка 3 |
| Обрезка выбрасывает худшего | «заменить последнего», обрезка до сортировки | ловушка 4 |
| В таблице только сыгранное | доверие числу, ключ в клиенте, правка хранилища | ловушки 5–7 |

## Модель: «Ловец комет» и таблица на 8 мест

Наш пример — браузерная аркада «Ловец комет»: раунд длится 60 секунд, игрок ловит сачком кометы, маленькая даёт 100 очков, большая — 500, а лучшие результаты попадают в таблицу на 8 мест. Игра, её правила, имена игроков и все числа — наш пример, а не данные какой-либо игры.

| Параметр (наш пример) | Значение |
|---|---|
| Раунд | 60 с, время в десятых долях секунды: t от 0 до 599 |
| Сачок | между двумя поимками не меньше 0,5 с |
| Кометы | маленькая — 100 очков, большая — 500; большая появляется раз в 5 с (t кратно 50) |
| Потолок по правилам | 16 800 очков за 120 поимок (считает сам код) |
| Таблица | 8 мест; строка — имя, счёт и `seq`, номер установления результата |
| Стартовая таблица | Оля 12000, Миша 9500, Дина 10400, Тимур 7400, Вера 9500, Костя 5000, Аня 6200, Борис 5000 — в порядке установления, `seq` от 1 до 8 |

Числа подобраны так, чтобы ловушки были видны сразу: два результата с пятью цифрами среди четырёхзначных проверяют сравнение строк, две пары ничьих (9500 и 5000) проверяют вторичный ключ, а одна из ничьих стоит на границе 8-го места и проверяет обрезку. Порядок установления не совпадает с порядком по очкам: Дина набрала 10 400 после Миши, а Вера — те же 9500, что и Миша, но позже.

## Код на JavaScript и проверка в Node.js

Код состоит из пяти модулей: правильная таблица, наивные варианты, правила раунда с пересчётом, три сервера и проверочный файл, который печатает все сцены. Запуск — Node.js 24.22.1, модули ES (`.mjs`); всё, что здесь печатается, — наш пример и наш расчёт.

Модуль `board.mjs` — рабочая таблица: функция сравнения по двум ключам, вставка с обрезкой и загрузка из строки JSON.

```js
// board.mjs — наш пример: таблица рекордов «Ловца комет» на 8 мест.
export const SIZE = 8;

// Порядок: больше очков — выше; при равенстве выше тот, кто установил результат раньше.
// seq — номер, который выдаёт тот, кто ведёт таблицу (сервер или локальный счётчик), а не клиент.
export function compareEntries(a, b) {
  if (a.score !== b.score) return b.score - a.score;
  return a.seq - b.seq;
}

// Вставка: сначала полный порядок, потом обрезка. Возвращает новую таблицу и место (или null).
export function insert(board, entry, size = SIZE) {
  if (!Number.isSafeInteger(entry.score) || entry.score < 0) throw new Error("счёт не целое число");
  const all = [...board, entry].sort(compareEntries);
  const place = all.indexOf(entry) + 1;
  return { board: all.slice(0, size), place: place <= size ? place : null };
}

// Загрузка из хранилища: числа приводим к числам, порядок восстанавливаем сами.
export function load(text, size = SIZE) {
  const rows = JSON.parse(text).map((r) => ({ name: String(r.name), score: Number(r.score), seq: Number(r.seq) }));
  return rows.filter((r) => Number.isSafeInteger(r.score)).sort(compareEntries).slice(0, size);
}

export const show = (board) => board.map((e, i) => (i + 1) + "." + e.name + " " + e.score).join("  ");
```

Модуль `naive.mjs` собирает реализации, которые выглядят рабочими, — каждая ловит одну ловушку из таблицы выше.

```js
// naive.mjs — наш пример: так делать не надо, каждая функция ловит одну ловушку.
import { SIZE } from "./board.mjs";

// 1. sort() без компаратора сравнивает строки, даже если в массиве числа.
export const sortDefault = (scores) => [...scores].sort().reverse();

// 2. Компаратор возвращает true/false вместо отрицательного числа, нуля или положительного.
export const sortBoolean = (board) => [...board].sort((a, b) => a.score < b.score);

// 3а. Новый результат ставят в начало списка и сортируют только по очкам.
export const insertFront = (board, entry) => [entry, ...board].sort((a, b) => b.score - a.score).slice(0, SIZE);

// 3б. Ничью решают по имени — порядок зависит от алфавита, а не от игры.
export const insertByName = (board, entry) =>
  [...board, entry].sort((a, b) => b.score - a.score || a.name.localeCompare(b.name, "ru")).slice(0, SIZE);

// 3в. Только очки: при ничьей порядок такой, в каком строки пришли из хранилища.
export const sortScoreOnly = (rows) => [...rows].sort((a, b) => b.score - a.score);

// 4а. «Не хуже последнего — заменяем последнего».
export function insertReplaceLast(board, entry) {
  const next = [...board];
  if (next.length < SIZE) next.push(entry);
  else if (entry.score >= next[SIZE - 1].score) next[SIZE - 1] = entry;
  return next.sort((a, b) => b.score - a.score || a.seq - b.seq);
}

// 4б. Обрезка до сортировки.
export const insertCutFirst = (board, entry) =>
  [entry, ...board].slice(0, SIZE).sort((a, b) => b.score - a.score || a.seq - b.seq);
```

Модуль `game.mjs` описывает правила раунда и пересчитывает счёт по ленте поимок. Лента здесь — список событий «поймал комету в момент t», а не запись нажатий клавиш; как записывать и проигрывать полный ввод, разобрано отдельно (ссылка ниже).

```js
// game.mjs — наш пример: правила раунда «Ловца комет» и пересчёт счёта по ленте поимок.
export const RULES = {
  roundTicks: 600,  // раунд 60 с, время в десятых долях секунды
  minGap: 5,        // между двумя поимками не меньше 0,5 с (сачок перезаряжается)
  bigEvery: 50,     // большая комета появляется раз в 5 с: t кратно 50
  points: { small: 100, big: 500 },
};

// Пересчёт: лента — массив поимок { t, kind }. Возвращает счёт или причину отказа.
export function recompute(log, rules = RULES) {
  let score = 0, last = -Infinity;
  for (const c of log) {
    if (!Number.isInteger(c.t) || c.t < 0 || c.t >= rules.roundTicks) return { ok: false, why: "поимка вне раунда, t=" + c.t };
    if (c.t - last < rules.minGap) return { ok: false, why: "две поимки ближе 0,5 с, t=" + c.t };
    if (!(c.kind in rules.points)) return { ok: false, why: "неизвестная комета" };
    if (c.kind === "big" && c.t % rules.bigEvery !== 0) return { ok: false, why: "большой кометы в t=" + c.t + " не было" };
    score += rules.points[c.kind];
    last = c.t;
  }
  return { ok: true, score };
}

// Самая выгодная лента, которую допускают правила: поимка каждые 0,5 с, большая — когда можно.
export function bestPossibleLog(rules = RULES) {
  const log = [];
  for (let t = 0; t < rules.roundTicks; t += rules.minGap)
    log.push({ t, kind: t % rules.bigEvery === 0 ? "big" : "small" });
  return log;
}

// Лента честной игры Гриши: 56 поимок раз в секунду, 3 из них — большие кометы.
export function grishaLog() {
  const log = [];
  for (let i = 0; i < 56; i++) log.push({ t: 10 * i, kind: [5, 10, 15].includes(i) ? "big" : "small" });
  return log;
}
```

Модуль `server.mjs` — три сервера общей таблицы. Сортируют они одинаково и правильно, через тот же `insert`; разница только в том, чему они верят.

```js
// server.mjs — наш пример: три сервера общей таблицы; все сортируют правильно, разница — чему они верят.
import { createHmac } from "node:crypto";
import { insert, compareEntries, SIZE } from "./board.mjs";
import { recompute } from "./game.mjs";

function makeBoard(initial) {
  let board = [...initial].sort(compareEntries), seq = Math.max(...initial.map((e) => e.seq));
  return {
    get rows() { return board; },
    add(name, score, clientSeq) {
      const r = insert(board, { name, score, seq: clientSeq ?? ++seq });
      board = r.board;
      return r.place;
    },
  };
}

// А. Верит числу. Если клиент прислал «время результата», верит и ему.
export function trustingServer(initial) {
  const b = makeBoard(initial);
  return { board: b, submit: (p) => ({ ok: true, place: b.add(p.name, p.score, p.at) }) };
}

// Б. Проверяет подпись HMAC. Ключ тот же, что зашит в клиентский бандл, — иначе клиент не смог бы подписать.
export const CLIENT_BUNDLE = 'const API = "/api/score";\nconst SECRET = "kometa-7f3a91";\n' +
  'function sign(p) { return hmacHex(SECRET, p.name + "|" + p.score); }\n';
const SECRET = "kometa-7f3a91";
export const hmac = (key, p) => createHmac("sha256", key).update(p.name + "|" + p.score).digest("hex");

export function signingServer(initial) {
  const b = makeBoard(initial);
  return {
    board: b,
    submit(p) {
      if (p.sig !== hmac(SECRET, p)) return { ok: false, why: "подпись не сходится" };
      return { ok: true, place: b.add(p.name, p.score) };
    },
  };
}

// В. Не верит числу: пересчитывает счёт по ленте поимок и сверяет с заявленным.
export function recomputingServer(initial) {
  const b = makeBoard(initial);
  return {
    board: b,
    submit(p) {
      const r = recompute(p.log);
      if (!r.ok) return { ok: false, why: r.why };
      if (r.score !== p.score) return { ok: false, why: "пересчёт " + r.score + ", заявлено " + p.score };
      return { ok: true, place: b.add(p.name, r.score) };
    },
  };
}
export { SIZE };
```

Проверочный файл `test.mjs` прогоняет восемь сцен на одной стартовой таблице. Случайности и часов в коде нет, поэтому вывод одинаков при каждом запуске.

```js
// test.mjs — наш пример: ловушки таблицы рекордов и подделка счёта, Node.js 24.
import { SIZE, compareEntries, insert, load, show } from "./board.mjs";
import * as naive from "./naive.mjs";
import { RULES, recompute, bestPossibleLog, grishaLog } from "./game.mjs";
import { trustingServer, signingServer, recomputingServer, CLIENT_BUNDLE, hmac } from "./server.mjs";

// Таблица в порядке установления результатов: seq 1 — самый ранний.
const START = [["Оля", 12000], ["Миша", 9500], ["Дина", 10400], ["Тимур", 7400],
  ["Вера", 9500], ["Костя", 5000], ["Аня", 6200], ["Борис", 5000]]
  .map(([name, score], i) => ({ name, score, seq: i + 1 }));
const BOARD = [...START].sort(compareEntries);
const names = (board) => board.map((e) => e.name).join(", ");

console.log("Таблица на " + SIZE + " мест, правильный порядок:");
console.log("   " + show(BOARD));

console.log("");
console.log("1. sort() без компаратора");
console.log("   " + naive.sortDefault(START.map((e) => e.score)).join(", "));

console.log("");
console.log("2. Компаратор возвращает true/false");
console.log("   на входе в порядке установления: " + show(naive.sortBoolean(START)));
const withNew = [...BOARD, { name: "Лиза", score: 11000, seq: 9 }];
const cut = naive.sortBoolean(withNew).slice(0, SIZE);
console.log("   Лиза 11000 дописана в конец: " + show(cut));
console.log("   Лиза в таблице: " + cut.some((e) => e.name === "Лиза") + "; правильно: место " + insert(BOARD, withNew[SIZE]).place);

console.log("");
console.log("3. Ничьи");
const alisa = { name: "Алиса", score: 9500, seq: 9 };
const front = naive.insertFront(BOARD, alisa);
console.log("   а) новый в начало, только очки:  " + names(front.filter((e) => e.score === 9500)) +
  "; Алиса на месте " + (front.indexOf(alisa) + 1));
console.log("   б) новый в конец, только очки:   " + names(naive.sortScoreOnly([...BOARD, alisa]).filter((e) => e.score === 9500)));
console.log("   в) ничья по имени:               " + names(naive.insertByName(BOARD, alisa).filter((e) => e.score === 9500)));
console.log("   правильно (раньше — выше):       " + names(insert(BOARD, alisa).board.filter((e) => e.score === 9500)) +
  "; Алиса на месте " + insert(BOARD, alisa).place);
const orders = new Set(), ordersFixed = new Set();
for (let k = 0; k < START.length; k++) {
  const rows = [...START.slice(k), ...START.slice(0, k)];
  orders.add(names(naive.sortScoreOnly(rows)));
  ordersFixed.add(names([...rows].sort(compareEntries)));
}
console.log("   г) те же 8 строк, 8 порядков чтения; разных таблиц: только очки — " + orders.size +
  ", очки + seq — " + ordersFixed.size);
const reread = naive.sortScoreOnly([...BOARD].reverse());
console.log("   таблица, прочитанная в обратном порядке: " + names(reread.filter((e) => e.score === 9500 || e.score === 5000)));

console.log("");
console.log("4. Обрезка до " + SIZE + " мест");
const placeText = (p) => (p === null ? "не попал(а)" : "место " + p);
const zhenya = { name: "Женя", score: 5000, seq: 9 }, lyova = { name: "Лёва", score: 100, seq: 9 };
console.log("   а) Женя 5000, «не хуже последнего — заменить»: " + names(naive.insertReplaceLast(BOARD, zhenya).slice(-2)) +
  "; правильно: " + names(insert(BOARD, zhenya).board.slice(-2)) + ", Женя: " + placeText(insert(BOARD, zhenya).place));
console.log("   б) Лёва 100, обрезка до сортировки: " + names(naive.insertCutFirst(BOARD, lyova).slice(-2)) +
  "; правильно: Лёва " + placeText(insert(BOARD, lyova).place));

console.log("");
console.log("5. Сервер верит числу");
const s5 = trustingServer(START);
console.log("   Хакер 999999: место " + s5.submit({ name: "Хакер", score: 999999 }).place);
const s5b = trustingServer(START);
console.log("   Ловкач 12000 и «время результата» 0: место " + s5b.submit({ name: "Ловкач", score: 12000, at: 0 }).place +
  ", Оля теперь на месте " + (s5b.board.rows.findIndex((e) => e.name === "Оля") + 1));

console.log("");
console.log("6. Подпись HMAC с ключом из клиентского JS");
const s6 = signingServer(START);
const honest = { name: "Гриша", score: 6800 };
honest.sig = hmac("kometa-7f3a91", honest);
console.log("   без подписи: " + s6.submit({ name: "Хакер", score: 999999, sig: "" }).why);
const key = CLIENT_BUNDLE.match(/SECRET = "([^"]+)"/)[1];
const forged = { name: "Хакер", score: 999999 };
forged.sig = hmac(key, forged);
console.log("   ключ из бандла: " + key + " (" + key.length + " символов); подделка: место " + s6.submit(forged).place);
const s6b = signingServer(START);
for (let i = 0; i < 3; i++) s6b.submit(honest);
console.log("   один честный пакет Гриши 6800 отправлен 3 раза: строк Гриши " +
  s6b.board.rows.filter((e) => e.name === "Гриша").length + ", выбыли: " +
  names(BOARD.filter((e) => !s6b.board.rows.includes(e))));

console.log("");
console.log("7. Правка локальной таблицы");
const storage = new Map([["comets.board.v1", JSON.stringify(BOARD)]]);
const edited = JSON.parse(storage.get("comets.board.v1"));
edited.find((r) => r.name === "Борис").score = 999999;
storage.set("comets.board.v1", JSON.stringify(edited));
const local = load(storage.get("comets.board.v1"));
console.log("   Борис после правки: место " + (local.findIndex((e) => e.name === "Борис") + 1) + ", счёт " + local[0].score);
const ceiling = recompute(bestPossibleLog()).score;
edited.find((r) => r.name === "Борис").score = ceiling - 800;
const capped = load(JSON.stringify(edited)).filter((e) => e.score <= ceiling);
console.log("   фильтр «не больше потолка " + ceiling + "»: Борис с " + (ceiling - 800) + " — место " +
  (capped.findIndex((e) => e.name === "Борис") + 1));

console.log("");
console.log("8. Сервер пересчитывает счёт по ленте поимок");
const s8 = recomputingServer(START);
const tLog = grishaLog();
console.log("   правила: раунд " + RULES.roundTicks / 10 + " с, поимки не чаще раза в 0,5 с, большая комета раз в " +
  RULES.bigEvery / 10 + " с; потолок " + ceiling + " за " + bestPossibleLog().length + " поимок");
console.log("   Гриша, " + tLog.length + " поимок, заявлено 6800: " + JSON.stringify(s8.submit({ name: "Гриша", score: 6800, log: tLog })));
console.log("   Хакер, лента Гриши, заявлено 999999: " + s8.submit({ name: "Хакер", score: 999999, log: tLog }).why);
console.log("   Хакер, чужая лента Гриши, заявлено 6800: " + JSON.stringify(s8.submit({ name: "Хакер", score: 6800, log: tLog })));
const spam = Array.from({ length: 2000 }, (_, i) => ({ t: i, kind: "big" }));
console.log("   Хакер, 2000 больших комет подряд: " + s8.submit({ name: "Хакер", score: 1000000, log: spam }).why);
const fakeBig = [{ t: 0, kind: "big" }, { t: 7, kind: "big" }];
console.log("   Хакер, большая комета не по расписанию: " + s8.submit({ name: "Хакер", score: 1000, log: fakeBig }).why);
console.log("   Бот, идеальная лента по правилам: " + JSON.stringify(s8.submit({ name: "Бот", score: ceiling, log: bestPossibleLog() })));
console.log("   итог: " + show(s8.board.rows.slice(0, 3)));
```

**Вывод прогона** (Node.js 24.22.1, `node test.mjs`):

```text
Таблица на 8 мест, правильный порядок:
   1.Оля 12000  2.Дина 10400  3.Миша 9500  4.Вера 9500  5.Тимур 7400  6.Аня 6200  7.Костя 5000  8.Борис 5000

1. sort() без компаратора
   9500, 9500, 7400, 6200, 5000, 5000, 12000, 10400

2. Компаратор возвращает true/false
   на входе в порядке установления: 1.Оля 12000  2.Миша 9500  3.Дина 10400  4.Тимур 7400  5.Вера 9500  6.Костя 5000  7.Аня 6200  8.Борис 5000
   Лиза 11000 дописана в конец: 1.Оля 12000  2.Дина 10400  3.Миша 9500  4.Вера 9500  5.Тимур 7400  6.Аня 6200  7.Костя 5000  8.Борис 5000
   Лиза в таблице: false; правильно: место 2

3. Ничьи
   а) новый в начало, только очки:  Алиса, Миша, Вера; Алиса на месте 3
   б) новый в конец, только очки:   Миша, Вера, Алиса
   в) ничья по имени:               Алиса, Вера, Миша
   правильно (раньше — выше):       Миша, Вера, Алиса; Алиса на месте 5
   г) те же 8 строк, 8 порядков чтения; разных таблиц: только очки — 3, очки + seq — 1
   таблица, прочитанная в обратном порядке: Вера, Миша, Борис, Костя

4. Обрезка до 8 мест
   а) Женя 5000, «не хуже последнего — заменить»: Костя, Женя; правильно: Костя, Борис, Женя: не попал(а)
   б) Лёва 100, обрезка до сортировки: Костя, Лёва; правильно: Лёва не попал(а)

5. Сервер верит числу
   Хакер 999999: место 1
   Ловкач 12000 и «время результата» 0: место 1, Оля теперь на месте 2

6. Подпись HMAC с ключом из клиентского JS
   без подписи: подпись не сходится
   ключ из бандла: kometa-7f3a91 (13 символов); подделка: место 1
   один честный пакет Гриши 6800 отправлен 3 раза: строк Гриши 3, выбыли: Аня, Костя, Борис

7. Правка локальной таблицы
   Борис после правки: место 1, счёт 999999
   фильтр «не больше потолка 16800»: Борис с 16000 — место 1

8. Сервер пересчитывает счёт по ленте поимок
   правила: раунд 60 с, поимки не чаще раза в 0,5 с, большая комета раз в 5 с; потолок 16800 за 120 поимок
   Гриша, 56 поимок, заявлено 6800: {"ok":true,"place":6}
   Хакер, лента Гриши, заявлено 999999: пересчёт 6800, заявлено 999999
   Хакер, чужая лента Гриши, заявлено 6800: {"ok":true,"place":7}
   Хакер, 2000 больших комет подряд: две поимки ближе 0,5 с, t=1
   Хакер, большая комета не по расписанию: большой кометы в t=7 не было
   Бот, идеальная лента по правилам: {"ok":true,"place":1}
   итог: 1.Бот 16800  2.Оля 12000  3.Дина 10400
```

## Что показал прогон: семь ловушек

Прогон подтвердил семь ловушек: четыре ломают порядок в самой таблице, три пропускают в неё результат, которого не было в игре. Каждая ниже описана по выводу, номера совпадают со сценами.

### Ловушка 1: sort() без компаратора сравнивает строки

`sort()` без функции сравнения упорядочивает элементы как строки, даже если в массиве числа. Сцена 1: счёт 12000, 9500, 10400, 7400, 9500, 5000, 6200, 5000 после `sort().reverse()` встал так: 9500, 9500, 7400, 6200, 5000, 5000, 12000, 10400. Лучший результат Оли оказался на 7-м месте, второй результат Дины — на 8-м: строка «12000» начинается с «1», а «1» в таблице символов стоит раньше «5», «6», «7» и «9».

Это поведение описано в документации MDN: без компаратора элементы приводятся к строкам и сравниваются по кодовым единицам UTF-16, поэтому «80» встаёт раньше «9». На данных одной длины — 9500, 7400, 6200 — таблица выглядит правильной, и ошибка всплывает, когда кто-то впервые набирает пятизначный счёт.

### Ловушка 2: компаратор true/false не сортирует

Компаратор, который возвращает `true` или `false`, в Node.js 24 не отсортировал таблицу вообще. Сцена 2: `(a, b) => a.score < b.score` вернул массив в исходном порядке установления — Миша с 9500 остался на 2-м месте выше Дины с 10 400. Хуже второй строки сцены: Лиза с 11 000 очков, дописанная в конец уже отсортированной таблицы, после такой «сортировки» осталась последней девятой строкой и была отрезана — в таблицу она не попала, хотя по правильной вставке её место 2-е.

Причина — договор функции сравнения: по MDN она должна возвращать отрицательное число, ноль или положительное, а `true` и `false` превращаются в 1 и 0, и для пары «a меньше b» компаратор говорит «равны». Подробно этот договор и то, что разные движки ведут себя с таким компаратором по-разному, мы разбирали в статье о [слоях отрисовки и сортировке по Y](/blog/sloi-otrisovki-i-poryadok-glubiny-z-order-i-sortirovka-po-y-v-2d); здесь важнее следствие для таблицы: ошибка выглядит как «рекорд не сохранился», а не как «сортировка сломана».

Чего прогон не подтвердил: мы ожидали перемешанный, но частично отсортированный порядок, а V8 в Node.js 24.22.1 на 8 и 9 элементах не переставил ничего. Поведение других движков мы не запускали; MDN приводит пример похожего компаратора, который V8 не сортирует, а SpiderMonkey сортирует.

### Ловушка 3: ничья решается не тем ключом

Ничья отнимает место у старого игрока, если её решает что угодно, кроме порядка установления результата. Сцена 3 добавляет Алису с 9500 очками — столько же, сколько у Миши и Веры, но позже обоих.

- **Новый результат ставят в начало и сортируют только по очкам (а).** Алиса встала на 3-е место выше Миши и Веры. Сортировка в Node.js стабильна, то есть равные элементы сохраняют порядок, в каком пришли, — а пришли они с Алисой первой.
- **Новый результат дописывают в конец (б).** Здесь та же сортировка только по очкам дала правильный порядок: Миша, Вера, Алиса. Гипотеза «сортировка только по очкам всегда ломает ничьи» не подтвердилась: при вставке в конец её спасает стабильность.
- **Ничью решают по имени (в).** Алиса встала первой среди трёх, а Вера обогнала Мишу: «В» в алфавите раньше «М». Порядок теперь зависит от букв, а не от игры, и Миша теряет место, ничего не сделав.
- **Строки читают в другом порядке (г).** Те же 8 строк, прочитанные с восьми разных позиций, при сортировке только по очкам дали 3 разные таблицы; с вторичным ключом `seq` — одну. Таблица, прочитанная в обратном порядке, поставила Веру выше Миши и Бориса выше Кости.

Последний пункт — главный: стабильная сортировка сохраняет порядок массива, но не знает, откуда этот порядок взялся. Строки, которые пришли из базы данных без явной сортировки, из объекта, собранного по ключам, или из списка «последние игры», где новые сверху, перевернут ничьи без единой ошибки в коде сортировки. Поэтому правило «новый ниже старого» должно жить в функции сравнения как второй ключ, а не в том, куда вы вставили строку.

### Ловушка 4: обрезка выбрасывает не ту строку

Обрезка до N мест выбрасывает не ту строку, если её делают до сортировки или заменой последнего. Сцена 4 проверяет два варианта на границе 8-го места, где Костя и Борис делят 5000 очков.

- **«Не хуже последнего — заменить последнего» (а).** Женя с 5000 очков заменил Бориса, хотя у Бориса те же 5000 и он набрал их раньше. Правильная вставка оставляет Костю и Бориса, а Женя в таблицу не попадает: сравнение `>=` на границе — та же ничья, только решённая в пользу нового.
- **Обрезка до сортировки (б).** Лёва с 100 очками попал на 8-е место, а Борис с 5000 выбыл: новую строку поставили в начало, отрезали девятую — ею оказался Борис — и только потом отсортировали. Правильная вставка Лёву в таблицу не пускает.

Оба варианта появляются из желания «не сортировать лишний раз» — ради экономии на девяти строках.

### Ловушка 5: сервер верит числу

Сервер, который принимает число счёта, ставит в таблицу любое число. Сцена 5: запрос с полем `score: 999999` занял 1-е место — при потолке по правилам игры 16 800. Сортировка на сервере та же, что в `board.mjs`, и она работает правильно: 999 999 больше 12 000, значит, первое место.

Вторая строка сцены показывает то же для ничьей. Сервер, который берёт «время результата» из запроса, поставил Ловкача с 12 000 и `at: 0` на 1-е место, а Олю, которая набрала 12 000 первой, сдвинул на 2-е. Номер установления, присланный клиентом, — такое же число, как счёт: если его можно отправить, его можно отправить любым.

### Ловушка 6: подпись с ключом в клиентском коде

Подпись HMAC не защищает счёт, если ключ подписи лежит в коде клиента. Сцена 6: сервер честно отклонил пакет без подписи («подпись не сходится»), но ключ из 13 символов достался одной регулярной строкой из текста клиентского бандла, и подделка 999 999 с правильной подписью заняла 1-е место.

Это не взлом в обычном смысле: клиент обязан подписать пакет, значит, ключ у него есть, а всё, что есть у браузерной игры, есть и у игрока. Разбить ключ на части или сжать код — лишь добавить шагов до той же строки. Подпись HMAC отвечает на вопрос «не изменился ли пакет по дороге», когда ключ знают только стороны, которым вы доверяете; браузер игрока к ним не относится.

Третья строка сцены — отдельная дыра, которую подпись тоже не закрывает: один честный пакет Гриши на 6800 очков, отправленный 3 раза, занял 3 строки, и из таблицы выбыли Аня, Костя и Борис. Повтор пакета закрывают одноразовым номером партии, который выдаёт сервер, но и это не делает число правдой.

### Ловушка 7: правка локальной таблицы

Локальная таблица меняется без игры, и правильная загрузка этого не замечает. Сцена 7: мы прочитали строку JSON из хранилища, поменяли Борису 5000 на 999 999 и записали обратно — так выглядит правка записи вручную. Функция `load` привела числа к числам, отсортировала их по двум ключам, и Борис оказался на 1-м месте со счётом 999 999.

Проверка «не больше потолка по правилам» отсекает невозможное, но не правдоподобное: Борис с 16 000 очков (потолок 16 800 минус 800) прошёл фильтр и снова встал на 1-е место. Для таблицы на одном устройстве это не беда — игрок обманывает себя. Для общей таблицы это значит, что локальную строку нельзя отправлять на сервер как результат.

## Правило порядка: два ключа и одна вставка

Рабочая таблица держится на функции сравнения с двумя ключами и вставке, которая сначала сортирует, потом обрезает. Этот рецепт можно перенести в любую игру, поменяв только поля:

```text
сравнение(a, b):
  1) счёт:          больше — выше            → b.score − a.score
  2) установление:  раньше — выше            → a.seq − b.seq
  возвращает число: < 0 — a выше, > 0 — b выше, 0 — только для одной и той же строки

вставка(таблица, новая, N):
  все = таблица + новая
  отсортировать все по сравнению
  место = позиция новой + 1
  таблица = первые N строк;  место > N → «не попал»

seq выдаёт тот, кто ведёт таблицу: сервер при приёме или локальный счётчик, не клиент
```

Несколько уточнений, которые выдержал прогон:

1. **Компаратор возвращает число.** Вычитание `b.score - a.score` подходит для целых очков; для ключа-строки нужен `localeCompare`, а не `>`.
2. **Второй ключ не повторяется.** `seq` у двух строк не совпадает никогда, поэтому функция сравнения возвращает 0 только для строки с самой собой и порядок не зависит от входа (сцена 3г: одна таблица из восьми порядков чтения).
3. **Счёт проверяется на входе.** `insert` отказывается от нецелого или отрицательного счёта, а `load` отбрасывает строки, где счёт не превратился в целое число.
4. **Место считается после обрезки.** Позиция новой строки в отсортированном списке длиной N + 1 — это и есть её место; если оно больше N, строка не попала, и это видно сразу, без отдельного сравнения с последним.
5. **Время — не ключ, а подпись.** Дату результата можно показать в таблице, но сравнивать по ней опасно: часы устройства переводят, а время с клиента подделывается (сцена 5).

Если в вашей игре ничью решает что-то третье — например, меньшее время прохождения при равных очках, — это третий ключ между счётом и `seq`, а не замена `seq`. Последним ключом всегда остаётся неповторяющийся номер.

## Почему счёт с клиента — заявка, а не результат

Счёт, который прислал браузер, — это утверждение игрока о своём результате, а не результат: всё, что считает клиент, игрок может посчитать иначе. Сцены 5–7 показывают три разные точки, где число меняется без игры, — запрос, подпись и хранилище — и в каждой правильная сортировка ставит подделку на 1-е место.

Правило границы простое: всё, что выполняется в браузере игрока, — код, ключи, запросы, локальное хранилище — принадлежит игроку, а сервер может доверять только тому, что посчитал или проверил сам. Для таблицы на одном устройстве граница не нужна: игрок, который правит свою строку, соревнуется с собой. Для общей таблицы вопрос «как защитить число на клиенте» не имеет ответа — защищать нужно приём.

| Что прислал клиент | Что может проверить сервер | Что остаётся открытым |
|---|---|---|
| Только число счёта | формат и потолок по правилам | любое число до потолка |
| Число и подпись с ключом из клиента | что пакет подписан этим ключом | ключ известен игроку — то же, что выше |
| Число и ленту событий раунда | пересчёт по правилам: интервалы, расписание, сумма | лента, сыгранная ботом или собранная вручную в пределах правил |
| Ленту ввода и зерно, повтор на сервере | всю партию той же симуляцией | бот, который играет идеально, и стоимость проверки |

Последняя строка таблицы — тема статьи о [повторе прохождения](/blog/povtor-prohozhdeniya-replay-zapis-vvoda-i-determinirovannaya-simulyaciya): если симуляция игры детерминирована, сервер может проиграть ленту ввода сам и получить счёт, не спрашивая клиента. Как сделать симуляцию повторяемой, разобрано там, здесь мы этого не пересказываем.

## Что сервер может проверить и чего не может

Сервер с пересчётом отсекает невозможные результаты, но не идеальную подделку в пределах правил. Сцена 8 показывает обе стороны на сервере, который получает ленту поимок и сам считает по ней счёт.

**Что отсеялось.** Честная лента Гриши — 56 поимок, 3 из них большие кометы — дала ровно заявленные 6800 и встала на 6-е место. Та же лента с заявкой 999 999 отклонена с причиной «пересчёт 6800, заявлено 999999». Лента из 2000 больших комет подряд отклонена на второй же поимке: «две поимки ближе 0,5 с, t=1». Лента с большой кометой в t=7 отклонена: по расписанию большие кометы бывают только в моменты, кратные 5 с.

**Что прошло.** Идеальная лента по правилам — 120 поимок каждые 0,5 с, большая комета каждый раз, когда она есть, — дала 16 800 и заняла 1-е место. Пересчёт не знает, играл ли её человек: правила она не нарушает. И лента Гриши, отправленная под именем Хакера с заявкой 6800, принята и встала на 7-е место — ниже Гриши, потому что пришла позже, — хотя Хакер в этот раунд не играл.

Из этого следуют три вывода для своей игры:

1. **Лента событий нужна, но её мало.** Она ограничивает подделку тем, что допускают правила, и превращает «999 999» в «не больше 16 800». Чем строже правила раунда (интервалы, расписание появления, физические пределы), тем уже окно для подделки.
2. **Лента должна быть привязана к партии.** Чужая лента прошла, потому что сервер не знал, кому и когда выдал этот раунд. Обычно раунд начинается с запроса к серверу, который выдаёт номер партии и, если в игре есть случайность, зерно; лента без такого номера или с чужим номером не принимается. Если расписание появления комет случайное, сервер может проверить его, только зная зерно, — как устроена случайность с зерном и почему она не обязана быть нечестной, разобрано в статье о [случайности без несправедливости](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor).
3. **Идеальная игра в пределах правил остаётся открытой.** Отличить сильного игрока от программы, которая ловит каждую комету, пересчёт не может. Это уже не задача таблицы рекордов, а задача отдельной защиты от ботов, и в этой статье мы её не разворачиваем.

Общую таблицу, где играют люди одновременно и в реальном времени, проверяет сервер, который сам ведёт состояние игры; устройство такого сервера — отдельная большая тема.

## Практический сценарий: общая таблица «Ловца комет»

Таблица рекордов сортируется по очкам и порядку установления, ничья достаётся тому, кто был раньше, а счёт на клиенте можно подделать, потому что всё в браузере принадлежит игроку, — поэтому общая таблица «Ловца комет» принимает не число, а ленту раунда и пересчитывает её сама. Ниже — порядок перехода от локальной таблицы к общей на 8 мест.

1. **Зафиксировать правило порядка.** Компаратор `compareEntries`: очки по убыванию, `seq` по возрастанию. Прогнать сцену 3г: из восьми порядков чтения должна получиться одна таблица.
2. **Заменить вставку.** Одна функция `insert`: всё вместе, сортировка, обрезка, место. Вызывает её экран итога раунда, который получает счёт параметром при переходе, как в статье о [сценах и переходах](/blog/sceny-i-perehody-na-javascript-menyu-uroven-pobeda). Прогнать сцену 4: Женя с 5000 и Лёва с 100 не попадают, Костя и Борис остаются.
3. **Локальную таблицу оставить локальной.** Она показывает игроку его лучшие раунды на этом устройстве и не отправляется на сервер как результат: сцена 7 показывает, что её строка меняется без игры.
4. **Выписать правила раунда как проверки.** Длительность 60 с, интервал поимок 0,5 с, большие кометы только по расписанию, очки 100 и 500. Посчитать потолок кодом, а не в уме: 16 800 за 120 поимок.
5. **Принимать ленту, а не число.** Сервер получает список поимок, пересчитывает его функцией `recompute` и сравнивает с заявкой; при расхождении — отказ с причиной в журнале. `seq` выдаёт сервер при приёме.
6. **Привязать ленту к партии.** Номер партии выдаётся при старте раунда и принимается один раз — это закрывает и повтор пакета из сцены 6, и чужую ленту из сцены 8.
7. **Проверить отказами.** 999 999 с честной лентой, 2000 поимок подряд, комета не по расписанию — все три должны быть отклонены с понятной причиной, как в сцене 8.

Проверяемый итог: в общей таблице нет результатов выше 16 800, ничьи решены в пользу того, кто раньше по номеру сервера, а одна лента даёт одну строку. Открытым остаётся идеальная игра бота в пределах правил — и это записано, а не скрыто за подписью.

## Когда вам это не подойдёт

Пересчёт на сервере и строгий порядок нужны, когда таблицу видят другие люди и место в ней что-то значит; вот где они лишние или их мало:

- **Таблица на одном устройстве.** Если рекорды видит только сам игрок, хватит правильной сортировки и вставки из `board.mjs`; сервер и лента ничего не добавят — подделывать там не для кого.
- **Таблица для класса или кружка.** Если результаты собирает учитель или ведущий и все сидят в одной комнате, проверка глазами дешевле серверной логики.
- **Игра без чёткого потолка.** Если счёт зависит от физики со множеством объектов и правила нельзя выписать как короткий список проверок, пересчёт по ленте событий превращается в повтор всей симуляции на сервере — это другой объём работы; как сделать симуляцию повторяемой, разобрано в статье о повторе.
- **Таблица с призами.** Если за место дают деньги или ценные награды, пересчёта ленты мало: остаются боты, сговор и кражи аккаунтов, и нужна отдельная защита, которую мы здесь не разбираем.
- **Сетевая игра в реальном времени.** Если игроки играют одновременно и видят друг друга, результат появляется на сервере сам, а не приходит заявкой; таблица там — просто запрос к данным сервера.
- **Большие таблицы.** Если в таблице тысячи игроков и место показывают каждому, массив в памяти и полная сортировка на каждую вставку — не тот инструмент: такую таблицу держат в базе данных с индексом по счёту и номеру. Правило порядка из двух ключей при этом остаётся тем же.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=tablica-rekordov-sortirovka-nichi-i-pochemu-schet-na-kliente-mozhno-poddelat) (подача заявки не гарантирует приглашение).

**Источники (проверено: ноябрь 2026, 11.11.2026):** [MDN — Array.prototype.sort()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) (без функции сравнения элементы приводятся к строкам и сравниваются по кодовым единицам UTF-16, поэтому «80» встаёт раньше «9»; функция сравнения должна возвращать отрицательное число, положительное или ноль; сортировка стабильна со стандарта ECMAScript 2019; компаратор, нарушающий антисимметрию, даёт разный результат в V8 и SpiderMonkey); [V8 — Stable Array.prototype.sort](https://v8.dev/features/stable-sort) (пост от 2 июля 2019 года: стабильность `Array#sort` закреплена в спецификации ES2019, в Chrome — с версии 70, в Node.js — с версии 12). Игра «Ловец комет», её правила, таблица на 8 мест, имена игроков, серверы, ключ подписи, функции `compareEntries`, `insert`, `load`, `recompute` и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.

**Читайте также:**
- [Очки, множители серии и рекорды в 2D-игре: как считать награду, чтобы хотелось переиграть](/blog/ochki-mnozhiteli-serii-i-rekordy-kak-schitat-nagradu)
- [Сохранения в браузерной игре: localStorage или IndexedDB, версии формата и защита от потери прогресса](/blog/sohraneniya-v-brauzernoj-igre-localstorage-indexeddb)
- [Повтор прохождения (replay): запись ввода и детерминированная симуляция](/blog/povtor-prohozhdeniya-replay-zapis-vvoda-i-determinirovannaya-simulyaciya)
- [Слои отрисовки и порядок глубины: Z-order и сортировка по Y в 2D](/blog/sloi-otrisovki-i-poryadok-glubiny-z-order-i-sortirovka-po-y-v-2d)
- [Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor)
- [Сцены и переходы на JavaScript: меню, уровень, пауза, экран победы и передача счёта](/blog/sceny-i-perehody-na-javascript-menyu-uroven-pobeda)
