The Complete Sass & SCSS Course: From Beginner to Advanced

A preprocessor like Sass build on CSS and enhances it with powerful capabilities like variables, nested selectors, and different generation options.

Sass & SCSS will make your code more maintainable and flexible so that you can reuse it more easily for other projects. You will also be able to tailor and modify your designs more easily.

Sass is the original language with the intent to improve upon plain old CSS. It uses a more clutter-free syntax without curly braces or semi-colons.

SCSS was created later in addition to Sass to provide a more CSS-like syntax. This makes it easier to transition from CSS to SCSS.

Both are equally powerful and add a lot of neat capabilities on top of CSS which you're gonna learn in this course. It is just a matter of taste which of both you prefer but SCSS has become a near-standard. The course lectures use SCSS.

Sublime Text is a very powerful text editor that supports a wide range of languages, including SCSS & Sass and all other languages you need for this course. Learn how to install Sublime Text 3 along with Package Control to easily power up your Sublime Text installation with the various available plugins.

Plugins you need for this course: Sass, SCSS, Sass Build, Emmet (optional but highly recommended)

Sass is available as a Ruby gem, which means that you need Ruby to install it. This lecture guides you through the installation steps for Ruby and Sass. Afterwards, you're gonna have all the tools you need for this course! Good feeling!

Check if all plugins for Sublime Text have been installed correctly. This lecture shows you how to create your first Sass file, try out the Emmet plugin and generate CSS code using the Sass Build plugin.

Set up a simple static HTML site project with a separate CSS directory and configure the Sass Build plugin to write the generated CSS code into that CSS directory. Also, install the SublimeBuildOnSave plugin to update the CSS file automatically on every save.

Sass variables can store any kind of CSS values, such as colors, lengths and fonts. They can be created as follows in SCSS syntax: $variable: [value];

Keep your variables organized using comments to make code more readable.

You can use variables whenever you want to make a value easily changeable or whenever you use the same value at different places. Creating a variable for them makes the code more maintainable because changes can be done at a single place (the variable declaration).

Partials allow you to define SCSS / Sass files that are not translated to CSS code.

This is usefor for various purposes. For example, partials are commonly used to define all variables (in one or more partials), to define a reset partial to include in your main layout, and in fact anytime you do not need a CSS file to be generated.

Mixins let you define reusable chunks of code that you can then use throughout all your projects. Mixins are one of the most important and powerful features of Sass and there are countless frameworks which also define useful mixins for you to discover.

You can also use mixins inside other mixin definitions to build on top of designs you already defined.

Make your mixins more flexible by using arguments.

You can define as many arguments as you want for a single mixin to pass in values like colors, sizes or fonts. Default values give you the choice to pass in those values or use some predefined default value.

When passing in arguments in the @include directive, you can use explicit names to make the code more readable. When using explicit names, you can pass in the arguments in any order you want.

You can use @content to pass in content to mixins. This is useful, for instance, to create mixins which apply a given style only to a specific browser.

When including the mixin, you can then define any styles you want inside it. These are then going to be inserted wherever @content is placed in the mixin definition.

Sass imports are an extension of normal CSS imports. In fact, there are four cases where Sass import are translated to CSS imports:

1. When the import starts with url()
2. When the import starts with http://
3. When importing a CSS file, e.g., @import "filename.css";
4. When using a media query

In addition, Sass imports allow you to import Sass & SCSS files. If none of the above cases is true, Sass will look for a Sass / SCSS file, just like when we imported the partials.

Bring together the power of mixins and imports to create a neat little mixin to import fonts from Google Fonts. The mixin just takes in the name of the font you want to import and handle the rest for you. No need to look up the URL yourself, no need to open up Google Fonts (if you know your fonts).

Put this mixin into your toolbox of reusable mixins for future projects!

Media queries allow you to define styles which should only be applied to a certain medium or a medium with certain properties. This is also available in CSS and is essential for responsive design.

In Sass, you can add the @media tag at any nesting level to include a media query that is only going to apply to the element you are targeting.

Combine mixins and media queries to create a powerful framework for addressing different screen sizes. Learn how more sophisticated frameworks provide the ability to target different devices and create truly responsive designs.

Sass allows you to perform calculations on values of different types, such as 1in - 12px. This is really useful in many cases to calculate dynamic dimensions for flexible layouts.

There are also some incompatible units such as em and px, so you cannot perform calculations like 1em + 4px. Also, make sure the end result of the calculations is a valid CSS unit. For example, 2px * 3px = 6px*px which is not a valid CSS unit (what's a "square pixel"?)

Learn how Sass handles color calculations. You can perform calculations from simple additions like #123456 + #654321 = #777777 to more complex expressions like #222 * #030201 = #664422.

Don't worry: Sass provides powerful and easily usable functions to handle color manipulations. So you won't usually perform calculations like these directly.

In essence, Sass functions take in arguments, perform some computation, and then return a value. Some functions are also available in CSS, such as the function rgb($red, $green, $blue) which returns a color made up of the RGB components passed in.

But Sass provides many more powerful functions than CSS and even allows you to create your own as well! In the following lectures, you'll get to know some of the most useful built-in Sass functions and also learn how to create your own.

Learn how to use four of the most useful Sass functions to manipulate colors:

1. darken($color, $amount) to darken colors
2. lighten($color, $amount) to lighten colors
3. opacify($color, $amount) to change the opacity of colors
4. transparentize($color, $amount) to also change the opacity/transparency of colors (opposite of opacify)

These functions are extremely useful to define hover colors, transition colors, or generally define colors based on an existing other color.

Creating custom Sass functions is not too difficult, even if you're not a programmer. It's really worth learning it to be able to encapsulate your logic in a reusable way -- just like frameworks do.

Knowing how to create functions using @function in Sass brings you one step closer to being able to write your own powerful frameworks and leave your competition behind.

You create a function using the @function directive and can define a return value after the @return directive.