У CSS-фреймворков есть одна общая черта - они не признаются многими веб-дизайнерами.

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

Но, выполняя недавно одно небольшое исследование, я столкнулась с некоторыми из фреймворков и изменила свое мнение об этих продуктах.

Существующие фреймворки

На сегодняшний день существует большое количество различных CSS-фреймворков (прим. переводчика: Bootstrap, KickStart, Skeleton, 960gs, Blueprint, YUI3CSS), начиная с самых простых, которые предоставляют только разметку страницы; и заканчивая сложными, которые содержат в своем комплекте формы, типографику и модули плавающей разметки.

Что я могу сказать, исходя из своего опыта работы - дизайнеры и дизайнерские агентства регулярно пользуются такими фреймворками, как Blueprint CSS или же 960 Grid System (часто называемой 960gs для сокращения). Также популярен Yahoo!’s YUI Grids. Это три фреймворка, с которыми я экспериментировала.

Предубеждение против фреймворков

Обо всех фреймворках у меня было представление: они созданы для веб-дизайнеров, которые хотят иметь быстрое решение для поставленной перед ними задачи и у которых нет своего собственного базового комплекта на CSS; или же для таких дизайнеров, которые просто не хотят понимать, как работает CSS. В любом случае, фреймворки созданы для тех, кто ищет быстрое легкое решение и не хочет сильно “заморачиваться”.

Но существует одна вещь, которую я не люблю - это пуристы, которые не открыты для чужих идей; которые никогда не готовы изменить свое собственное мировоззрение. Я люблю CSS и могу быть пуристкой в некоторых случаях. Но я также понимаю, что не может быть ничего совершенного и что таблицы стилей могут также быть неряшливыми. Мы все стремимся создавать красивый и чистый код, который будет одновременно валидным и семантичным; но при этом который прекрасно работает в реальном проекте; который может быть легко обновлен; который может редактироваться несколькими людьми с разным представлением о “совершенстве” и имеющим разный опыт работы, а также квалификации.

Но я отвлеклась от темы. Что я хотела сказать, так это то, что все мы иногда используем странные имена классов и никто от этого еще не пострадал. Это та вещь, за которую часто критикуют CSS-фреймворки. Имена классов наподобие grid_16 или span-8 далеки от идеала, но если принимать во внимание поставленную перед ними задачу - быть пригодными для использования в любом проекте - то в этом есть смысл (что касается большинства случаев).

Несемантичность имен классов может компенсироваться “хорошими” именами идентификаторов (например, class="span-8" id="aside") или же применением семантичных элементов стандарта HTML5 (например, aside или section).

Когда я пробовала работать с фреймворками, я задавала несколько вопросов в Twitter чтобы разобраться с ними (большей частью это были жалобы, если быть честной). Не нужно быть волшебником, чтобы догадаться - многие люди упрекали меня за использование фреймворков. Я получила много негативных комментариев и помню даже, как один из пользователей сказал, что фреймворки бесполезны. Один или два человека сказали, что они все же используют фреймворки и очень довольны этим фактом (мнения при этом могут расходиться).

Каркасность фреймворков

Мое мнение всегда было таково, что фреймворки полезны хотя бы тем фактом, что могут создавать каркасы страниц под браузеры. Поэтому я решила создать одну и ту же очень простую разметку в трех фреймворках - Blueprint, 960gs и YUI 3 Grids - для того, чтобы сравнить.

Фреймворк CSS Blueprint

Фреймворк CSS Blueprint был создан в 2007 году автором Olav Bjørkøy. Этот фреймворк считается наиболее всесторонним, так как в нем уделено внимание не только созданию разметки на основе модульной сетки, но и продуманной системе типографики, учитывающей такой важный момент веб-дизайна, как вертикальный ритм. Во фреймворк также включена таблица сброса стилей (reset) и таблица стилей для вывода на печать (print), а также основные стили для веб-форм:

Blueprint CSS

Этот фреймворк использует 24-колоночную сетку (каждая колонка шириной 30 пикселей и у каждой колонки есть правый margin в 10 пикселей). Но вы можете создать свою собственную разметку с помощью встроенного конструктора.

Использовать Blueprint очень просто, так как в нем применяется “обертка” с классом container, внутри которой расположены все остальные блоки страницы, формирующие сетку. В зависимости от ширины каждого из внутренних контейнеров, можно использовать соответствующие классы.

Например, класс span-24 для блока, который должен занимать всю ширину своего блока-родителя (то есть - все 24 колонки). Или же класс span-8 для блока, который должен занимать только 8 из 24 колонок макета. Если блок является последним внутри своего блока-родителя или колонки, то ему необходимо присвоить дополнительный класс last (прим. переводчика: чтобы убрать правый margin у этого блока и не нарушать разметку).

Рабочий пример HTML-разметки, созданной в этом фреймворке, показан ниже:

Мною в коде также добавлено имя класса b для тех контейнеров, которые имеют контент. Для этих контейнеров мне необходимо добавить легкую фоновую заливку и небольшой margin внизу, для того, чтобы каркас смотрелся лучше (здесь создается пример “на быструю руку”, поэтому допустимо добавление этого класса в качестве внутренних стилей):

.b { background:#d4d4d4; margin-bottom:10px; }

Ниже показана картинка уже готового каркаса, созданного во фреймворке “CSS Blueprint”:

Каркас, созданный в фреймворке CSS Blueprint

Создание этого фреймворка заняло у меня меньше 10 минут (я знаю, что каркас получился очень простым), включая быстрое чтение “Руководства пользователя”.

960gs

Фреймворк 960 Grid System был создан в марте 2008 года автором Nathan Smith. При его разработке особое внимание уделялось модульной сетке; несмотря на то, что этот фреймворк также предоставляет поддержку основных типографских стилей, основная его задача - создание кросс-браузерного каркаса страницы (имеющего полную поддержку браузерами и идентификатор A-Grade [по классификации Yahoo][6]). А также самых разных модификаций, основанных на общем шаблоне модульной сетки.

Фреймворк 960 Grid System

В этой статье для фреймворка 960gs был создан еще более проста разметка, так как основная идея была показать разницу между именованием классов и вложенностью между различными фреймворками.

Фреймворк 960 Grid System по умолчанию работает с двумя типами модульных сеток - 12-колоночной или 16-колоночной. Для блока-обертки, включающего в себя все внутренние элементы сетки, необходимо добавить класс с именем container_16 (или container_12); внутренние элементы должны иметь имена классов grid_16, grid_14 и так далее в зависимости от того, сколько колонок они должны занимать по ширине.

Ниже показана окончательная HTML-разметка, созданная в этом фреймворке:

 class="container_16">
  class="grid_16 b">
  Header
 
class="grid_4 b"> Sidebar class="grid_12 b"> Main content class="grid_16 b"> Footer

И вот как будет выглядеть эта разметка в окне браузера:

Каркас, созданный во фреймворке 960 Grid System

Также, как и с Blueprint, для фреймворка 960 Grid System существует несколько online-сервисов для дополнительной настройки этого фреймворка. Сервис [Fluid 960 Grid System][9] основан на оригинальном 960gs, но позволяет создавать как фиксированные, так и резиновые макеты; а также включает в себя основные стили для таких элементов, как навигация, таблицы, формы, статьи и типографику.

YUI 3 Grids

Фреймворк YUI 3 Grids является частью библиотеки Yahoo! User Interface (YUI). В состав библиотеки, помимо CSS, входят скрипты на JavaScript. Этот фреймворк работает точно также, как и все остальные рассмотренные в этой статье фреймворки, но с одной лишь разницей: в нем нет контейнера-обертки с предустановленной шириной; есть только предустановленные “единицы”, в которых измеряется ширина контейнера и которые наследуют все остальные контейнеры, в него вложенные.

Фреймворк YUI 3 Grids

В этом случае, чтобы задать ширину для контейнера модульной сетки, эту ширину устанавливают для элемента body:

body {
 margin: auto;
 width: 960px;
}

Свойство margin: auto размещает контейнер по центру страницы. Затем, также как и в остальных фреймворках, мы должны добавить контейнер-обертку с классом yui3-g. Контейнеры должны принимать имена классов, основанных на процентах от ширины, которую они должны занимать.

Например, если боковая панель занимает треть от общей ширины всей страницы, имя ее класса должно быть yui3-u-1-3; если основной контейнер должен занимать две трети от всей ширины страницы, имя класса для нее должно быть следующим - yui3-u-2-3. YUI имеет список предустановленных классов единиц (этот список представлен на домашней странице фреймворка).

Окончательная HTML-разметка имеет вид:

 class="yui3-g">
  class="yui3-u-1 b">
  Header
 
class="yui3-u-1-3 b"> Sidebar class="yui3-u-2-3 b"> Main content class="yui3-u-1 b"> Footer

И готовый вид будет таким:

Каркас, созданный во фреймворке YUI 3 Grids

Обратите внимание, что фреймворк YUI 3 Grids не имеет промежутков (gutter) между колонками - я считаю это недостатком.

Вывод статьи

Из трех рассмотренных в этой статье фреймворков для меня однозначным победителем является CSS Blueprint. Руководство пользователя по этому фреймворку размещено на главной странице сайта (не нужно искать); оно написано простым и ясным языком, со множеством примеров. А тот факт, что в него включена хорошая поддержка типографики, добавляет этому фреймворку большой плюс.

Еще одним плюсом CSS Blueprint является развитое сообщество, которое постоянно создает под него новые плагины, темы и другие инструменты, которые расширяют возможности данного фреймворка.

Для меня фреймворк 960gs оказался гораздо более трудным для понимания; у меня заняло более получаса усилие понять, как работает этот фреймворк и создать в нем макет страницы. В противоположность сайту Blueprint, домашняя страница 960gs не имеет ясного и простого руководства пользователя, поэтому мне пришлось искать “на стороне” описания по использованию этого фреймворка. Мне понравился фреймворк Fluid 960gs, но у меня сложилось впечатление, что он является подобием Blueprint.

Большинство людей, с которыми я общалась во время своих экспериментов с фреймворками, сказали, что они вообще не пользуются ими. Но те, которые говорили, что пользуются, упоминали именно фреймворк 960gs. Поэтому, возможно, я в его изучении зашла “не с той стороны”. Существует множество красивых сайтов, построенных на этом фреймворке (для этого просто посмотрите на домашнюю страницу проекта) наподобие великолепного Black Estate Vineyard:

Black Estate Vineyard на 960gs

Тот факт, что фреймворк YUI является подстраиваемым под любую ширину - это большой плюс. Но уменьшенное количество комбинаций с “единицами” делает использование этого фреймворка несколько неудобным; мне показалось немного неправильным, что существуют какие-то ограничения при работе с разметкой страницы. Если мое утверждение неверное, прошу меня исправить, так как я не нашла объяснения данного момента в руководстве пользователя.

Заключение

Прим. переводчика: схалтурил - заключение мною переведено только частично; ну любит девушка многословные выводы …

Как уже упоминалось мною раньше, я считаю CSS-фреймворки “быстрым решением”. И я все еще считаю, что так оно и есть; но в то же время мне они не кажутся плохой штукой. Зачем тратить часы на создание прекрасного, но созданного вручную CSS-макета, когда существуют великолепные готовые решения, уже созданные за нас? Жизнь - это не только кодинг (это действительно так) и существуют более прекрасные вещи, которые я могу сделать за то время, которое я бы потратила на решение проблем, уже решенных за меня.

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

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

И я, конечно, не осуждаю тех дизайнеров или дизайнерские агентства, которые используют “решения из коробки” наподобие Blueprint, так как выгоды использования превосходят такие незначительные минусы, как слишком раздутый код или несемантичные имена классов.

Мой вердикт: нет, фреймворки - это не зло.

Оригинал статьи - Are CSS Frameworks Evil?


При создании CSS-правил сталкивались ли вы с ситуацией, когда при откате (fallback) шрифта у последнего менялась пропорциональность и текст начинал выглядеть больше или меньше оригинального?

Возможно, новое замечательное свойство font-size-adjust из стандарта CSS3 поможет нам исправить ситуацию?

Что делает свойство font-size-adjust

Первое, что нужно сделать - это использовать браузер Firefox для того, чтобы страница с примером отображалась правильно. Да, не Safari, а только Firefox!

Свойство font-size-adjust позволяет установить оптимальный коэффициент пропорциональности при использовании отката шрифта; если шрифт-заменитель имеет коэффициент пропорциональности, отличающийся от такого же коэффициента у главного шрифта, высота текста x-height (которая приблизительно равна размеру буквы х этого шрифта в нижнем регистре) останется неизменной.

Давайте рассмотрим рисунок ниже:

Сравнение двух шрифтов

Как видим на рисунке, шрифт Baskerville и Georgia имеют разный коэффициент пропорциональности. Если произойдет замещение шрифта (с учетом того, что шрифт Baskerville является главным), то в реальности размер шрифта визуально будет больше, при одинаковой величине.

Прим. переводчика. Еще раз - своими словами. На картинке видно, что одинаковые буквы А размером 320 пикселей у шрифта Baskerville и у шрифта Georgia на самом деле не одинаковые. Пропорции (о которых говорит Inyaili) букв у этих шрифтов разные! Теперь вспомним, как задается обычно шрифт в CSS-правилах.

К примеру, так:

font: bold 12px/18px Baskerville, Georgia, serif;

или же так:

font-family: Baskerville, Georgia, serif;

То есть, в правилах мы устанавливаем сначала главный шрифт Baskerville, который должен отображаться на странице; и вспомогательный шрифт Georgia, который должен отображаться, если браузер не найдет главный шрифт Baskerville (это и есть откат шрифта, о котором упоминается в этой статье). В принципе - это основы CSS .

Теперь, если принимать во внимание картинку “Сравнение двух шрифтов”, то нетрудно представить, что произойдет при такой замене (откате).

Шрифт Baskerville заменится шрифтом Georgia, у обоих при этом в правилах CSS установлена одинаковая высота в 320 пикселей. Но фактическая высота (точнее - пропорции) вспомогательного шрифта Georgia больше, чем у первостепенного Baskerville! Догадайтесь, что произойдет с готовым дизайном страницы при таком откате?

При использовании свойства font-size-adjust значение свойства font-size для шрифта-заменителя будет разделено на значение font-size-adjust.

Не путайте свойство font-size-adjust со свойством -webkit-text-size-adjust, которое используется для подстройки размера текста на iPhone.

Как определить значение свойства font-size-adjust

Отрывок из спецификации W3C однозначен:

Коэффициент пропорциональности для выбранных шрифтов может быть высчитан путем сравнения одного и того же текста, но с разным значением font-size-adjust. Если значение свойства font-size-adjust подобрано верно, то при одинаковом размере шрифта текст останется неизменным для всех используемых на странице шрифтов.

Ниже я собираюсь на примере повторить вышесказанное. Давайте посмотрим на следующий код, в котором имеется параграф с двумя span.

p{
	font-family: Times New Roman;
	font-size: 400px;
}
span{
	border: 1px solid #ff0000;
}
.adjust{
	font-size-adjust: 0.5;
}

a class="adjust">a

Оба элемента span наследуют свойство font-family от своего родителя (элемента p), но второй элемент span также имеет еще и свойство font-size-adjust, заданное через класс adjust, значение которого выбрано наугад - 0.5.

Если вы откроете страницу примера, то взгляните на образец слева: высота красных квадратов не совпадает - значение свойства font-size-adjust подобрано неверно.

У вас все квадраты на странице примера имеют одинаковую высоту? Что я говорила?

После нескольких экспериментов я выбрала значение 0.455. И CSS-код, создающий второй пример (расположенный на странице справа).

p{
	font-family: Times New Roman;
	font-size: 400px;
}
span{
	border: 1px solid #00ff00;
}
.adjust{
	font-size-adjust: 0.455;
}

Если вы снова перейдете на страницу примера, то обнаружите, что квадраты с зелеными границами имеют одинаковую высоту (прим. переводчика - у меня они имели не совсем одинаковую высоту) - то есть теперь у нас величина свойства font-size-adjust для выбранных шрифтов установлена верно.

Пример работы свойства font-size-adjust

Для того чтобы показать, как в действительности работает свойство font-size-adjust для текста, мною был создан следующий пример.

На этой странице font stack состоит из следующих шрифтов: Calibri, Lucida Sans и Verdana (именно в этом порядке шрифты должны отображаться на странице в окне браузера).

Браузер Safari генерирует эту страницу следующим образом:

Страница с правилом font-size-adjust в браузере Safari

А вот так генерирует эту страницу браузер Firefox:

Страница с правилом font-size-adjust в браузере Firefox

Как видите, браузер Firefox поддерживает одинаковую x-высоту (x-height) букв в зависимости от того, какой шрифт используется.

Мною не рассматривался вопрос выравнивания текста (свойство text-align), так как цель этой статьи была показать, каким образом свойство font-size-adjust может быть применено для сохранения целостности и удобочитаемости текста.

Кроме того, даже не смотря на то, что первый блок div имеет корректный font stack, мне пришлось вручную прописывать в правилах шрифты Lucida Sans и Verdana для остальных блоков div. Так что вы (и я) можете заметить разницу несмотря на то, что установлены все три шрифта.

Заключение

Догадываюсь, что использование свойства font-size-adjust в конечном счете имеет только негативное применение. Но этот вопрос может быть заголовком уже другой статьи, цель же этой - просто пример использования достаточно малоизвестного CSS3-свойства, которое может быть полезным в некоторых случаях.

Признаюсь, что я не тестировала свойство font-size-adjust в реальных условиях, поэтому была бы рада услышать ваши отзывы по этому поводу. Данное свойство на сегодняшний день поддерживается только браузером Firefox версии от 1.0 до 3.0.

У Inyaili de Leon есть еще одна интересная статья, которую планируется мною прочитать - “Будущее CSS типографики” (The Future Of CSS Typography) на малоизвестном ресурсе для дизайнеров Smashing Magazine.

Примечание переводчика: интересная, как и всегда, у девушки получилась статья. Для меня свойство font-size-adjust вообще было открытием. Помимо этого, есть масса других статей (в том числе русскоязычных) на тему font-size-adjust, но эта мне показалась самой лучшей, так как автор не лениться пробовать на практике те вопросы, которые описывает в статье. Сделал перевод в меру своих сил, поэтому могут быть неточности, конечно.

Оригинал статьи расположен по адресу - “The Little Known font-size-adjust CSS3 Property”.


Инструмент, который призван сделать жизнь прогрессивных веб-дизайнеров немного легче, это Modernizr.

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

Обзор Modernizr

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

В последнее время я использую Modernizr практически постоянно для того, чтобы выделить те браузеры, которые не поддерживают специфические свойства стандарта CSS3.

Как работает Modernizr

Для того, чтобы установить Modernizr, сначала скачайте его с этой страницы - http://www.modernizr.com/. Затем внутри тега head html-страницы подключите распакованный из архива файл modernizr-1.0.min.js:

Вторым шагом будет подключение класса no-js для корневого элемента html:

 class="no-js">

Для чего необходимо подключать класс no-js к элементу html?

Потому что элемент html с классом no-js будет состоянием страницы по-умолчанию. Если JavaScript (js) на странице отключен, то скрипт Modernizr также не будет работать (совместно со всеми остальными функциями страницы, завязанными на этом языке), поэтому было бы хорошо, если у нас будет возможность отката (fallback) для этого случая.

Прим. переводчика: попробую от себя объяснить в двух словах, но иначе (если вдруг непонятно) что хотела сказать прекрасная девушка, автор статьи. Если на сайте отключена поддержка JavaScript, то класс no-js для элемента html - это та “зацепка”, на которую можно повесить все CSS-fallback’и для этого случая.

Если же поддержка JavaScript в браузере включена, то произойдет динамическая подмена класса no-js для элемента html на целую группу других классов. В результате исходный код страницы может выглядеть примерно так:

 class="js canvas canvastext geolocation rgba hsla no-multiplebgs borderimage borderradius boxshadow opacity no-cssanimations csscolumns no-cssgradients no-cssreflections csstransforms no-csstransforms3d no-csstransitions video audio cufon-active fontface cufon-ready">

Впечатляет, не правда ли? Но что означают все эти классы? Давайте разберемся.

В данном случае, страница была открыта в браузере Firefox 3.5. Этот браузер (к сожалению) не поддерживает множественные фоны на CSS, CSS-градиенты и CSS-трансформации.

Скрипт Modernizr умеет автоматически определять возможности браузера, в котором открыта текущая веб-страница. Для каждого из CSS-свойств в скрипте Modernizr имеются свои собственные классы для их обозначения.

Например, множественные фоны на CSS “обозначены” как multipebgs, CSS-градиенты как cssgradients, CSS-трансформации как csstransforms и так далее.

Когда Modernizr определит, какие CSS-свойства данный браузер поддерживает, а какие нет, он создаст своеобразный отчет - список классов, по которому можно точно узнать, что браузер “умеет”, а что - нет.

Если браузер поддерживает CSS-свойство трансформации, то на элемент html скрипт Modernizr “подцепит” класс csstransforms. А если браузер не поддерживает это свойство, то Modernizr добавит для имени класса csstransforms префикс no- и также “повесит” этот класс на элемент html, но в виде no-csstransforms. И так далее …

Пример такого списка-отчета и был показан выше.

Что мне даст эта (ценная) информация?

Логичный вопрос - “а что мы можем делать с этой информацией?”. Хорошо, давайте рассмотрим простой пример.

Множественные фоны на CSS

Фон вашего сайта тщательным образом отстроен и вы используете множественные фоны для того, чтобы сделать его более простым и быстрым с помощью CSS-кода.

Ваш CSS выглядит следующим образом:

#nice {
 background: url(background-one.png) top left repeat-x,
 url(background-two.png) bottom left repeat-x;
}

И браузер генерирует этот прекрасный (ведь не даром же идентификатор имеет имя nice) фон так:

Множественные фоны

При использовании библиотеки Modernizr ваш код CSS должен быть преобразован в такой вид:

#nice {
 background: url(background-one.png) top left repeat-x;
}
.multiplebgs #nice {
 background: url(background-one.png) top left repeat-x,
 url(background-two.png) bottom left repeat-x;
}

И вот что увидят посетители сайта в зависимости от того, каким браузером (понимает он множественный фон или нет) они пользуются:

Множественный фон с Modernizr в Safari

Множественный фон с Modernizr в Opera

Это очень простой пример использования скрипта Modernizr, но он должен послужит образцом того, что можно сделать с помощью данной библиотеки.

HTML5

Библиотека Modernizr также позволяет использовать новые элементы, доступные в HTML5 - header, footer, section, hgroup, video и так далее и стилизовать их.

Однако, это не означает, что все эти элементы можно использовать также в браузере IE. Но вы можете стилизовать эти элементы и тогда IE “поймет” их и не сможет игнорировать.

Прим. переводчика: загадочная фраза, которая лично мне ни о чем не говорит. Требует дальнейшего изучения.

JavaScript

Вы также можете анализировать в вашем собственном JavaScript возможности, которые поддерживает Modernizr, используя пример следующего синтаксиса:

if (Modernizr.geolocation) {
 ...
}

Заключение

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

Оригинал статьи - How to use Modernizr


Как всегда случайно набрел в просторах Интернет на интересный блог одной девушки-дизайнера с не менее интересным именем Inayaili de León Persson.

Более того, эта девушка португальского происхождения родом из Панамы, но родилась она в СССР! С 2008 года живет в Лондоне и работает ведущим веб-дизайнеров в Canonical. Как все запутано!

Но это было лирическое вступление. Переходим к главному. Мне на глаза уже давно попадались описания функции calc() - на CSSTricks (еще не успел прочитать) и на htmlbook (успел прочитать). Последний источник как-то не впечатлил, из-за сухости изложения материала, наверное.

А вот на сайте девушки с таким необычным именем функция calc() описана кратко, но интересно, с примерами. И хоть написана статья была в далеком 2011 году, мне интересно было ее прочитать для себя (и фактически перевести).

Что такое функция calc()

Функция calc() может быть использована для вычисления различных линейных размеров на странице. Например, с ее помощью можно рассчитывать значение границ, margin, padding, кегля и многое другое.

Вычисление ширины объектов может быть чрезвычайно сложной задачей, особенно если макет сайта резиновый; функция calc() уникальная, потому что она позволяет выполнять расчеты внутри самих таблиц стилей CSS.

Функция calc() умеет работать с простейшими математическими операторами:

  • сложением +
  • вычитанием -
  • умножением *
  • делением /

Давайте рассмотрим простейший пример работы функции calc():

div{
  width: calc(100% - 20px);
 }

Очень просто, не правда ли? В одной функции может использоваться не один, а несколько математических операторов:

div{
 width: calc(100% - 20px + 2px*2);
}

В текущей спецификации говориться, что операции умножения и деления имеют приоритет над операциями сложения и вычитания. Это означает, что в примере выше сначала будет вычислено выражение 2px*2, и только затем два оставшихся - сложение и вычитание. Также обратите внимание, что деление на 0 приведет (и должно привести) к ошибке.

Спецификация по функции calc() еще не завершена, но ее основы уже готовы.

Простой пример calc()

Для того, чтобы показать возможности функции calc(), была создана базовая разметка страницы с помощью этой функции.

Разметка состоит из основного контейнера div id="main" (расположенного слева), колонки справа div id="accessory" и подвала, помещенного внизу div id="footer".

Ниже приведен код этой разметки:

После этого я говорю, что основной контейнер div.wrapper должен занимать всю ширину своего контейнера (100%) за вычетом 40 пикселей и располагаться горизонтально, по центру:

.wrapper{
 width: 1024px; /* Откат для браузеров, которые не поддерживают функцию calc() */
 width: -moz-calc(100% - 40px);
 width: calc(100% - 40px);
 margin: auto;
}

В коде выше была добавлена строка отката для браузеров, которые не поддерживают работу с функцией calc(), а также браузерный префикс -moz- для браузера Firefox 4.

Затем устанавливается ширина, границы, плавание влево и margin для основного блока с контентом div#main:

#main{
 border: 8px solid #b8c172;
 float: left;
 margin: 0 20px 20px 0;
 padding: 20px;
 width: 704px; /* Откат для браузеров, которые не поддерживают функцию calc() */
 width: -moz-calc(75% - 20px*2 - 8px*2);
 width: calc(75% - 20px*2 - 8px*2);
}

Давайте разберемся с функцией calc() в этом примере кода. Здесь я хочу, чтобы ширина контейнера div#main равнялась 75% (75% от ширины контейнера-родителя, не забывайте об этом!).

Но из этой ширины мне необходимо вычесть padding слева и справа от контейнера - 20px*2, а также ширину границы с обоих сторон - 8px*2.

Переходим к боковой панели div#accessory и говорим ей, что она должна занимать оставшуюся ширину контейнера-родителя в 25%. Но при этом также должны учитываться ширина границы этого блока, margin-right: 20px и padding. Блок будет “плавать” вправо:

#accessory{
 border: 8px solid #b8c172;
 float: right;
 padding: 10px;
 width: 208px; /* Откат для браузеров, которые не поддерживают функцию calc() */
 width: -moz-calc(25% - 10px*2 - 8px*2 -20px);
 width: calc(25% - 10px*2 - 8px*2 -20px);
}

Если более подробно разобрать выражение calc(25% - 10px*2 - 8px*2 -20px), то увидим, что из первоначальной ширины 25% вычитается padding справа и слева 10px*2, ширина правой и левой сторон границы этого блока 8px*2, а также правый margin для блока-контейнера div#main.

Блок-подвал footer просто имеет ширину, равную всей ширине блока-родителя. Я думаю, что описывать стили для этого блока излишне.

Если уменьшать размер окна браузера, то при достижении им определенной величины ширина боковой панели div#accessory становиться слишком маленькой, что нарушает дизайн страницы.

Поэтому в код ниже был добавлен простой media query, с помощью которого у блоков div#main и div#accessory убирается плавание влево-вправо и пересчитывается ширина обоих блоков так, чтобы они занимали 100% ширины блока-родителя за минусом ширины границ и соответствующих padding:

@media screen and (max-width: 768px){
 #main, #accessory{
  float: none;
 }
 #main{
  margin-right: 0;
  width: -moz-calc(100% - 20px*2 - 8px*2);
  width: calc(100% - 20px*2 - 8px*2);
 }
 #accessory{
  width: -moz-calc(100% - 20px*2 - 8px*2);
  width: calc(100% - 20px*2 - 8px*2);
 }
}

Приведенный выше пример разметки страницы является очень упрощенным. Но есть надежда, что он заинтересует вас и подтолкнет к дальнейшим экспериментам с замечательной функцией calc().

Поддержка браузерами

Функция calc() поддерживается браузером IE9 и Firefox 4 (для которого необходимо указать браузерный префикс -moz-calc()). Я понимаю, однако, что применение этой функции в устаревших браузерах к таким вещам, как анимация, может быть большой проблемой. Но в тоже время, анимация не является жизненно важной необходимостью сайта.

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

В своих примерах я предпочла использовать откат в виде абсолютной величины (ширина блока) для браузеров, которые не поддерживают данную функцию.

Дальше переводить не стал, ибо идет сплошная “вода” в виде заключения и всяческих пожеланий, не относящаяся к делу.


Статья на NetTuts+, написанная Johnathan Croom в 2012 году.

Основная цель статьи - показать преимущество использования любого из трех описанных в ней препроцессоров Sass, LESS и Stylus. Обзор прекрасно подойдет для новичков, которые только открывают для себя эту грань веб-дизайна.

В этой статье мы рассмотрим преимущества и выгоды использования трех различных препроцессоров - Sass, LESS и Stylus.

Введение

Препроцессоры CSS были созданы с одной единственной целью - добавить стилевым таблицам CSS мощь и одновременную гибкость без нарушения кросс-браузерности. Все препроцессоры компилируют созданный с помощью их синтаксиса код в стандартный CSS-код, который понимает и использует любой браузер, каким бы древним он (браузер) не был.

Существуют множество преимуществ, которые привносят препроцессоры в таблицы стилей CSS и в этой статье мы рассмотрим только некоторые из них, как хорошо известные, так и мало распространенные. Давайте приступим к обзору.

Синтаксис

Наиболее важной частью при написании кода в любом препроцессоре CSS является его синтаксис. В счастью для нас, синтаксис всех трех препроцессоров, которые мы будем рассматривать, имеют CSS-подобный вид.

Sass & LESS

Оба препроцессора Sass и LESS имеют стандартный CSS-синтаксис. Это делает задачу конвертирования уже существующего CSS-кода в синтаксис любого из этих препроцессоров простой и быстрой. Sass использует для своих файлов расширение .scss, LESS - расширение .less.

Вид обычного файла в синтаксисе Sass или LESS представлен ниже:

/* style.scss или style.less */
h1{
 color: #0982c1;
}

Хорошо видно, что это обычный синтаксис CSS, который прекрасно конвертируется в Sass (SCSS) или LESS.

Важно обратить внимание, что Sass (SCSS) также имеет старую версию синтаксиса Sass, в которой опущены точки с запятой и фигурные скобки.

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

Синтаксис Sass (старая версия) выглядит следующим образом:

/* style.sass */
h1
 color: 0982c1

Stylus

Для своих файлов этот препроцессор использует расширение .styl. Синтаксис препроцессора Stylus более многословный (прим. переводчика: автор что-то напутал здесь) в нем применяется за основу стандартный синтаксис CSS, но допускается применение различного сочетания скобок, двоеточий и точек с запятой.

Примеры синтаксиса Stylus:

/* CSS-подобный синтаксис */
h1 {
 color: #0982C1;
}
/* опущены фигурные скобки */
h1
 color: #0982C1;
/* опущены фигурные скобки, двоеточия и точки с запятой */
h1
 color #0982C1

Все варианты синтаксиса, показанные выше, являются валидными и в результате компиляции получается правильный CSS-код. Например, такой код скомпилируется в стандартный CSS без ошибок:

h1 {
 color #0982c1
}
h2
 font-size: 1.2em

Переменные

В препроцессорах переменные объявляются и используются внутри файлов стилей CSS. Переменные могут принимать любое значение, допустимое в CSS (цвет, число или текст) и может ссылаться из любого места CSS-документа.

Sass

В препроцессоре Sass переменная объявляется с помощью символа $, при этом имя переменной и ее значение отделяются друг от друга двоеточием так, как это делается в CSS:

$mainColor: #0982c1;
$siteWidth: 1024px;
$borderStyle: dotted;
body {
 color: $mainColor;
 border: 1px $borderStyle $mainColor;
 max-width: $siteWidth;
}

LESS

Переменные в LESS точно такие же, как и в Sass, за исключением того, что перед именем переменной ставится символ @:

@mainColor: #0982c1;
@siteWidth: 1024px;
@borderStyle: dotted;
body {
 color: @mainColor;
 border: 1px @borderStyle @mainColor;
 max-width: @siteWidth;
}

Stylus

Переменные в Stylus не нуждаются ни в каком знаке для своего объявления, но, тем не менее, могут использовать символ $. Как правило, завершающий символ строки точка с запятой также не нужен, за исключением случая, когда имя переменной и ее значение совпадают.

Еще один достойный упоминания момент заключается в том, что Stylus (0.22.4) компилирует код, даже если в нем имя переменной объявлено с помощью символа @, но при вызове этой переменной в коде подстановки значения переменной не происходит.

Другими словами, не выполняется такая операция:

mainColor = #0982c1
siteWidth = 1024px
$borderStyle = dotted
body
 color mainColor
 border 1px $borderStyle mainColor
 max-width siteWidth

Скомпилированный CSS

Каждый из представленных в виде примера файлов компилируется в точно такой же CSS-код. Вы можете включить воображение, чтобы представить, насколько полезными могут быть переменные.

Благодаря им отпадает необходимость задавать значение цвета и потом двадцать раз повторять его в CSS-коде. Или же поставлена задача изменить ширину сайта и для этого необходимо “перерыть” код в поисках этой величины.

Прим. переводчика: здесь автор немного утрирует ситуацию, так как в любом нормальном редакторе кода имеется функция поиска.

Ниже представлен CSS-код после выполнения компиляции:

body {
 color: #0982c1;
 border: 1px dotted #0982c1;
 max-width: 1024px;
}

Вложенность (nesting)

Если в коде CSS поставлена задача обратиться одновременно к нескольким элементам, имеющим одного и того же родителя, то писать снова и снова этого родителя - занятие утомительное.

Например, так:

section {
  margin: 10px;
}
section nav {
  height: 25px;
}
section nav a {
  color: #0982C1;
}
section nav a:hover {
  text-decoration: underline;
}

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

Sass, LESS & Stylus

Все три препроцессора имеют абсолютно одинаковый синтаксис для вложенных селекторов:

section {
 margin: 10px;
 nav {
  height: 25px;
  a {
   color: #0982C1;
   &:hover {
    text-decoration: underline;
   }
  }
 }
}

Скомпилированный CSS

Ниже показан скомпилированный в CSS результат кода, представленного выше. Сравните с тем кодом, который мы писали в самом начале - абсолютно одинаково. Но какое удобство при использовании преимуществ препроцессора!

section {
 margin: 10px;
}
section nav {
 height: 25px;
}
section nav a {
 color: #0982C1;
}
section nav a:hover {
 text-decoration: underline;
}

Подмешивания (mixins)

Миксины mixins являются функциями, которые позволяют многократно использовать сгруппированные свойства внутри CSS-кода. Вместо того, чтобы просматривать весь код в поисках нужных строчек для их изменения, теперь можно вносить изменения только один раз, внутри миксина.

Применение подмешиваний особенно оправдывает себя при создании специфичных стилей для элементов или простановке браузерных префиксов. Когда миксин вызывается внутри CSS-селектора, происходит распознавание аргументов этого миксина, затем его стили применяются к селектору, который его вызвал.

Прим. переводчика: в приведенных ниже примерах стоит обратить внимание на разницу в синтаксисе объявления и вызова миксина внутри CSS-селектора для всех трех препроцессоров.

Sass

/* Sass mixin по имени error с аргументом $borderWidth, значение которого по умолчанию равно 2px */
@mixin error($borderWidth: 2px) {
 border: $borderWidth solid #F00;
 color: #F00;
}
.generic-error {
 padding: 20px;
 margin: 4px;
 @include error(); /* Подключается миксин по имени error */
}
.login-error {
 left: 12px;
 position: absolute;
 top: 20px;
 @include error(5px); /* Подключается миксин по имени error со значением аргумента $borderWidth, равным 5px; то есть происходит переопределение значения аргумента */
}

LESS

/* LESS mixin по имени error с аргументом $borderWidth, значение которого по умолчанию равно 2px */
.error(@borderWidth: 2px) {
 border: @borderWidth solid #F00;
 color: #F00;
}
.generic-error {
 padding: 20px;
 margin: 4px;
 .error(); /* Подключается миксин по имени error */
}
.login-error {
 left: 12px;
 position: absolute;
 top: 20px;
 .error(5px); /* Подключается миксин по имени error со значением аргумента $borderWidth, равным 5px; то есть происходит переопределение значения аргумента */
}

Style

/* Stylus mixin по имени error с аргументом $borderWidth, значение которого по умолчанию равно 2px */
error(borderWidth= 2px) {
 border: borderWidth solid #F00;
 color: #F00;
}
.generic-error {
 padding: 20px;
 margin: 4px;
 error(); /* Подключается миксин по имени error */
}
.login-error {
 left: 12px;
 position: absolute;
 top: 20px;
 error(5px); /* Подключается миксин по имени error со значением аргумента $borderWidth, равным 5px; то есть происходит переопределение значения аргумента */
}

Скомпилированный CSS

Результатом компиляции из всех трех препроцессоров будет одинаковый CSS-код:

.generic-error {
 padding: 20px;
 margin: 4px;
 border: 2px solid #f00;
 color: #f00;
}
.login-error {
 left: 12px;
 position: absolute;
 top: 20px;
 border: 5px solid #f00;
 color: #f00;
}

Наследование (inheritance)

При написании CSS стилей “классическим” способом, для того чтобы применить одни и те же свойства к нескольким элементам в HTML-документе, нам следовало бы создать такой код:

p,
ul,
ol {
 /* какие-то стили здесь */
}

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

В противоположность этому применяются наследование. Наследование - это возможность для одних CSS-селекторов наследовать свойства у другого селектора.

Прим. переводчика: обратите внимание на одинаковый синтаксис подключения (объявления) наследования внутри CSS-селектора с помощью директивы @extend.

Sass & Stylus

.block {
 margin: 10px 5px;
 padding: 2px;
}
p {
 @extend .block; /* Наследовать свойства у селектора класса .block */
 border: 1px solid #EEE;
}
ul, ol {
 @extend .block; /* Наследовать свойства у селектора класса .block */
 color: #333;
 text-transform: uppercase;
}

Скомпилированный CSS

.block, p, ul, ol {
 margin: 10px 5px;
 padding: 2px;
}
p {
 border: 1px solid #EEE;
}
ul, ol {
 color: #333;
 text-transform: uppercase;
}

LESS

Препроцессор LESS не поддерживает наследование в полной мере так, как это организовано в Sass или Stylus. Вместо добавления множественных селекторов в один набор свойств, наследование трактуется как миксин без аргументов.

Импорт стилей выполняется для каждого селектора. Обратной стороной такого подхода является постоянное повторение строк со свойствами в компилированном CSS-стиле.

Вот как может выглядеть LESS-код с наследованием:

.block {
 margin: 10px 5px;
 padding: 2px;
}
p {
 .block; /* Наследование свойств у селектора класса .block */
 border: 1px solid #EEE;
}
ul, ol {
 .block; /* Наследование свойств у селектора класса .block */
 color: #333;
 text-transform: uppercase;
}

Скомпилированный CSS

.block {
 margin: 10px 5px;
 padding: 2px;
}
p {
 margin: 10px 5px;
 padding: 2px;
 border: 1px solid #EEE;
}
ul,
ol {
 margin: 10px 5px;
 padding: 2px;
 color: #333;
 text-transform: uppercase;
}

Как хорошо видно из кода, стили класса .block добавлены для селекторов, которым требуется задать наследование у этого класса.

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

Импортирование

В CSS-сообществе к импортированию стилей с помощью директивы @import существует стойкое негативное отношение, так как такой подход порождает множественные HTTP-запросы к серверу, что замедляет работу браузера и нагружает сам сервер. Однако, в препроцессорах технология импортирования работает иначе.

В любом из трех препроцессоров импортирование одного файла внутрь другого фактически приводит к вставке кода одного файла в другой при компиляции, в результате которой получается один CSS-файл.

Прим. переводчика: другими словами, в препроцессорах импортирование необходимо для компиляции одного файла из нескольких. В стандартном CSS импортирование приводит к подстановке одного кода внутрь другого.

Обратите внимание, что при компилировании файла со стандартным подключением с помощью директивы @import "file.css" внутри него компиляции последнего не происходит. А вот миксины или переменные импортируются и используются в стилевом файле, как положено. Технология импортирования очень удобная, так как она позволяет создавать множество отдельных файлов для правильной организации проекта.

/* file.{type} */
body {
 background: #EEE;
}
@import "reset.css";
@import "file.{type}";
p {
 background: #0982C1;
}

Скомпилированный CSS

@import "reset.css";
body {
 background: #EEE;
}
p {
 background: #0982C1;
}

Функции работы с цветом

“Цветовые” функции созданы для трансформации цвета при компиляции. Такие функции чрезвычайно полезны при создании градиентов, затемнения цвета при hover и многое другое.

Sass

lighten($color, 10%); /* возвращает цвет на 10% светлее чем $color */
darken($color, 10%); /* возвращает цвет на 10% темнее чем $color */
saturate($color, 10%);  /* возвращает цвет на 10% более насыщенный чем $color */
desaturate($color, 10%); /* возвращает цвет на 10% менее насыщенный чем $color */
grayscale($color); /* возвращает шкалу полутонов цвета $color */
complement($color); /* returns complement color of $color */
invert($color);   /* возвращает инвертированный цвет от $color */
mix($color1, $color2, 50%); /* возвращает результат смешивания цвета $color1 с цветом $color2 */

Представленный выше код является всего лишь кратким списком функций работы с цветом в Sass. Полный список всех доступных функций расположен по адресу Sass Documentation.

“Цветовые” функции могут использоваться везде, где требуется работа с цветов в коде. Простой пример - объявлена переменная с цветом, к которой дальше в коде применяется функция затемнения цвета darken:

$color: #0982C1;
h1 {
 background: $color;
 border: 3px solid darken($color, 50%);
}

LESS

lighten(@color, 10%); /* возвращает цвет на 10% светлее чем $color */
darken(@color, 10%); /* возвращает цвет на 10% темнее чем $color */
saturate(@color, 10%);  /* возвращает цвет на 10% более насыщенный чем $color */
desaturate(@color, 10%); /* возвращает цвет на 10% менее насыщенный чем $color */
spin(@color, 10); /* возвращает цвет, смещенный на 10 градусов вправо относительно цвета @color */
spin(@color, -10); /* возвращает цвет, смещенный на 10 градусов влево относительно цвета @color */
mix(@color1, @color2); /* возвращает результат смешивания цвета $color1 с цветом $color2 */

Список функций препроцессора LESS находится на официальном сайте проекта LESS Documentation.

Ниже показан пример того, как можно применять “цветовые” функции в LESS:

@color: #0982C1;
h1 {
 background: @color;
 border: 3px solid darken(@color, 50%);
}

Stylus

lighten(@color, 10%); /* возвращает цвет на 10% светлее чем $color */
darken(@color, 10%); /* возвращает цвет на 10% темнее чем $color */
saturate(@color, 10%);  /* возвращает цвет на 10% более насыщенный чем $color */
desaturate(@color, 10%); /* возвращает цвет на 10% менее насыщенный чем $color */

Полный список всех функций работы с цветом препроцессора Stylus представлен на сайте проекта Stylus Documentation.

И пример использования “цветовой” функции в Stylus:

color = #0982C1
h1
 background color
 border 3px solid darken(color, 50%)

Арифметические операции

Благодаря препроцессорам выполнение арифметических операций внутри CSS-кода теперь осуществляется просто и легко. Такая возможность часто бывает полезной.

Прим. переводчика: стоит упомянуть о функции из CSS3 по имени calc(), которая также позволяет выполнять внутри CSS-кода простые арифметические операции.

Sass, LESS & Stylus

body {
 margin: (14px/2);
 top: 50px + 100px;
 right: 100px - 50px;
 left: 10 * 10;
}

Практические примеры

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

Браузерные префиксы

Одним из наиболее ярких примеров преимущества использования препроцессоров является написание с их помощью свойств с браузерными префиксами. Один раз создав миксин с поддержкой браузерных префиксов, мы избавляем себя от рутинной работы.

Например, создадим для всех трех препроцессоров миксин скругления углов блока:

Sass

@mixin border-radius($values) {
 -webkit-border-radius: $values;
   -moz-border-radius: $values;
     border-radius: $values;
}
div {
 @include border-radius(10px);
}

LESS

.border-radius(@values) {
 -webkit-border-radius: @values;
   -moz-border-radius: @values;
     border-radius: @values;
}
div {
 .border-radius(10px);
}

Stylus

border-radius(values) {
 -webkit-border-radius: values;
   -moz-border-radius: values;
     border-radius: values;
}
div {
 border-radius(10px);
}

Скомпилированный CSS

div {
 -webkit-border-radius: 10px;
   -moz-border-radius: 10px;
     border-radius: 10px;
}

Трехмерный текст

Создание эффекта трехмерности для текста с помощью CSS-свойства text-shadow является прекрасной идеей. Единственная проблема заключается в работе с цветом, которая достаточно трудная и обременительная.

Используя миксины и функции для работы с цветом, мы можем создать объемный текст и изменять его цвет на лету:

Sass

@mixin text3d($color) {
 color: $color;
 text-shadow: 1px 1px 0px darken($color, 5%),
        2px 2px 0px darken($color, 10%),
        3px 3px 0px darken($color, 15%),
        4px 4px 0px darken($color, 20%),
        4px 4px 2px #000;
}
h1 {
 font-size: 32pt;
 @include text3d(#0982c1);
}

LESS

.text3d(@color) {
 color: @color;
 text-shadow: 1px 1px 0px darken(@color, 5%),
        2px 2px 0px darken(@color, 10%),
        3px 3px 0px darken(@color, 15%),
        4px 4px 0px darken(@color, 20%),
        4px 4px 2px #000;
}
span {
 font-size: 32pt;
 .text3d(#0982c1);
}

Stylus

text3d(color)
 color: color
 text-shadow: 1px 1px 0px darken(color, 5%), 2px 2px 0px darken(color, 10%), 3px 3px 0px darken(color, 15%), 4px 4px 0px darken(color, 20%), 4px 4px 2px #000
span
 font-size: 32pt
 text3d(#0982c1)

В примере для Stylus я выбрал вариант написания свойства text-shadow в одну строку, так как здесь я опустил фигурные скобки.

Скомпилированный CSS

span {
 font-size: 32pt;
 color: #0982c1;
 text-shadow: 1px 1px 0px #097bb7,
        2px 2px 0px #0875ae,
        3px 3px 0px #086fa4,
        4px 4px 0px #07689a,
        4px 4px 2px #000;
}

Колонки

Использование переменных и числовых значений для этих переменных пришла мне в голову, когда я только начал знакомиться с возможностями CSS-препроцессоров. Объявление ширины для макета внутри переменной делает задачу изменения этой ширины (при необходимости) простой и быстрой:

Sass

$siteWidth: 1024px;
$gutterWidth: 20px;
$sidebarWidth: 300px;
body {
 margin: 0 auto;
 width: $siteWidth;
}
.content {
 float: left;
 width: $siteWidth - ($sidebarWidth+$gutterWidth);
}
.sidebar {
 float: left;
 margin-left: $gutterWidth;
 width: $sidebarWidth;
}

LESS

@siteWidth: 1024px;
@gutterWidth: 20px;
@sidebarWidth: 300px;
body {
 margin: 0 auto;
 width: @siteWidth;
}
.content {
 float: left;
 width: @siteWidth - (@sidebarWidth+@gutterWidth);
}
.sidebar {
 float: left;
 margin-left: @gutterWidth;
 width: @sidebarWidth;
}

Stylus

siteWidth = 1024px;
gutterWidth = 20px;
sidebarWidth = 300px;
body {
 margin: 0 auto;
 width: siteWidth;
}
.content {
 float: left;
 width: siteWidth - (sidebarWidth+gutterWidth);
}
.sidebar {
 float: left;
 margin-left: gutterWidth;
 width: sidebarWidth;
}

Скомпилированный CSS

body {
 margin: 0 auto;
 width: 1024px;
}
.content {
 float: left;
 width: 704px;
}
.sidebar {
 float: left;
 margin-left: 20px;
 width: 300px;
}

Некоторые уловки препроцессоров

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

Сообщение об ошибках

Если вы уже пишите код на CSS достаточно давно, то наверняка сталкивались с ситуацией, когда внутри кода закралась ошибка, которую вы никак не можете найти. Если вы попадали в точно такую же ситуацию, то могу вас обрадовать - существует способ решить такую задачу.

CSS-препроцессоры могут сообщать об ошибках в коде и заставить их поступать таким образом достаточно просто. В этом случае препроцессор сам сообщает вам, в каком месте CSS-кода находиться ошибка (и все счастливы).

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

Комментирование

В CSS-препроцессоре при компиляции из кода удаляются любые комментарии в виде двойного слеш’а (// это комментарий). Но, в тоже время, блочные комментарии (/* это комментарий */) остаются в коде без изменений.

На заметку: при компиляции в минимизированную версию CSS-файла удаляются любые комментарии.

Заключение

Каждый из трех рассмотренный в этой статье CSS-препроцессоров (Sass, LESS и Stylus) обладает своим собственным, уникальным способом решения одной и той же задачи. Это дает в руки разработчика возможность выбора, каким способом выполнить поставленную задачу. Объединяет все препроцессоры способность расширить горизонты кодера с одновременным сохранением кросс-браузерности и чистоты кода.

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

На этом все.