Хорошая новость: это не баг браузера и не сломанный CSS. Это просто особенность того, как работает гибкая верстка. И сейчас мы разберёмся, почему элементы «улетают», и как это быстро пофиксить.

Почему элементы сжимаются и едят друг друга

Представь: ты создал flex-контейнер, положил внутрь три блока одинакового размера. По логике они должны остаться такими же. Но стоп - они вдруг начали сжиматься! Что-то меняется, они становятся меньше, и теперь всё помещается в одну строку, хотя раньше должны были переноситься.

Вся беда в одном скрытом свойстве: flex-shrink. По умолчанию оно равно 1, и это значит, что все flex-элементы будут сжиматься, если их коллективная ширина больше ширины контейнера. Браузер просто решает: «Окей, ребята, вместиться нужно, так что сжимайтесь». И вот уже твои красивые блоки стали тощими полосками.

Вторая причина - это отсутствие flex-basis. Когда элемент не знает, какой у него должна быть базовая ширина, он начинает ориентироваться на контент. Если контента мало, блок становится тонким. Если контента много и он не переносится (например, длинное слово или URL), контейнер может переполниться.

Вот основные сценарии, которые приводят к «улётам»:

• Flex-shrink по умолчанию = 1: элементы сжимаются автоматически, даже если ты этого не просил
• Нет явной ширины или flex-basis: элементы не знают, какой размер им выбрать
• Контент больше контейнера: длинные слова и текст ломают макет
• Отсутствие flex-wrap: элементы давятся в одну строку вместо переноса

Решение номер один: запрети сжиматься

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

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

Когда использовать:

• Ты хочешь, чтобы элементы сохраняли ровно ту ширину, которую ты установил
• У тебя не очень много элементов, и они точно поместятся
• Ты работаешь с чем-то, что не должно менять размер (например, иконки или логотипы)

.flex-item {
  flex-shrink: 0;
}

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

Решение номер два: отключи сжатие через flex

Есть более универсальный способ - использовать shorthand свойство flex. Вместо того чтобы настраивать flex-grow, flex-shrink и flex-basis отдельно, ты можешь просто написать flex: 0 или flex: 1 - и браузер сам разберётся.

flex: 0 - это означает: не расти, не сжиматься, занимай ровно столько, сколько нужно контенту. Это часто спасает, когда ты не знаешь, какой будет размер элемента.

flex: 1 - противоположное: расти, если есть свободное место, но не сжиматься ниже минимума.

Делаешь ты это вот так:

.flex-item {
  flex: 0; /* Не растёт, не сжимается */
}

Либо вот так для элементов, которые должны занять равное место:

.flex-item {
  flex: 1; /* Делит пространство поровну с другими такими же */
}

Заметь: когда ты пишешь flex: 1, браузер автоматически устанавливает flex-basis на 0%, что очень удобно для равномерного распределения.

Решение номер три: добавь flex-wrap и давай им дышать

Если элементов много и ты хочешь, чтобы они переносились на новую строку вместо того, чтобы сжиматься, добавь flex-wrap: wrap. Теперь, когда места не хватает, они просто прыгнут на следующую строку.

Это особенно полезно для адаптивных макетов, карточек товаров или галерей. Вместо того чтобы ломаться в пикселе, элементы спокойно переносятся.

.flex-container {
  display: flex;
  flex-wrap: wrap;
}

Теперь твой контейнер может быть многострочным, и каждая строка будет содержать столько элементов, сколько влезет. Это намного красивее, чем когда всё мнётся в одну полосу.

Бонус: проблема с контентом, который не влезает

Теперь представь другую ситуацию: ты установил flex-shrink: 0, но внутри элемента есть длинное слово или URL, которое не переносится. Оно просто вывалится за границы контейнера и сломает весь макет.

Для таких случаев есть два верных помощника:

• overflow-wrap: break-word - разрешает браузеру разрывать длинные слова
• word-break: break-word - аналогично, но работает немного по-другому
• min-width: 0 - очень важное свойство! Оно говорит браузеру, что элемент может быть уже, чем его контент

Вместе с этим твой flex-элемент будет вести себя адекватно:

.flex-item {
  flex-shrink: 0;
  min-width: 0; /* Позволяет сжаться ниже размера контента */
  overflow-wrap: break-word;
}

Этот набор спасает, когда ты работаешь с пользовательским контентом, который ты не можешь контролировать.

Сравнение подходов: какой выбрать

На что ещё обратить внимание

Есть ещё несколько нюансов, которые часто упускают новички. Например, если ты используешь align-items: center для вертикального выравнивания, а содержимое очень большое, оно может выползти за границы контейнера. Это не ошибка - это просто особенность того, как работает выравнивание.

Также помни про минимальный размер по умолчанию. По спецификации Flexbox элементы не должны сжиматься меньше своего содержимого (минимума). Если внутри есть слово, блок не станет уже этого слова, даже если ты просишь его сжаться. Чтобы это изменить, нужно явно задать min-width или min-height.

И ещё одна подлость: если использовать position: absolute внутри flex-контейнера, элемент выпадает из потока и контейнер его не видит. Это может привести к странному поведению и коллапсу высоты.

Главное, что нужно запомнить

Флекс-элементы - это не просто блоки, которые расставляются в ряд. Это живые существа, которые пытаются вместиться в контейнер и заполнить пространство оптимально. flex-shrink, flex-grow и flex-basis - это их настройки поведения. Знаешь эти три свойства - и половина проблем решена.

Второе главное: всегда явно задавай эти свойства, если хочешь предсказуемого результата. Не полагайся на дефолты браузера, если поведение критично. И помни про min-width: 0 - это волшебное свойство, которое часто спасает макет от краха, особенно когда внутри текст или контент переменного размера.