Variables and Data Types Reference

1. Variable Declaration with $ Syntax

Concept Syntax Example Notes
Basic Declaration $variable-name: value; $primary-color: #3498db; Use hyphen or underscore naming
Variable Usage property: $variable-name; color: $primary-color; Reference declared variable
Naming Convention $kebab-case $btn-primary-bg Recommended: lowercase with hyphens
Underscore Equivalence $var-name === $var_name $main-color = $main_color Hyphens and underscores are interchangeable
Reassignment $var: new-value; $size: 20px; Variables can be reassigned
Required Prefix Must start with $ $font-size font-size ✗ (invalid variable)

Example: Variable declaration and usage

// Color variables
$primary-color: #3498db;
$secondary-color: #2ecc71;
$text-color: #333;

// Spacing variables
$spacing-unit: 8px;
$margin-base: $spacing-unit * 2;

// Typography
$font-primary: 'Helvetica', sans-serif;
$font-size-base: 16px;

// Usage
.button {
  background: $primary-color;
  color: white;
  font-family: $font-primary;
  margin: $margin-base;
  
  &:hover {
    background: $secondary-color;
  }
}

2. Variable Scope (global, local, !global flag)

Scope Type Definition Location Accessibility Example
Global Scope Top-level (outside blocks) Accessible everywhere $global-var: value;
Local Scope Inside { } blocks Only within that block .class { $local: value; }
!global Flag Inside block with flag Creates/modifies global variable $var: value !global;
Shadowing Local var with same name Local overrides in scope Global $x shadowed by local $x
Function Scope Inside @function Isolated to function @function { $local: 1; }
Mixin Scope Inside @mixin Isolated to mixin @mixin { $local: 1; }

Example: Variable scope demonstration

// Global variable
$color: red;

.component {
  // Local variable (only in this block)
  $local-color: blue;
  color: $local-color;      // blue
  background: $color;       // red (global)
}

.another {
  color: $color;            // red (global accessible)
  // color: $local-color;   // ERROR: undefined
}

// Modifying global from local scope
.modifier {
  $color: green !global;    // Changes global $color
}

.test {
  color: $color;            // green (global was modified)
}

// Shadowing example
$size: 10px;

.shadow {
  $size: 20px;              // Local, shadows global
  font-size: $size;         // 20px (local)
  
  .nested {
    font-size: $size;       // 20px (parent local)
  }
}

.no-shadow {
  font-size: $size;         // 10px (global)
}
Warning: Use !global sparingly. It can lead to unexpected side effects and makes code harder to maintain.

3. Variable Interpolation #{} Syntax

Use Case Syntax Example Output
Selector Interpolation .#{$var} { } $name: 'header';
.#{$name} { }
.header { }
Property Interpolation #{$var}: value; #{$prop}: 10px; margin: 10px;
String Interpolation "text #{$var}" "font-#{$weight}" "font-bold"
URL Interpolation url(#{$var}) url(#{$path}/img.png) url(/assets/img.png)
Media Query @media #{$query} @media #{$mobile} @media (max-width: 768px)
At-rule Names @#{$rule} @#{$directive} Dynamic directive names
Comment Interpolation /* #{$var} */ /* v#{$version} */ /* v2.1.0 */

Example: Variable interpolation patterns

$theme: 'dark';
$side: 'left';
$size: 'large';

// Selector interpolation
.button-#{$theme} {
  background: black;
}
// Output: .button-dark { background: black; }

// Property interpolation
.box {
  margin-#{$side}: 20px;
}
// Output: .box { margin-left: 20px; }

// String interpolation
$base-path: '/assets/images';
.icon {
  background: url('#{$base-path}/icon.svg');
}

// Dynamic class generation
@each $sz in small, medium, large {
  .btn-#{$sz} {
    padding: #{$sz};
  }
}

// Media query interpolation
$breakpoint: '(min-width: 768px)';
@media #{$breakpoint} {
  .container { width: 750px; }
}

// Combining variables
$prefix: 'app';
$component: 'header';
.#{$prefix}-#{$component} {
  // .app-header
}
Note: Interpolation with #{} is required for selectors and property names, but optional for values.

4. Default Values with !default Flag

Concept Syntax Behavior Use Case
Default Assignment $var: value !default; Only assigns if variable is undefined or null Library/framework configuration
Already Defined $var: 10px; $var: 20px !default; $var remains 10px User overrides preserved
Undefined Variable $new: 5px !default; $new is set to 5px Provides fallback value
Null Override $var: null; $var: 5px !default; $var becomes 5px Null is treated as undefined
Import Order User vars → Library defaults User configuration takes priority Configurable frameworks
Module Config With @use...with Configure module variables Modern module system NEW

Example: !default flag usage

// _library.scss (component library)
$primary-color: blue !default;
$spacing: 8px !default;
$border-radius: 4px !default;

.button {
  background: $primary-color;
  padding: $spacing;
  border-radius: $border-radius;
}

// user-config.scss (user customization)
// Set BEFORE importing library
$primary-color: red;
$spacing: 12px;
// $border-radius not set, will use default

@import 'library';
// Result: red background, 12px padding, 4px radius

// ===================================
// Pattern: Configurable mixin
@mixin button($bg: null, $padding: null) {
  $bg: $bg or $primary-color !default;
  $padding: $padding or $spacing !default;
  
  background: $bg;
  padding: $padding;
}

// Modern module system
// _theme.scss
$color: blue !default;

// main.scss
@use 'theme' with (
  $color: red    // Override default
);
Note: !default is essential for creating configurable libraries and themeable components.

5. Variable Data Types (numbers, strings, colors, booleans, null)

Data Type Examples Operations Notes
Number 42, 3.14, 10px, 2em +, -, *, /, %, <, >, comparisons Can have units or be unitless
String "text", 'text', unquoted Concatenation (+), interpolation Quoted or unquoted
Color #fff, rgb(), hsl(), red Color functions (lighten, darken, mix) Multiple format support
Boolean true, false and, or, not, if/else Conditional logic
Null null Represents absence of value Omits property in output
List 1px 2px 3px, (a, b, c) List functions (nth, join, append) Space or comma separated
Map (key: value, key2: value2) Map functions (get, merge, keys) Key-value pairs
Function Reference get-function('name') First-class functions Advanced meta-programming

Example: Variable data types

// Numbers
$width: 100;                  // Unitless
$height: 50px;                // With unit
$opacity: 0.75;               // Decimal
$duration: 2s;                // Time unit

// Strings
$font-quoted: "Helvetica";    // Quoted
$font-unquoted: Arial;        // Unquoted
$path: '/assets/images';      // Path string

// Colors
$color-hex: #3498db;
$color-rgb: rgb(52, 152, 219);
$color-rgba: rgba(52, 152, 219, 0.8);
$color-hsl: hsl(204, 70%, 53%);
$color-name: blue;

// Booleans
$is-dark-mode: true;
$is-mobile: false;

// Null
$optional-border: null;       // Won't output

// Lists
$margins: 10px 20px 10px 20px;
$colors: red, green, blue;
$mixed: (1px solid black);

// Maps
$theme: (
  primary: #3498db,
  secondary: #2ecc71,
  text: #333
);

// Usage examples
.box {
  width: $width + px;         // 100px
  border: $optional-border;   // Omitted (null)
  
  @if $is-dark-mode {
    background: black;
  }
}

Type Checking Functions

Function Returns
type-of($var) Type name
unit($num) Unit as string
unitless($num) true/false

Null Behavior

  • Null values omit properties
  • Useful for conditional styles
  • Treated as undefined with !default
  • List/map operations ignore null

6. CSS Custom Properties vs SCSS Variables

Feature SCSS Variables ($var) CSS Custom Properties (--var)
Compilation Compiled away (preprocessor) Present in final CSS (runtime)
Syntax $variable: value; --variable: value;
Usage color: $variable; color: var(--variable);
Scope Static, compile-time Dynamic, cascade and inherit
Browser Support All (compiled to CSS) Modern browsers (IE11- not supported)
JavaScript Access Not accessible Can read/modify via JS NEW
Media Query Context Can use different values Inherits from cascade
Calculations Compile-time only Can use calc() at runtime
Fallback N/A (value required) var(--x, fallback)
Performance No runtime cost Slight runtime overhead

Example: SCSS variables vs CSS custom properties

// SCSS Variables (compile-time)
$primary: #3498db;
$spacing: 16px;

.button {
  background: $primary;        // Compiled to: background: #3498db;
  padding: $spacing;           // Compiled to: padding: 16px;
}

// CSS Custom Properties (runtime)
:root {
  --primary: #3498db;
  --spacing: 16px;
}

.button {
  background: var(--primary);  // Stays in CSS
  padding: var(--spacing);     // Can change at runtime
}

// ===================================
// Combining Both (Best Practice)
$default-primary: #3498db;

:root {
  --primary: #{$default-primary};  // SCSS sets initial value
  --spacing: 16px;
}

.button {
  background: var(--primary);
  
  // JavaScript can change:
  // element.style.setProperty('--primary', 'red');
}

// ===================================
// Theme switching with CSS variables
.theme-light {
  --bg: white;
  --text: black;
}

.theme-dark {
  --bg: black;
  --text: white;
}

.component {
  background: var(--bg);
  color: var(--text);
  // Theme switches without recompiling!
}

// SCSS variables for theme
$themes: (
  light: (bg: white, text: black),
  dark: (bg: black, text: white)
);

@each $theme, $colors in $themes {
  .theme-#{$theme} {
    --bg: #{map-get($colors, bg)};
    --text: #{map-get($colors, text)};
  }
}

When to Use Which?

Use SCSS Variables Use CSS Custom Properties
Build-time configuration Runtime theming
Calculations during compilation Dynamic value changes
Internal component logic JavaScript interaction
Mixin/function parameters User customization
Older browser support needed Modern cascade features
Note: Best practice: Use SCSS variables for compile-time values and CSS custom properties for runtime theming. Combine both for maximum flexibility.