0Pricing
Web3 & DApp Development Fundamentals · レッスン

ループとCalldataのテクニック

より安価な操作

「ループとCalldataのテクニック」はCoddyKit上の無料Web3 & DApp Development Fundamentalsレッスンです。 これはレッスン3/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはWeb3 & DApp Development Fundamentals学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Web3 & DApp Development Fundamentalsコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

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 SSTORE

Unchecked 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 calldata parameters and shrink payloads
  • Always bound loops to avoid gas-limit DoS

Next we measure these gains with profiling tools.

よくある質問

「ループとCalldataのテクニック」レッスンは無料ですか？

はい。「ループとCalldataのテクニック」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Web3 & DApp Development Fundamentalsコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Web3 & DApp Development Fundamentalsコースには全4レッスンが含まれています。

「ループとCalldataのテクニック」で何を学びますか？

より安価な操作 ブラウザで直接実行するハンズオンコードでWeb3 & DApp Development Fundamentalsを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Web3 & DApp Development Fundamentalsを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのWeb3 & DApp Development Fundamentalsは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン3/4です。

「ループとCalldataのテクニック」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このWeb3 & DApp Development Fundamentalsレッスンでコードを書いて実行できますか？

はい。すべてのWeb3 & DApp Development Fundamentalsレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. Gasコストモデル
  2. ストレージ最適化
  3. ループとCalldataのテクニック
  4. Gasの測定
← Web3 & DApp Development Fundamentalsに戻る