Синхронизация данных между устройствами: конфликты и версии

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

Почему одни и те же данные становятся разными

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

Если ты играешь на телефоне, рекорд записывается в телефон. Если на компьютере — в компьютер. Эти две копии ничего не знают друг о друге, пока между ними нет синхронизации.

Разошедшиеся данные могут появиться по разным причинам:

• Офлайн-работа. Ты что-то сделал без интернета, и приложение не успело отправить изменения на сервер.
• Задержка сети. Запись ушла с одного устройства, но второе успело прочитать старую версию раньше, чем пришла новая.
• Разные часы. Устройства могут иметь немного разное время, и приложение путается, какое изменение было позже.
• Ошибка пользователя. Закрыл приложение слишком быстро, не дождавшись сохранения.

Проблема не в том, что «всё сломалось», а в том, что данные нужно не просто копировать, а согласовывать. И здесь начинается самое интересное.

Last-write-wins: простое, но не всегда честное решение

Самый простой способ разрешить конфликт — сказать: «Кто записал последним, тот и прав». Эта стратегия называется last-write-wins — «побеждает последняя запись». Если на телефоне рекорд 87, а на компьютере 54, и компьютер синхронизировался позже, то на сервере останется 54. Твой рекорд 87 исчезнет.

Почему так происходит? Потому что приложение не сравнивает сами значения, а сравнивает только время записи. Оно видит: «Запись с компьютера новее → значит, она главная». Даже если по факту она хуже.

Last-write-wins легко реализовать, поэтому его часто используют в простых приложениях. Но он не подходит, когда важна логика данных. Для игрового рекорда такая стратегия обидна: старое значение может затереть настоящее достижение. Для текстовой заметки — ещё хуже: старая версия может затереть правки, над которыми ты работал час.

Merge: когда данные нужно не заменять, а объединять

Более умный подход — merge, то есть слияние. Вместо того чтобы выбирать одну запись, приложение анализирует обе копии и пытается собрать из них правильный результат.

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

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

Слияние удобно разделить на два уровня:

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

Версии и метки времени: как приложения понимают, что изменилось

Чтобы сливать данные, приложению нужно понимать, что именно поменялось. Для этого используются версии и метки времени.

Простейший вариант — хранить у каждой записи дату последнего изменения. Но, как мы уже видели, время на устройствах может расходиться, поэтому один только timestamp ненадёжный.

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

Представь это как цепочку черновиков:

1. Версия 1: рекорд 12.
2. Версия 2: рекорд 54 (сделан на компьютере).
3. Версия 3: рекорд 87 (сделан на телефоне).

Если сервер знает все три версии, он легко поймёт, что 87 — это последнее достижение, и не перезапишет его более старой копией. Даже если компьютер пришлёт версию 2 позже, чем телефон прислал версию 3, сервер поймёт: «Такая версия уже есть, и есть более новая. Игнорирую».

Как это решено в курсе: прогресс объединяется, а не заменяется

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

Именно здесь важна синхронизация. Если ты смотришь уроки и проходишь практику то с телефона, то с компьютера, прогресс должен оставаться единым. В курсе это реализовано через слияние: прогресс не заменяется последней записью, а мержится.

Что это значит на практике:

• Пройденные уроки отмечаются как выполненные, даже если они отмечены на разных устройствах.
• Результаты практики не теряются, если ты переключился с телефона на компьютер.
• Сервер хранит актуальное состояние и разрешает конфликты в пользу пользователя, а не в пользу случайной последней записи.

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

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

Практический блок: как не потерять данные в своём приложении

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

1. Где хранятся данные? Только на устройстве или ещё и на сервере? Если только локально — синхронизации не будет.
2. Что произойдёт, если два устройства отправят разные значения? Приложение должно не просто перезаписать, а сравнить или слить данные.
3. Как обрабатывается офлайн? Если пользователь что-то сделал без интернета, изменения должны отправиться позже, а не исчезнуть.
4. Есть ли метки времени или версии? Без них сложно понять, какая копия актуальная.
5. Какие данные можно смело мержить? Счётчики, прогресс, рекорды — обычно да. Сложные документы — нужен более умный алгоритм.

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

Заключение

Синхронизация данных — это не волшебная кнопка «сделать как на всех устройствах». Это выбор стратегии: либо ты доверяешь последней записи, либо учишь приложение объединять изменения. Last-write-wins проще, но может стереть важное. Merge надёжнее, но требует продуманной логики.

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