1. Better loops

1. Standard loop

for (uint256 i = 0; i < arr.length; i++) {
    sum += arr[i];
}

• Calls arr.length (a storage or memory load every iteration)
• Uses checked arithmetic, which adds gas due to overflow checking.

1. Optimized Loop

   uint256 len = arr.length;// this is a must
   for (uint256 i; i < len;) {
       sum += arr[i];
       unchecked { ++i; }
   }
   

   • Caches length once (no repeated storage read). Avoids repeated sload/mload costs (~100 gas per storage read).
   • Uses unchecked to skip overflow checks (safe if bounds known). unchecked saves ~30–40 gas per iteration.
   • Uses ++i instead of i++ (slightly cheaper pre-increment). Using ++i saves ~5 gas per loop.

2. Storage Packing & Bit-Packing

• Pack multiple small variables (e.g. uint80, bool, address) into one 256-bit slot to reduce storage writes.
• Packed structs and fields dramatically reduce both deployment and runtime gas costs.

3. Use calldata instead of memory for Read-Only Parameters

For external functions, calldata avoids copying to memory, saving significant gas, especially for arrays.

4. Cache Storage Reads One-Time

• Reading from storage is expensive (~100 gas per access). When a state variable is accessed multiple times within a function, each read charges gas—even for “warm” accesses (i.e. a slot you've already touched).
• By loading a state variable into a local memory or stack variable and reusing it, you pay only one storage read. Further accesses use gas-cheap memory or stack reads—a saving of ~100 gas per duplicate access.

uint256 public number;

function bad() public view returns (uint256) {
    require(number < 10);      // 1st read
    return number * 2;         // 2nd read
}

function good() public view returns (uint256) {
    uint256 _num = number;     // 1st and only storage read
    require(_num < 10);
    return _num * 2;
}

Summing an array: uses ~1,829 gas less with calldata vs memory