Sztuczki dotyczące pętli i calldata
Tańsze operacje
Sztuczki dotyczące pętli i calldata to bezpłatna lekcja Web3 & DApp Development Fundamentals na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Web3 & DApp Development Fundamentals, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Web3 & DApp Development Fundamentals zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
Loops Multiply Cost
Loops are dangerous for gas because every operation inside runs once per iteration. A single expensive call inside a loop can blow your gas budget or hit the block gas limit.
The goal is to push as much work as possible outside the loop and make each iteration as cheap as possible.
Cache the Length
Reading array.length on a storage array costs an SLOAD each time the loop condition is checked. Cache the length in a local variable before the loop.
// BAD: SLOAD on every iteration
for (uint256 i = 0; i < items.length; i++) { }
// GOOD: one SLOAD
uint256 len = items.length;
for (uint256 i = 0; i < len; i++) { }Avoid Storage Inside Loops
Never read or write the same storage slot repeatedly inside a loop. Accumulate into a local variable and write the result once after the loop ends.
// GOOD: single storage write after the loop
uint256 total = 0;
for (uint256 i = 0; i < len; i++) {
total += amounts[i];
}
balance = total; // one SSTOREUnchecked Increment
Since Solidity 0.8, arithmetic has built-in overflow checks that cost extra gas. A loop counter that can never realistically overflow can be incremented inside an unchecked block.
for (uint256 i = 0; i < len;) {
// loop body
unchecked { ++i; }
}Pre-increment over Post-increment
++i is marginally cheaper than i++ because post-increment must produce a temporary copy of the old value. The saving is tiny per operation but adds up across many iterations.
Prefer ++i in loop counters where the return value is unused.
for (uint256 i = 0; i < len; ++i) {
// ++i avoids a temporary copy
}Calldata over Memory
For external functions, declaring array and struct parameters as calldata instead of memory avoids copying the data into memory. Calldata is read-only and cheaper to access.
// Cheaper: no memory copy
function process(uint256[] calldata data) external {
for (uint256 i = 0; i < data.length; ++i) { }
}Shrink Calldata
Each non-zero calldata byte costs 16 gas. Smaller payloads mean cheaper transactions. Techniques include:
- Packing multiple values into one
uint256 - Using smaller types where the ABI allows
- Passing indices instead of full structs when the data is already on-chain
Short-Circuit Conditions
Logical operators && and || short-circuit: the second operand is only evaluated if needed. Order conditions so the cheapest or most-likely-decisive check comes first.
// Check the cheap flag before the expensive storage read
if (isEnabled && expensiveStorageCheck()) {
// ...
}Avoid Redundant Reads
If you access the same calldata or memory element multiple times in a loop body, cache it in a local variable. While calldata access is cheaper than storage, repeated access still adds up.
for (uint256 i = 0; i < len; ++i) {
uint256 v = data[i]; // read once
total += v;
if (v > max) max = v;
}Bound Your Loops
Unbounded loops over user-controlled arrays can exceed the block gas limit, making the function permanently uncallable (a denial-of-service risk).
Always cap iteration counts or use a pull-based pattern where users process their own entries, keeping each transaction within safe gas bounds.
require(ids.length <= 100, "too many");
for (uint256 i = 0; i < ids.length; ++i) { }Putting It Together
An optimized loop typically: caches the length, accumulates into locals, uses calldata inputs, increments with unchecked { ++i; }, and stays bounded.
Each trick is small alone, but combined they can cut loop gas by a large fraction.
function batch(uint256[] calldata vals) external {
uint256 len = vals.length;
uint256 total;
for (uint256 i = 0; i < len;) {
total += vals[i];
unchecked { ++i; }
}
sum = total;
}Quick Check
Why is using calldata instead of memory for an external function's array parameter cheaper?
Recap
You learned loop and calldata gas tricks:
- Cache array length before looping
- Accumulate in locals, write storage once
- Use
unchecked { ++i; }for safe counters - Prefer
calldataparameters and shrink payloads - Always bound loops to avoid gas-limit DoS
Next we measure these gains with profiling tools.
Często zadawane pytania
Czy lekcja „Sztuczki dotyczące pętli i calldata” jest bezpłatna?
Tak — pełny tekst „Sztuczki dotyczące pętli i calldata” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Web3 & DApp Development Fundamentals, przejdź na CoddyKit PRO. Kurs Web3 & DApp Development Fundamentals zawiera 4 lekcji w sumie.
Co nauczysz się w „Sztuczki dotyczące pętli i calldata”?
Tańsze operacje Ćwiczysz Web3 & DApp Development Fundamentals z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Web3 & DApp Development Fundamentals?
Nie wymagamy żadnego doświadczenia. Web3 & DApp Development Fundamentals w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Sztuczki dotyczące pętli i calldata”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Web3 & DApp Development Fundamentals?
Tak. Każda lekcja Web3 & DApp Development Fundamentals zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Model kosztu gas
- Optymalizacja storage
- Sztuczki dotyczące pętli i calldata
- Pomiar gas