متغيرات الحالة وتخطيط التخزين

Welcome to understanding how data lives on the blockchain! In Solidity, state variables are special variables whose values are permanently stored in the contract's storage on the blockchain.

Think of them as the persistent memory of your smart contract. Their values are saved even after a function finishes executing and across different transactions.

Solidity uses different data locations to manage where information is stored during contract execution. These locations have big impacts on gas costs and how your variables behave.

• storage: Permanent state on the blockchain.
• memory: Temporary data for function execution.
• calldata: Read-only data for external function arguments.

Variables declared at the contract level (outside of any function) are automatically assigned to storage. These are your contract's state variables.

Data in storage is expensive to modify because every change is written to the blockchain, making it permanent and immutable (in the sense of its history).

This contract stores a number in a state variable. Notice how myNumber keeps its value between calls to setNumber and getNumber.

memory is a temporary data location. It's used for variables that exist only during a function call and are discarded once the function execution completes.

It's cheaper than storage for temporary data, making it ideal for arrays, strings, or structs that are created and used within a single function.

This function creates a string in memory, modifies it, and returns it. The string only exists for the duration of the function call.

calldata is a special read-only data location used exclusively for external function parameters. It's even cheaper than memory because data is not copied into memory, just referenced.

You cannot modify calldata. It's typically used for large data passed to external functions, saving gas by avoiding copies.

This external function takes a string as calldata. Notice it's read-only and efficient for external calls.

Choosing the right data location is crucial for gas optimization and correct contract behavior:

• Storage: Permanent, expensive, contract state.
• Memory: Temporary, cheaper, within-function variables.
• Calldata: Read-only, cheapest, external function arguments.

Always use the most restrictive and cheapest option possible.

Solidity packs state variables into 256-bit (32-byte) storage slots to save space and gas. Smaller types (like uint8, bool) can be packed together into a single slot.

However, this packing can be complex and depends on the order of variable declarations. Understanding it helps optimize gas costs, especially with structs and arrays.

Great job! You've learned about the fundamental data locations in Solidity: storage, memory, and calldata.

• State variables live in storage, making them persistent.
• memory is for temporary data during function execution.
• calldata is for efficient, read-only external function arguments.

Understanding these helps you write more efficient and correct smart contracts. Next, we'll explore complex data structures like Mappings and Dynamic Arrays!