Жаропонижающие средства для детей назначаются педиатром. Но бывают ситуации неотложной помощи при лихорадке, когда ребенку нужно дать лекарство немедленно. Тогда родители берут на себя ответственность и применяют жаропонижающие препараты. Что разрешено давать детям грудного возраста? Чем можно сбить температуру у детей постарше? Какие лекарства самые безопасные?
CSS-переменные, или, точнее, кастомные CSS-свойства, доступны в Chrome начиная с 49 версии. Они могут быть полезны для уменьшения количества повторяющегося кода в CSS, создания впечатляющих эффектов вроде смены тем на лету и, потенциально, создания полифилов для будущих возможностей CSS.
Хаос в CSS
Обычная практика при разработке приложения - составить набор фирменных цветов, которые будут использоваться, чтобы поддержать единый стиль. Увы, многократное использование этих цветов в CSS не только является рутинной работой, но ещё и создаёт пространство для возникновения ошибок. Если в какой-то момент один из цветов нужно будет поменять, разработчик может неосторожно воспользоваться поиском и заменой по всему документу, что в большом проекте может быть довольно опасно.
В последнее время многие разработчики стали использовать CSS-препроцессоры типа SASS или LESS, которые решают эту проблему с помощью переменных. Хотя эти инструменты заметно увеличили продуктивность разработки, препроцессорные переменные имеют очень серьёзный недостаток: они статичны и не могут меняться на лету. Появление возможности динамически менять переменные не только позволит на лету менять темы сайта или приложения, но также означает значительное расширение возможностей отзывчивого дизайна и возможность создания полифилов для будущих свойств CSS. С выходом Chrome 49 переменные стали доступны в виде кастомных CSS-свойств.
Кастомные свойства в двух словах
Кастомные свойства расширяют наш CSS-инструментарий двумя новыми возможностями:
- Автор кода может присваивать произвольные значения свойствам с придуманными им самим именами.
- Функция var() позволяет затем использовать эти значения в других свойствах.
Краткий пример для демонстрации:
:root { --main-color : #06c ; } #foo h1 { color : var (--main-color); }Функция var() возвращает значение кастомного свойства и заменяется им, в результате чего получается color: #06c; . Если кастомное свойство где-то определено в таблице стилей, оно будет доступно функции var .
На первый взгляд синтаксис может показаться странным. Многие разработчики недоумевают: «Почему бы просто не использовать $foo в качестве имён переменных?» Это было сделано специально для повышения гибкости и возможности в перспективе создавать макросы для $foo . Более подробно об этом можно прочесть в статье одного из авторов спецификации, Таба Аткинса (Tab Atkins).
Синтаксис кастомных свойств
Синтаксис кастомных свойств довольно прост:
Header -color : #06c ;
Обратите внимание, что кастомные свойства регистрозависимы, то есть --header-color и --Header-Color - это два разных свойства. Хотя синтаксис поначалу может показаться незамысловатым, на самом деле он позволяет сделать довольно много. К примеру, ниже - пример валидного кастомного свойства:
--foo: if (x > 5 ) this.width = 10 ;
Хотя это выражение не будет работать в качестве переменной (а также не будет валидным значением любого обычного свойства), потенциально оно может быть прочитано и обработано на лету с помощью JavaScript. Это означает, что кастомные свойства могут открыть доступ ко всевозможным интересным техникам, недоступным с нынешними CSS-препроцессорами. Так что если вы, позёвывая, думаете что-то вроде «Какая разница, у меня есть SASS…», подумайте ещё раз! Это не те переменные, с которыми вы привыкли работать.
Каскад
Кастомные свойства следуют стандартным правилам каскада, так что вы можете определить одно и то же свойство на разных уровнях специфичности:
:root { --color: blue; } div { --color: green; } #alert { --color: red; } * { color: var(--color); } <p > У меня синий цвет, унаследованный от root!p > <div > А для меня установлен зелёный!div > <div id ="alert" > Ну а для меня - красный! <p > И для меня красный: из-за наследования!p > div >
Это означает, что можно использовать кастомные свойства в медиавыражениях для управления отзывчивым дизайном. Примером использования может служить увеличение внешних отступов от основных структурных элементов при увеличении размеров экрана:
:root { --gutter : 4px ; } section { margin : var (--gutter); } @media (min-width: 600px ) { :root { --gutter : 16px ; } }Необходимо отметить, что вышеприведённый приём невозможно повторить используя CSS-препроцессоры, потому что они неспособны переопределять переменные внутри медиавыражений. У этой возможности огромный потенциал!
Также есть возможность использовать кастомные свойства, получающие своё значение из других кастомных свойств. Это может быть крайне полезно для настройки тем:
:root { --primary-color : red; --logo-text : var (--primary-color); }Функция var()
Чтобы получить и использовать значение кастомного свойства, понадобится функция var() . Вот её синтаксис:
var (Здесь
Этот метод особенно пригодится для стилизации веб-компонент, использующих Shadow DOM, поскольку кастомные свойства могут пересекать теневые границы. Автор веб-компоненты может создать начальный дизайн при помощи фолбеков, а потом настроить стили при помощи кастомных свойств:
<x-foo > #shadow <style > p { background-color : var (--text-background, blue); } style > <p > У этого текста жёлтый фон, потому что так указано в документе! Иначе был бы синий. p > x-foo > /* В стилях основного приложения: */ x-foo { --text-background: yellow; }При использовании var() нужно иметь в виду несколько нюансов. Например, переменные не могут быть именами свойств:
.foo { --side : margin-top; var (--side): 20px ; }Это не является эквивалентом присваивания margin-top: 20px; . Более того, второе объявление не является валидным, и выбросит ошибку.
Аналогично, невозможно создать значение, часть которого берётся из переменной:
.foo { --gap : 20 ; margin-top : var (--gap)px ; }Это тоже не является эквивалентом margin-top: 20px; . Чтобы собрать значение, понадобится кое-что другое: функция calc() .
Создание значений с помощью calc()
На случай, если вы никогда раньше с ней не работали, функция calc() - это небольшой, удобный инструмент, позволяющий выполнять вычисления, чтобы определять значения в CSS. Она поддерживается всеми современными браузерами , и её можно использовать вместе с кастомными свойствами для создания новых значений. Например:
.foo { --gap : 20 ; margin-top : calc (var(--gap) * 1px ); /* зашибись */ }Работа с кастомными свойствами в JavaScript
Чтобы получить значение кастомного свойства, используйте метод getPropertyValue() объекта CSSStyleDeclaration.
<p > Этот абзац красного цвета!p > /* JS */ var styles = getComputedStyle(document.documentElement); var value = String(styles.getPropertyValue("--primary-color")).trim(); // value = "red"
Аналогично, чтобы динамически менять значение кастомного свойства, используйте метод setProperty() объекта CSSStyleDeclaration .
/* CSS */ :root { --primary-color: red; } p { color: var(--primary-color); } <p > А теперь этот абзац зелёного цвета!p > /* JS */ document.documentElement.style.setProperty("--primary-color", "green");
Также при задании значения кастомного свойства на лету можно использовать ссылку на другое кастомное свойство, вставив функцию var() в вызов setProperty() .
/* CSS */ :root { --primary-color: red; --secondary-color: blue; } <p > Здорово! Этот абзац синего цвета!p > /* JS */ document.documentElement.style.setProperty("--primary-color", "var(--secondary-color)");
Поскольку кастомные свойства могут ссылаться на другие кастомные свойства, можете представить какие интересные динамические эффекты можно будет делать подобным образом.
Поддержка браузерами
На данный момент кастомные свойства поддерживаются в Chrome 49, Firefox 42, Safari 9.1, и iOS Safari 9.3.
Оригинальная статья: CSS Variables: Why Should You Care? Статью вычитывали:
При работе с CSS аргументами часто может быть полезным думать о них, как о двух разных типах:
Первичные пользовательские свойства
Это свойство, которое вы можете изменять в разных селекторах, в медиа-запросах или с помощью псевдо-селекторов:hover или:focus или, например, с помощью JavaScript. Обычно она содержит одно значение:
: root { --wrapper: 900px; --guter: 10px; }
Вторичные пользовательские свойства
Это аргументы, которые вычисляются из других. Например, в коде ниже размер ячейки сетки(grid) --rowHeight — вычисляется из нескольких первичных. Результат вычисления применяется к свойству, но никогда не обновляется вручную — только пересчитывается в результате изменения первичных CSS переменных.
Может быть полезно добавлять префикс вторичным аргументам, как в этом примере, чтобы вы и другие люди, работающие с вашим кодом, знали, что их нельзя менять вручную:
:root { --wrapper: 900px; --guter: 10px; / * s-префикс обозначает вторичное пользовательское свойство * / --s-rh:calc((var(--wrapper)-(3*var(--guter)))/4); }
Единственным исключением могла бы быть ситуация, когда вам нужно изменить способ вычисления значения, но теоретически после его установки он должен быть постоянным. Это может отбить охоту у разработчиков, не знакомых с вашим кодом вносить изменения без необходимости.
Область видимости
Во моих примерах я объявляю CSS переменные в:root , который представляет собой элемент :
:root { ---bgColor: red; }
Однако, в этом нет строгой необходимости, и более того, это не очень хорошая практика .
Большинство причин, по которым не рекомендуется задавать CSS переменные в глобальной области видимости в Javascript также применимы к CSS. Если бы вы при этом захотели использовать пользовательское свойство для фона-цвета -bgColor в разных компонентах, то столкнулись бы со всеми проблемами, связанными с областью видимости. Лучше всего объявлять их в селекторе, например, если вы работаете в компонентах:
My-component { ---bgColor: red; } .some-other-component { ---bgColor: blue; }
В вышеприведенном фрагменте кода -bgColor привязан к каждому компоненту, поэтому вы можете использовать переменную с тем же именем, не опасаясь, что это повлияет на что-либо вне этого компонента.
Установка величин по умолчанию
С помощью CSS переменных вы можете установить величину(или несколько величин) по умолчанию. Это означает, что в некоторых ситуациях вам нужно только объявить свои переменные в той точке, в которой они должны измениться. В коде ниже CSS переменная -bgColor для поля объявляется только при достижении ширины в 40em — до этого она принимает значение по умолчанию(red):
В этом втором примере вы можете видеть, что селекторы h1 и p имеют разные величины по умолчанию для своего свойства цвета, но оба принимают переменную при наведении:
Использование пользовательских свойств с препроцессорными
Один из недостатков CSS-аргументов — они не работают в медиа-запросах или псевдоклассах, например:nth-child(var(-n)) не будет работать. Поэтому, скорее всего, вы все равно захотите использовать препроцессорные аргументы .
Я бы предостерег от смешивания этих двух типов пользовательских свойств, если вы не полностью понимаете их отличия. Аргументы Sass скомпилируются до того, как ваш код попадает в браузер, тогда как в CSS они не получат вычисленное значение, пока не попадут в браузер. Это означает, что в приведенном ниже коде величина ширины для.box1 будет работать, но.box2 выдает ошибку, потому что величина для -halfWidth передается браузеру в виде строки:
$width: 600px; $halfWidth: $width/2; :root { --halfWidth: $width/2; } .box1 { ширина: $halfWidth; } .box2 { width: var(--halfWidth); // это некорректно }
Однако вы можете использовать calc() , как в предыдущих примерах. Смотрите результат в ниже:
Если вы проинспектируете элемент в консоли Chrome и перейдете на вкладку «Вычисляемые стили»(Computed Styles), вы увидите, что значение ширины для.box2 не вычисляется. В нашей компании мы используем много функций Sass, например, для вычисления rem из пикселей при определении размера. Я обнаружил, что это оказалось проблемой, когда я попытался передать функцию Sass в аргумент CSS, например, --width: rem (600px) . Есть плагин PostCSS , который может преобразовывать пиксели в rem чтобы достичь желаемого результата, но мне нужно будет немного поэкспериментировать с ними, прежде чем я буду уверенно рекомендовать их использовать с CSS переменными.
Тем не менее, существуют сценарии, в которых использование препроцессорных и CSS переменных в одном блоке кода вместе имеет смысл, например, в медиа-запросах, как упоминалось ранее.
Кто уже давно занимается вёрсткой, много раз чувствовали, что CSS-код труден для правок. Например, Вам захотелось поменять цветовую гамму на всей странице. Что для этого нужно? Поменять у всех блоков один цвет на другой. Неудобно? Согласен, для этого придумали SASS и LESS , однако, это так себе выход. Например, Вам хочется заменить всю цветовую гамму через JavaScript , или увеличить ширину нескольких блоков в 2 раза? Очевидно, что работа эта требует написание однообразного кода. К счастью, относительно недавно появилась возможность задавать переменные прямо в CSS , и браузеры их без проблем обрабатывают. Об этом мы поговорим в этой статье.
Давайте разберём следующий код:
Некоторый текст...
Объявляются в псевдоэлементе root (хотя можно и прямо в самих элементах объявлять переменные). Использование же их очень простое: вместо конкретного значения свойства пишется var(имя_переменной) . Особенно интересно использование переменных вместе с функцией calc() . Благодаря этому можно увеличивать или уменьшать множество элементов на сайте, сохраняя при этом все пропорции.
По мере роста проекта его CSS файлы разрастаются и засоряются. Справиться с этим помогут CSS переменные, они дают возможность повторно использовать повторяющиеся CSS свойства.
Раньше переменные можно было использовать только в Less или Sass, но это препроцессоры и требуют компиляции перед использованием. Теперь переменные доступны в чистом CSS.
Объявление и использование переменных в CSS
На переменные в CSS распространяются те же ограничения и правила наследования, что и на обычные CSS правила. Самый простой способ использовать их — объявить их глобально в псевдо-классе :root , так все остальные селекторы смогут его наследовать.
:root{ --awesome-blue: #2196F3; }
Для доступа к значению переменной надо использовать конструкцию var(…) . Обратите внимание, что имена зависят о регистра, то есть —foo != —FOO .
Some-element{ background-color: var(--awesome-blue); }
Поддержка
На данный момент Firefox поддерживает переменные в CSS. В Google Chrome начиная с версии 49 это возможность включена, если вы используете версию 48 или более старую, то вы можете вручную включить поддержку, перейдя на страницу chrome://flags/ и включить Enable experimental Web Platform features .
Пример 1 — Цветовые схемы
Переменные в CSS полезны, когда вам надо применить одно и то же свойство для разных элементов, например, повторяющиеся цвета в теме. Вместо того, чтобы копировать один и тот же цвет везде где он нужен, мы можем использовать переменную.
Теперь, если заказчик захотел поменять цвет на странице, мы можем изменить весь стиль поменяв одну строку (строку объявления переменной). Без переменных нам пришлось бы менять все места, где используется этот цвет.
Пример 2 — Понятные названия для сложных свойств
Еще одна замечательная возможность, которую дают CSS переменные — спрятать сложное свойство за коротким понятным именем. Хороший пример — CSS свойства с несколькими параметрами, например: box-shadow , transform и font .
Объявив переменную с понятным именем мы сможем использовать её не тратя время на разбор сложного свойства.
Пример 3 — Динамические переменные
Когда переменная объявлена несколько раз, к ней применяются стандартные CSS правила наследования. Следующий пример демонстрирует как можно динамически управлять свойствами в зависимости от действий пользователя, при этом сохранить краткий и чистый код.
Наведите на зеленый и на синий блоки.
Заключение
Как видите переменные довольно просты в использовании и их определенно стоит попробовать. Рассмотрим еще пару вещей, на которые стоит обратить внимание:
- Функция var() имеет второй параметр, который будет использован в качестве значения, если переменная вызовет ошибку: width: var(--custom-width, 20%);
- При объявлении собственного правила так же можно использовать переменные: --base-color: #f93ce9; --background-gradient: linear-gradient(to top, var(--base-color), #444);
- Переменные можно использовать с еще одним нововведением в CSS — функцией calc(). Однако работает это пока только в Firefox: --container-width: 1000px; max-width: calc(var(--container-width) / 2);
На этом все! Попробуйте использовать CSS переменные, но пока избегайте их в серьезных проектах.
Последнее обновление: 18.11.2018
Как и в языках программирования, в CSS можно определять переменные. Переменные в CSS могут хранить стандартные значения, которые можно присвоить, обычным свойствам CSS, например, цвет фона, цвет шрифта, высоту шрифта, ширину и высоту элементов и так далее. Затем их можно многократно использовать в различных частях определения стилей.
Стоит отметить, что хотя часто используется термин "переменные" (css variables), официально они называются custom properties (кастомные или настраиваемые свойства).
Определение переменных CSS должно начинаться с префикса -- , например, --my-color . Они могут быть определены для любого элемента. Например:
Третий блок.
Здесь в коде CSS для элемента div определены две переменныx: --text-color и --text-size
Text-color: #ff4757; --text-size: 20px;
С помощью выражения var() мы можем ссылаться на эти переменные в любой части кода CSS:
#p1 { color: var(--text-color); font-size: var(--text-size); }
В итоге первый блок получит высоту шрифта из --text-size, второй блок получит цвет шрифта из --text-color, а третий блок получит оба этих компонента.
Если нам потребуется изменить цвет текста, достаточно будет изменить значение переменной.
Подобные переменные можно определить для любого элемента. При этом они наследуется дочерними элементами. Так, в примере выше мы видим, что вложенный элемент параграфа получает стили от родительского div.
Но если бы параграф находился бы вне блока div:
Третий блок.
Тогда бы значения из переменных к нему бы не применялись:
Если же необходимо, чтобы переменные могли бы использоваться глобально для всех элементов, тогда их определяют для элемента :root
:root{ --text-color: #ff4757; --text-size: 20px; }
Резервные значения
При определения переменных могут содержать какие-нибудь ошибки, например, переменная не определена (вообще не определена или в ее названии опечатка). В этом случае мы можем указать при применении переменной резервные значения, которые бдут применяться в случае, если значение переменной некорректно.
Второй параметр в функции var() позволяет задать резервное значение. Это может быть как точное значение, так и опять же значение другой переменной:
Color: var(--text-color, var(--reserved-color));
Для второй переменной можно также определить резервное значение, если она некорректна:
Color: var(--text-color, var(--reserved-color, red));
