Полное руководство по Angular @if
- 18 мая 2025
Одно из самых заметных нововведений в Angular — это встроенный синтаксис для управляющих конструкций, который появился в версии 17. Он решает одну из самых частых задач, с которой сталкивается каждый разработчик: показывать или скрывать элементы на странице в зависимости от условия. Раньше для этого использовали привычную структурную директиву *ngIf
. Теперь у нас есть более современная альтернатива — синтаксис @if
, часть нового подхода к управлению шаблоном.
В этом гайде мы сравним оба варианта, разберёмся, чем @if
лучше, и покажем, как можно перейти на него автоматически. Также поговорим об одной распространённой ошибке — о том, как не стоит использовать @if
вместе с пайпом async
.

Содержание
В этом материале разбираем:
- Зачем понадобился новый синтаксис управляющих конструкций
- Что такое
@if
в Angular - Как работает синтаксис
@if
- Как использовать
@if
вместе сelse
- Как использовать
@if
,else if
иelse
- Почему
@if
не нужно импортировать - Почему больше не нужен синтаксис со звёздочкой (*)
- Почему
@if
лучше, чем*ngIf
- Как просто перейти на новый синтаксис @if
- Чем
@if
отличается от скрытия элементов через CSS - Распространённый антипаттерн: вложенные
@if
с пайпом async - Краткое резюме
Зачем нужен новый синтаксис управляющих конструкций?
Как объясняет Минко Гечев в посте, где впервые представили @if, новый встроенный синтаксис управления потоком исполнения даёт сразу несколько преимуществ:
- Более лаконичный и удобный синтаксис, ближе к JavaScript, — выглядит интуитивно и требует меньше обращений к документации.
- Конструкции вроде
@if
сразу доступны в шаблоне — ничего импортировать не нужно. - Улучшенная проверка типов за счёт более точного сужения типов.
- Этот синтаксис работает на этапе сборки, а не в рантайме, что снижает нагрузку и помогает уменьшить размер бандла, а заодно улучшить Core Web Vitals.
- Кроме того, новая система управления потоком в шаблоне упростит внедрение реактивного подхода на основе signal-ов в будущем.
Подробнее о @if и новом синтаксисе шаблонов можно почитать в официальной документации: Angular Control Flow.
Что такое @if в Angular?
@if
для Angular — это то же самое, что обычный if
для JavaScript.
Это новый синтаксис шаблонов, с помощью которого можно условно отображать элементы в шаблоне Angular. Он встроен в сам фреймворк и позволяет показывать или скрывать части интерфейса в зависимости от логического условия.
В отличие от привычной структурной директивы *ngIf
, @if
не требует импорта даже в standalone-компонентах — он доступен по умолчанию.
Синтаксис стал короче и понятнее, а ещё поддерживает конструкции else if
и else
, чего раньше в *ngIf
не было.
Давайте разберёмся, как он работает.
Синтаксис @if
Вот простой пример, показывающий, как использовать новый синтаксис:
@Component({
template: `
@if (showHello) {
<h2>Hello</h2>
}
`,
})
class Test {
showHello: boolean = true;
}
Код выше отобразит заголовок Hello
только в том случае, если значение свойства showHello
— true
.
Видите, насколько этот синтаксис похож на обычный if
в JavaScript?
if (showHello) {
return `<h2>Hello</h2>`;
}
Почти один в один!
Синтаксис @if с else
В отличие от старого *ngIf
, новый синтаксис @if
поддерживает конструкцию else
.
Посмотрим на пример:
@Component({
template: `
@if (showHello) {
<h2>Hello</h2>
}
@else {
<h2>Goodbye</h2>
}
`,
})
class Test {
showHello: boolean = true;
}
Код выше работает так:
- Элемент
<h2>Hello</h2>
отображается, если свойствоshowHello
—true
. - Элемент
<h2>Goodbye</h2>
отображается, еслиshowHello
—false
.
Визуально это очень похоже на конструкцию if-else
в JavaScript — читается просто и интуитивно.
Синтаксис @if else if else
И это ещё не всё. Angular теперь поддерживает и конструкции else if
. Раньше с *ngIf
так сделать было нельзя — приходилось выкручиваться с дополнительными переменными или вложенными блоками.
@Component({
template: `
@if (showHello) {
<h2>Hello</h2>
}
@else if (showGoodbye) {
<h2>Goodbye</h2>
}
@else {
<h2>See you later</h2>
}
`,
})
class Test {
showHello: boolean = true;
showGoodbye: boolean = false;
}
Код выше работает следующим образом:
- Показывает заголовок
<h2>Hello</h2>
, еслиshowHello
—true
. - Если
showHello
—false
, ноshowGoodbye
—true
, отображается<h2>Goodbye</h2>
. - Если оба условия ложны, выводится
<h2>See you later</h2>
.
Согласитесь, это почти дословно повторяет логику обычного if
/ else if
/ else
в JavaScript — просто, понятно и без лишнего кода.
Почему @if больше не нужно импортировать?
Обратите внимание, что теперь нам не нужно импортировать директиву @if
из @angular/common
в шаблоны компонентов. Это потому, что @if
— не директива. Это часть движка Angular.
Новый синтаксис встроен прямо в ядро шаблонизатора, и поэтому доступен «из коробки» в любом шаблоне. Он работает так же, как интерполяция {{variable}}
или синтаксис i18n
— ничего дополнительно подключать не нужно.
Почему теперь не нужен синтаксис со звёздочкой (*)?
Раньше *
использовалась только потому, что ngIf
была структурной директивой. Эта звёздочка — просто синтаксический сахар, который упрощал работу с такими директивами.
А с @if
всё иначе: он не является структурной директивой, поэтому в звёздочке больше нет необходимости.
Почему @if лучше, чем *ngIf?
Кратко подведём итоги, чем @if
выигрывает у *ngIf
:
- Короче и понятнее
- Не требует импортов
- Поддерживает
else if
иelse
- Не даёт лишней нагрузки в рантайме
- Подготавливает почву для будущего развития Angular (например, signal-ов)
Как просто перейти на новый синтаксис @if
Если вы используете более старые версии Angular, можно перейти на новый синтаксис @if
с помощью Angular CLI.
В Angular CLI есть автоматическая миграция, которая обновит весь ваш код до нового синтаксиса @if
:
ng generate @angular/core:control-flow
Эта команда заменит все директивы *ngIf
в вашем проекте на новый синтаксис — и не только на @if
, но также на @for
и @switch
.
Чем @if отличается от скрытия элементов с помощью обычного CSS
В HTML мы можем скрывать элементы, управляя свойствами display
и visibility
:
- если установить
display: none
, элемент не отображается в документе; - если установить
visibility: hidden
, элемент не виден.
На первый взгляд результат один и тот же, но на самом деле это не так.
В обоих случаях скрытый элемент всё ещё существует в DOM, тогда как с @if
— нет: элемент вообще не попадает в DOM.
Антипаттерн с несколькими вложенными @if и пайпом async
Помните, в начале мы упоминали антипаттерн, связанный с @if
?
Если вы используете RxJS в своём коде, это важно, потому что такая ошибка встречается часто и напрямую касается @if
.
Речь идёт об использовании @if
не для отображения или скрытия элементов, а просто для получения значения из Observable
с помощью пайпа async
. Этот антипаттерн иногда называют «цепочкой async pipe» или «пирамидой ужаса».
Пример антипаттерна:
@if (user$ | async; as user) {
....
@if (course$ | async; as course) {
....
@if (lessons$ | async; as lesson) {
....
}
}
}
Как видно, мы используем async
для распаковки значений разных Observable
и сохраняем их в локальные переменные шаблона.
Затем эти переменные передаются в следующий @if.
Мы повторяем @if
и async
на нескольких уровнях страницы только ради доступа к данным — и больше ни для чего. Эта практика усложняет чтение и поддержку кода при большом количестве вложенностей. Кроме того, она усложняет рефакторинг, особенно если такая логика используется в нескольких местах на странице.
Хороший способ избежать этого — изменить компонент так, чтобы он предоставлял один data$ Observable
, содержащий все нужные данные.
Начнём с описания интерфейса:
interface PageData {
user: User;
course: Course;
lessons: Lesson[];
}
Затем создадим общий Observable
:
@Component({...})
export class Component implements OnInit {
private data$: Observable<PageData>;
ngOnInit() {
const user$ = // ... инициализация user$ Observable
const course$ = // ... инициализация course$ Observable
const lessons$ = // ... инициализация lessons$ Observable
this.data$ = combineLatest([user$, course$, lessons$])
.pipe(
map(([user, course, lessons]) => {
return {
user,
course,
lessons
}
})
);
}
}
Оператор combineLatest
— это один из способов объединить Observable
.
Наконец, используем @if
с async
в шаблоне:
@if (data$ | async; as data) {
....
{{data.course}}
{{data.user}}
{{data.lessons}}
}
Как видно, это избавляет от ненужных вложенных @if
и делает код гораздо более читаемым и поддерживаемым. Если применить такую структуру в начале шаблона, все нужные данные будут доступны в любом месте.
В этом гайде мы рассмотрели новый синтаксис @if
в Angular. Мы увидели, что он более лаконичный и читаемый, не требует импортов и поддерживает конструкции else if
и else
, чего не было в прежнем синтаксисе с *ngIf
.
С @if
нам больше не нужна директива NgIf
, как и странный местами синтаксис со звёздочкой (*), используемый для структурных директив.
Синтаксис @if
— мощное и удобное дополнение к инструментам Angular. Попробуйте его в деле!
«Доктайп» — журнал о фронтенде. Читайте, слушайте и учитесь с нами.
Читать дальше

Функции в JavaScript: полное руководство для начинающих
Функции в JavaScript — это блоки кода, которые выполняют определённую задачу и могут быть вызваны многократно. Они помогают структурировать программу, делая код чище и удобнее для поддержки. В этой статье мы разберём, как создавать функции, какие их виды существуют, и как использовать параметры, возвращаемые значения и другие возможности. Всё с примерами, чтобы вы могли сразу начать применять знания!
- 16 августа 2025

Как скачать JSON на JavaScript: метод fetch()
Метод fetch()
— это один из ключевых инструментов веб-разработки. Он появился как альтернатива устаревшему XMLHttpRequest
и сразу изменил привычный подход к работе с данными в браузере. Сегодня трудно представить приложение без динамической подгрузки: комментарии в соцсетях, бесконечные ленты новостей, онлайн-магазины с фильтрацией товаров — всё это работает благодаря запросам к серверу, которые обрабатываются без перезагрузки страницы.
- 13 августа 2025

document.open(), write(), writeln(), close() в браузере: когда можно и когда нельзя
Эти методы управляют потоковой записью HTML прямо в документ. Они удобны во время парсинга страницы, но опасны после загрузки: могут стереть текущее содержимое, блокируют поток, ухудшают производительность и плохо сочетаются с современными практиками. Ниже — безопасные сценарии, риски и актуальные альтернативы.
Функция находится в статусе ограниченной доступности в Baseline.
- 10 августа 2025

Как работает navigator.credentials: API для входа без пароля
navigator.credentials
— это интерфейс Web Authentication API, который позволяет браузеру управлять учётными данными пользователя. С его помощью можно безопасно получать, сохранять и автоматически подставлять данные для входа: пароли, токены или ключи. Это делает процесс аутентификации проще и безопаснее — особенно на сайтах, где важен пользовательский опыт и скорость входа.
Доступно в Baseline в статусе «Widely Available» с 2022-07-15
Как это работает
Сегодня вам бесплатно доступен тренажёр по HTML и CSS.
Вы можете запросить сохранённые данные с помощью navigator.credentials.get()
. Например, при загрузке страницы входа можно попытаться автоматически получить логин и пароль пользователя, если он ранее их сохранил:
const cred = await navigator.credentials.get({
password: true,
mediation: 'optional' // чтобы не мешать потоку, если данных нет
});
if (cred) {
console.log('Получен логин:', cred.id);
console.log('Пароль:', cred.password);
// Здесь можно автоматически отправить данные на сервер
}
Если учётные данные доступны, вы можете использовать их для входа без дополнительных действий от пользователя. Это особенно удобно на мобильных устройствах и в приложениях с частыми сессиями.
Можно ли сохранять логин и пароль вручную?
Да, через navigator.credentials.store()
вы можете сохранить учётные данные, которые пользователь только что ввёл:
const cred = new PasswordCredential({
id: 'user@example.com',
password: '12345678'
});
await navigator.credentials.store(cred);
Теперь при следующем визите вы сможете использовать get()
, чтобы получить эти данные без необходимости ручного ввода.
Безопасность
API работает только на HTTPS и требует, чтобы страница была в фокусе. Браузеры могут показывать уведомления, если данные используются без явного действия пользователя — это защита от скрытых запросов.
Поддержка и ограничения
- Поддерживается в Chrome, Edge, Android WebView.
- Safari и Firefox поддерживают только часть API или вовсе не поддерживают.
- Нельзя использовать на сторонних сайтах (только собственный домен).
Это API особенно хорошо подходит для проектов, где важна быстрая авторизация и нет смысла постоянно спрашивать логин-пароль у пользователя.
Больше обзоров веб-функций — в телеграм-канале HTML Academy.
Нашли ошибку или опечатку? Напишите нам.
- 3 августа 2025

Как использовать cause для более понятной обработки ошибок в JavaScript
Новое свойство cause
в объекте error
позволяет узнать исходную причину сбоя и облегчить отладку, особенно при повторении ошибок. Оно помогает выстроить цепочку событий и лучше понимать, где возникла проблема. Свойство доступно в Baseline в статусе «Widely Available» с 20 марта 2024 года.
- 3 августа 2025

HTTP/3: зачем он нужен и как понять, что он работает
HTTP/3 — это новая версия протокола обмена данными между браузером и сервером. В отличие от предыдущих HTTP/1.1 и HTTP/2, он построен поверх протокола QUIC и использует UDP вместо TCP. Это делает соединения быстрее, стабильнее и безопаснее.
HTTP/3 доступен в Baseline в статусе «Newly Available» с 2024-09-16.
Чем HTTP/3 лучше
🚀 Сегодня вам бесплатно доступен тренажёр по HTML и CSS.
- Быстрее устанавливается соединение. Больше нет отдельной стадии TLS: всё объединено.
- Меньше задержек. Даже при потере пакета браузер не ждёт восстановления всего потока, как в TCP.
- Устойчивость к переключениям сети. QUIC сохраняет соединение, даже если пользователь, например, переключился с Wi-Fi на LTE.
- Безопасность по умолчанию. Все соединения — только через шифрование (TLS 1.3).
Эти преимущества особенно важны для мобильных пользователей и тех, кто часто сталкивается с нестабильным интернетом.
Как работает
HTTP/3 основан на QUIC — это транспортный протокол от Google, который работает через UDP. Он умеет передавать данные параллельно по разным потокам, не блокируя друг друга при сбоях. QUIC внедрён в современные браузеры и серверные платформы.
Нужно ли что-то делать?
Если вы разработчик сайта или веб-приложения, то скорее всего ничего специально делать не нужно — браузер сам выберет HTTP/3, если сервер его поддерживает. Ваш сайт будет работать быстрее просто потому, что инфраструктура на это перешла.
Если вы настраиваете сервер (например, NGINX или Cloudflare), тогда стоит включить поддержку HTTP/3. На популярных платформах это можно сделать одной строчкой.
Как проверить, используется ли HTTP/3
В Chrome или Edge:
- Откройте DevTools → вкладка Network.
- Перезагрузите страницу.
- Добавьте колонку Protocol (правый клик по шапке таблицы).
- Посмотрите, есть ли
h3
у запросов — это и есть HTTP/3.
Через терминал (если у вас установлен curl):
curl -I --http3 https://example.com
Если сервер не поддерживает HTTP/3, будет ошибка или произойдёт откат на HTTP/2.
Через JavaScript
На уровне кода нельзя напрямую узнать версию протокола, но можно сделать fetch и посмотреть заголовки ответа через инструменты разработчика:
fetch('https://example.com')
.then(response => console.log(response.headers))
А затем проверить в DevTools, какой протокол был использован.
Что важно помнить
- HTTP/3 — это не «фича», которую вы вызываете в коде, а часть транспортного уровня.
- Он поддерживается большинством современных браузеров: Chrome, Firefox, Edge, Safari.
- Но он работает только с HTTPS, как и HTTP/2.
Заключение
HTTP/3 делает интернет быстрее, безопаснее и стабильнее — особенно на слабых сетях и мобильных устройствах. Вам не нужно менять HTML, JavaScript или CSS, чтобы получить преимущество. Главное — чтобы сервер и хостинг поддерживали эту технологию.
Если вы разрабатываете сайт с упором на производительность — убедитесь, что HTTP/3 включён. Это шаг вперёд к более отзывчивым и доступным интерфейсам.
Больше обзоров веб-функций — в телеграм-канале HTML Academy.
Нашли ошибку или опечатку? Напишите нам.
- 27 июля 2025

Как работает Map в JavaScript
Коллекция Map
— это встроенный объект JavaScript, предназначенный для хранения пар ключ-значение. Она похожа на обычный объект ({}
), но обладает важными преимуществами:
- Любые типы ключей — строки, числа, объекты, функции.
- Сохранение порядка вставки — перебор идёт в том порядке, в котором вы добавили элементы.
- Удобные методы для работы —
set()
,get()
,has()
,delete()
,clear()
и итерации черезfor...of
.
Эта структура особенно полезна, если вы хотите чётко контролировать порядок элементов и не ограничиваться только строковыми ключами, как в обычных объектах.
Пример: создаём коллекцию и работаем с ней
? Сегодня вам бесплатно доступен тренажёр по HTML и CSS.
const userInfo = new Map();
userInfo.set('name', 'Алексей'); // строка
userInfo.set(42, 'Число'); // число
userInfo.set(true, 'Булево'); // логическое значение
console.log(userInfo.get(42)); // Выведет: 'Число'
Здесь мы добавили три элемента с разными типами ключей. Именно это отличает Map
от обычного объекта — вы можете использовать, например, ключи-объекты или даже функции:
const objKey = { id: 1 };
const fnKey = () => {};
userInfo.set(objKey, 'объект');
userInfo.set(fnKey, 'функция');
console.log(userInfo.get(objKey)); // 'объект'
Перебор Map
Вы можете пройтись по элементам Map
с помощью for...of
:
for (const [key, value] of userInfo) {
console.log(key, value);
}
Также доступны методы:
map.keys()
— только ключи,map.values()
— только значения,map.entries()
— пары [ключ, значение].
console.log([...userInfo.keys()]); // Все ключи
console.log([...userInfo.values()]); // Все значения
Проверка наличия, удаление и очистка
userInfo.has('name'); // true
userInfo.delete(42); // удаляет элемент с ключом 42
userInfo.clear(); // полностью очищает Map
Отличия от объектов
Особенность | Map | Object |
---|---|---|
Типы ключей | любые | только строки и символы |
Порядок | сохраняется | не гарантирован |
Итерация | проще и более гибкая | требует Object.entries и т. д. |
Производительность | быстрее на больших объёмах | может быть медленнее |
Когда использовать Map
Используйте Map
, если:
- Нужен предсказуемый порядок элементов.
- Ключами должны быть не только строки.
- Нужно часто добавлять, удалять или перебирать элементы.
- Важно избежать конфликтов с ключами вроде
__proto__
илиhasOwnProperty
.
Заключение
Map
— мощная и удобная структура данных, особенно когда работа с обычными объектами становится громоздкой. Она расширяет привычные возможности, делает код чище и понятнее, а также даёт контроль над ключами и порядком. В современном JavaScript Map
— это стандарт, на который стоит ориентироваться в сложных приложениях.
Больше обзоров веб-функций — в телеграм-канале HTML Academy.
Нашли ошибку или опечатку? Напишите нам.
- 27 июля 2025

10 приёмов работы с console, которые должен знать каждый разработчик
Консоль разработчика — важный инструмент отладки в JavaScript. С помощью методов console
можно выводить информацию о работе скрипта, отслеживать ошибки, логировать данные и анализировать производительность. В браузере это доступно через панель разработчика (DevTools), обычно на вкладке «Console».
- 18 июля 2025

Оператор ** в JS: возведение в степень
Оператор **
— это современный и лаконичный способ возводить числа в степень в JavaScript.
Он появился в стандарте ECMAScript 2016 и заменил собой более громоздкий вызов Math.pow()
.
Вместо Math.pow(3, 4)
теперь можно написать 3 ** 4
, что читается и набирается проще.
- 25 июня 2025

Полный гайд по объекту Date в JavaScript
Объект Date
позволяет создавать, сравнивать и форматировать дату и время. Используется для отображения текущего времени, вычисления интервалов и работы с таймзонами в веб-приложениях.
Доступно в Baseline в статусе «Widely Available» с 2018-01-29
- 25 июня 2025