Solidity Crash Course - Part 03 : Variables, Scopes, Abstract contracts

Solidity Crash Course - Part 03 🚀

Introduction

Welcome back to our Solidity crash course! In this part, we’ll explore variables, variable scopes, and abstract contracts. Understanding these concepts will help you write more efficient and secure smart contracts. Let’s dive in! 😃

---

Solidity - Variables 📌

What are Variables?

Variables in Solidity are used to store data on the blockchain or within a smart contract’s execution context. Solidity provides different types of variables to handle various data efficiently.

Example of Variables

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract VariablesExample {
    uint256 public myNumber = 42; // State variable
    string public myText = "Hello, Solidity!";
    bool public isActive = true;
}

Why do we need variables?

🔹 Store information like user balances, contract state, or configurations.
🔹 Improve code reusability by using values dynamically instead of hardcoding.
🔹 Enable contract interactions by letting users modify and retrieve stored data.

Best Use Case

Use variables to store important contract data like token balances, user addresses, or contract states.

---

Solidity - Variable Scopes 🌍

What is Variable Scope?

Variable scope determines where a variable can be accessed within a contract. Solidity has three main types of variable scopes:

1. State Variables – Stored permanently on the blockchain.
2. Local Variables – Exist only within a function and disappear after execution.
3. Global Variables – Provide blockchain-related information (e.g., sender address, block timestamp).

Example of Variable Scopes

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ScopeExample {
    uint256 public stateVar = 100; // State Variable

    function localExample() public pure returns (uint256) {
        uint256 localVar = 50; // Local Variable
        return localVar;
    }

    function globalExample() public view returns (address) {
        return msg.sender; // Global Variable
    }
}

Why do we need variable scopes?

🔹 Security & Optimization – Limiting access to variables prevents accidental or malicious modifications.
🔹 Gas Efficiency – Local variables use less gas than state variables since they are not stored on-chain.
🔹 Better Code Structure – Proper scoping improves code readability and maintainability.

Best Use Case

Use state variables for permanent data storage, local variables for temporary calculations, and global variables for retrieving blockchain-specific details.

---

Solidity - Abstract Contracts 🎭

What is an Abstract Contract?

An abstract contract is a contract that contains at least one function without an implementation. It cannot be deployed on its own but acts as a blueprint for other contracts to inherit from.

Example of an Abstract Contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

abstract contract Animal {
    function makeSound() public virtual returns (string memory);
}

contract Dog is Animal {
    function makeSound() public pure override returns (string memory) {
        return "Woof!";
    }
}

Why do we need abstract contracts?

🔹 Code Reusability – Define a common structure for multiple contracts.
🔹 Enforcement of Standards – Ensures child contracts implement necessary functions.
🔹 Better Organization – Keeps smart contract development modular and clean.

Best Use Case

Use abstract contracts when you want different contracts to follow a common interface but allow them to implement their own logic.

---

Conclusion 🎉

In this part, we covered:
✅ Variables and how they store data.
✅ Variable scopes and their importance.
✅ Abstract contracts for defining contract templates.

Stay tuned for more Solidity learning! 🚀