← Back to Rust Course | Chapter 2: Variables & Types | Lesson 3 of 7

Constants

A constant is a value that gets a permanent name and can never, ever be changed while the program runs.

In this page:

  1. Declaring a Constant
  2. Naming Convention
  3. Constants at Global Scope
  4. Constants vs Variables
Syntax
rust 
const NAME: Type = value;

Declaring a Constant

Constants are declared with the const keyword, always require an explicit type, and can never be mutated. They represent values that are fixed for the entire run of the program.

Example: Declaring a Constant

markup 
const MAX_SCORE: i32 = 100;

// Entry point: execution of the program starts here
fn main() {
    // Print "Maximum possible score is {}" to the console, substituting in `MAX_SCORE` (with a trailing newline)
    println!("Maximum possible score is {}", MAX_SCORE);
}

Naming Convention

By strong convention, Rust constants are named using SCREAMING_SNAKE_CASE -- all uppercase letters with underscores between words. This visually distinguishes constants from regular variables at a glance.

Example: Naming Convention

markup 
const SECONDS_PER_MINUTE: i32 = 60;

// Entry point: execution of the program starts here
fn main() {
    // Print "A minute has {} seconds" to the console, substituting in `SECONDS_PER_MINUTE` (with a trailing newline)
    println!("A minute has {} seconds", SECONDS_PER_MINUTE);
}

Constants at Global Scope

Unlike let bindings, constants can be declared outside of any function, at the top level of a file, making them accessible throughout the module.

Example: Constants at Global Scope

markup 
const GREETING: &str = "Welcome";

// Entry point: execution of the program starts here
fn main() {
    // Print "{}, traveler!" to the console, substituting in `GREETING` (with a trailing newline)
    println!("{}, traveler!", GREETING);
}

Constants vs Variables

Constants differ from immutable let variables in three ways: they always need a type, they can be declared in the global scope, and their value must be knowable at compile time rather than computed at runtime.

Example: Constants vs Variables

markup 
const PI_APPROX: f64 = 3.14159;

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `radius`, set to `2.0`
    let radius = 2.0;
    // Print "Circle area: {}" to the console, substituting in `PI_APPROX * radius * radius` (with a trailing newline)
    println!("Circle area: {}", PI_APPROX * radius * radius);
}
Related Topics

Mutability with mut · Variable Shadowing · Declaring Variables with let · Integer Types

{# common_mistakes/chapter_summary/browser_support: on Hindi pages the view already swaps in the hi_ translation fields (or blanks these out if untranslated), so this renders correctly for both languages without a lang_code check here. #}
Common Mistakes
  1. Using lowercase names for constants instead of Rust's convention of SCREAMING_SNAKE_CASE.
  2. Forgetting that constants always require an explicit type annotation, unlike let bindings.
  3. Trying to declare a constant with mut -- constants can never be mutable, unlike let variables.
Chapter Summary
  • Constants are declared with const and must have an explicit type annotation.
  • Constants are always immutable -- they can never be marked mut.
  • By convention, constant names use SCREAMING_SNAKE_CASE.
  • Constants can be declared in any scope, including the global scope outside of main.
🔒

Chapter Quiz — Complete all 7 topics to unlock

0/7 topics done

Complete these topics first:

← Previous Lesson Mutability with mut Next Lesson → Variable Shadowing

Login to run this code

C/C++/Java/PHP execution requires a free account. Your code is saved — you'll land right back in the editor after logging in.