Solidity variable detailed explanation type, scope and best practice record

Detailed explanation of Solidity variables: Type, Scope and Best Practices

introduction

In Solidity smart contract development, variables are one of the most basic and important concepts. This article will explore in-depth variable types, scopes, life cycles, and usage techniques in Solidity.

1. Types and declarations of variables

1.1 State Variables

State variables are stored on the blockchain and permanently stored in the contract storage.

contract StateVariableExample {
    // Public state variable    uint256 public totalSupply;
    // Private state variable    address private owner;
    // Constant state variable    uint256 constant public DECIMALS = 18;
    // Immutable state variable    address immutable public CREATOR;
    constructor() {
        CREATOR = ;
    }
}

1.2 Local Variables

contract LocalVariableExample {
    function calculate() public pure returns (uint) {
        // Local variables are only valid in the function        uint256 a = 1;
        uint256 b = 2;
        uint256 result = a + b;
        return result;
    }
}

1.3 Global Variables

Special built-in variables that can be accessed anywhere:

contract GlobalVariableExample {
    function getBlockInfo() public view returns (
        uint256 blockNumber,
        uint256 timestamp,
        address sender
    ) {
        blockNumber = ;    // Current block number        timestamp = ;    // Current block timestamp        sender = ;           // Caller address    }
}

2. Visibility of variables

2.1 Visibility modifier

public: Publicly visible
private: Only visible within the contract
internal: Contracts within and inherited are visible
external: Externally visible only (for functions only)

contract VisibilityExample {
    uint256 public publicVar;      // Automatically generate getter function    uint256 private privateVar;    // Only accessible within the contract    uint256 internal internalVar;  // Can be accessed by inherited contracts    function getPrivateVar() public view returns (uint256) {
        return privateVar;  // Access private variables through public functions    }
}

3. The storage location of variables

3.1 Storage location description

The storage location of variables affects Gas cost and data persistence:

Storage location	Persistence	Gas Cost	use
storage	permanent	high	State variables
memory	temporary	middle	Function parameters and return values
calldata	Read-only temporary	Low	External function parameters

3.2 Storage location example

contract StorageExample {
    struct Data {
        uint256[] numbers;
        string text;
    }
    Data[] public dataArray;
    function processData(Data memory _data) public {
        // storage quote        Data storage newData = ();
        // Copying of memory to storage         = _data.numbers;
         = _data.text;
    }
}

4. Special variable types

4.1 Mapping variables

contract MappingExample {
    // Simple mapping    mapping(address =&gt; uint256) public balances;
    // Nested Mapping    mapping(address =&gt; mapping(address =&gt; bool)) public approvals;
    function updateBalance(uint256 _amount) public {
        balances[] = _amount;
    }
    function approve(address _spender) public {
        approvals[][_spender] = true;
    }
}

4.2 Enum variables (Enum)

contract EnumExample {
    enum Status { Pending, Active, Inactive }
    Status public currentStatus;
    function setStatus(Status _status) public {
        currentStatus = _status;
    }
    function isActive() public view returns (bool) {
        return currentStatus == ;
    }
}

5. Gas optimization of variables

5.1 Packaging storage variables

Reduce storage slot usage by reasonable sorting:

contract StorageOptimization {
    // Not optimized: Use 3 storage slots    uint128 a;    // Slot 1    uint256 b;    // Slot 2    uint128 c;    // Slot 3    // After optimization: Use 2 storage slots    uint128 a;    // Slot 1    uint128 c;    // Slot 1    uint256 b;    // Slot 2}

Storage slot calculation formula:
Storage cost = Number of storage slots × 20000 gas Storage cost = Number of storage slots \times 20000 \text{ gas} Storage cost = Number of storage slots × 20000 gas

5.2 Constants and immutable variables

useconstantandimmutableCan save gas:

contract ConstantExample {
    // Compilation constants, not taking up storage    uint256 constant public MAX_SUPPLY = 1000000 * (10 ** 18);
    // Fixed during deployment, only taking up code space    address immutable public TREASURY;
    constructor(address _treasury) {
        TREASURY = _treasury;
    }
}

Summarize

In Solidity, use variables correctly for:

Contract function implementation
Gas optimization
Safety assurance
Code maintainability

It is crucial. The developer should:

Understand the characteristics of different types of variables
Select storage location reasonably
Pay attention to the visibility control of variables
Follow naming specifications
Implement necessary safety measures

Best Practice Recommendations

Priority useconstantandimmutable
Reasonably organize state variables to save storage space
Handle external calls and state changes with caution
Do variable initialization
Use clear naming conventions
Regular audit of variable usage

Reference resources

Solidity official documentation
OpenZeppelin contract library
Ethereum Security Best Practices

By rationally applying the knowledge related to these variables, we can develop safer and more efficient smart contracts. Continuous learning and practice are the key to improving Solidity development skills.

This is the article about the detailed explanation of Solidity variables: types, scopes and best practices. For more related Solidity types, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!