Gestione degli errori con Revert/Require
Implementi strategie efficaci di gestione degli errori utilizzando `require()`, `revert()` e `assert()` per rendere robusta l'esecuzione dei contratti.
Gestione degli errori con Revert/Require è una lezione Blockchain Smart Contracts with Solidity gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Blockchain Smart Contracts with Solidity, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Blockchain Smart Contracts with Solidity include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Robust Contracts: Error Handling
Welcome to error handling in Solidity! Writing smart contracts requires extreme care, as they often manage valuable assets and are immutable once deployed.
Effective error handling is crucial for creating robust and secure decentralized applications (dApps). It helps prevent unexpected behavior and protects users.
`require()`: Validating Inputs
The require() function is your primary tool for validating conditions that must be true before a function executes.
- It checks pre-conditions and user inputs.
- If the condition is false, it reverts all state changes made in the current transaction.
- It refunds any remaining gas to the caller, effectively canceling the transaction.
Use require() for external conditions and user-provided data checks.
`require()` in Action
Let's see require() in a simple contract. This function only allows users older than 18 to register.
pragma solidity ^0.8.0;
contract UserRegistration {
uint public minAge = 18;
address[] public registeredUsers;
function registerUser(uint _age) public {
// Validate user input: age must be at least minAge
require(_age >= minAge, "Must be 18 or older to register.");
registeredUsers.push(msg.sender);
}
}`revert()`: Flexible Error Handling
The revert() statement offers more flexibility than require(), especially when you need to handle complex error logic or integrate with custom error types.
- Like
require(), it reverts all state changes and refunds gas. - It's often used inside
ifstatements for more intricate conditional checks. - It can be called directly or with a string message, similar to
require().
Custom Errors with `revert()`
Solidity 0.8.4+ introduced Custom Errors. These are more gas-efficient than string messages and provide better clarity for off-chain applications.
You define custom errors at the contract or file level, then use them with revert(). They help reduce transaction costs and improve contract readability.
Custom Error Demo
Here's how to define and use a custom error with revert(). Notice the error keyword.
pragma solidity ^0.8.4;
contract Wallet {
address public owner;
uint public balance;
// Define a custom error
error InsufficientFunds(uint requested, uint available);
constructor() {
owner = msg.sender;
}
function deposit() public payable {
balance += msg.value;
}
function withdraw(uint _amount) public {
require(msg.sender == owner, "Only owner can withdraw.");
// Use revert() with the custom error
if (_amount > balance) {
revert InsufficientFunds(_amount, balance);
}
balance -= _amount;
payable(owner).transfer(_amount);
}
}`assert()`: Internal Invariants
The assert() function is used for a very specific purpose: checking internal invariants.
- It verifies conditions that should never be false if your code is working correctly.
- If an
assert()fails, it indicates a bug in your contract logic. - Crucially, a failed
assert()consumes all remaining gas, unlikerequire()andrevert()which refund gas.
Use assert() for post-conditions or internal consistency checks, not for user input validation.
When to Use Which?
Choosing the right error handler is key:
require(): For validating user inputs, external conditions, or state changes before execution. Refunds gas.revert(): For more complex error logic, often with custom errors. Also refunds gas.assert(): For internal consistency checks and invariants. Indicates a bug if it fails and consumes all gas.
Prioritize require() and revert() for expected errors, and reserve assert() for unexpected, internal errors.
Error Handling Check
You're building a function that transfers tokens. Before sending, you need to ensure the sender has enough balance. If not, the transaction should fail and refund any unused gas.
Recap: Error Handling
You've learned how to make your Solidity contracts robust with proper error handling:
require()is for validating external conditions and user inputs.revert()offers flexibility, often used with gas-efficient custom errors.assert()is for internal invariants, signaling a bug if it fails.
Mastering these ensures your smart contracts are secure and predictable. Great job!
Domande Frequenti
La lezione «Gestione degli errori con Revert/Require» è gratuita?
Sì — il testo completo di «Gestione degli errori con Revert/Require» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Blockchain Smart Contracts with Solidity, passa a CoddyKit PRO. Il corso Blockchain Smart Contracts with Solidity include 4 lezioni in totale.
Cosa imparerò in «Gestione degli errori con Revert/Require»?
Implementi strategie efficaci di gestione degli errori utilizzando `require()`, `revert()` e `assert()` per rendere robusta l'esecuzione dei contratti. Eserciti Blockchain Smart Contracts with Solidity con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Blockchain Smart Contracts with Solidity?
Non è richiesta alcuna esperienza precedente. Blockchain Smart Contracts with Solidity su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Gestione degli errori con Revert/Require»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Blockchain Smart Contracts with Solidity?
Sì. Ogni lezione Blockchain Smart Contracts with Solidity include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Ereditarietà e interfacce
- Librerie e contratti astratti
- Gestione degli errori con Revert/Require
- Modifier e pattern checks-effects-interactions