Кто прав, если оба правы: последняя запись, слияние по полям и часы

Здесь будет встроен видео-разбор темы (5–7 минут, YouTube / RuTube / VK Видео) — тем, кто лучше воспринимает на слух, текст ниже не обязателен.

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

Сравним два способа возить изменения. Первый — наш: операция несёт только изменённые поля, и обе стороны накладывают её на строку («Журнал: имена и номера рождаются на телефоне»). Второй — самый распространённый в обычных API: устройство шлёт строку целиком с отметкой времени, а сервер оставляет ту, что свежее. Это и есть «последняя запись побеждает», last write wins. Прогноз: что окажется у сервера в каждом случае?

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  journal: Journal;
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

// в зале без сети правят повторы, дома в тот же вечер — вес: поля разные
phone.journal.change(set, { reps: 8 });
web.journal.change(set, { weightKg: 85 });
phone.sync();
web.sync();
console.log("операциями по полям:", JSON.stringify(server.rows.get(set)));

// «последняя запись побеждает»: устройство шлёт строку целиком, свежая вытесняет прежнюю
type Snapshot = { row: Row; at: number };
function lastWrite(state: Snapshot | undefined, next: Snapshot): Snapshot {
  return state && state.at > next.at ? state : next;
}
let state: Snapshot | undefined;
for (const snapshot of [
  { row: { id: set, exercise: "жим", weightKg: 80, reps: 8 }, at: 5 },
  { row: { id: set, exercise: "жим", weightKg: 85, reps: 5 }, at: 6 },
]) {
  state = lastWrite(state, snapshot);
}
console.log("последней записью строкой:", JSON.stringify(state!.row));

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  journal: Journal;
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

// в зале без сети правят повторы, дома в тот же вечер — вес: поля разные
phone.journal.change(set, { reps: 8 });
web.journal.change(set, { weightKg: 85 });
phone.sync();
web.sync();
console.log("операциями по полям:", JSON.stringify(server.rows.get(set)));

// «последняя запись побеждает»: устройство шлёт строку целиком, свежая вытесняет прежнюю
type Snapshot = { row: Row; at: number };
function lastWrite(state: Snapshot | undefined, next: Snapshot): Snapshot {
  return state && state.at > next.at ? state : next;
}
let state: Snapshot | undefined;
for (const snapshot of [
  { row: { id: set, exercise: "жим", weightKg: 80, reps: 8 }, at: 5 },
  { row: { id: set, exercise: "жим", weightKg: 85, reps: 5 }, at: 6 },
]) {
  state = lastWrite(state, snapshot);
}
console.log("последней записью строкой:", JSON.stringify(state!.row));

экран примера

Сначала предположите, что выведет код

Операциями по полям сохранились обе правки: вес 85 с веб-версии и повторы 8 с телефона. Последняя запись строкой оставила строку веб-версии целиком — и вместе с ней вернула прежние повторы 5. Правка, сделанная в зале, исчезла без единого сообщения, причём проиграла она не другой правке того же поля, а просто оказалась внутри строки, которая приехала чуть раньше.

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

«Последняя запись побеждает» — это не правило разрешения конфликтов, а отказ его иметь. Конфликта в нём нет по определению: побеждает не правка, а строка, и вопрос «что человек на самом деле менял» просто не задаётся.

Пока поля разные, слияние по полям выглядит всемогущим. Посмотрим на случай, где оно бессильно: оба поправили одно и то же поле. В зале человек дожал десятый повтор и записал это, а дома вспомнил, что повторов было одиннадцать, и поправил в веб-версии.

Одно из двух значений проиграет — это неизбежно, и само по себе не беда. Беда в другом, и прогноз про неё: что покажет телефон, что покажет веб-версия и что окажется у сервера после того, как оба синхронизируются дважды?

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

// оба правят ОДНО поле: в зале дожали до десяти, дома вспомнили, что было одиннадцать
phone.journal.change(set, { reps: 10 });
web.journal.change(set, { reps: 11 });
phone.sync();
web.sync();
phone.sync();
web.sync();

const reps = (client: Client) => String(client.store.get(set)?.reps);
console.log("A видит", reps(phone), "| B видит", reps(web), "| у сервера", String(server.rows.get(set)?.reps));
console.log("в журнале сервера:", server.journal.map((e) => e.opId + " " + JSON.stringify(e.fields)).join(", "));

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

// оба правят ОДНО поле: в зале дожали до десяти, дома вспомнили, что было одиннадцать
phone.journal.change(set, { reps: 10 });
web.journal.change(set, { reps: 11 });
phone.sync();
web.sync();
phone.sync();
web.sync();

const reps = (client: Client) => String(client.store.get(set)?.reps);
console.log("A видит", reps(phone), "| B видит", reps(web), "| у сервера", String(server.rows.get(set)?.reps));
console.log("в журнале сервера:", server.journal.map((e) => e.opId + " " + JSON.stringify(e.fields)).join(", "));

экран примера

Сначала предположите, что выведет код

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

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

Значит, правило должно быть не про очередь, а про сравнение: один и тот же набор операций обязан давать один и тот же итог, в каком бы порядке они ни пришли. Сравнивать есть чем — у операции есть время устройства at и имя opId. Таблица полей в главе 6 обещала, что at понадобится «правилу конфликтов»; пора его написать. Отметка ставится не на строку, а на каждое поле: изменилось поле — запомнили, чья правка его поставила.

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

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function apply(row: Row | undefined, op: Op): Row;

// journal сервера из прошлого прогона: вставка и две правки одного поля
const journal: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "A:2", rowId: "A-1", fields: { reps: 10 }, at: 2 },
  { opId: "B:1", rowId: "A-1", fields: { reps: 11 }, at: 3 },
];

type Mark = { at: number; opId: string };
// порядок правок полный: сначала время, потом имя операции
const newer = (a: Mark, b: Mark) => (a.at !== b.at ? a.at > b.at : a.opId > b.opId);

function mergeFields(row: Row | undefined, marks: Record<string, Mark>, op: Op): Row {
  const next: Fields = { ...row };
  for (const field of Object.keys(op.fields)) {
    const was = marks[field];
    if (was && !newer(op, was)) continue;
    next[field] = op.fields[field];
    marks[field] = { at: op.at, opId: op.opId };
  }
  return { ...next, id: op.rowId };
}

// веб-версия свою правку применила первой, чужую получила потом
const orders: [string, Op[]][] = [
  ["порядок сервера", journal],
  ["порядок веб-версии", [journal[0], journal[2], journal[1]]],
];
for (const [name, ops] of orders) {
  const marks: Record<string, Mark> = {};
  let byArrival: Row | undefined;
  let byMarks: Row | undefined;
  for (const op of ops) {
    byArrival = apply(byArrival, op);
    byMarks = mergeFields(byMarks, marks, op);
  }
  console.log(name + ": по прибытии reps " + byArrival!.reps + ", по отметкам reps " + byMarks!.reps);
}

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function apply(row: Row | undefined, op: Op): Row;

// journal сервера из прошлого прогона: вставка и две правки одного поля
const journal: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "A:2", rowId: "A-1", fields: { reps: 10 }, at: 2 },
  { opId: "B:1", rowId: "A-1", fields: { reps: 11 }, at: 3 },
];

type Mark = { at: number; opId: string };
// порядок правок полный: сначала время, потом имя операции
const newer = (a: Mark, b: Mark) => (a.at !== b.at ? a.at > b.at : a.opId > b.opId);

// веб-версия свою правку применила первой, чужую получила потом
const orders: [string, Op[]][] = [
  ["порядок сервера", journal],
  ["порядок веб-версии", [journal[0], journal[2], journal[1]]],
];
for (const [name, ops] of orders) {
  const marks: Record<string, Mark> = {};
  let byArrival: Row | undefined;
  let byMarks: Row | undefined;
  for (const op of ops) {
    byArrival = apply(byArrival, op);
    byMarks = mergeFields(byMarks, marks, op);
  }
  console.log(name + ": по прибытии reps " + byArrival!.reps + ", по отметкам reps " + byMarks!.reps);
}

экран примера

Сначала предположите, что выведет код

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

Две правки легко получают одинаковый at: в миниатюре часы — счётчик, а на телефонах одна миллисекунда — это один тик системного таймера, и попасть в него вдвоём проще, чем кажется. Что тогда решит сравнение «строго новее»? Ничего: остаётся та правка, которую применили первой, и мы снова зависим от порядка. Прогноз: что покажут два правила — «только время» и «время, потом opId»?

rn

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Mark = { at: number; opId: string };

// две правки одного поля, сделанные на разных телефонах в одну и ту же миллисекунду
const ops: Op[] = [
  { opId: "A:2", rowId: "A-1", fields: { reps: 10 }, at: 5 },
  { opId: "B:1", rowId: "A-1", fields: { reps: 11 }, at: 5 },
];

function winner(rule: (a: Mark, b: Mark) => boolean, order: Op[]): string {
  let mark: Mark | undefined;
  let reps = 5;
  for (const op of order) {
    if (mark && !rule(op, mark)) continue;
    mark = { at: op.at, opId: op.opId };
    reps = Number(op.fields.reps);
  }
  return String(reps);
}

const onlyTime = (a: Mark, b: Mark) => a.at > b.at;
const withOpId = (a: Mark, b: Mark) => (a.at !== b.at ? a.at > b.at : a.opId > b.opId);
const reversed = [ops[1], ops[0]];
console.log("только время: сервер видит", winner(onlyTime, ops), "| B видит", winner(onlyTime, reversed));
console.log("время и opId: сервер видит", winner(withOpId, ops), "| B видит", winner(withOpId, reversed));

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Mark = { at: number; opId: string };

// две правки одного поля, сделанные на разных телефонах в одну и ту же миллисекунду
const ops: Op[] = [
  { opId: "A:2", rowId: "A-1", fields: { reps: 10 }, at: 5 },
  { opId: "B:1", rowId: "A-1", fields: { reps: 11 }, at: 5 },
];

const onlyTime = (a: Mark, b: Mark) => a.at > b.at;
const withOpId = (a: Mark, b: Mark) => (a.at !== b.at ? a.at > b.at : a.opId > b.opId);
const reversed = [ops[1], ops[0]];
console.log("только время: сервер видит", winner(onlyTime, ops), "| B видит", winner(onlyTime, reversed));
console.log("время и opId: сервер видит", winner(withOpId, ops), "| B видит", winner(withOpId, reversed));

экран примера

Сначала предположите, что выведет код

Без второго ключа устройства разошлись опять, теперь на равном времени. С opId порядок стал полным: у любых двух правок есть однозначно старшая, потому что имена операций уникальны — «устройство плюс счётчик» из главы 6. Какое из имён считать старшим, не важно; важно, что ответ одинаков у всех.

Правило целиком — семь строк, и дальше оно лежит в подложке, общее для телефона и сервера. Общее не для красоты: если стороны складывают операции по-разному, строки разъедутся снова, просто медленнее.

tsлистинг · не запускается

// merge.ts — одно правило для телефона и сервера
type Mark = { at: number; opId: string };

// полный порядок: сначала время, потом имя операции. Без второго ключа
// при равном времени устройства расходятся
const newer = (a: Mark, b: Mark) => (a.at !== b.at ? a.at > b.at : a.opId > b.opId);

function merge(row: Row | undefined, op: Op, marks: Record<string, Mark>): Row {
  const next: Fields = { ...row };
  for (const field of Object.keys(op.fields)) {
    const was = marks[field];
    // поле меняется, только если правка новее его отметки
    if (was && !newer(op, was)) continue;
    next[field] = op.fields[field];
    marks[field] = { at: op.at, opId: op.opId };
  }
  return { ...next, id: op.rowId };
}

// store.ts — у хранилища появился один метод: операция ложится правилом полей,
// а отметки лежат рядом со строками и по сети не едут
function apply(op: Op): Row {
  const row = merge(rows.get(op.rowId), op, marksOf(op.rowId));
  write(row);
  return row;
}

// merge.ts — одно правило для телефона и сервера
type Mark = { at: number; opId: string };

// полный порядок: сначала время, потом имя операции. Без второго ключа
// при равном времени устройства расходятся
const newer = (a: Mark, b: Mark) => (a.at !== b.at ? a.at > b.at : a.opId > b.opId);

function merge(row: Row | undefined, op: Op, marks: Record<string, Mark>): Row {
  const next: Fields = { ...row };
  for (const field of Object.keys(op.fields)) {
    const was = marks[field];
    // поле меняется, только если правка новее его отметки
    if (was && !newer(op, was)) continue;
    next[field] = op.fields[field];
    marks[field] = { at: op.at, opId: op.opId };
  }
  return { ...next, id: op.rowId };
}

// store.ts — у хранилища появился один метод: операция ложится правилом полей,
// а отметки лежат рядом со строками и по сети не едут
function apply(op: Op): Row {
  const row = merge(rows.get(op.rowId), op, marksOf(op.rowId));
  write(row);
  return row;
}

Отметки полей никуда не едут. По сети идут те же операции, что и раньше, — opId, rowId, fields, at, — а отметки каждая сторона считает сама, пока их применяет. Контракты sync.push и sync.pull от этой статьи не меняются ни на одно поле.

Вся сила нового правила — в поле at, и пора сказать, откуда оно берётся: это часы устройства. В главе 6 они уже соврали однажды — идентификатор, собранный из показаний часов, поставил операции двух телефонов не в том порядке, в каком их создали («Журнал: имена и номера рождаются на телефоне»). Там это стоило веры в порядок. Здесь это стоит правки.

Сценарий самый обычный. Дома поправили вес, телефон эту правку забрал и показал. В зале человек, увидев её, ставит свой вес — то есть правит позже и в ответ на увиденное. Но часы телефона отстают: его счётчик показывает 7 при увиденной отметке 10 (на настоящем телефоне это пять минут отставания). Прогноз: какой вес останется после слияния и что изменит гибридное правило?

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function createMerge(): (row: Row | undefined, op: Op) => Row;

// подход записан утром, дома вечером поправили вес — часы там идут верно
const done: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "B:1", rowId: "A-1", fields: { weightKg: 85 }, at: 10 },
];
const merge = createMerge();
let row: Row | undefined;
for (const op of done) {
  row = merge(row, op);
}
console.log("правка с веб-версии: weightKg", String(row!.weightKg));

// в зале телефон эту правку уже забрал и человек ставит свой вес — позже по времени.
// Но часы телефона отстают: его счётчик показывает 7
const lagging: Op = { opId: "A:2", rowId: "A-1", fields: { weightKg: 82.5 }, at: 7 };
console.log("часы телефона отстают: weightKg", String(merge(row, lagging).weightKg));

// гибридные часы: отметка = max(свои часы, самое позднее увиденное) + 1
const seen = 10;
const hybrid: Op = { ...lagging, at: Math.max(7, seen) + 1 };
console.log("гибридные часы: at", hybrid.at, "| weightKg", String(merge(row, hybrid).weightKg));

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function createMerge(): (row: Row | undefined, op: Op) => Row;

// подход записан утром, дома вечером поправили вес — часы там идут верно
const done: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "B:1", rowId: "A-1", fields: { weightKg: 85 }, at: 10 },
];
const merge = createMerge();
let row: Row | undefined;
for (const op of done) {
  row = merge(row, op);
}
console.log("правка с веб-версии: weightKg", String(row!.weightKg));

// в зале телефон эту правку уже забрал и человек ставит свой вес — позже по времени.
// Но часы телефона отстают: его счётчик показывает 7
const lagging: Op = { opId: "A:2", rowId: "A-1", fields: { weightKg: 82.5 }, at: 7 };
console.log("часы телефона отстают: weightKg", String(merge(row, lagging).weightKg));

// гибридные часы: отметка = max(свои часы, самое позднее увиденное) + 1
const seen = 10;
const hybrid: Op = { ...lagging, at: Math.max(7, seen) + 1 };
console.log("гибридные часы: at", hybrid.at, "| weightKg", String(merge(row, hybrid).weightKg));

экран примера

Сначала предположите, что выведет код

Правка с отстающих часов проиграла той, на которую отвечала: вес остался 85. Посмотрите на это глазами человека — он поставил 82,5, экран показал 82,5, а через минуту, после синхронизации, вернулось 85. Это худший вид потери: не «не сохранилось», а «сохранилось и откатилось само».

Лечится это на клиенте и двумя строками. Отметка берётся не прямо с часов, а как max(свои часы, самое позднее увиденное) + 1: раз мы видели отметку 10, наша следующая правка обязана быть новее десяти. Такие часы называют гибридными — в них есть и настоящее время, и счётчик событий. В прогоне отметка стала 11, и правка победила.

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

Отстающие часы теряют одну правку — свою. Спешащие теряют чужие, и не одну: пока чужие отметки ниже, побеждает всё, что написано с убежавших часов. Прогноз: какой вес останется после двух поздних правок с веб-версии и что будет с третьей, сделанной уже после того, как её часы увидели отметку 1000?

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function createMerge(): (row: Row | undefined, op: Op) => Row;

const merge = createMerge();
let row: Row | undefined;
row = merge(row, { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 });

// у телефона часы убежали вперёд: его счётчик показывает 1000
row = merge(row, { opId: "A:2", rowId: "A-1", fields: { weightKg: 100 }, at: 1000 });

// дома вес правят ещё дважды, и обе правки позже по настоящему времени
for (const at of [11, 12]) {
  row = merge(row, { opId: "B:" + at, rowId: "A-1", fields: { weightKg: 82.5 + at }, at });
}
console.log("спешащие часы: weightKg", String(row!.weightKg));

// веб-версия увидела отметку 1000 и подтянула свои часы гибридным правилом
const after: Op = { opId: "B:3", rowId: "A-1", fields: { weightKg: 90 }, at: Math.max(12, 1000) + 1 };
console.log("после того как часы подтянулись: weightKg", String(merge(row, after).weightKg));

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function createMerge(): (row: Row | undefined, op: Op) => Row;

const merge = createMerge();
let row: Row | undefined;
row = merge(row, { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 });

// у телефона часы убежали вперёд: его счётчик показывает 1000
row = merge(row, { opId: "A:2", rowId: "A-1", fields: { weightKg: 100 }, at: 1000 });

// дома вес правят ещё дважды, и обе правки позже по настоящему времени
for (const at of [11, 12]) {
  row = merge(row, { opId: "B:" + at, rowId: "A-1", fields: { weightKg: 82.5 + at }, at });
}
console.log("спешащие часы: weightKg", String(row!.weightKg));

// веб-версия увидела отметку 1000 и подтянула свои часы гибридным правилом
const after: Op = { opId: "B:3", rowId: "A-1", fields: { weightKg: 90 }, at: Math.max(12, 1000) + 1 };
console.log("после того как часы подтянулись: weightKg", String(merge(row, after).weightKg));

экран примера

Сначала предположите, что выведет код

Вес 100 пережил обе поздние правки — только потому, что у телефона в тот вечер часы показывали на тысячу делений вперёд. Зато первая же синхронизация подтянула чужие часы гибридным правилом, и следующая правка встала выше. Вот зачем гибридные часы нужны на всех устройствах: они не делают время правильным, но ограничивают вред вруна тем, что он успел написать до встречи с остальными.

В цикле синхронизации это две строки: одна при записи — now() вместо Date.now(), другая на приёме страницы. Обе уезжают в подложку и работают до конца части.

tsлистинг · не запускается

// clock.ts — часы устройства, гибридные
let ticks = 0;

export function now(): number {
  // счётчик рядом со временем: отметка не повторится, даже если часы стоят
  ticks = Math.max(ticks, Date.now()) + 1;
  return ticks;
}

// увидели чужую отметку — подтянули свою: правка, сделанная в ответ
// на увиденное, обязана быть новее его
export function see(at: number): void {
  if (at > ticks) ticks = at;
}

// sync-loop.ts — приём страницы из «Цикла синхронизации», одна новая строка
for (const entry of page.changes) {
  if (entry.opId.startsWith(device + ":")) continue;
  see(entry.at);
  store.apply(entry);
}

// clock.ts — часы устройства, гибридные
let ticks = 0;

export function now(): number {
  // счётчик рядом со временем: отметка не повторится, даже если часы стоят
  ticks = Math.max(ticks, Date.now()) + 1;
  return ticks;
}

// увидели чужую отметку — подтянули свою: правка, сделанная в ответ
// на увиденное, обязана быть новее его
export function see(at: number): void {
  if (at > ticks) ticks = at;
}

// sync-loop.ts — приём страницы из «Цикла синхронизации», одна новая строка
for (const entry of page.changes) {
  if (entry.opId.startsWith(device + ":")) continue;
  see(entry.at);
  store.apply(entry);
}

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

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

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

// оба правят одно поле, каждый без сети и не зная про другого
phone.journal.change(set, { reps: 10 });
web.journal.change(set, { reps: 11 });
phone.sync();
web.sync();
phone.sync();
web.sync();
const reps = (client: Client) => String(client.store.get(set)?.reps);
console.log("A видит", reps(phone), "| B видит", reps(web), "| у сервера", String(server.rows.get(set)?.reps));
console.log("отметки правок:", server.journal.slice(1).map((e) => e.opId + " at " + e.at).join(", "));

// а теперь веб-версия правит, уже увидев чужую правку
web.journal.change(set, { reps: 12 });
web.sync();
phone.sync();
const last = server.journal[server.journal.length - 1];
console.log("ответная правка:", last.opId + " at " + last.at, "| A видит", reps(phone), "| B видит", reps(web));

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  get(id: string): Row | undefined;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

// оба правят одно поле, каждый без сети и не зная про другого
phone.journal.change(set, { reps: 10 });
web.journal.change(set, { reps: 11 });
phone.sync();
web.sync();
phone.sync();
web.sync();
const reps = (client: Client) => String(client.store.get(set)?.reps);
console.log("A видит", reps(phone), "| B видит", reps(web), "| у сервера", String(server.rows.get(set)?.reps));
console.log("отметки правок:", server.journal.slice(1).map((e) => e.opId + " at " + e.at).join(", "));

// а теперь веб-версия правит, уже увидев чужую правку
web.journal.change(set, { reps: 12 });
web.sync();
phone.sync();
const last = server.journal[server.journal.length - 1];
console.log("ответная правка:", last.opId + " at " + last.at, "| A видит", reps(phone), "| B видит", reps(web));

экран примера

Сначала предположите, что выведет код

Все трое показывают одиннадцать — расхождения нет. А отметки у первых двух правок одинаковые, at 2 у каждой: оба устройства писали свою первую правку по своим часам, и счётчики совпали. Спор решил второй ключ — B:1 старше A:2 по имени. Зато ответная правка веб-версии получила отметку 3: гибридные часы подняли её выше увиденного, и победила она уже по времени, без всяких ничьих.

Что из этого видит человек? Ничего. Правило работает ниже разметки, и экран про конфликты не знает: он подписан на хранилище через useSyncExternalStore — «Свой хук: логика без разметки» части IV, заново это не объясняется. Прогноз: сколько раз отрисуется экран подхода и что он напечатает, если сначала нажать «+2,5 кг», а потом получить с сервера чужую правку повторов?

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  visible(): Row[];
  subscribe(listener: () => void): () => void;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;
const { View, Text, Pressable } = ReactNative;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

function SetScreen() {
  const rows = React.useSyncExternalStore(phone.store.subscribe, phone.store.visible);
  const row = rows[0];
  console.log("на экране:", String(row.weightKg), "кг ×", String(row.reps));
  return (
    <View>
      <Text>{String(row.exercise)}</Text>
      <Pressable testID="heavier" onPress={() => phone.journal.change(set, { weightKg: 82.5 })}>
        <Text>+2,5 кг</Text>
      </Pressable>
    </View>
  );
}

mount(<SetScreen />);
setTimeout(() => fireEvent.press("heavier"), 50);
// дома в этот же вечер правят повторы, и правка доезжает до телефона
setTimeout(() => {
  web.journal.change(set, { reps: 12 });
  web.sync();
  phone.sync();
}, 120);

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Verdict = { opId: string; status: "applied" | "duplicate" | "rejected"; reason?: string };
interface Server {
  rows: Map<string, Row>;
  journal: (Op & { seq: number })[];
  net: { offline: boolean; loseResponse: boolean };
  push(batch: Op[]): { verdicts: Verdict[] };
  pull(cursor: number, limit: number): { changes: (Op & { seq: number })[]; cursor: number; hasMore: boolean };
}
declare function createServer(): Server;
interface Store {
  visible(): Row[];
  subscribe(listener: () => void): () => void;
}
interface Journal {
  newId(): string;
  change(rowId: string, fields: Fields): void;
}
interface Client {
  store: Store;
  journal: Journal;
  sync(): Verdict[];
}
declare function createClient(device: string, server: Server): Client;
const { View, Text, Pressable } = ReactNative;

const server = createServer();
const phone = createClient("A", server);
const web = createClient("B", server);
const set = phone.journal.newId();
phone.journal.change(set, { exercise: "жим", weightKg: 80, reps: 5 });
phone.sync();
web.sync();

mount(<SetScreen />);
setTimeout(() => fireEvent.press("heavier"), 50);
// дома в этот же вечер правят повторы, и правка доезжает до телефона
setTimeout(() => {
  web.journal.change(set, { reps: 12 });
  web.sync();
  phone.sync();
}, 120);

экран примера

Сначала предположите, что выведет код

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

А если всё-таки спрашивать, то в React Native это отдельная работа: своим диалогом на Modal, потому что штатный Alert в веб-сборке — пустой метод (глава 4). И задавать вопрос придётся тому устройству, которое первым увидело обе правки, — а это не обязательно то, что сейчас в руках.

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

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

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function createMerge(): (row: Row | undefined, op: Op) => Row;

// счётчик подходов за неделю: записи в форме «стало столько» — той самой,
// которой в прошлой статье лечили повтор. До зала их было три
const merge = createMerge();
let row: Row | undefined;
for (const op of [
  { opId: "A:1", rowId: "week", fields: { sets: 3 }, at: 1 },
  { opId: "A:2", rowId: "week", fields: { sets: 4 }, at: 5 },
  { opId: "B:1", rowId: "week", fields: { sets: 4 }, at: 6 },
]) {
  row = merge(row, op);
}
console.log("по полям:", String(row!.sets), "| а подходов сделано 5");

// вклады: строка хранит не итог, а кто сколько добавил
type Counts = Record<string, number>;
function mergeCounts(a: Counts, b: Counts): Counts {
  const next: Counts = { ...a };
  for (const device of Object.keys(b)) next[device] = Math.max(next[device] || 0, b[device]);
  return next;
}
const total = (counts: Counts) => Object.values(counts).reduce((sum, n) => sum + n, 0);

const before: Counts = { A: 2, B: 1 };
const phone: Counts = { ...before, A: 3 };
const web: Counts = { ...before, B: 2 };
console.log("по вкладам:", total(mergeCounts(phone, web)));
console.log(
  "в обратном порядке:", total(mergeCounts(web, phone)),
  "| повторно:", total(mergeCounts(mergeCounts(phone, web), web)),
);

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function createMerge(): (row: Row | undefined, op: Op) => Row;

// счётчик подходов за неделю: записи в форме «стало столько» — той самой,
// которой в прошлой статье лечили повтор. До зала их было три
const merge = createMerge();
let row: Row | undefined;
for (const op of [
  { opId: "A:1", rowId: "week", fields: { sets: 3 }, at: 1 },
  { opId: "A:2", rowId: "week", fields: { sets: 4 }, at: 5 },
  { opId: "B:1", rowId: "week", fields: { sets: 4 }, at: 6 },
]) {
  row = merge(row, op);
}
console.log("по полям:", String(row!.sets), "| а подходов сделано 5");

// вклады: строка хранит не итог, а кто сколько добавил
type Counts = Record<string, number>;
function mergeCounts(a: Counts, b: Counts): Counts {
  const next: Counts = { ...a };
  for (const device of Object.keys(b)) next[device] = Math.max(next[device] || 0, b[device]);
  return next;
}
const total = (counts: Counts) => Object.values(counts).reduce((sum, n) => sum + n, 0);

const before: Counts = { A: 2, B: 1 };
const phone: Counts = { ...before, A: 3 };
const web: Counts = { ...before, B: 2 };
console.log("по вкладам:", total(mergeCounts(phone, web)));
console.log(
  "в обратном порядке:", total(mergeCounts(web, phone)),
  "| повторно:", total(mergeCounts(mergeCounts(phone, web), web)),
);

экран примера

Сначала предположите, что выведет код

Слияние по полям дало четыре. Обе правки победить не могут, а пишут они одно и то же число, так что победитель ничего не добавляет к проигравшему. Заметьте, что ничего и не «потерялось по ошибке»: потерялась прибавка, которой в записи просто нет — «стало 4» не помнит, что до него было три.

Вклады чинят это сменой того, что хранится: в строке не число, а по счётчику на устройство, а итог — их сумма. Слияние тогда — максимум по каждому устройству, три строки кода. В прогоне видно, что ведёт оно себя правильно при любом обращении: пять в прямом порядке, пять в обратном, пять при повторном слиянии той же пачки. Три свойства, ради которых всё затевалось: перестановочность (порядок не важен), сочетательность (можно сливать по частям — у max это даром) и идемпотентность (повтор ничего не меняет).

Это и есть идея CRDT — бесконфликтно сливаемых типов данных — на уровне понимания: не хранить значение, которое придётся выбирать, а хранить то, что сливается само. Настоящие реализации делают то же самое для текста, списков и деревьев: @automerge/automerge 3.5.0 и yjs 13.6.33. API здесь намеренно не показан — в «Подходе» он не нужен, а пересказ чужого интерфейса по памяти ничему не учит. Эссе Ink & Switch про local-first, с которого началась глава 6, стоит как раз на CRDT и Automerge; а вот критика «последней записи» из этой статьи — наша, в эссе её нет.

правило	что делает с правками	чем платит
последняя запись строкой	оставляет одну строку целиком	теряет чужую правку, даже сделанную в другом поле
слияние по полям с отметкой `[at, opId]`	сохраняет правки разных полей, у одного поля берёт новейшую	хранит отметку у каждого поля и зависит от часов устройства
вклады устройств	не теряет ни одной прибавки	значение превращается в набор чисел и растёт с числом устройств
спросить человека	не теряет ничего	вопрос и экран для него; в дневнике одного человека это перебор

Цена вкладов — рост: строка помнит столько чисел, сколько устройств у человека было за всё время, и вычеркнуть из неё потерянный телефон нельзя — итог уменьшится. Для дневника с двумя-тремя устройствами это ничто, для документа с сотней соавторов — отдельная работа, которой и заняты настоящие библиотеки CRDT.

Слияние по полям сохраняет обе правки, если правили разное; «последняя запись побеждает» уносит чужую правку целиком — в прогоне повторы 8 исчезли вместе с проигравшей строкой.
Когда правили одно поле, кто-то проигрывает всегда, и это нормально. Ненормально другое: без явного правила устройства расходятся молча — телефон 11, веб-версия 10, сервер 11, и свести их уже нечем.
Правило обязано быть перестановочным: отметка [at, opId] у каждого поля даёт один и тот же итог в любом порядке применения. opId — обязательный второй ключ, иначе при равном времени расхождение возвращается.
at — часы устройства, и они врут. Отстающие проигрывают правку, сделанную позже; спешащие выигрывают у всех поздних правок. Гибридные часы max(своё, увиденное) + 1 чинят то, что человек видел, и только это.
Счётчик слиянием по полям не лечится: два «стало 4» дают 4, а подходов пять. Лечится сменой того, что хранится: вклады устройств, слияние максимумом по каждому, итог — сумма; перестановочно, сочетательно, идемпотентно.
Это идея CRDT на уровне понимания; настоящие реализации — Automerge и Yjs, и эссе Ink & Switch стоит на них. Критика «последней записи» здесь наша: в эссе её нет.

1/4Телефон поправил в подходе повторы, веб-версия — вес. Почему «последняя запись побеждает» всё-таки теряет одну из правок?

2/4Оба устройства поправили одно и то же поле, обе операции доехали до сервера, ни одна не потерялась. Почему телефон и веб-версия показывают разное?

3/4Телефон забрал чужую правку с отметкой 10, показал её человеку, и человек тут же поправил это поле у себя. Часы телефона показывают 7. Какую отметку должна получить его правка?

4/4Оба устройства добавили по подходу и записали «стало 4». Слияние по полям даёт 4, хотя подходов сделано 5. Что с этим делать?

Правило, которое сравнивает только время

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

rn

type Fields = Record<string, string | number | boolean>;
type Op = { opId: string; rowId: string; fields: Fields; at: number };
type Mark = { at: number; opId: string };

// правило слияния: чья правка поля новее, та и побеждает
const newer = (a: Mark, b: Mark) => a.at > b.at; // ваш код

function reps(order: Op[]): string {
  let mark: Mark | undefined;
  let value = 5;
  for (const op of order) {
    if (mark && !newer(op, mark)) continue;
    mark = { at: op.at, opId: op.opId };
    value = Number(op.fields.reps);
  }
  return String(value);
}

// две правки одного поля, сделанные в одну и ту же миллисекунду на разных телефонах
const ops: Op[] = [
  { opId: "A:2", rowId: "A-1", fields: { reps: 10 }, at: 5 },
  { opId: "B:1", rowId: "A-1", fields: { reps: 11 }, at: 5 },
];
console.log("сервер видит", reps(ops), "| веб-версия видит", reps([ops[1], ops[0]]));
// сейчас устройства показывают разное, а должны сойтись на одном значении

экран примера

Сначала предположите, что выведет код

Сравнение по времени надо дополнить вторым ключом — именем операции:

jsлистинг · не запускается

const newer = (a: Mark, b: Mark) => (a.at !== b.at ? a.at > b.at : a.opId > b.opId);

const newer = (a: Mark, b: Mark) => (a.at !== b.at ? a.at > b.at : a.opId > b.opId);

Вывод становится сервер видит 11 | веб-версия видит 11.

Какое из имён считать старшим — вопрос вкуса: важно, что opId уникален и сравнивается одинаково везде. Без второго ключа правило перестаёт быть правилом ровно там, где оно нужнее всего: при равном времени побеждает тот, кто успел применить первым, а это у каждого устройства своё. Вместе at и opId дают полный порядок — любые две правки сравнимы, и ответ один на всех.

Гибридные часы, забывшие про единицу

Телефон забрал чужую правку с отметкой 10 и в ответ поставил свой вес; его собственные часы показывают 7. Отметку он считает гибридным правилом, но одной детали в нём не хватает. Посмотрите, чем это кончилось для ответной правки, и почините расчёт.

rn

type Fields = Record<string, string | number | boolean>;
type Row = Fields & { id: string };
type Op = { opId: string; rowId: string; fields: Fields; at: number };
declare function createMerge(): (row: Row | undefined, op: Op) => Row;

const done: Op[] = [
  { opId: "A:1", rowId: "A-1", fields: { exercise: "жим", weightKg: 80, reps: 5 }, at: 1 },
  { opId: "B:1", rowId: "A-1", fields: { weightKg: 85 }, at: 10 },
];
const merge = createMerge();
let row: Row | undefined;
for (const op of done) {
  row = merge(row, op);
}

// телефон забрал чужую правку и в ответ ставит свой вес.
// Часы телефона отстают: его счётчик показывает 7, а увиденная отметка — 10
const ticks = 7;
const seen = 10;
const at = Math.max(ticks, seen); // ваш код
const answer: Op = { opId: "A:2", rowId: "A-1", fields: { weightKg: 82.5 }, at };
console.log("отметка ответной правки:", at, "| weightKg", String(merge(row, answer).weightKg));
// сейчас ответная правка проигрывает той, на которую отвечает

экран примера

Сначала предположите, что выведет код

К максимуму нужно прибавить единицу — иначе ответная правка встаёт вровень с той, на которую отвечает:

jsлистинг · не запускается

const at = Math.max(ticks, seen) + 1;

const at = Math.max(ticks, seen) + 1;

Вывод становится отметка ответной правки: 11 | weightKg 82.5.

Без единицы отметки совпадают, и спор решает второй ключ, opId. Здесь он оказался не на стороне телефона, но дело не в этом: даже выиграв, такая правка выиграла бы случайно. Единица выражает простую вещь — то, что сделано после увиденного, обязано быть новее увиденного. На этом гибридные часы и стоят: время в них не только измеряется, но и считается.

Вклады, которые складываются

Счётчик подходов хранит вклады устройств, но слияние написано сложением. Пока пачка приходит один раз, итог похож на правду. Посмотрите, что делает с ним повторное слияние, и почините mergeCounts.

rn

type Counts = Record<string, number>;

// вклады устройств: у каждого свой счёт подходов за неделю
function mergeCounts(a: Counts, b: Counts): Counts {
  const next: Counts = { ...a };
  for (const device of Object.keys(b)) next[device] = (next[device] || 0) + b[device]; // ваш код
  return next;
}
const total = (counts: Counts) => Object.values(counts).reduce((sum, n) => sum + n, 0);

// до зала подходов было три: два записал телефон, один — веб-версия.
// Потом каждый добавил по одному, не зная про другого
const phone: Counts = { A: 3, B: 1 };
const web: Counts = { A: 2, B: 2 };
console.log("слияние:", total(mergeCounts(phone, web)), "| в обратном порядке:", total(mergeCounts(web, phone)));
console.log("та же пачка пришла второй раз:", total(mergeCounts(mergeCounts(phone, web), web)));
// сейчас итог зависит от числа слияний, а подходов сделано 5

экран примера

Сначала предположите, что выведет код

Вклад устройства — это не прибавка, а его текущий счёт, поэтому сливать надо максимумом:

jsлистинг · не запускается

next[device] = Math.max(next[device] || 0, b[device]);

next[device] = Math.max(next[device] || 0, b[device]);

Вывод становится слияние: 5 | в обратном порядке: 5 и та же пачка пришла второй раз: 5.

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

Кто прав, если оба правы: последняя запись, слияние по полям и часы

Видеоразбор темы за 5–7 минут

Последняя запись побеждает — и уносит чужую правкуДве правки в разные поля одной строки, а выживает одна

Оба правили одно поле: тихое расхождениеA видит 11, B видит 10, и ни одна сторона не ошиблась

Часы устройства врутОтстающие часы проигрывают правку, сделанную позже, а спешащие выигрывают у всех

Два устройства с готовым правиломНичья, решённая opId, и экран, который ни о чём не спрашивает

Счётчик: 4 вместо 5Ни одна правка не потерялась, а прибавка потерялась

Итогошпаргалка по теме

Проверьте себявопросы по теме

Задачизадачи с решениями

Правило, которое сравнивает только время

Гибридные часы, забывшие про единицу

Вклады, которые складываются