Scope of variables in Rust

Introduction

Scope tells us where a variable can be used in the code. It helps keep things organized and avoids mistakes.

When you want to use a variable only inside a small part of your program.

When you want to avoid changing a variable by mistake in other parts of the code.

When you want to reuse the same variable name in different parts without conflict.

When you want to understand where a variable is created and where it stops existing.

Syntax

Rust

fn main() {
    let x = 5; // x is valid from here
    {
        let y = 10; // y is valid only inside this block
        println!("x = {}, y = {}", x, y);
    } // y is no longer valid here
    println!("x = {}", x);
    // println!("y = {}", y); // This would cause an error
}

Variables declared inside curly braces {} are only usable inside those braces.

Variables declared outside are usable inside inner blocks too.

Examples

Variable b is only inside the inner block. Outside, it is not known.

Rust

fn main() {
    let a = 1;
    {
        let b = 2;
        println!("a = {}, b = {}", a, b);
    }
    // println!("b = {}", b); // Error: b not in scope here
}

Variable x is declared in main and can be used anywhere inside main.

Rust

fn main() {
    let x = 10;
    println!("x = {}", x);
}

You can declare a new variable with the same name inside a block. It hides the outer one temporarily.

Rust

fn main() {
    let x = 5;
    {
        let x = 10; // shadows outer x
        println!("inner x = {}", x);
    }
    println!("outer x = {}", x);
}

Sample Program

This program shows how a variable inside a block can hide the same variable outside. The outer variable keeps its value after the block.

Rust

fn main() {
    let number = 7;
    println!("Outside block: number = {}", number);
    {
        let number = 42; // shadows outer number
        println!("Inside block: number = {}", number);
    }
    println!("After block: number = {}", number);
}

Important Notes

Shadowing lets you reuse variable names safely inside smaller scopes.

Trying to use a variable outside its scope causes a compile error.

Summary

Scope defines where a variable can be used.

Variables inside blocks are only valid inside those blocks.

Shadowing allows temporary replacement of a variable inside a smaller scope.