0Pricing
Blockchain Smart Contracts with Solidity · Leçon

Variables d’état et organisation du stockage

Comprenez la différence entre le stockage, la mémoire et calldata, ainsi que la manière dont les variables d’état persistent sur la blockchain.

Variables d’état et organisation du stockage est une leçon Blockchain Smart Contracts with Solidity gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Blockchain Smart Contracts with Solidity, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Blockchain Smart Contracts with Solidity comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

What are State Variables?

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.

Data Locations in Solidity

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.

Deep Dive into `storage`

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).

`storage` in Action

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

pragma solidity ^0.8.0;

contract StorageExample {
    uint public myNumber; // This is a state variable, lives in storage

    function setNumber(uint _num) public {
        myNumber = _num;
    }

    function getNumber() public view returns (uint) {
        return myNumber;
    }
}

Understanding `memory`

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.

`memory` in Action

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

pragma solidity ^0.8.0;

contract MemoryExample {
    function greet(string memory _name) public pure returns (string memory) {
        string memory greeting = "Hello, ";
        // Use abi.encodePacked for simple string concatenation
        return string(abi.encodePacked(greeting, _name, "!"));
    }
}

Introducing `calldata`

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.

`calldata` in Action

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

pragma solidity ^0.8.0;

contract CalldataExample {
    // This function can only be called externally
    function processData(bytes calldata _data) external pure returns (uint) {
        // You cannot modify _data directly, but can read its properties
        return _data.length; // Returns the byte length of the data
    }

    // Another example returning calldata directly
    function echoString(string calldata _message) external pure returns (string calldata) {
        return _message;
    }
}

Comparing Data Locations

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.

How Storage is Organized

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.

Data Location Quiz

Which data location is used for permanent storage of a contract's state variables on the blockchain?

Summary of Data Locations

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!

Questions Fréquemment Posées

La leçon « Variables d’état et organisation du stockage » est-elle gratuite ?

Oui — le texte complet de « Variables d’état et organisation du stockage » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Blockchain Smart Contracts with Solidity, passe à CoddyKit PRO. Le cours Blockchain Smart Contracts with Solidity comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Variables d’état et organisation du stockage » ?

Comprenez la différence entre le stockage, la mémoire et calldata, ainsi que la manière dont les variables d’état persistent sur la blockchain. Tu pratiques Blockchain Smart Contracts with Solidity avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Blockchain Smart Contracts with Solidity ?

Aucune expérience préalable n'est requise. Blockchain Smart Contracts with Solidity sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Variables d’état et organisation du stockage » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Blockchain Smart Contracts with Solidity ?

Oui. Chaque leçon Blockchain Smart Contracts with Solidity inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Variables d’état et organisation du stockage
  2. Mappings et tableaux dynamiques
  3. Événements et journalisation des données
  4. Emplacements de stockage et optimisation du gas
← Retour à Blockchain Smart Contracts with Solidity